DynamicTMN® Java GDMO Agent API

The DynamicTMN® Java GDMO Agent API is a high-level agent role Java application framework for the rapid implementation of Java-based Common Management Information Protocol (CMIP) Q3 agents. The API provides a plethora of high-level API components along with an MIT and a default management object implementation framework in order to minimize the amount of application code required to implement custom agents.

The DynamicTMN® Java GDMO Agent API provides the high-level programming interface for use in developing complex TMN agent applications with minimal effort. By supplying a generic managed object implementation framework which implements the default CMIS message processing for most CMIS operations as well as including built-in support for MIT scope and filter evaluation, the GDMO agent API allows the developer to concentrate on the custom agent behaviour while the agent framework handles the rest.

The DynamicTMN® Java GDMO Agent API has the following features:

• high level GDMO agent API
• hides protocol/service level operations
• built-in processing of M-GET,M-SET,M-CREATE and M-DELETE
• built-in MIT/MIB support for CMIS scoping and filtering
• built-in support for standard X.721 notification types
• user-extensible managed object (MO) implementation classes
• Management Information Tree (MIT) support
• default resolution of NAME-BINDINGs for M-CREATE operations
• extensible agent code generator
• easily extensible to support other transport protocols
• XML configurable agent framework
• XML MIB persistence engine (MOs stored as XML)
• XML MIB population

The DynamicTMN® Java GDMO Agent API provides several core high-level API classes for implementing CMIP agents. These classes include:

• CoreAgent
• XmlCoreAgent
• MIT
• MO
• MOFactory
• ManagedObject

The CoreAgent is a configurable and extensible agent implementation which provides default CMIP message processing support for M-CREATE,M-DELETE, M-GET,M-SET and M-EVENT-REPORT. It contains an MIT, default generic Managed Object implementation and configuration methods for attaching custom managed object implementations. It also includes a default Event Forwarding Discriminator (EFD) implementation.

The XmlCoreAgent extends the CoreAgent to add an XML configuration module such that you can now configure the agent through a single XML configuration file.

The MIT class provides a Java implementation of a Management Information Tree (MIT) structure which contains the set of managed objects in your agent. It provides built-in support for processing scoped and filtered CMIS operations as well as a user-friendly API for accessing managed objects in the MIT.

The MO interface defines the interface for all managed object implementation classes in the agent. It includes methods for handling the different CMIS operations we well as methods for accessing information about the managed object.

The MOFactory is an abstract factory class which is used to create new MO instances to be included in the agents MIT. It provides build-in support for the determination and enforcement of NAME-BINDINGs, managed object attribute initialization based on GDMO defined default/initial values, create request validation of required (mandatory) attributes, and much more. Each custom MO implementation should implement a custom MOFactory which is then attached to the CoreAgent so that the agent can create new instances of the managed object.

The ManagedObject class is a generic MO implementation which can be used to represent ANY GDMO managed object. It provides a default implementation of the message processing for the M-CREATE, M-DELETE, M-GET, M-SET and M-EVENT-REPORT CMIS services. This class may be extended in order to provide custom processing for any or all of the CMIS services.

For a complete set of API examples, API Javadoc, developer guides, agent simulators and much more, please download the DynamicTMN® CMIP Suite evaluation package.

Download DynamicTMN® CMIP Suite Evaluation

The DynamicTMN® Java GDMO Agent API includes an agent code generator which will generate the skeleton code for implementing a custom agent with any number of custom managed object implemention classes. It allows you to specify the set of managed object classes you wish to implement and will generate the following:

• XmlCoreAgent skeleton
• MO class for each specified managed object classes
• MOFactory class for each generated MO class
• MOSuite for configuring the generated MOs

The generated code provides a default implementation for the M-CREATE, M-DELETE, M-GET, M-SET and M-EVENT-REPORT CMIS services and as such will function without modification. In order to provide your own custom implementation, you simply need to add your own custom processing code to the appropriate method in the generated skeleton code. For example:

   public void processAction(ActionMOPendingIndication pi,
                             ActionTypeId action_type,
                             AbstractData action_info)
   {
      // -- check for the 'simpleNodeResetAction' action type.
      if (action_type.equals(simpleNodeResetAction))
      {
         try
         {
            // -- generate the reply info --
            // -- ASN.1 type:  GraphicString
            pi.setReplyInfo("my reply value...");
         }
         catch(Exception e)
         {
            // process the exception...
         }
      }
      else // pass to superclass processing...
      {
         super.processAction(pi, action_type, action_info);
      }
   }

For a complete set of API examples, API Javadoc, developer guides, agent simulators and much more, please download the DynamicTMN® CMIP Suite evaluation package.

Download DynamicTMN® CMIP Suite Evaluation

The DynamicTMN® Java GDMO Agent API implements a portion of the components from the following standards in addition to the standards implemented by the underlying APIs it utilizes:

• ITU-T X.701: Systems Management Overview
• ITU-T X.710: Common Management Information Serivce (CMIS)
• ITU-T X.711: Common Management Information Protocol (CMIP)
• ITU-T X.720: Structure of Management Information (SMI)
• ITU-T X.721: Definition of Management Information (DMI)
• ITU-T X.722: Guidelines for the Definition of Managed Objects (GDMO)
• ITU-T X.723: Generic Management Function
• ITU-T X.725: General Relationship Model
• ITU-T X.730: Object Management Function
• ITU-T X.731: State Management Function
• ITU-T X.732: Attributes for Representing Relationships
• ITU-T X.733: Alarm Reporting Function
• ITU-T X.734: Event Report Management Function
• TMF 042: TMForum GDMO API
• RFC1006: OSI over TCPIP (CMIP/OSI over TCP/IP)

Note: These standards provide components implemented directly by the DynamicTMN® GDMO Agent API. The API will also support ANY technology specific standard (SONET,Trouble Admin, etc) or vendor proprietary GDMO and ASN.1 through the use of the ASN.1 and GDMO Compiler.

The DynamicTMN® Java GDMO Agent API uses the following DynamicTMN® Java APIs:

• CMIS Messaging API
• ASN.1 API
• ASN.1 & GDMO Metadata API

And is included in the following DynamicTMN® products:

• DynamicTMN® CMIP Agent SDK
• DynamicTMN® CMIP eBonding/TA SDK
• DynamicTMN® CMIP NPAC/LNP SDK
• DynamicTMN® CMIP Web Services/XML SDK