JP2000066980A - Different kind protocol correspondence communication network management system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To use the same component for the operation of various management protocols by allowing a component to transmit an accessor together with data structure (protocol data unit: PDU) and allowing a component processing the PDU to access the PDU through the accessor. SOLUTION: A communication component transfers a PDU with a unique accessor attached other than the PDU. An event object to be transferred includes the accessor other than the PDU. An analytical and setting component of the PDU accesses a PDU through the accessor. Further, the communication component needing a response PDU transmits an answer receptor as well as a request PDU and a component returning the response PDU to the communication component returns a response to the communication component through the answer receptor.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to communication network management, and more particularly to a communication network management system for maintaining and controlling the operation of a communication network.

[0002]

2. Description of the Related Art The technology of the present invention relates to a software component for operating a protocol used for communication with another information system when implementing a component-oriented communication management system, and particularly relates to an existing CMIP (Common Management Interface Protocol), This is a technology related to a function of managing an SNMP (Simplified Network Management Protocol) agent, a CORBA client / server function for exchanging data with other systems, and a data conversion function that enables integration of various management protocols.

In recent years, as the types of devices handled by the communication network management system have increased, it has become necessary for the communication network management system to handle a plurality of different communication network management protocols.
In order to solve this, as shown in FIG. 11, each communication network management protocol function and other functions are manufactured as highly independent software components (components), and a communication network management system is manufactured by combining these. A way to do that has been proposed.

In order to increase the independence of each component, there is a tendency that data exchanged between components is encapsulated and transferred as an event object to another component.

When a program is produced by combining components, it is common to increase the versatility of parts by unifying the data structure (data structure of event objects) exchanged between components as much as possible. . For example, it is possible to use a data structure (integer type, character string type, array type, etc.) that already exists in the computer language that constitutes the component, or to use a data structure (a Java language
Collection etc.). Attempts to specify a method for exchanging data between components using these methods include InfoBus (“InfoBus 1.1 Specificati
on ", Mark Colan, Lotus Development Corp, 1998.3.16)
There is.

In a component (communication component) in which a function of a communication protocol is mounted, a data structure (protocol data unit: PDU) to be handled is generally complicated. For example, to implement CMIP functions, ASN.1
It is necessary to handle the data structure described in IDL, and to implement the function of CORBA, it is necessary to handle the data structure described in IDL. In ASN.1 and IDL, in addition to basic types such as integer types, new types can be defined by arbitrarily combining basic types. These new types are usually handled corresponding to computer language structures. There is a standard method for converting a data structure described in ASN.1 or IDL to a data structure expressed in a widely used computer language such as C ++ or Java, and this is automatically performed. Tools are also commercially available. Many communication components use a data structure that is generated by converting from ASN.1 or IDL into a computer language using this standard method for the data structure exchanged between components. These data structures are array types or Collection
There is a part that does not correspond to a general structure such as the above, and the data structure is analyzed and generated mainly using components dedicated to each protocol. FIG. 12 shows a data flow centering on the communication component.

[0007] 1. On the communication path between the management system and the managed system or higher system, PDUs are IDL or ASN.1
Are encoded according to an encoding rule defined in association with, for example, and flow as a bit pattern (step 5).
1).

[0008] 2. Inside the communication component, the bit pattern on the communication path is analyzed and converted into a structure expressed in a computer language. At this time, mapping is performed by a unique method or a standard method for each protocol (step 52).

3. The event object includes a PDU expressed in a computer language (step 53).

[0010] 4. The components that parse the PDU are:
It cannot be analyzed unless the structure of the transmitted PDU is understood. Therefore, a dedicated one is used for each communication protocol (step 54).

5. Components for setting the PDU include:
The analysis cannot be performed unless the structure of the PDU to be set is understood. Therefore, a dedicated one is used for each communication protocol (step 55).

When implementing the agent function or the server function of the communication protocol, it may be necessary to return a response to the manager or client that sent the request. The communication component attaches an activation identifier or the like to the processing request data from the arriving manager or client, and sends the data to a component that performs actual processing.
The component that has executed the process creates response data, assigns an activation identifier, and sends it back to the communication component.

The communication component identifies the manager or client that sent the request from the activation identifier and sends response data to the system. This is shown in FIG.

1. If the communication component wants a response, the communication component replaces the request PDU with some identifier (activation identifier).
(Step 56).

2. The component that branches the request also branches the activation identifier (step 57).

3. Each component on the path passes the activation identifier (step 58).

4. When receiving the response data, the communication component also receives the activation identifier attached to the request PDU, thereby distinguishing which request the response is to (step 59).

[0018]

A system including a communication component needs to handle data (PDU) exchanged over a protocol. PDUs cannot be unified representation for the following reasons. (1) The data structure of a PDU has a different structure for each type of protocol, and its language mapping also differs.
Furthermore, even with the same protocol, the data structure of the PDU is different if the management information definition is different. (2) Since the data structure of a PDU is generally complicated and represented by a structure in standard computer language mapping, it is handled by a conventionally proposed method of unifying the data structure between components using an array or the like. Can not do. (3) It is conceivable to define a common data structure that includes the main protocols currently used for communication network management and convert them once to this data structure. It takes. (4) Data structures such as (3) cannot always include PDUs of a new protocol that will appear in the future.

