Home > Articles > Networking > Network Administration & Management

  • Print
  • + Share This
This chapter is from the book

Elements of NMS Development

Development of NMS software is interesting and challenging. This section introduces some of the typical development areas and some important issues that often arise.

NMS Development

A typical scenario for a management system developer is the following:

  • Using a browser-based GUI, the developer has provisioned onto the network a managed object such as an ATM virtual circuit or an MPLS LSP.

  • The developer wants to check that the software executed the correct actions.

  • During provisioning, the developer verifies that the correct Java code executed using a Java console and trace files (similar actions can be done for C/C++ systems).

  • The database is updated by the management system code, and this can be checked by running an appropriate SQL script.

  • The next step is verifying that the correct set of managed objects was written to the NE. To do this, the developer uses a MIB browser to check that the row object has been written to the associated agent MIB.

Clearly, this type of development requires a broad range of skills. Other skills not mentioned include:

  • Data analysis—matching NE data to the NMS database schema

  • Data analysis—defining NMS-resident objects that exist in complex component form in the network (an example is a VPN, as discussed earlier in this chapter)

  • Upgrade considerations for when MIBs change (as they regularly do)

  • UML, Java, and object-oriented development

  • Class design for major NMS features, like MPLS provisioning

  • GUI development

  • Middleware using CORBA-based products

  • Insulating applications from low-level code

These are now described in more detail.

Data Analysis

MIBs are crucial components in a management system. Many vendors provide the MIB modules for their NEs in the form of a number of text files. These files can then be incorporated into an NMS and also used in conjunction with MIB browsers. MIBs contain the managed object definitions of interest and are used to derive part of the database schema for the NMS. This latter is the structure and definition of the data used as the basis of the NMS. We assume the use of relational database technology in this book, and the model for this consists of tables. Typically, the NMS database schema contains a great many tables; for instance, there might be a table for storing the details of LSPs, another for PVCs, and so on. The schema represents an overall data definition for the NMS, and the managed object data is also defined here. This latter point means that there is a degree of duplication in that the NMS has a schema and the MIB objects of interest are contained in it as well as in the agent MIBs. This is what was meant earlier in the chapter when we mentioned storing the same data in two different places. The NMS tracks and modifies the values of NE-managed object instances and stores these in its own database.

While the MIBs can be used to form the basis of the management system information model, there are additional elements needed in the NMS database schema. These are default values, or the values used when the database is first built. Examples are –1 for integers and NULL for booleans (i.e., neither true nor false). Later, we will see the need for sensible default values, particularly for MIB objects that can be modified by the NMS.

The database product can be any of the excellent, general-purpose engines available, such as Informix and Oracle.

When MIBs Change: Upgrade Considerations

Supporting different MIB versions is a recurring network management problem. Let's assume that a given network has 20 of the same ATM/MPLS switch model all running firmware revision 3.2. Now, the network operator decides to upgrade five of the switches to firmware revision 4.0 (in order to gain access to some new feature). Upgrading software like this can be expensive if it results in any downtime due to software bugs. The cost can also be increased if extra hardware is needed, such as a processor upgrade, more RAM or flash memory, or extra line cards.

The NMS can provide assistance during upgrades by downloading the new image to the selected switches (and backing up the old image). However, the new features added to the switches means that they now support extended and possibly also new MIB modules. The NMS must continue to be able to interact with the devices not upgraded, so it must be able to recognize both the new and the old MIBs. Following are guidelines for providing an upgrade path following MIB changes:

  • Deprecate old objects no longer in use—don't delete them from the MIB if at all possible.

  • Keep the MIB object identifiers sequential; add new OIDs as necessary. It is not uncommon for new columns to be added to MIB tables as NEs are enhanced. The old objects should not be modified during any such enhancements in order to maintain backward compatibility.

  • Don't change any existing OIDs in MIBs that are currently in use by the NMS. RFC 2578 provides guidelines for this.

  • Ensure that MIB files do not have to be changed in order to work with management systems. Sometimes MIBs that successfully compile into agents cannot be parsed into management systems. This can be caused by limitations on the part of the management system or the agent parser. Whatever the reason, it is important that no manual changes are needed in order to incorporate MIBs into an NMS. This underlines the crucial role played by MIBs.

Following these guidelines helps provide a seamless upgrade path for the addition of new MIB objects while at the same time maintaining support for existing ones. MIB objects should only ever be removed with the utmost caution because there may be management system software that relies on their presence. Non-existent MIB objects that are accessed by an NMS will result in an SNMP exception propagating back to the NMS.

