1

1

CORBA Navigator, A Versatile CORBA Client and its

application to Network Management

KAWABATA, Taichi YATA, Kouji IWASHITA, Katsushi

NTT Network Innovation Laboratories{kawabata.taichi, iwashita.katsushi, yata.kouji}@lab.ntt.co.jp

APNOMS 2003

Abstract We have developed the versatile CORBA client that we call CORBA Navigator. CORBA Navigator can instantly access any CORBA server, and its access (operation) order can be specified by a UML diagram. CORBA (Common Object Request Broker) is being widely used in a variety of fields. It is playing an important role in telecommunication management. The international standards for telecommunication management used to be based upon CMIP (Common Management Information Protocol). However, CORBA-based telecommunication management standards are now emerging. Unfortunately, CORBA is still too complex. For the network carrier companies to adopt an CORBA-based EMS (Element Management System), it is important to have the tools that provide easy access to the CORBA-based EMS. Existing client systems are EMS specific and so are rather inflexible. In this paper, we describe the features of CORBA Navigator, show what prevents the realization of versatile CORBA client, and how we solved these problems. We also show how we applied the CORBA Navigator to the new telecommunication management standard for B-PON (Broadband Passive Optical Network), which adopts CORBA and UML.

2

2

Introduction

For efficient testing and development of CORBA network management system, CORBA client software that can dynamically access any interface of any CORBA server based on UML scenario is demanded, so that non-programmers can test the CORBA EMS with ease.

For efficient testing and development of CORBA network management system, CORBA client software that can dynamically access any interface of any CORBA server based on UML scenario is demanded, so that non-programmers can test the CORBA EMS with ease.

CORBA and UML will play more important roles in Network Management, especially for interconnecting NMS (Network Management System) and EMS

(Element Management System)

CORBA and UML will play more important roles in Network Management, especially for interconnecting NMS (Network Management System) and EMS

(Element Management System)

CORBA as Network Management StandardCORBA as Network Management StandardCORBA as Network Management Standard

• From CMIP to CORBA• CORBA is less expensive.• Various object technologies can be easily adopted.

• CORBA is open standard and is non-proprietary• It has a long history and is applied to various fields.• It has been adopted in Q834.4 (B-PON) NMS standards, and some other network management protocols.

Network ManagementAnd UML

Network ManagementNetwork ManagementAnd UMLAnd UML

• UML has been accepted as International Standard （ISO/ITU-T）

• It is based on object oriented system.• It has been adopted in Q834.3 (B-PON) standard to describe the process and behavior of Network Management System.

1.IntroductionToday, CORBA (Common ORB Architecture) [1] is starting to play more an important role in the Network Management field. As such, it is pushing aside CMIP [2] and ASN.1, the conventional approach to network management. CMIP was specifically designed for network management but its narrow target range makes it unpopular and expensive. CORBA, on the other hand, is a flexible and popular general purpose communication protocol. It is an open standard developed by Object Management Group (OMG), and is non-proprietary. CORBA also has a very long history, and has been applied to various fields, including finance, manufacturing, and transportation. Recently, more people are switching from CMIP to CORBA for network management, because of its popularity and cost-effectiveness. As a result, the recent trend on network management is to adopt CORBA. A typical example is Q834.4[3], the network management protocol for B-PON (Broadband Passive Optical Network). It is now expected that there will not be any CMIP-based protocol for B-PON management. In another new trend, UML[4], the Unified Modeling Language, is being adopted to describe the behavior of various systems. It is a modeling language that can describe the behavior of a system by using modeling diagrams, developed by OMG and accepted as an international standard by both ISO and ITU. A UML-based B-PON Network Management standard has been developed by OMG; it is called Q834.3 [5]. In short, both CORBA and UML, developed and maintained by OMG and adopted by international standardization bodies, will play important roles in network management. In Q834.4, NMS (Network Management System) and EMS (Element Management System) use CORBA as their communication protocol. It is expected that other network management systems will also use CORBA in this layer. Existing CORBA servers can usually be accessed only by special-purpose client programs. This means that it is difficult for non-programmers to develop or test CORBA-based EMS. To efficiently develop and test CORBA network management systems, we need CORBA client software that can dynamically access any interface of any CORBA server based on UML scenarios. This would allow non-programmers to test any CORBA EMS with ease and would lead to the wider acceptance of CORBA in the network management field.

3

3