Since the PDU cannot be unifiedly expressed, the communication component cannot unify the data structure exchanged between the components, and the component connected to the communication component (such as the data conversion component) is dedicated to the management protocol handled by the communication component. It has become something. Therefore, the conventional method has the following problems (1) to (3). (1) A dedicated PDU analysis and setting component is required for each management protocol, and the types of components increase. (2) This requires the developer to handle various types of components, which increases the burden. (3) Further, in order to support a new communication protocol, it is necessary not only to newly manufacture a communication component but also to newly manufacture a component connected to the new communication component. When implementing the agent function or server function of the communication protocol and returning a response to the manager or client that sent the request,
The developer needs to process the data output from the communication component and create a program to return the data to the communication component again. This involves the following issues (4)-
(6). (4) When using a visual development tool such as connecting components on a screen with a line, the developer needs to draw a return path to the communication component. Therefore, the event transfer path becomes complicated. In particular, when a branch is made during the processing of the PDU and it is necessary to draw a return path from a plurality of positions to the communication component, the display becomes complicated on the development tool, and the comprehension is reduced. (5) When there are a plurality of communication components, the developer must always be aware of which communication component the response data is returned to, and create a program. (6) Since the startup identifier and the method of returning a plurality of pieces of response data differ depending on the communication component, the developer must always create a program while paying attention to how to return the response data to the communication component. further,
The components of the path must have different functions for each communication component in order to pass an activation identifier having a different format for each communication component.

An object of the present invention is to solve the above problems,
The most economical PD that can be adapted to each protocol
The purpose of the present invention is to provide a method of utilizing the structure of U.

[0021]

SUMMARY OF THE INVENTION In order to solve the above-mentioned problems, a communication management system according to the present invention, which supports different protocols, comprises:
Include the accessor and answer receptor together with the PDU in the event object.

That is, the communication network management system of the present invention is a communication network management system configured by combining a communication component that is a component having a function of a communication protocol and a component that is another software component. Data structure P
A communication component that sends a DU or another component sends an accessor together with a PDU, and
The component corresponding to U accesses the PDU via the accessor.

Further, a character string is passed to the accessor, and the position inside the PDU is designated by the character string.

Further, the communication component requiring the response PDU sends an answer receptor together with the request PDU, and the component returning the response PDU to the communication component returns the response to the communication component via the answer receptor. It was done.

[0025]

Next, embodiments of the present invention will be described with reference to the drawings. FIG. 1 is a basic explanatory diagram of a communication network management system supporting heterogeneous protocols according to the present invention.

An accessor is an object having a function of extracting and setting basic data from a PDU. The basic data is a data structure (an integer type, a character string type, an array type thereof, etc.) existing in the computer language constituting the component from the beginning.

The accessor not only converts the entire PDU into basic data, but also designates a specific part of the PDU by a character string, and converts and extracts only that part into basic data. Similarly, in addition to setting the entire PDU from the basic data, a specific part of the PDU is specified by a character string, and only that part is replaced with the specified basic data value.

The greatest feature of the accessor according to the present invention is a function of specifying a position in a PDU using this character string. By specifying a part of the PDU with a character string, it is possible to specify even the inside of a structure that cannot be represented by an array or Collection interface. Hereinafter, this character string is called a label (FIG. 6).

As a label for designating a position inside a PDU, an identifier used in information definition description by ASN.1 shown in FIG. 10 or IDL shown in FIG. 6 can be used as it is. , Should be easy for developers to understand.

This is possible because the accessor holds the information definition description itself. Also, OMG IDL Ja
In va mapping, etc., by executing reflection on the Java data structure converted to Java, it is possible to infer the identifier used in the original IDL. Even if it is not stored, the position inside the data structure of the PDU can be specified by the character string by the identifier used in the information description definition.

Although different accessors are used for different management protocols, the accessor has the same interface for all management protocols. A component that sends out a PDU, such as a communication component, inserts and sends out an accessor at the same time as putting a PDU in an event object and transferring it. A data conversion component or the like connected to the communication component does not directly access the PDU, but accesses the data of the PDU through a standard interface of the accessor.

The component that operates the PDU does not depend on the data structure of the PDU by the accessor, so it is independent of the management protocol, and the same component can be used for the operation of various management protocols. This reduces the types of components (solution of problem (1)) and reduces the burden on developers (problem (2)
Resolution).

The structure of the PDU can be hidden inside the communication component, and the data structure of the PDU optimal for each protocol can be used. Furthermore, since the PDU is not converted into a unified data structure in advance, no conversion cost is required.

When a new management protocol is introduced, the data conversion component and the like can be reused only by designing and manufacturing the accessor again (solution of the problem (3)). This situation is shown in FIG. 1 and FIG. 1. The communication component transfers the PDU by adding its own accessor in addition to the PDU (step 1). 2. The transferred event object includes an accessor in addition to the PDU (step 2). 3. The PDU analysis / setting component accesses the PDU via the accessor (step 3).

The answer receptor is an object that performs processing for returning response data to the communication component in order to return a response to the manager or client that sent the request.

