Atropos

Active Virtual Network Management Prediction

Chapter 2: Atropos Installation

Stephen F. Bush and Amit Kulkarni
(bushsf@crd.ge.com, kulkarni@crd.ge.com)

Previous Chapter
Beginning of Tutorial
Next Chapter

Getting the Code

  1. This package contains the AVNMP code. New versions can be retrieved from http://www.crd.ge.com/~bushsf/an .
  2. The Magician execution environment is required to run AVNMP and is available from the University of Kansas or contact Amit Kulkarni.
  3. An SNMP client is not required, but is useful for monitoring and managing the system. SNMP packages are available from many sources, one source is http://www.net.cmu.edu/groups/netdev/software.html .
This should be enough information to start running. The remaining content of this file provides more detail about the program organization and customization. 

Installation

  1. See the instructions with the code for the latest installation instructions.
  2. Uncompress and untar the Java source files.                          (gunzip atropos.tar.gz, tar xvf atropos.tar)
  3. In order for the code to compile, you must first have Ant properly installed on your system. Ant can be found at Jakarta's Ant site, or you can download them from here.
  4. One you have ant properly installed, you need to edit one file which is found in the conf directory. It is entitled env.properties.default. You MUST copy it to env.properties and edit the values inside. This will help to autoconfigure the helpful scripts used to run magician and atropos.
  5. Once you have properly edited env.properties, the next step is to let the system configure itself. This is done by being in the same directory as the build.xml file and typing: "ant configure". This will setup the system and configure some help scripts found in the bin directory
  6. The final step is to compile the system. This can be accomplished by typing: "ant". This will compile the java sources and place them in the correct directory.

Setting up Magician

Atropos injects active packets into the Magician active network execution environment. The Magician execution environment must be running on every node in the active network in order for Atropos to run also. The following is a quick step-by-step process for setting up an active network. For more detailed instructions and a description of Magician, head to the Magician homepage .
  1. First we must set up a Four11 server. The Four11 server is the configuration server that all active nodes will contact to find out information about themselves. Edit conf/Four11.conf to the proper hostname and port that the Four11 server will run on.
  2. Next we must set up our active network topology. This is done by editing the conf/SampleNet.conf file. It contains the network name and a list of nodes and their neighbors. You can follow the example set forth in conf/SampleNet.conf or head to the magician installation page.
  3. After setting up the active network topology, we must now edit conf/magician.properties. This file contains the paths used by the Four11 server to find out what machine it is running on and also the configuration file for the active network topology.

Running ATROPOS

The instructions given in this document assume that the Magician Execution Environment (EE) is being used. Once the Magician EE is setup, there should be a network configuration file in the Magician Four11 directory that describes the EE topology. Start the appropriate Host and Nodes for your configuration. Note that wallclock time on all nodes should be synchronized for best performance.
 

Notes:

  1. To get Atropos up and running, there are startup scripts in the bin directory. They should be have been modified to system's set up by running "ant configure". 
  2. The following is a brief description of the scripts in the bin directory
    1. startn.sh: starts an active node with a nodename passed in from the command line
    2. starth.sh: starts an active host with a nodename passed in the from the command line
    3. start_nodes.sh: a startup script to start up nodes on multiple hosts (pass "sun" as a command line argument to execute on a solaris specific environment)
    4. kill_nodes.sh: kills nodes started up on remote machines (pass "sun" as a command line argument to kill nodes on a solaris network)
    5. start411.sh: a simple script to start up the four11 server

