Mobile Agent. Summer Project Report. Indian Institute of Technology Kanpur Department of Computer Science and Engineering

Transcription

1 Mobile Agent Summer Project Report Indian Institute of Technology Kanpur Department of Computer Science and Engineering B V V Srirajdutt Sourav Khandelwal Prateek Mishra 1

2 Abstract In computer science, a mobile agent is a composition of computer software and data which is able to migrate (move) from one computer to another autonomously and continue its execution on the destination computer.the use of internet and the World-Wode-Web has become widespread in the recent years and mobile agent technology has proliferated at an equally rapid rate. In our project, we aim to implement our mobile agent framework. The implementation has been done in Java language to ensure platform independence among agent applications. The design goals have focused on providing complete coverage of flexible agent mobility, support for agent interaction and reliable agent transmission. 1 Motivation A mobile agent has the unique ability to transport itself from one system in a network to another in the same network. This ability allows it to move to a system containing an object with which it wants to interact and then take advantage of being in the same host or network as the object. Our interest in mobile agents is not motivated by the technology but rather by the benefits agents provide for the creating distributed systems. There are at least seven main benefits, or good reasons, to start using mobile agents. They reduce the network load. They overcome network latency. They encapsulate protocol. They execute asynchronously and autonomously. They adapt dynamically They are heterogeneous. They are robust and fault-tolerant. 2 Introduction and Overview A Mobile Agent, namely, is a type of software agent, with the feature of autonomy, social ability, learning, and most importantly, mobility. More specifically, a mobile agent is a process that can transport its state from one environment to another, with its data intact, and be capable of performing appropriately in the new environment. Mobile agents decide when and where to move. Movement is often evolved from RPC methods. Just as a user directs an Internet browser to visit a website (the browser merely downloads a copy of the site or one version of it in the case of dynamic web sites), similarly, a mobile agent accomplishes a move through

3 data duplication. When a mobile agent decides to move, it saves its own state, transports this saved state to the new host, and resumes execution from the saved state. A mobile agent is a specific form of mobile code. However, in contrast to the Remote evaluation and Code on demand programming paradigms, mobile agents are active in that they can choose to migrate between computers at any time during their execution. This makes them a powerful tool for implementing distributed applications in a computer network. An open multi-agent systems (MAS) is a system in which agents, that are owned by a variety of stakeholders, continuously enter and leave the system. 3 Potential Application These are some of the potential application of mobile agents. Each exploits the benefits of using mobile agent in some way. E-Commerce: Personal Assistance: Secure Brokering: Distributed Information Retrieval: Telecommunication Networks Services: Workflow Application and Groupware: Monitoring and Notification: Information Dissemination: Parallel Processing: 4 Implementation Details Our Agent infrastructure implementation consists of a set of Java classes for server execution, client execution, agent initiation, agent handling and agent Interaction. Each node in the system consists of a number of interating component servers that would be executing one or more Java Virtual Machines. The description of the agent architecture is described in the flow chart below in Fig. 1. 2

4 Figure 1: Agent System Flow Chart Description The following steps are involved in our implementation - Reading Configuration List Setup Class List Setup Server List Setup Agent List Setup Dead Agent List Setup Service List Setup Communication List Setup Starting Services Server Class Load Server Client Proxy Agent Proxy Console 3

5 4.1 Reading Configuration This stage involves reading various configuration like on which interface the agent has to bind, path where agent classes can be found, ports on which its server and class load server has to run, range of ip addresses to scan for locating peer nodes, and load which this node can bear. 4.2 List Setup This stage involves initializing many lists which are used by the agent system in course of agent execution in the system. Some are essential for smooth running of framework while others are necessary for debugging Class List Setup This stage involves making list of all agent classes with its path and time of modification. If a foreign agent comes to this node and its class definition is not found in this list or its version is newer than that in the list, then it s definition is requested. Once the agent class definition comes, it is added to the list. The ClassList storing the agent class information present on the local node AgentName ClassPath Date WordCount.class C:/mobileAgents/WorCount.class GenMatrix.class C:/mobileAgents/Agent2.class Server List Setup This stage involves the checking of connections between various nodes.every node tries to connect with other node which are already not connected. Once connected, it adds the remote node to its Server List for further communication.this connection setup stage also involves authentication through java SSL sockets. It also maintains two list for monitoring out and in packet count for each node. Servers IP OutCount InCount Agent List Setup This stage involves maintaining a list of all the agents running on the current node. The list maintains list of all the agents - the class Name, the unique ID of the agent, its source and destination. Also the references to the Object and Thread of the corresponding Agent Manager are maintained here. Agent List is basically a list of all the Agent Manager threads running i.e., the list of all the agents that are currently running on this system and the corresponding references to access them. 4