When the communication component transfers the PDU in the event object, it transmits the answer receptor at the same time when a response is required. The data conversion component connected to the communication component transfers the answer receptor as it is to the next component. Finally, after the generation of the PDU of the response data is completed, the response data is returned to the communication component by opening the standard interface of the answer receptor instead of directly returning the response data to the communication component.

The answer receptor knows the communication component to return a response to (usually the communication component that created itself) and returns a response there. Also,
The answer receptor internally stores information (activation identifier) for identifying a plurality of requests sent from the same communication component, and automatically associates requests with responses.

As the answer receptor, a different one is used for each communication component, but the interface of the answer receptor is the same for all communication components.

A component having a function of merely delivering a PDU in an event object to an answer receptor is prepared, and this is called a terminator. When the terminator receives the response PDU and the answer receptor, the response PDU is sent to the communication component via the answer receptor, and the communication component sends the response data to the manager or the client and ends the processing. By placing this terminator at the end of the chain of components from the communication component to the analysis of the request PDU and the generation of the response PDU, it is not necessary to draw the return path of the response data to the communication component. That is, when using a visual development tool that connects components on a screen with lines, the developer does not need to draw a return path to the communication component (solution of the problem (4)).

Therefore, the event transfer path is simplified. In particular, even when a branch is made during the processing of a PDU and it is necessary to draw a return path from a plurality of positions to the communication component, the path becomes a tree on the development tool, and the understanding is improved.

Even if there are a plurality of communication components, the developer only needs to return a response to the answer receptor included in the event object, so the program can be executed without being aware of which communication component returns the response data. Can be manufactured (solution of the problem (5)).

The answer receptor holds the request-response correspondence information in the most convenient way for the communication component and can hide this from the developer.

The answer receptor has an interface for receiving an indication that there are two or more responses. When there are a plurality of responses, the interface is first notified of the plurality of responses to the answer receptor via this interface, and later, Pass multiple responses.

In particular, when the route branches and there is a possibility that there is a response from both routes, the answer receptor is indicated through this interface that there are multiple responses. This allows developers to create programs without being aware of how to return response data to communication components, and to make the components of the route general-purpose components that do not depend on the method of responding to requests and responses. Yes (solution of problem (6)). This situation is shown in FIG. 2 and FIG.

1. The communication component transfers the PDU with a unique answer receptor in addition to the request PDU. At this time, information sufficient to identify the request is added to the answer receptor (step 1-).
1).

2. The transferred event object includes an answer receptor in addition to the PDU (step 2-1).

3. When branching the request, the answer receptor also branches, indicating that the answer receptor may have more than one response. The answer receptor communicates this to the communication component or processes it independently (step 3-1).

4. Components on the pathway allow the answer receptor to pass. Even when PDUs are exchanged, the answer receptor is allowed to pass as it is. Generally, PDUs are switched somewhere in the path to convert the requested PDU into a response PDU (step 4).

5. The terminator delivers the response PDU to the answer receptor. Answer receptor is response P
Pass the DU to the communication component. At this time, the answer receptor delivers the request to the communication component, including the request. The communication component returns a response to the manager or client (step 5).

[0050]

[Example] Java is used as a computer language, and JavaBeans (JavaBeans API Specifi
An example using cation Ver.1.01, SUN Microsystems 1997.6.24) is shown. In this example, a method of uniformly handling three typical protocols used for communication network management, CMIP, SNMP, and CORBA, will be described.

1. PDU Event Object In JavaBean, data transferred between components based on an event model is called an event object. In this embodiment, 1 of this event object
One is PD which is data exchanged on the protocol.
An object including a U, an accessor and, if necessary, an answer receptor is defined as a PDU event object.

In addition to the above, some event objects transfer a basic type (such as a character string type or a numeric type).
No special mechanism is required for each component to retrieve data from the event object that transfers the base type.

The 1.1 accessor will be described. The data to be obtained and set from the PDU via the accessor is of a basic type such as a character string type or a numeric type so that any component can be recognized. Specifically, Java in
t. long, short char, byte, float, double, Java. lan
g. String, byte []. In the interface of the accessor, prepare a method to fetch each basic type and a method to set. To these methods, a character string (label) indicating a basic type element in the PDU structure is always passed. The structure of the label is a sequence of multiple words, and this word allows the words used in the definition of ASN.1 or IDL describing the PDU to be used as they are.