Starting Magician and Atropos

  1. Before we can begin, Magician's four11 server must be running. To do this, you can either run bin/start411.sh or by typing the following:
    2. ${JAVA} -classpath <path to magician.jar> magician.Four11.Four11 <network name> &
  2. Next we must start up the active nodes. This can be done either with the bin/startn.sh script (passing in the node name assigned to each node via the SampleNet.conf file or similar) or by typing the following:
    3. ${JAVA} -classpath <path to atropos classes>:<path to magician.jar> magician.Node.NetworkNode <nodename> <network name> <file name for output>
  3. Finally we can set up our active host. The active host is responsible for sending out the driving process into the network. It is here that you can choose what type of active application you want to send out into the network. This can by done via the bin/starth script (passing in the node name assigned to the node via the SampleNet.conf file or similar) or by typing the following:
    4. ${JAVA} -classpath <path to atropos classes> host.activehost.ActiveHostTPut <nodename> <network name> -trace <file name for output>
  4. From the active host prompt, you can can try the example load prediction application called LoadGen which is included with atropos.
    1. The Debug level can be set by adjusting the value of AvnmpDebug in your environment, e.g. "setenv AvnmpDebug 255" (See AvnmpDebug ).
    2. At the Magician host enter (assuming host name is AH-1):
      1. send atropos.start.InjectSnmp AH-1                            (this injects SNMP instrumentation into the network)
      2. send atropos.load.LoadGen AH-1                                 (this begins a sample application called LoadGen)
      3. send atropos.start.Flood AN-1                                       (this injects the logical processes into the network)
      4. send atropos.start.AvnmpSmartDriver AH-1           (this starts the driving process on the host node)
    3. An SNMP walk of the MIB at any of the running nodes will display the AVNMP state, application predicted state, and actual application state. The mibs are included in mib-avnmp.txt and mib-loadpred.txt.
    4. LoadGen attempts to transmit packets to AN-1. This is currently hardcoded in avnmp.java.load.LoadGen and can be changed and recompiled if necessary.

ATROPOS Architecture

The figure above provides a high level view of an ATROPOS residing on two network nodes. The AvnmpSmartDriver polls the Active Application (AA) and generates virtual messages (streptichrons) which are algorithmic representations of expected future state. This information is passed through the system which is comprised of Atropos Logical Processes (AvnmpLP). The AvnmpLP handles rollback. The Atropos packets are capable of checking current state with predicted state and causing a rollback if necessary.

The figure above zooms into a detailed view of the AvnmpSmartDriver and AvnmpLP. The Active Virtual Network Management Prediction algorithm encapsulates each Physical Process within a Logical Process. A Physical Process is nothing more than an executing task defined by program code. The Logical Process can be thinly designed to use the physical processes' software. If that is not possible, then the entire model can be designed into the Logical Process. Consider the following example:
The packet forwarding process on a router is an example of a Physical Process. A Logical Process consists of the Physical Process, data structures, and instructions to maintain message order and correct operation as the system executes ahead of wallclock time. The packet forwarding Logical Process maintains load values in its State Queue and handles rollback due to out-of-order input messages or out-of-tolerance real messages as explained later.
To be more specific, a Logical Process maintains, and sends, numerous objects and structures during its execution. For Atropos, the packets sent are an implementation of Magician's SmartPacket which follows the Active Network Encapsulation Protocol format. The information contained, and transmitted, within the SmartPacket are:
An important part of the architecture for network management is that the state queue of the Atropos system is the network Management Information Base. The Active Virtual Network Management Prediction state queue values are the Simple Network Management Protocol Management Information Base Object values. They are the values expected to occur in the future. The current version of the Simple Network Management Protocol has no mechanism for a managed object to report its future state; currently all results are reported assuming the state is valid at the current time. In working on predictive Active Network Management there is a need for managed entities to report their state information at times in the future. These times are unknown to the requester. A simple means to request and respond with future time information is to append the future time to all Management Information Base Object Identifiers that are predicted. This requires making these objects members of a Management Information Base table indexed by predicted time. Thus a Simple Network Management Protocol client, which does not know the exact time of the next predicted value can issue a get-next command appending the current time to the known object identifier. The managed object responds with the requested object valid at the closest future time.

Atropos Dependencies

The following table lists the Atropos classes and their dependencies upon Magician execution environment interfaces,  application specific interfaces, and the network management interfaces. Each class element of the table also contains a brief description of the class. By looking down the columns of the table, one can quickly gain an idea for what parts of Atropos would need to be modified to port to another EE, use another network management framework, or build a new predictive application model.