CORBA Navigator

• Versatile User Interface which can handle any IDL type, including `struct’, `sequence’, `any’, `array’and `union’. It also properly handles all exception types.

• It reads local IDL files, so no Interface Repository is needed to access CORBA Object.

• The user can choose the data type, and can input any value, for the argument of operation in user-friendly way.

• Multiple Operations can be executed in sequence. The order of operations can be specified by the UML diagram.

Sample Screenshot of CORBA Navigator

We have developed CORBA Navigator which can instantly access anyCORBA server and can use UML diagram to specify scenario-based

access. It allows non-programmer to test any CORBA server.

2. The Characteristics of CORBA NavigatorWe have proposed and developed the CORBA Navigator, which can access any CORBA server given the IDL (Interface Definition Language) files that describe the access interface of the CORBA server. CORBA Navigator dynamically creates a table-like user interface for the operations specified in the IDL files. It supports virtually all IDL types, including primitives, `struct', `sequence', `array', `any' `union' and any combination of them. After the user inputs the values for operation, CORBA Navigator executes the operation on the CORBA objects, and the operation results are also displayed in a structured manner. The results can also be used in the arguments of other operations by copying or dragging the values to the corresponding GUI. CORBA Navigator can also handle all exceptions properly as they occur.CORBA Navigator reads local IDL files, so there is no need to prepare an interface repository server to access the CORBA object. The user can choose the data type, and can input any value as the argument of an operation in user-friendly way. The user's choice of data types and the values set can be saved to an external file for later retrieval, together with the result of the operation (if it is executed). CORBA Navigator can execute multiple operations on multiple objects in a sequential manner, where the order can be specified by the UML diagram. This means that the CORBA Navigator user can use the UML tool to design scenarios, such as the order of test operations.

4

4

The Purpose of CORBA Navigator• CORBA Navigator can free the developer and tester of network

management system from the burden of programming CORBA client.

InterfaceSpecification

(IDL)

OperationProcedure

(UML)

Programming Steps

Access to CORBA Agent

Implementation of ORB

Operations

Implementation of User

Interface

Reading UML Specs.

Access toCORBA Agent

CORBA Navigator omits these programmer-related steps, so non-

programmer can access CORBA agents.

�CORBA Navigator

• The Variety of CORBA Types must be properly supported.• Dynamically identified objects must be appropriately named for

the users.

problems

Compilation of UML

ORB ��� Object Request Broker※

�　Traditional Way to access CORBA Agent

3. The Purpose of CORBA NavigatorThe main purpose of CORBA Navigator is to free to the developer and tester of the network management system from the burden of programming a CORBA client. CORBA Navigator is a versatile CORBA client that can access any CORBA server without demanding any knowledge about CORBA programming. The traditional approach to accessing a CORBA server is to create client software using a series of complicated steps. For example, IDL files had to be compiled to create the stub files. Then, the user would have to read the scenario to determine the operation order, and then create a client program which implemented the stub files accordingly. A key problem was the need to design the user interface. This is a difficult task since the argument types specified in the IDL file are usually structurally complex. CORBA Navigator lifts from the CORBA equipment developer and user to need to acquire programmer-like skills. To achieve these goals, we had to solve two major problems. The first problem was how to show the user the CORBA types which can be quite complex. Second was how to identify the anonymous objects that can be "discovered" by the client by chance. Also, the sequence of operations should be specified in a non-program-like manner for ease of use. The following material will show how we solved these problems.

5

5

module Sample19 {interface Calc;struct BBB {

unsigned long age;string name;

};

union DDuni switch(short) {case 1:

string value1;case 2:

BBB value2;case 3:

Eseq value3;};

typedef sequence<long> Eseq;

typedef DDuni Type1[2][5];

typedef DDuni MyDDuni;

typedef any MyAny;interface Calc {

DDuni method1(in DDuni a, out DDuni b, inout DDuni c);Type1 method2(in Type1 a, out Type1 b, inout Type1 c);

};};

Customizable User Interface for Operations

Type and Tag names are automatically displayed, so

the user does not need to refer to the IDL file.

struct

union（choice）

sequence

arrays

Problem：　CORBA Data type may contain complex data types which make setting operation arguments difficult.Providing ALL possible arguments on screen may actually make the operation impossible.

Data Structures are described in table-form, where data-type

choices dynamically reflect the user-input field.

any

IDL File