The accessor has a function of extracting the type name of a PDU or a part of the type name of a PDU specified by a label as a character string. Accessors do not perform meaning conversion. An example of a specific interface definition of an accessor is shown below. public interface PDUAccessor {public boolean isValid (Object pdu); --- Check data setting public String toString (Object pdu); --- String conversion public boolean equals (Object a, Object b); PDU comparison //- ------------------------------------------------- public String getType (Object pdu); public String getType (Objectpdu, String label); public boolean isInstance (Object pdu, String type); public boolean isInstance (Object pdu, String label, String type); // ------ -------------------------------------------- public int getSize (Object pdu ); public int getSize (Object pdu, String label); Extract int (number of elements) data by public object setSize (Object pdu, int count); public Object setSize (Object pdu, String label, int count); (Number of elements) // ----------------------------------------- --------- public boolean booleanValue (Object pdu); public boolean booleanValue (Object pdu, String label); Public Object setValue (Object pdu, boolean i); Set boolean type data by public Object setValue (Object pdu, String label, boolean i); // --------------- ----------------------------------- public byte byteValue (Object pdu); public byte byteValue (Objectpdu, String label); extract byte type data by public object setValue (Object pdu, byte b); public Object setValue (Object pdu, String label, byte b); set byte type data // ------- ------------------------------------------- public char charValue (Object pdu) ; char char data is retrieved by public char charValue (Object PDU, String label); public Object setValue (Object pdu, char c); char data is set by public Object setValue (Object pdu, String label, char c); // ------------------------------------------------ --- public double doubleValue (Object pdu); public double doubleValue (Object pdu, String label); bject setValue (Object pdu, double d); Set double type data by public Object setValue (Object pdu, String label, double d): // ----------------- ---------------------------------- public float floatValue (Object pdu); public float floatValue (Object pdu, String get float type data by label); public Object setValue (Object pdu, float f); set float type data by public Object setValue (Object pdu, String label, float f); // ------- -------------------------------------------- public int intValue (Object pdu ); public int intValue (Object pdu, String label); Extract int type data by public object setValue (Object pdu, int i); public Object setValue (Object pdu, String label, int i); Set int type data by Yes // ----------------------------------------------- ---- extract long type data by public long longValue (Object pdu); public long longValue (Object pdu, String label); public Object setValue (Object pdu, lo ng l); public object setValue (Object pdu, String label, long l); to set long data // ------------------------ --------------------------- public short shortValue (Object pdu); short type data by public short shortValue (Object pdu, String label); Public Object setValue (Object pdu, short s); Set short type data by public Object setValue (Object pdu, String label, short s); // -------------- ------------------------------------- public String stringValue (Object pdu); public String stringValue (Object Get string type data by pdu, String label); public Object setValue (Object pdu, String label, String s); Set String type data by public Object setValue (Object pdu, String label, String s); // ---- ------------------------------------------------ public byte [] bytesValue (Object pdu); public byte [] bytesValue (Object pdu, String label); Extract byte type data by public Object setValue (Object pdu, byte [] s ); public Object setValue (Object pdu, String label, byte [] s); to set byte type data // ----------------------- ----------------------------- public Object insertElementAt (Object pdu, String s); add an element with public Object removeElementAt (Object Remove elements with pdu), String s); // ------------------------------------ ---------------- public String getSelection (Object pdu); public String getSelection (Object pdu, String label);} Accessor for CORBA that retrieves the label of the element selected by An example using Java is described below. COR
BA IDL is mapped to Java language by 0MG (CORBA
Specification Ver.2.2: Mapping of OMG IDLto Java)
Has been decided. The PDU structure on Java used by the communication component of CORBA in this embodiment is IDLinterface
For each method, it is determined individually for request and response.
The PDU structure for the request is an array of Java.lang.Object,
Include the in or inout argument of the method as an array element. The response PDU structure is also an array of Java.lang.Object, and a return value other than void type and an out or inout argument are included as array elements. Return value and argument types are IDL J
Use ava mapping as is.

The CORBA accessor utilizes the fact that words used in IDL have been converted to Field names and Method names, and uses Java reflection to set the name of the Fiel
Search for d and Methond and execute. For the array type, the index is specified by a number, and symbols having special meanings such as + (increase the number of elements) and S (last element) can be used. Example of IDL --- See Figure 6 PDU structure below struct log {unsigned long time; where time is label, character string, long is type long value or less IDL structure typedef sequence <log>logs; interface agent {CORBA interface Definition void getLogs (in unsigned long from; Corresponds to the following * 1 in unsigned long to; out logs cmiplogs; Corresponds to the following * 2 out logs snmplogs;);}; Example of JAVA after conversion final public class log { The type definition of the argument converted to Java public int time; class public int value; public log () {...} public log (int time, int value) {...} public Java.lang.String () {....}} The following holder (inclusive class) final Public class logsHolder implements org.CORBA.portable.Streamable {public coo.CORBAtest.log [] value; public logsHolder () {} public logsHolder (coo.CORBAtest .log [] value) {...} public void_read (org.omg.CORBA.portable.InputStreaminput) {...} publicvoid_write (org.omg.CORBA.portable.OutputStreamoutput) {...} public org.omg .C ORBA.TypeCode_type () {...}} The following interface is converted to Java public interface agent extends org.omg.CORBA.Object {public void getLogs (int from, int to, * 1 corresponds to logs Holder cmiplogs, logsHolder snmplogs * 2));} PDU structure for request of method getLogs Java.lane.Object [2] Reference drawing Figure 8 PDU structure definition with two elements in object class below // Element 0 (corresponds to from) Type: Java.lang.Integer // Type of element 1 (corresponding to): Java.lang.Integer Structure of response PDU of method getLogs Java.lang.Object [2] Reference drawing 9 // Element 0 (cmiplogs Type): log [] [] indicates an array // Type of element 1 (corresponding to snmplogs): log [] Example of a label Reference drawing is an example of 0: 2: time for the response of the method getLogs When the time of the third element of the PDU argument cmiplogs is expressed "0: 2: time" This method does not use any class other than the Java class generated by the IDL compiler In, there is no need to write any new program. An example of a CMIP accessor in Java is described below. For ASN.1 used in CMIP,
Mapping to Java is not defined directly. Mapping from ASN.1 to IDL (JIDM: Inter-domain Management:
(Specification Translation, X / Open) is defined, so it can be converted to IDL and then to Java. However, in this embodiment, this method is not used, and the ASN.1 data structure is expressed in a unique format most convenient for the implementation of the CMIP communication component. This data structure has almost the same interface as the accessor, and the accessor simply converts the method name and argument. Example of ASN.1 Reference drawing Figure 10 PDU structure of ASN.1 IntervalsOfDay :: = SET OF SEQUENCE {intervalStart Time24, former is label; latter is type intervalEnd Time24} Time24 :: = SEQUENCE {hour INTEGER (0..23 ), minute INTEGER (0..59)} Example of label Referencing drawing: $: intervalStart: mminute IntervalsOfDay represents the last element of “inervalStart” minute "$: intervalStart: minute" Example of SNMP accessor in Java Is described below. SNMP
Uses ASN.1 to define the data structure, similar to CMIP. However, the SNMP communication component used in the present embodiment, when handling the PDU inside the computer,
The bit patterns sent over the network are handled directly in memory without conversion to the Java language data structure. Therefore, the SNMP accessor is
The bit pattern is directly analyzed to extract or set data.

1.2 Answer Receptor The answer receptor of this embodiment has the following interface. (1) an interface for passing a response PDU,
(2) An interface that indicates that there are two response PDUs.

When there is only one response, only the interface (1) is used. If there is a possibility that there are two responses, call the interface of (2) before calling the interface of (1). Then, the answer receptor accepts the response data until the interface of (1) is called twice. If there are three or more responses, (2) before the time at which two or more responses remain
(Number of responses minus one). Then, the answer receptor accepts the response data until the interface of (1) is called (the number of times the interface of (2) is called + 1) times.

This method is particularly effective when response data is returned from a plurality of different components. That is, every time the path of the component chain branches,
By calling the interface of (2),
Whichever path returns the response first, the answer receptor can accept the response until the other path returns a response. An example of the interface definition of the answer receptor is shown below. public interface AnswerReceptor {public void setAnswer (int pos, int answerId, Object pdu); * 1 public void moreAnswer (); * 2} * 1 above is (1) Interface that passes response PDU * 2 above is (2) 1. Interface indicating that there are two response PDUs. Component In JavaBeans, software component (component)
Is called a Bean. A bean has three concepts: (1) a method for receiving events and other information, (2) an event that sends out an event object to convey information to other components, and (3) a property for acquiring and setting the internal state of the Bean. There is.

The components used in this embodiment will be described below. 2.1 The CMIP manager component will be described. The parts that provide the function of CMIP manager are M-GET, M-SET
There are types corresponding to CMIS services such as. Each CMIP component has (1) a trigger event for taking a timing to send a request, and (2) baseManage described in a PDU of CMIP.
Has a method to receive events that set parameters such as dObjectInstance, scope, filter. In addition, by referring to the GDMO definition file specified in the property at the time of execution, the information definition is independent. Upon receiving the trigger event, the CMIP component issues a CMIP request to the agent, and sends out the returned response PDU together with the CMIP accessor as a PDU event object. LinkedRe
In the case of ply, events are transmitted by the number of responses, and finally an event having an empty PDU indicating the end of the response is transmitted. If the trigger event includes an answer receptor, it is also sent to all PDU event objects.

2.2 The SNMP manager component will be described. Parts that provide the SNMP manager function are GET, SET, GE
There are types corresponding to protocol services such as T-NEXT. Each SNMP component has a method for receiving (1) a trigger event for setting a timing for sending a request and (2) an event for setting parameters such as an agent host name, a community, and an OID of a target attribute.

The SNMP MIB set in the property
Information definition independent by referring to the definition file at the time of execution.

When the SNMP component receives the trigger event,
An SNMP request is sent to the designated agent, and the returned response PDU is sent out together with an SNMP accessor as a PDU event object. If the trigger event includes an answer receptor,
Assigned to U event object and sent.

2.3 Client Component and CORBA Server Component One type of CORBA client component can call methods of any CORBA server object. CO
Specify parameters such as the interface name, name, and method to be called of the RBA server object in the properties,
Uses CORBA's InterfaceRepository and Java Reflection API to make information definition independent. The CORBA client component uses the value of the remote server call
It receives it as a U event object and sends out the return value from the server as a PDU event object together with the accessor for CORBA. If the PDU event object of the argument value includes an answer receptor, it is also sent to the return value PDU event object.

On the other hand, each CORBA server component corresponds to one CORBA server object instance, and sends out a PDU event object corresponding to the CORBA method.

When the method call request from the client arrives at the CORBA server component, the CORBA server component sends out the method argument as a PDU event object together with the CORBA accessor and the CORBA answer receptor. The CORBA server component obtains a return value using the framework of the answer receptor and terminator, and returns a response to the calling client.

2.4 PDU Analysis Component The PDU analysis component is a component that receives a PDU event object and extracts a basic type therefrom. This component has a property that holds a character string (label) representing a part of the PDU, and a PDU.
Has a method that receives

When a PDU event object arrives at this component, a part of the PDU is extracted based on the label stored in the property and sent out as an event object representing the basic type. At the same time, the PDU event object is transmitted as it is. Also, the type name of the PDU can be extracted instead of the partial value.

2.5 PDU Constant Generation Component The PDU constant generation component is a component that newly creates and sends a PDU event object. This component has a type corresponding to the type of PDU (CMIP, SNMP, CORBA in this embodiment). Each P
The DU constant generation component has a property indicating a constant value of the PDU and a method for receiving a trigger event.

When a trigger event arrives at this component, a PDU is generated based on the information stored in the property and transmitted as a PDU event object together with an accessor unique to each PDU. If the trigger event contains an Answer Receptor,
Assigned to the event object and sent.

2.6 PDU Setting Component The PDU setting component is a component that receives a PDU event object and rewrites its basic type element. This component has a property that holds a character string (label) representing a part of the PDU,
It has a method for receiving a DU and a method for receiving a basic type for writing.

When the PDU event object and the basic type data arrive at this component, a part of the PDU is rewritten based on the label stored in the property, and the changed PDU event object is transmitted.

2.7 Terminator A terminator receives a PDU event object and sends a PDU to an answer receptor contained therein.
Is a component that delivers No events are dispatched from this component. 2.8 Other components Components that perform calculations, branching, etc. operate by receiving a basic type event object. The output is also of the basic type. 3. Example of operation An example of the case where the above components are actually operated by combination is shown. 3.1 Example of Polling SNMP The following shows an example of polling an SNMP agent using a combination of CORBA and SNMP protocols. The system of this example has the following three functions. (1) The server operates as a server that receives a polling interval setting and a polling destination host name setting from a CORBA client. (2) Operate as an SNMP manager that polls the SNMP agent based on the set data. (3) CORBA that writes polling results to the database
Act as a client.

FIG. 4 shows a combination of components. The operation procedure in this figure will be described below.

1. CORBA communication component: implements the CORBA server function that receives the setting of polling interval. When a polling interval time setting method is called from the CORBA client, which is a higher system, the argument P
DU and send it together with CORBA accessor (step 11).

2. PDU analysis component: Set the label in the property and set the C via the CORBA accessor.
Extracts the int type polling interval at the position specified by the label from the ORBA PDU and sends it. The PDU is discarded here because no component is connected to the destination (step 12).

3. Timer component: The timer component has a method for setting a time interval, and sends out a trigger event at the set time interval (step 13).

4. CORBA communication component: A CORBA server function that receives the setting of the host name is realized. When the host name setting method is called from the CORBA client, which is the higher system, the argument is put in the PDU and the CO
The data is transmitted together with the RBA accessor (step 14).

5. PDU analysis component: Set the label in the property and set the C via the CORBA accessor.
Extracts the String host name at the position specified by the label from the ORBA PDU and sends it. The PDU is discarded here because no component is connected to the destination (step 15).

6. PDU constant generation component: Generates an SNMP PDU for polling. The host name from step 5 is stored, and when a trigger event from step 3 comes, an SNMP PDU is generated and sent out together with the SNMP accessor. Properties are set in advance for the designated host so as to create a PDU for GETting the time and the total number of processed packets (step 16).

7. SNMP communication component: Step 1
6 is transmitted as an SNMP GET and a response is received. The response is sent with the SNMP accessor. Two components are connected to this component, and a PDU is sent to both 8 and 9 (step 1).
7).

8. PDU constant generation component: CORBA P for writing polling results to the database
Generate a DU. Constants are stored in advance according to the properties, and when the PDU from step 17 comes, CO
Generates an RBA PDU and sends it together with the CORBA accessor. Here, the fields of the time and the number of packets are set to 0 (step 18).

9. PDU analysis component: a label is set in the property, an int type polling time at a position designated by the label is extracted from the SNMP PDU via the SNMP accessor, and sent to step 20.
The DU is directly sent to step 11 (step 1).
9).