Specific ties to the Magician environment are noted in green.
Specific ties to the Atropos-Enhanced application are in red.
Interfaces to SNMP are in pink.
 

Atropos Dependencies Table
Class Description Magician EE Interfaces Application (AA) Interfaces Management (SNMP) Interfaces
Amain
Starts up an individual LP on a node. The steps to incorporate this into an execution environment.
 This is an active packet and thus is highly Magician dependent.    
AvnmpSmartDriver Starts up an individual Driving Process on a node.  This is an active packet and thus is highly Magician dependent.    
Flood Starts Amain on all Active Nodes. Magician dependent.    
InjectSnmp Injects the SNMP protocol interface in order to hold the predicted values and to manage the AVNMP system.     Primarily handles management functionality of instrumenting all active applications on the node with SNMP.
Driver Generates virtual messages. Magician dependent calls are made to NetLoggerEventManager and
SPThread.currentSPThread.sleep()		    
Gvt Global Virtual Time implementation.      
HtmlDebug Write HTML log files.      
AvnmpBW Add itself to the receive queue with some measurement hooks that are Magician dependent. 
This is an active packet and thus is currently highly Magician dependent.
  • queueSize()  
  • xmitRate()  
  • recvRate()  
  • Seconds()  
  • GetNodeName()

    • smallstate access to add itself to the receive queue
   
SnmpInterface Holds all the Object IDs of which AVNMP needs to be aware.     This is a management function.
ConfigInterface Holds configurable information for the system.      
AvnmpDebug Set debug level.      
AvnmpDriverRb
Accesses smallstate to notify DP of rollback.
    
AvnmpLP The Logical Process     Many calls to the management interface.
AvnmpPacket The virtual message (streptichron) - 
AvnmpPacket.compPred() checks the predicted accuracy by calling PayLoad.streptiChron().		     Calls the management interface to accuracy of prediction with actual application. avnmp.java.lp.SnmpInterface holds the object id information for AVNMP and the application.
AvnmpQueue General queue base class      
AvnmpRecQueue This is the logical process receive queue.   This is where AvnmpPacket.compPred() is called which ties to the application. Calls the application via the management framework interface.
AvnmpSndQueue Saves sent messages      
AvnmpStat (utility) Implements variable statistics.      
AvnmpState Logical Process state      
AvnmpStateQueue Logical Process State Queue     Includes updateSnmpObjects(). This is where the prediction is stored in the MIB.
AvnmpTime Base class for time management.      
PredMeasure (utility) This is a utility to check the prediction accuracy weighted by time.      
PredVector (utility) Vector of PredMeasure objects.     Contains SnmpAgentContext.updateSubAgent().
GnuPlot Write data to be plotted into GnuPlot files.      
PP This is the model of the process to be Atropos-Enhanced.    This is the model of the process to be Atropos-Enhanced.   
PayLoad No ties to Magician other than Node names for the route.   Highly application dependent. Contains source route for load prediction application.  
splitElement, splitTable Implements probabilistic routing.   Used in PayLoad to include probabilities of splits and joins in a route. Implements load application.  
LoadGen (Sample Application) Generates packets. This is a Magician active packet. This is the application.  
LoadPacket (Sample Application) Packets generated by LoadGen. This is a Magician active packet. This is the application. Load and Uptime are available via the management interface.

Atropos FILES and Java Packages

The complete Atropos documentation is found in the Atropos API .

Startup

Main Packages

SNMP Instrumentation

Sample Application

atropos.lp.ConfigInterface Parameters

Operational Configuration Parameters

 
Previous Chapter
Beginning of Tutorial
Next Chapter
 
The complete ATROPOS documentation is found in the ATROPOS API. 
This research is funded by DARPA/ITO Contract Number: F30602-98-C-0230 supported by the Air Force Research Laboratory/IF.
The project web site is http://www.crd.ge.com/~bushsf/an


SourceForge Logo