Can we have software move from one machine to another on its own. We certainly can. Mobility of a software on its own opens a whole new door to the way we think of consuming services on servers. To consume a service from another machine, the general or more talked ways are to invoke a web service or to make a RPC/RMI call. But if we can introduce the attribute of mobility in a software, it can travel to another machine and consume a service and either hop to more servers or come back home.
Let's first try to understand a bit about remote method invocation before I move down to object mobility. Remote Method Invocation (RMI) is a common way nowadays via which we can have services or objects residing on remote machines and can call those functions from a local machine.
It’s pretty interesting how it is done. Over here, we will not go into the details of how it is implemented, but simply here is a picture that might help you visualize what is going on.
The coding complexity is not huge but what is happening under the hood is a bit tricky to understand. Again in short, using RMI we can actually call a function of an object which is not residing in the same machine.
Now, what if instead of our software being able to call a function on the remote object we could have our object itself travel over the network. Sounds interesting, then fasten your seat belt and read on how it is done.
This is a pretty interesting concept called Object or Agent mobility or in more general Terms Software Mobility. We can send in an object over the network which will wake up on another machine and then it can do some specified task, and then come back. Pretty interesting isn't it. Here is a picture to visualize it.
So now what we have here is instead of calling a function of a remote object we are sending our own object to go to another remote machine and do some processing over there and then come back with results. If we can make our objects intelligent and they have mobility then we can do wonders.
The implementation portion is not rocket science at all so here is a bit of idea how it is done. It is two fold:
- How to transfer objects from one machine to another
- How to receive and send back the object
The first question is simple to answer. We need to learn how to transfer objects via networks. Be careful to serialize the class whose object you will be sending across the network using Serializable attribute. I will let the reader figure out how to transfer an object over the network using a TCP Connection. I will just say it can be done.
For the second question, we should make our server aware of the fact that they will and can receive such objects, so on receiving such an object it will know which function of the object to call to start the object and the object should in turn know which function of the server to call to be able to get back home. As the Sever should have some mechanism to throw back an object, the server will get the home address (home IP) of the object from its data and then throw him back functions. Therefore in short there should be a specified interface an agent should follow so that based on that interface the remote machine can call up some functions of the agent. And also the server should have a defined interface so that the agent can call the remote machines function. For a bit more clarification, here are interfaces that may get you started off.
public void AgentMigrate(IMobileAgent Agent, String DstAddr, int DstPort);
public void AgentSendBackToHome(IMobileAgent Agent);
public string AgentGetSearchFileName();
public void AgentArrived(IAgentServer Srv);
public void PrintResults();
Apart from the implementations of these interfaces, you will need another class or function which will create, initialize the object and throw it to a server and wait to receive the object back, when it is thrown back by the server.
Please note, the server should be listening on a specified port all the time and will receive the objects. On getting an object, it will call the objects'
AgentArrived(…) function. When the object decides it wants to go back home, it will call the servers
AgentSendBackToHome (…) function. The agent might or can travel to another server instead of going home and that can be achieved by the agent calling the servers
Points of Interest
An example and usage of this object mobility is in distributed search, where we can have multiple agents with different AI in them travelling to different servers and extracting information and then coming back from where they started. All the results of the agents can be deduced to a meaningful search result. For a moment, think wild and I am sure you will come up with a dozen other useful things you can do, since now you know something like this can be done. And on top of it, is it not cool that your software is actually roaming around the network.
I hope this post sheds a bit of light on Object mobility. And now its time to play around with this and make interesting stuff. Have fun!