4. Features of CORBA Navigator4.1. Customizable User Interface for OperationsThis slide shows a typical example of how the CORBA Navigator's GUI handles complex CORBA IDL types. CORBA Navigator adopts a `table-like' GUI that expands the complex IDL types to the simpler ones moving from the leftmost column to the right. For each row, the rightmost column is where you actually enter the primitive types. The middle of the table shows the structure of data type constructed from the CORBA type definition described in the IDL file. CORBA's non-primitive types include `struct', `union', `sequence', `arrays' and `any'. Among them, `struct' and `arrays' consist of multiple CORBA types, while `union' consists of one of the multiple candidate types tagged with case name. Here, our main goal is to make the user able to input any CORBA type specified as the arguments of the operations specified in the IDL files. There are two aspects to input values of CORBA type. First one is to choose, or rather, `design', which or how many data types the user want to input. For example, `union' type lets the user choose which CORBA type to be input. `sequence' type lets the user choose how many data of specific CORBA type are to be input. Second one is to input the actual values into the table, which has been “designed”by the user. The values can be directly input, or copied from other GUI panels, or linked to the other GUI panesl.These choices and the values inputs can be saved as an external file for later retrieval.

6

6

Naming Rules for each Interface

Object Naming System in CORBA Navigator

No Name (IOR)Interface-E

Name by handInterface-D

log_dateName from attribute

Interface-C

get_name()

Name from operation result

Interface-B

NumberingInterface-A

….

Abc/def/XYZ

Interface-C~030503Interface-C~030502Interface-B~KeithInterface-B~BobInterface-A~3Interface-A~2Interface-A~1

Object from Naming Service / URL

Object Name Directory

corbaloc: ….. /abc/def/XYZ

For CORBA Objects which are not registered in Naming Service, CORBA Navigator provides a simple Object Naming system. It uses attributes and interfaces of the object to name the object.

4.2. Object Naming System in CORBA Navigator Besides structured data types and primitives, CORBA IDL allows CORBA `objects' to be specified as the arguments of CORBA operations. Therefore, we must provide a way for the user to distinguish and specify the CORBA objects. Usually, CORBA Naming Service provides the function of assigning names to CORBA objects. However, usually only distinguished server-role CORBA objects have their own names. CORBA Navigator provides a simple object naming system that uses with simple rules to name objects; for example, from the attributes of objects. This allows even anonymous CORBA objects to be recognized, via its characteristics, and handled. Naming rules for CORBA objects can be assigned to the interface of Objects. CORBA Navigator provides four methods for naming anonymous CORBA objects. If no method is specified, anonymous CORBA objects are not named at all. The first method is to manually name each new CORBA object as it is recognized by CORBA Navigator. When the user chooses this option, a dialog box appears whenever the operation is finished and a new object with the interface specified in naming rules is recognized. The second method is to name an object using its attribute value. When this option is selected, when a new CORBA object is recognized, a name is generated from its specified attribute and its interface name. The user also has to specify which attribute should be used for naming. The third method is to name an object from its specified operation result. When this option is selected, the user has to specify which operation and which part of the result should be used as the name of the object. When a new object to that interface is recognized, CORBA Navigator executes the specified operation and the its result are used to generate the name. The fourth method is to name the object from recognition order. In short, the name is a number. This method is useful when there is no specific reason for naming an object in a particular way, but the user still wants to name it to simplify later operations.

7

7

Specifying the Order of Operation by UML Diagram

Problem: UML requires the objects in the sequence diagram to have their own name, but CORBA objects

usually don’t have names unless they are explicitly registered in the Naming Service. When the name of the newly recognized object