10. PDU setting component: A label is set in the property, and the polling time sent from step 19 is written into the time field at the position specified by the label of the CORBA PDU via the CORBA accessor. Send the modified PDU (step 2
0).

11. PDU analysis component: A label is set in a property, and the number of int type packets at the position designated by the label is extracted from the SNMP PDU via the SNMP accessor and transmitted to 12. The PDU is discarded here because no component is connected to the destination (step 21).

12. PDU setting component: a label is set in a property, and the number of packets transmitted from step 21 is written into a packet number field at a position designated by the label of the CORBA PDU via the CORBA accessor. Send the modified PDU (step 2
2).

13. CORBA communication component: operates as a CORBA client, and the PDU from step 22
To the CORBA server. The server name, interface name, and method name are set in advance in the properties (step 23).

3.2 Example of Retrieving CMIP An example of retrieving an event log record for a CMIP agent by combining the CORBA and CMIP protocols will be described. The system of this example has the following two functions. (1) Operates as a CORBA server that takes two times as arguments and returns the contents of an event log record that occurred between those times. (2) Operate as a manager who goes to the CMIP agent to search for event log records. FIG. 5 shows a combination of components. The operation procedure in FIG. 5 will be described next.

1. CORBA communication component: A CORBA server function that receives the occurrence time range (from, to) of the event log record to be searched is realized. C which is the upper system
When the retrieval method is called from the ORBA client, its argument is put into the PDU and sent to the following steps 32 and 33 together with the CORBA accessor and the answer receptor for receiving the contents of the log record (step 31).

