Component Based TMN Architecture

Jim. Agnello, Raymond Raud

August, 1997

Introduction

Network management systems are known to be custom software development projects with significant budget and human resources throughout their life-cycle. The Network management systems support network operator processes that, in turn are designed from the existing network architecture and operation infrastructure of the organization.

Fast evolution of communication and computing fields and their apparent merger calls for fast and inexpensive development of network management solutions. With wider acceptance of ITU-T Telecommunication Management Network (TMN) standards the operation processes and infrastructure of service providers and end users becomes standardized. That, enables the use of new operation support systems integrated from off-the-shelf management components. The components themselves must provide standard functionality and support standard interfaces for simple construction. The combination of components for a solution is unique and custom for the used technology, services and operation processes.

The possibility to use off-the-shelf components opens the door to more economical solutions, but it also presents software architecture challenges to ensure flexibility, dependability, interoperability, programmability, and scaleability of solutions. While dependability can be provided largely through techniques like proper management of network objects, hardware platform and resource availability, interoperability can be ensured by strict adherence to the TMN interface standards, scaleability can be implemented through distributed, layered architecture. Programmability and flexibility remain the challenges. A component architecture that addresses this issue is discussed below.

The Components

ITU-T TMN standard defines hierarchical, layered NMS architecture. The TMN architecture consists of Agents that implement the server functions, Managers that implement the client functions and a communication mechanism for selective data exchange. These basic building blocks lend themselves into recursive application for data aggregation and abstraction through the hierarchy of all layers for a total management solution. Three types of components are required in the architecture: Management Components to build layer servers, Solution Components to embed management applications and user interfaces and Mediation Components to interface to network data sources of various protocols.

ITU-T TMN standard provides Open Systems Interconnection (OSI) specifications for communications interfaces between management layers. The recursive TMN architecture, is much more general in nature. It can be applied for decomposition inside a management layer as well. The choice of interface protocols for these interfaces remains open. It must be selected by specific requirements to the overall solution. If different from CMIP/OSI, the corresponding architecture elements must provide equivalent functionality. For example, TMN manager functionality in CORBA is available through the ORB and the client stub, TMN agent functions are implemented through the ORB, skeleton and CORBA Services. CORBA offers significantly lighter protocol than OSI and extensive functionality for programmatic interfaces of applications developed in heterogeneous environments. Despite all CORBA advantages the only international standard interface is still OSI.

Management Component
Each layer provides its view of managed network objects based on the data abstracted and aggregated from the layer below. To access the lower layer data appropriate Manager functions must be incorporated. Agent function serves the layer’s view for management solutions and higher layer management systems. In between the Manager and Agent reside the data abstraction, aggregation, mediation algorithms.
The Agent and the Manager of a layer implement the layers interface and must strictly adhere to the standards to ensure interoperability of layers. We assume, that the communication interface defines not only the communication setup and protocol, but also the semantics of data elements passed through the interface. In the case of OSI that would be the standard Information Models in GDMO/ASN.1, for CORBA interface definitions in IDL.

The abstraction, data aggregation and mediation algorithms represent the behavior of managed objects exposed by the component. Here lies the standard and solution specific component behavior. It must be initially configured (standard), but accessible, for programmability and flexibility of the total solution.

Mediation Component
The real world is not ideal. In parallel with some network elements providing ITU standard Q3 interfaces there are numerous other management protocols in use. TL/1 is a traditional telecommunication language while a growing number of SNMP managed network elements are being deployed in the access to the network. CORBA is gaining support due to concise object-oriented architecture, lightweight protocol and a choice of inexpensive development tools.

A Management Component that implements the TMN Agent functionality for the TL/1 managed device will have a syntax driven TL/1 message parser/composer interfacing the network element. A TMN Agent with fit equipment model implements the standard managed objects for the rest of the management system. A data mediation algorithm ties these two elements. For SNMP mediation instead of the TL/1 parser/composer an SNMP protocol stack is used. In both cases the general Management Component architecture and functions of its elements remain the same ensuring programmable flexible total solution.

Note, that the TMN Agent element may provide a Q3 interface or implement an equivalent set of CORBA objects instead.

Solution Component
At each TMN layer the operator, telecommunication technician, accesses the network object view appropriate for the functions of the layer. Network object’s view, specific to the management layer is represented at the user’s screen by User Objects. Each User Object reflects certain characteristics of one or many network objects to support the operation processes. The management application consisting of Manager(s), data aggregation, mapping and mediation algorithms, User Object Server and user interface provides a solution to a specific management need – Solution Component.

The component receives the network data from the Agents through the Manager functions. It applies appropriate data aggregation and mediation algorithms to map this data into User Objects. Since many technicians may be working with the same management application, the same User Objects must be served to many work station’s user interface simultaneously – a User Object Agent function. Other communication protocols, like Corba or RMI are more appropriate between this Agent and the user interface than CMIP.

Building Network Management Systems from Components

Recursive application of Management Components that consist of Manager Agent pairs with data abstraction, aggregation and mediation used to tie together standards compliant elements flexibly allows to build full featured management information data flow. Note, that many Management Components may be used in parallel to achieve full functionality of a TMN layer. A layer may also be implemented with an hierarchy of Management Components. Redundant Management Components with matching functionality

will provide increased dependability of total solution. Interoperability of the Management Components and Solution Components are ensured by the use of International standard interfaces and communication protocols.

The Solution Components, tapping into the data flow at appropriate layer will provide the management solutions for the user. Solution Component’s interface to the TMN data flow is standard, thus ensuring interoperability. Many Solution Components implementing different applications may be subscribing to the same layer’s Agents.

Each of these components can be pre-built by the standards for specific technology, management layer and application. Combining different off-the-shelf components the user can build a total solution to the specific management needs. The flexibility and programmability of the solution is ensured by opening the data abstraction, aggregation and mediation algorithms for modification.

Building Components

Being fully standards driven, generating corresponding C++ code and packaging the Manager and Agent elements for a off-the-shelf Management or Solution Component is obvious. The actual behavior of managed objects defined in standards in form of free text can be implemented only after the data source for these objects is known. Using a Manager with known information model (TL/1 parser/composer or SNMP stack) for the data source for the Agent’s network objects enables standard behavior implementation. Opening the managed object behavior for modification by the user adds programmability and flexibility to the component architecture. The user is typically a telecommunications expert, but not a programmer.

The user must have tools and interface matching his skills for that task. C++ code development is rarely listed among the skills. Subject matter experts (SME) in variety of fields (including telecommunications) have long used declarative style (for example, rules) languages to insert their knowledge into support systems. Implementing standard managed object behavior in rules and providing a convenient rules based interface for the user to modify the object behavior makes the flexibility and programmability of the components based architecture real.

The behavior, defined in rules, is naturally embedded into the managed objects. Since the objects are small, their behavior is expressed in small number of rules. That eliminates the main deficiency of the monolithic rule based solutions – complex and numerous rules that require extensive testing, maintenance and rule administration.