matches the name specified in the UML diagram, they are `enabled’ for operation.As described before, CORBA Navigator can name the

objects. UML software can assume these names when drawing the sequence diagram.

Assumed object name is put in

UML.

Design-Time Execution-Time

CORBA Navigator provides the plug-in software for UML tool. It enables the user to design the operation scenario with UML tools and can export the scenario file to CORBA Navigator.

4.3. Specifying the Order of Operation by UML Diagram CORBA Navigator provides software plug-ins for the UML tool. It enables the user to design an operation scenario using the tool and export the resulting scenario file to CORBA Navigator. For now, CORBA Navigator provides a plug-in for "Together ControlCenter"[6], the UML tool that fully supports CORBA IDL. This plug-in simply reads the sequence diagram of the specified actor, andoutputs a scenario file that can be read by CORBA Navigator. When CORBA Navigator reads this file, it creates multiple GUI panels for each operation as ordered by the scenario. When an operation is specified in a UML sequence diagram, the target object of the operation must be specified, usually with the name of the object. However, the target object sometimes has no name. In this case, the user can specify a tentative name in the design phase. Upon design completion, CORBA Navigator reads the scenario file with these tentative names, and when a newly recognized object is named and its name matches the tentative name specified in the UML, the operation with that object is then "activated". This feature is intuitive and requires no programming skill, enabling common users to handle CORBA servers.

8

8

Structure of CORBA NavigatorInterfaceDefinition

File

InterfaceDefinition

File

Compilation ofIDL File

Stub InterfaceClasses

Stub InterfaceClasses

Client-side ORBClient-side ORB

Server Side

This part depends uponthe CORBA Implementation

CORBA NavigatorCORBA Navigator

Object NameManagement

Object NameManagement

IDL InformationIDL Information

GUIGUI

Reflection

PreparingScenario UML

ObjectRetrievalObject

Retrieval

GUIFactoryGUI

Factory

Naming Service /IOR File

Object NameFile

ParametersFile

External Flow

Internal Flow

IOR ���　Interoperable Object Reference

※

5. Structure of CORBA Navigator First of all, IDL files for the target CORBA objects are needed. Also, CORBA Navigator requires the stub files compiled from IDL files using the user's preferred CORBA software. CORBA Navigator assumes that the stub files conform to the Java Mapping Specification of CORBA, and that they permit access to the CORBA server by the “Java reflection” feature. This dispenses with the interface repository. The user, if desired, can prepare the scenario files (not mandatory). Scenario files are usually generated by the UML tool (which reads the IDL files), but the user can also write them on his own. When a scenario file is given to CORBA navigator, it creates multiple GUI panels for each operation in the order specified in the scenario file. The user interface for the specific operation is created ("GUI Factory" in the diagram) from the IDL file information, and, optionally, the scenario file. On the other hand, the CORBA object for the operation is obtained from CORBA Naming Service (by specifying the server location and name), or from the URL (location of IOR file, etc.). The object reference is then named and stored in the “Object Name Management” section. The user of CORBA Navigator specifies the object and then its operation, which connects the GUI for a specific operation to the object to be operated. When operation is executed, the result is returned. If the return value contains a new CORBA object, it is registered with its new name in the "Object Name Management" section. The name is generated according to the naming rule specified by the user. If not specified, the objects are anonymous and can only be referenced by the IOR. Object names, the operation parameter values specified in the GUI and the returned result values, can all be stored in an external file in XML format. Therefore, it is easy to automatically extract the values from the file, or modify the file entries for later re-use, by using XML tools or text editors.

9

9

Implementation of CORBA Navigator

• Implementation by Java– Uses Java Mapping Specification for CORBA– No Interface Repository needed.

Java-Capable PlatformsIncluding Windows 2000 or XP, Linux

JDK 1.4.1

OS

OpenORBApacheLog4J

ORBVisiBroker, OpenORB,

Java ORB, etc

CORBAserver

IDLFile

CORBA NavigatorCombinedControlCenter

6. Implementation of CORBA Navigator. CORBA Navigator is fully written in Java. Therefore, it can run on any Java platform that runs JDK 1.4.1, including Windows, Solaris, and Linux. Access to a CORBA server is done according to the Java Mapping Specification for CORBA, thus any use desired ORB can be used. CORBA Navigator use some free software such as Apache Log4J and OpenORB (for parsing IDL files), making development low cost and reliable. The Together ControlCenter, the UML tool, is also fully written in Java, making it multi-platform. Also, its expandability makes it easy to develop the plug-in software.

10

10

CORBA Navigator and B-PON Management System

NMS CORBANavigator

EMS

B-PONSystem

Operation Scenario created by UML

(based on Q834.3)

Q834.4 Interface

Q834.4IDL Files

EMS of Various vendors

CORBA Navigator has been applied for conformance tests of B-PON NMS.

How CORBA Navigator helps the development of B-PON NMS.

� CORBA Navigator enables the sequence of multiple CORBA operations specified by the UML, enabling complex server tests without programming experience.• By using CORBA Navigator with prepared client, we get double assurance of EMS conformance. Also, it is useful to spot the cause of problem when NMS behaves in an unusual manner.�　CORBA Navigator is particularly useful when IDL is frequently changed, as it can immediately access the CORBA server even if IDL is changed.

What is Q834?Q834 is a telecommunication management standard that adopts UML and CORBA as its underlying network management protocol. Q834 consists of 4 parts, whose 3rd part is the behavior of management system; the 4th part is about CORBA protocol.

7. CORBA Navigator and B-PON Management System CORBA Navigator has been applied to the development and test of Q834.4, which specifies the management interface and protocol between NMS (Network Management System) and EMS (Element Management System) for B-PON (Broadband Passive Optical Network). The B-PON management specification, which has the ITU-T specification number of Q834, has four parts. The third part, Q834.3, uses the UML sequence diagram to specify the behavior of the B-PON network management protocol. The fourth part, Q834.4, specifies the CORBA interface for the B-PON management system. When CORBA Navigator was developed, Q834.4 had not been fully formalized. Therefore, at the request of the FSAN (Full Service Access Network) group that is responsible for the development of Q834, we verified a specific part (Profile Management) of the Q834.4 draft standard using the prototype B-PON EMS system[7]. CORBA Navigator offers three significant benefits in the development process of B-PON EMS. First, a B-PON EMS tester can design various testing scenarios with the UML tools and can easily execute the tests using CORBA Navigator. Even though multiple operations are involved, no programming is required, making the tests possible by non-programmers. Second, CORBA Navigator is a versatile form of CORBA client software, which means that it can immediately check any CORBA server. A prototype EMS usually requires a special CORBA client designed for testing, but it is provided by the vendor and inflexible. By using CORBA Navigator with EMS equipped clients, we can make doubly sure of EMS validity. Third, CORBA Navigator is particularly useful when IDL is frequently changed, as it can immediately access the new CORBA server even if its IDL specification is changed, without re-writing of the client software. This significantly reduces the IDL development time.

11

11

Conclusion• We have proposed, and developed, the versatile

CORBA client called CORBA Navigator, which can instantly access any CORBA server.– CORBA is, and will be, widely used for network management.– Existing CORBA server requires CORBA client user to have

programming experience, which hinders the spread of CORBA standard.

• CORBA Navigator provides a versatile, programming-less environment to CORBA IDL developers and testers.

• To enable ideal CORBA usability, several problems must be solved.

• We applied CORBA Navigator to B-PON Network Management System and verified its effectiveness.

8. Conclusion. Today, there exist various protocols for computer communication, including web service, DCOM, RMI, and CORBA. However, among them, only CORBA is open-standard, non-proprietary, and scalable. As a result, CORBA is widely used today and it will become dominant in the future. CORBA is, however, a large and complex standard. To access a CORBA server, one must compile an IDL file, prepare the client software that will use the stub files, and create the user interface. In short, it takes several complicated steps to access the CORBA server. CORBA Navigator offers immediate access to any CORBA server. It requires only the IDL files and an object reference for the server. It removes the burden of programming skill from the CORBA client, making access to a CORBA server as simple as web browser access to an HTTP server. Moreover, a UML sequence diagram can be used to specify the execution order of multiple operations in CORBA Navigator. This makes CORBA access scenarios easy to create. To make such versatility possible, we had to solve two problems. The first was how to handle the complex IDL data types while maintaining usability. The second was how to show anonymous CORBA objects to the user. CORBA Navigator has been applied to the development of the Q834.4 standard itself and the EMS based on Q834.4. We verified its usability, and are planning to refine the software by integrating the feedback obtained from Q834.4 tests. References [1]: Object Management Group, "The Common Object Request Broker: Architecture and Specification", Revision 2.3, June 1999 [2]: Common Management Information Protocol, ISO/IEC 9596-1:1991. [3]: ITU-T Recommendation Draft Q834.4, A CORBA Interface Specification for Broadband Passive Optical Networks Based on UML Interface Requirements, 2003. [4]: Object Management Group, "Unified Modeling Language Specification", 2002. [5]: ITU-T Recommendation Q834.3, A UML Description for Interface Requirements for Broadband Passive Optical Networks, 2001. [6]: TogetherSoftware, Together ControlCenter version 6.0 [7]: TERAUCHI Hironori and et. al, Mounting and Evaluation of Standard CORBA Network Control Interface to EMS for BPON, Technical Report of IEICE TM2002-92