6 AgentID AgentName Object Reference Thread Reference Source Destination 4360 Hello Thread WordCount Thread Dead Agent List Setup This stage involves maintaining a list of all agent which once executed on this node. It is basically used to keep log of all activities on the current node. It is also used in case of retract. If some node tries to retract a agent(which is now dead) which it once sent to this node, then this agent is moved form dead agent list to that node. AgentID AgentName Source Destination 4360 Hello WordCount Service List Setup This stage involves maintaining list of all services provided by all agents. whenever a agent starts it can decide which services it is going to provide. AgentName AgentID Methods Hello 4360 null WordCount 1939 wc,string,int 4.3 Starting Services This stage involves starting of all the services and related threads which will run on this node. These services are required by the agent system for the agent initiation, mobility and agent interaction Server This Server listens for any incoming connection. If connection is accepted, then it creates a Server Proxy thread which later sends this packet to agent proxy for analysis Class Load Server This servers listens for request coming from some node for agent class definition. If it has the corresponding class definition in the Class List, then it sends it to the requesting node. Here a file transfer takes place. The request actually comes from the Class Load Client, which is forked whenever a class definition is not found locally. 5

7 4.3.3 Client Proxy Reads packets from Client Buffer and accordingly creates a Object and Thread of Client class which will later send the packet Agent Proxy Agent Proxy class is the heart of the system and handles all the activities other than the ones that involving Agent Interaction. The class is responsible to receive and analyze all the activities and perform the operations as needed. It receives Packets or commands from Server and Console through a buffer and accordingly sets the action that the particular Agent Manager has to do. It is responsible for creating new objects and threads when an agent is to begin execution on this node. It is also responsible to update the corresponding Agent List, Dead Agents List etc Console Users interact with a Agent System by developing agent application programs. These agent application programs are implemented as Java objects. The system listens on the console for any input from the user. Once user gives a line of input, it parses the input and accordingly if necessary forks a Console Proxy thread giving it a packet which later forwards the received packet to agent proxy for further analysis. 5 Data Structures Packet Communication Packet Packet Queue 5.1 Packet This is the standard structure that is used for the transfer of all the information of agents from one node to other. All the information is serialized to save the current state of the agent execution and the serialized byte code is moved to the foreign node as a packet where the saved information is retrieved from the packet. Packet Source Destination ClassName ActionName ClassID Object Redirect 5.2 Communication Packet This is the standard structure used for agent interaction. 6