Adding new technologies to NEs is a major cause of significant MIB changes. This causes additional problems for the management system because (as we've seen) it derives its managed object model from the MIBs. New MIB objects that are needed in the database require corresponding schema changes. These can be effected using either SQL scripts or special-purpose code. Changing the management system schema is not without risk. Existing application code is affected, and it can easily introduce bugs. The skills required to match MIB changes to schema updates are very important.

UML, Java, and Object-Oriented Development

The use of standards is a recurring theme throughout the networking industry. It is essential for management system developers to adopt a standards-based approach in their work. To this end, we can use linked overviews in conjunction with documents like IETF RFCs and ETSI/ANSI standards. UML [UMLRumbaugh] provides a standard technique for system development. It provides some very useful tools for both specification and development.

UML allows for the development process to be opened up to a degree that is difficult to match with older methods such as the waterfall model. It allows for the separation of requirements from specification and design decisions by the provision of different views including:

  • Structured classification (use cases, classes, components, and nodes)

  • Dynamic behavior (describes system changes over time)

  • Model management (organization of the model itself)

In effect, UML provides a model-based scheme of development. The model and its associated views then become part of the finished software.

Domain experts and other stakeholders can assist the development by defining the principal actors (either internal system users or end users) in the management system. Use cases provide a means for defining the ways in which the actors interact with the system. Sequence diagrams describe message exchanges that go together to make up transactions. The different views fit well into a solution-engineering context because they naturally allow for several different perspectives. These and the other features of UML can greatly assist the construction of robust management systems. Products like Rational Rose are excellent for this purpose [RationalRose].

Class Design for Major NMS Features

Class design can be initiated from UML use cases. Using tools like Rational Rose helps to facilitate automation of this process. Normally, generated classes are merely skeletons with no code included. However, even this is useful, because once the main classes are defined, the programming task is bounded. The great merit of UML is that the stakeholders can influence the class structure. This departs from the older approach in which stakeholders just specify requirements.

GUI Development

An important aspect of management system development is the GUI. This is particularly so when the client is thin. A well-designed GUI reduces the need for training and provides an effective tool for managing networks. It provides the user interface and should be as generic as possible. To this end, visual controls should be as technology-independent as possible, for example, using the words like connection instead of PVC or LSP/tunnel, or routes instead of ATM designated transit list or MPLS Explicit Route Object (we describe these last two objects later in the chapter—for the moment, let's take them as simple paths through a network). The visual controls should also hide as much complexity as possible and provide sensible default values that the user can override if required.

There are many excellent tools, such as Borland JBuilder, available for crafting GUIs. Often, the GUI is the last item of a management system to be fully tested. So, the individual GUI components should be fully tested using tools like JBuilder well in advance of full integration. Developers' problem-solving skills should be focused on fully exercising as much GUI code as possible to reduce delays in delivery.

Middleware Using CORBA-Based Products

CORBA is a suite of specifications issued by the Object Management Group [OMGWeb]. Using the Internet Inter-Orb Protocol (IIOP), a CORBA-based program from any vendor can interoperate with another vendor's CORBA-based program. This works for almost any combination of platforms, programming languages, and networks. CORBA applications are made up of objects that present an interface. This interface is part of the contract that a server object offers to the clients that invoke it. The interface is defined in the OMG Interface Definition Language (IDL) and is completely separate from the underlying implementation. So, application A written on PC X can call the exported methods of classes in application B on UNIX workstation Y located in a remote network. CORBA provides the glue needed to join many different code components together into what looks like a single system.

The distributed nature of network management provides a good setting for the use of CORBA-based software. One example is SNMP notification/trap management. When the management system receives a trap from the network, it can store the details in a database and then notify another application such as a GUI client. This notification can take the form of invoking an object in a CORBA application implemented on the client machine. This can also be achieved using technologies such as Java Remote Method Invocation (RMI), RPC, or COM, but CORBA provides what is almost complete independence from the underlying systems and networks. This is an extremely powerful capability.

Insulating Applications from Low-Level Code

Insulating applications from low-level code was briefly described earlier and illustrated in Figure 3-4. It is very important that the various layers of management system software be as technology-independent as possible. This is similar in concept to the way in which network architectures are layered. Each layer is implemented independently. Only the services offered to upper layers are exposed [Tanenbaum1996]. The implementation is encapsulated inside the layer. In a similar fashion, low-level code that provides access to technology such as SNMP, MIBs, IP, and User Datagram Protocol (UDP) should be partitioned as much as possible. Only a simple interface should be exposed to the layer above. This also aids comprehension by other developers. We will see this technique in the MPLS case study in Chapter 8.

  • + Share This
  • 🔖 Save To Your Account