2. PDU constant generation component: CMIP
Generates a PDU of CMIP for designating a filter condition. The constant of the CMIS Filter that specifies the range of eventTime by the property is stored in advance, and when the PDU from step 31 comes, the CMIP
Is generated and transmitted together with the CMIP accessor.
At this time, the answer receptor included in the PDU event object from step 31 is also sent out (step 32).

3. PDU analysis component: Set the label in the property and set the C via the CORBA accessor.
From the ORBA PDU, from of the int type occurrence time range at the position specified by the label is extracted and sent to step 34. The PDU is sent to step 36 (step 3
3).

4. Operation component: int of occurrence time
Multiply the value by 1000 and convert seconds to milliseconds. This is because the units for handling time in the CORBA and CMIP PDUs are different (step 34).

[0092] 5. PDU setting component: set the label in the property, via the CMIP accessor,
The time (from) sent from step 34 is written in the time field at the position specified by the label of the CMIP PDU. The changed PDU is transmitted (step 35).

6. PDU analysis component: Set the label in the property and set the C via the CORBA accessor.
The int-type occurrence time range to at the position specified by the label is extracted from the ORBA PDU and sent to step 37. The PDU is discarded here because no component is connected to the destination (step 36). ).

7. Operation component: int of occurrence time
The value is multiplied by 1000, and the unit of seconds is converted to the unit of millisecond (step 37).