8 5.3 Packet Queue The PacketQueue is used to buffer the packets that are created in the system. Four different Packet Queues are used in the system for different purposes: Agent Buffer - Buffers the agents started to be handled by agent manager Client Buffer - Buffers the agents to be moved to the remote server Console and Server Buffer - Buffers the packets coming from console and server 6 Agent Mobility Since the agent objects are composed of a combination of code and data, object mobility means the network transportation of both code and data. The Client Proxy handles the mobility of the agents to foreign servers. Beyond providing for just the mobility of code and data, the agent system provides for the transmission of state information detailing where the agent has been and state of the variables in execution and where it is going and what it still has to do. Mobility of an agent s data was accomplished using the Java Object Serialization facility. Transfer an agent state is a matter of serializing an agent s data down into a format suitable for network transmission, transmitting the data in this format, and then deserializing the data back into the original agent. This is very similar to the mechanism used by Java Remote Method Invocation (RMI) for passing an object by value between distributed objects. RMI itself does not provide for true object mobility as it provides for no mobility of an object s code and in fact requires that the code for any objects passed by value be pre-installed on both sides of the network connection. Java s Object Serialization features provide an almost transparent mechanism by which Java objects can be serialized into data streams and provided suitable technology for implementing agent mobility. The problem of transmitting an Agent s code is solved in a manner similar to the way in which a web browser loads a Java applet. A browser will typically implement a special Java class called a called a ClassLoader. The Java virtual machine makes a callback into the ClassLoader object whenever the system attempts to load the bytecodes for a Java class. In response to this callback, the ClassLoader implemented within the browser makes an HTTP request to a web browser in order to retrieve the file on the server containing the bytecodes for the class. The Java language provides a mechanism for converting the contents of this file into an actual Java class from which objects can be instantiated. Our Agent infrastructure uses a very similar mechanism to support mobility of code. As an agent travels around a network its bytecodes and the bytecodes of any objects it creates and stores in its member variables are loaded via a special ClassLoader. This ClassLoader packages theses bytecodes into a special data structure whose location and information is passed with the agent. During the deserialization of the agent, the bytecodes for the agent and its related classes can be retrieved from this data structure and are used to instantiate a new copy of the agent. Following is the description of the mobility of the agent in our agent system. The agent framework maintains four lists on every system the framework is running: 7

9 ServerList ClassList AgentList ServiceList The functions of these lists have been discussed before.the ServerList gives the information about the possible systems on which the agent framework is currently active. The local node initiates the mobility of the agent to any of the active servers. The Agent List maintains all the required information of the agentthe classname, the unique ID of the agent generated by using the Hash class, its source and destination. The agent manager handling the agent suspends the corresponding agent which was in execution and saves the state of the agent along with the details obtained from the agent list in a packet. This packet is put into the client buffer which is then handled by the client proxy. The Client Proxy reads the packets from the client buffer and accordingly creates a Object and Thread of client class. The client establishes the connection with the destination server where the packet is to be moved. On the other hand, the server also is listening to the port for establising the connection. Once the connection is established,client moves the packet corresponding to the agent to the destination server and the server starts the server proxt thread which handles the packet from the client. Server proxy reads the packet recieved from the client and adds it in the agent buffer. It also looks for the agent class executable in the ClassList of its local system. If the executable is not present or an older version of the executable is present, then it is loaded from the client machine with the help of ClassLoadServer and the classlist is updated. The agent is then handled by the agent manager in the foreign system and the AgentList of the destination node is updated. 7 Testing Users interact with the agent system by developing the agent application programs. These agent application programs are implemented as Java objects. We have built some small agent applications inorder to test the working of the agent system. Matrix Multiplication agent application is one of the agent application which has been used to test the entire working of the agent system. The goal is to multiply of two significantly large matrices in a distributed fashion. The two matrices are divided into small sub matrices and send as agents to the active servers in the network where they execute locally in the foreign system and returns the results. All the agents after execution and returns back to the originating system with the corresponding results of the multiplication. 8

10 Figure 2: Matrix Multiplication Description 9

11 Agent Execution Commands agent agentname agent agentname start agent agentname stop agent agentname sleep duration agent agentname resume agent agentname suspend agent agentname retract agent agentname move agent agentname move ip agent agentname move ip true agent agentname clone agent agentname clone ip agent agentname clone ip true 8 Conclusion and Future Work The application aimed at has been developed as efficiently as possible and has been tested in the live local network at IIT Kanpur. Subsequently we would like to extend this to include all the improvements that have been mentioned in the above discussion so far. In the coming versions. We would also like to make this more robust so that this can be used as a commercial application. 9 Acknowledgements We would also like to thank the guide Dr. R. K. Ghosh for giving us this wonderful opportunity and his guidance throughout the project and making this learning experience enjoyable for all. References [1] [2] Lange, D., and Oshima, M. Programming and Deploying Java Mobile Agents with Aglets. Addison- Wesley Longman, Reading, Mass., [3] [4] [5] Arjav J. Chakravarti, Xiaojin Wang, Jason O. Hallstrom and Gerald Baumgartner, Implementation of Strong Mobility for Multi-Threaded Agents in Java [6] 10