DynamicTMN® GDMO Agent API

IEC61850/MMS OSI TL1 CMIP SNMP Agent Manager Simulator

Overview | Classes | Examples | Standards | Related

The 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.

GDMO Agent API Overview

The 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 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

GDMO Agent API Classes

The 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.

GDMO Agent API Code Generator

The 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.

Supported Standards

The 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 Service (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 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.

Related DynamicTMN® Components

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