8. PDU setting component: set the label in the property, via the CMIP accessor,
The time (to) sent from step 37 is written in the time field at the position designated by the label of the CMIP PDU, and the changed PDU is sent out (step 38).

9. CMIP communication component: P from 8
The DU is received as CMIP Filter information, and the other information is set in the property using the CMIP GE
Execute T. In properties, specify log as base object, specify firstLevelOnly as Scope, and set eventID and stateChangeDe as attributedIDList
Specify bfinition. The response from the agent is C
It is sent together with the accessor for MIP and the answer receptor sent from 1. The response from the agent is 0
It is an indefinite number of numbers. A PDU is transmitted for each response from the agent, and finally a special PDU with NULL set is transmitted (step 39).

10. Loop control component: This component contains a plurality of Ps sent from step 39.
A loop is controlled to combine DUs into one CORBA PDU. Actually, it is formed of a plurality of components. However, in this embodiment, to simplify the explanation, one component is used.
Described as one component. This component has one method for receiving PDUs. First PDU
Sends an initialization trigger event. PD
If U is not NULL, true is transmitted as the loop condition, and the PDU is also transmitted as it is. If the PDU is NULL,
Send true to the loop condition, reset the internal state,
The next PDU is regarded as the first PDU, and an initialization trigger is output. Initialization trigger is step 41
To the loop condition to step 42, the PDU to step 4
3 is sent. At the time of the trigger, the received PDU is transmitted as it is (step 40).

11. PDU constant generation component: CM
Generate a CORBA PDU that stores the IP search result.
With a response structure that should be returned to 1 by property,
CORB value if there were no event log records
The constant of the PDU of A is stored in advance, and when the trigger from step 40 comes, the PDU is generated and transmitted together with the CORBA accessor. At this time, the answer receptor included in the PDU event object from step 40 is also sent out. The number of elements to be generated is “0”. (Step 41) 12. Conditional branch component: This component tr
Has a function to send to the ue side or false side. The event object is received from step 41 or 47. The condition receives the loop condition of step 40. When the loop condition is true, the event object is transferred to step 45, and when false, the event object is transferred to step 38. When a response PDU is first received from the CMIP manager in step 39, the CORBA is sent from step 41 to send an initialization trigger in step 40.
Is sent. If the first response is NULL, the loop condition is false and the C from step 41
The ORBA PDU is sent to step 48 to return the value if there were no event log records. If the first response is not NULL, the loop condition is true and CORBA
Are sent to step 45. Step 39 CM
When the second or subsequent response PDU is received from the IP manager, if the response is NULL, the loop condition is fals.
e, CORBA PD returned through step 47
U is sent to step 48 and a CORBA response is returned.
If the response is not NULL, the loop condition is true,
The CORBA PDU is sent again to step 45 (step 42).

13. PDU analysis component: set the label in the properties, via the CMIP accessor
EventTime specified by label from CMIP PDU
It is extracted as a long type millisecond value and sent to step 14. The PDU is sent to step 16 (step 4
3).

14. Operation component: eventTime l
The ong value is divided by 1000 to convert a millisecond unit to a second unit (step 44).

15. PDU setting component: A label is set in the property, and the time sent from step 44 is written to the time field at the position specified by the label of the CORBA PDU via the CORBA accessor.
Label is specified as "+: time" and the element is increased by one. The changed PDU is transmitted (step 45).

16. PDU analysis component: set the label in the properties, via the CMIP accessor
StateChangeDefini specified by label from CMIP PDU
The value of the attribute of the number of packets in the action is extracted as an int type value and sent to step 47. The PDU is discarded here because no component is connected to the destination (step 46).

17. PDU setting component: A label is set in a property, and the number of packets transmitted from step 46 is written into a packet number field at a position designated by the label of the CORBA PDU via the CORBA accessor. The label is designated as "$: time", and is written to the last element that has been increased by one in step 45. Return the changed PDU to step 42. In step 42, while the condition is true, the CORBA PDU goes through steps 45 and 47 again (step 47).

18. Terminator component: When the loop condition becomes false, the CORBA PDU is sent to this terminator. Terminator is Step 31
This CORBA PD
Pass U. Thereby, the CORBA communication component in step 31 can acquire the response PDU to be returned to the client, and the response is returned to the client.

[0105]

As described above, according to the present invention, according to the present invention, a component sends a PDU including an accessor, accesses the corresponding PDU via the accessor, and returns a response through the accessor together with an answer receptor. By doing so, the following effects are obtained.

1. The components that operate the PDU of the present invention are not dependent on the data structure of the PDU by the accessor, and thus are independent of the management protocol, so that the same component can be used for processing various management protocols. This reduces the types of components and reduces the burden on the developer.

2. The structure of the PDU can be hidden inside the communication component, and the optimum PDU for each protocol is
Data structure can be used.

3. Also, when introducing a new management protocol, just re-design and manufacture only the accessor,
Data conversion components can be reused.

4. In the interface to the accessor,
Unlike the conventional data unification method, since the character string indicates the internal position of the PDU, an element having an arbitrary structure including a structure can be specified.

5. Since the identifier used in the information definition description can be used for the character string to the interface to the accessor, an easy-to-understand program can be written.

6. When implementing a communication protocol agent function or server function and returning a response to the manager or client that sent the request, the developer draws a path that returns response data to the communication component by using an answer receptor or terminator. Eliminates the need. That is, when using a visual development tool that connects components on a screen with lines, the developer does not need to draw a return path to the communication component. Therefore, the event transfer path is simplified. In particular, even when a branch is made during the processing of a PDU and it is necessary to draw a return path from a plurality of positions to the communication component, the path becomes a tree on the development tool, and the understanding is improved.

7. Even when there are a plurality of communication components, the developer can create a program without being aware of which communication component returns data in response.

8. The developer can create a program without being conscious of how to return response data to the communication component, and the component of the path can be a general-purpose component that does not depend on a method of taking correspondence between a request and a response.

9. These make it possible to efficiently construct a communication network management system.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram showing a basic configuration of a communication network management system supporting heterogeneous protocols according to the present invention.

FIG. 2 is an explanatory diagram of an operation of the communication network management system shown in FIG.

FIG. 3 is a diagram showing a flow of operation of the communication network management system of the present invention when it is necessary to return a response.

FIG. 4 is a diagram showing an operation flow in the case of a combination of components based on a combination of CORBA and SNMP.

FIG. 5 is a diagram showing an operation flow in the case of a combination of CORBA and CMIP.

FIG. 6 is a diagram illustrating a structure of a PDU according to an example of IDL.

FIG. 7 is a diagram illustrating an example in which a character string is passed to an accessor and an internal position in a PDU is specified by the character string.

FIG. 8 is a diagram showing a structure of a request PDL of getlogs of IDL.

FIG. 9 is a diagram illustrating a structure of a PDU for response to the PDU of FIG. 8;

FIG. 10 shows ASN. FIG. 3 is a diagram showing the structure of one PDU.

FIG. 11 is an explanatory diagram of a conventional communication network management system.

12 is a diagram showing an operation flow for a data flow of the conventional communication network management system shown in FIG. 11;

FIG. 13 is a diagram illustrating a flow of a PDU processing operation when an agent / server function of a conventional communication protocol is implemented.

[Explanation of symbols]

 Reference Signs List 10 Managed system 10-1 Host system 20 Management system 30 SNMP agent 40 CORBA server 50 CMIP agent Numbers in small circles are step numbers.

 ──────────────────────────────────────────────────続 き Continued on front page (72) Inventor Hiroyuki Maeda 3-19-2 Nishi-Shinjuku, Shinjuku-ku, Tokyo Japan Telegraph and Telephone Corporation (72) Inventor Masahisa Tago 3-19 Nishishinjuku, Shinjuku-ku, Tokyo No. 2 Nippon Telegraph and Telephone Corporation (72) Taichi Kawahata Inventor Taichi Kawabata 3-19-2 Nishishinjuku, Shinjuku-ku, Tokyo F-Term within Nippon Telegraph and Telephone Corporation 5B089 AA20 AD17 AE09 AF07 AF08 CA18 CA19 CC13 DD02 DD18 5K034 AA14 AA16 HH01 HH02 HH61

Claims (3)

[Claims] In a communication network management system configured by combining a communication component which is a component having a function of a communication protocol and a component which is another software component, a communication for transmitting a PDU which is a protocol-dependent data structure. Components and other components are PD
A communication network management system, wherein a component that sends an accessor together with a U and processes the PDU accesses the PDU via the accessor. 2. The communication network management system according to claim 1, wherein a character string is passed to the accessor, and a position inside the PDU is specified by the character string. 3. In a communication network management system configured by combining a communication component which is a component having a function of a communication protocol and a component which is another software component, a communication component which requires a response PDU is requested by a communication component. Sends an answer receptor with the PDU of the
The communication network management system, wherein the component that returns the DU to the communication component returns a response to the communication component via an answer receptor.