KR100270915B1 - Metwork management platform and method - Google Patents

Abstract

TECHNICAL FIELD The present invention relates to a network management platform. In particular, the present invention relates to a management agent through dynamic addition of a dedicated agent, a scheduler, a monitor, a class, and access to a database. The present invention relates to a network management platform and method including an internal data structure for providing parallelism, efficient concatenation with real resources, and persistence of management while preventing duplication of common information of managed object instances.

An agent kernel for initializing the agent and establishing and delivering associations with the manager, and providing dynamic addition of classes to handle agent extensibility; Dedicated agent exists in the form of a thread by the cooperative delivery of the agent kernel, responsible for one or more administrators to perform a management service; External and internal data structures that provide data, and execution code of managed objects provided at GDMO compilation. Object framework that provides data and code related to managed objects by providing monitors and schedulers that are responsible for concatenating basic skeletons and actual resources. and; A structure that implements a containment relationship between managed objects, comprising: a containment tree for performing all operations on the managed object with the location and domain name of the managed object; A GDMO compiler that receives a description of a managed object described by a user, generates a managed object code, creates a new managed object by using the managed object code and code written by the user, and adds new syntax; It is characterized by providing a network management platform including a lower communication structure in charge of communication between the manager and the agent.

Description

Network management platform and method

TECHNICAL FIELD The present invention relates to a network management platform. In particular, the present invention relates to a management agent through dynamic addition of a dedicated agent, a scheduler, a monitor, a class, and access to a database. The present invention relates to a network management platform and method including an internal data structure for providing parallelism, efficient concatenation with real resources, and persistence of management while preventing duplication of common information of managed object instances.

The Telecommunication Management Network (TMN) has a Manager and Agent model proposed by the Open System Interconnection (OSI) Network Management Scheme, which manages one or more management operations and requests management operations services from the agents. The agent manages the managed objects in the agent management area and informs the administrator of the result of performing the management operation service requested by the manager or the notification authorized by the managed object.

The management objects actually store management information of network elements and also store up-to-date management information through interaction with real network elements. The managed objects have a logical relationship of inclusion relations with each other according to name binding information of their own management object class. To represent a managed object having a corresponding relation, the agent includes an internal inclusion tree. Will be maintained. Here, the include tree is the starting point for performing the management operation of the agent and is the core for managing managed objects. The name binding is information used when an instance is registered in the include tree to indicate which instance is associated with it. For example, 'system-Object1' indicates that an instance of the Object1 class is linked to an instance of the system class on the inclusion tree.

Referring to FIG. 1 illustrating an example of an inclusion tree in the above-described manner, it includes an inclusion tree composed of a system class and instances of a plurality of object classes TObject0 to TObject8. Each managed object instance (11, 12) managed by an agent maintains the information it needs, that is, when an instance (11, 12) of an object1 class (TObject1) and an object2 class (TObject2) is created. Set the value of the management information to be maintained.

However, in this case, elements commonly used in a plurality of management objects are overlapped and managed. The duplicate information 13 is as shown in FIG. 1. That is, since elements commonly used in the plurality of managed object instances 11 and 12 are duplicated and managed, it causes waste of system resources, and management information must be maintained in each managed object instance 11 and 12. If there are a large number of instances, it becomes difficult to manage their management information.

In order to solve the problems as described above, the network management platform according to an embodiment of the present invention is an object-oriented platform that provides OSI network management concept and TMN concept, dedicated agent, scheduler, monitor, dynamic addition of a class, database The purpose of this study is to improve agent performance and performance by providing parallelism of management operations, efficient concatenation with actual resources, and persistence of management through the access of.

In addition, as a method for efficiently managing the managed object information, the object information is managed by class information, which is the information that the instances have in common and the information that the instances have in common, to avoid duplication of information that they have in common. The purpose is to efficiently manage the information of the managed object by enabling the reuse of the information.

1 is a diagram illustrating an inclusion tree by an Open System Interconnection (OSI) network management scheme in a conventional Telecommunication Management Network (TMN).

Figure 2 is a block diagram showing the configuration of a network management platform according to an embodiment of the present invention.

3 is a flowchart showing the overall network management method according to an embodiment of the present invention.

4 is a flowchart illustrating an agent initialization process of FIG. 3.

FIG. 5 is a flowchart illustrating a linking process with a manager in FIG. 3. FIG.

FIG. 6 is a flowchart illustrating a management service performing process in FIG. 3. FIG.

Explanation of symbols on the main parts of the drawings

20: Agent Kernel

30: Dedicated Agent

40: Object Framework

41: External Data Structure

42: Internal Data Structure

43: Scheduler & Monitor

44: MIB (Management Information Base)

50: containment tree

60: Guidelines for the Definition of Managed Objects Compiler

61: Abstract Syntax Notation.1 Compiler

62: Syntax Compiler

70: Communication Interface Structure

The network management platform according to an embodiment of the present invention for achieving the above object performs the initialization and delivery of the agent and the establishment of the association with the manager, and provides a dynamic addition of the class agent kernel responsible for the scalability of the agent and; Dedicated agent exists in the form of a thread by the cooperative delivery of the agent kernel, responsible for one or more administrators to perform a management service; External and internal data structures that provide data, and execution code of managed objects provided at GDMO compilation. Object framework that provides data and code related to managed objects by providing monitors and schedulers that are responsible for concatenating basic skeletons and actual resources. and; A structure that implements a containment relationship between managed objects, comprising: a containment tree having a location and domain name of the managed object, which is a reference point for all operations on the managed object; A GDMO compiler that receives a description of a managed object described by a user, generates a managed object code, creates a new managed object by using the managed object code and code written by the user, and adds new syntax; Characterized in that it comprises a lower communication structure responsible for communication between the manager and the agent.

Here, the internal data structure distinguishes and maintains instance information, which is the information constituting the inclusion tree, and class information, which is information that the instances have in common, and is initialized by the external data structure and is managed by the external data structure. The information on the package, operation, notification, parameters, and actions and the interrelationship between the information are characterized. In addition, the internal data structure is characterized in that after generating the class information, the management objects to use the generated class information has a pointer value indicating the generated class information.

Network management method according to an embodiment of the present invention for achieving the above object comprises the steps of performing the initialization of the agent; Performing an association with an administrator according to an association establishment request; Characterized in that a process including performing a management service according to the management service request.

The agent initialization process may include: giving a pointer to information commonly used while reading a data structure required by the agent kernel from an external data structure; Storing the read data structure in an internal data structure to connect pointers between the internal data structures; Performing a management object creation function to generate management objects of the initial creation instance; Establishing an information exchange path with a network element to store the connector and notifying the network element of the effect of the creation of the managed objects; Checking whether the generated management objects are a polling service request management object and registering them with a scheduler using a set time, execution time, execution function, and the connector; Periodically performing the designated functions to link the designated functions using the network element and the connector; Registering the created instances with an inclusion tree; And making each node of the include tree have a pointer to the instance to perform access to the MIB. The agent initialization process may further include: checking whether the generated management objects are monitor service request management objects and registering them with a monitor using an execution function and the connector; And monitoring the connector from the registered time to perform a specified function only upon input.

The linkage process with the manager may include: generating a dedicated agent by checking a linkage setting request of the manager; Generating an association number and authorizing it to the dedicated agent; And exchanging management information with the corresponding manager after transmitting the linkage request response using the associated manager with the link number.

The performing of the management service may include: checking a management service request and determining whether a filter is in error; Performing class level filtering using the internal data structure; Performing region processing and class level filter processing on the inclusion tree to determine whether the requested management service is permitted and whether the corresponding value is appropriate before selecting the management objects to access the management object by using the internal data structure. Steps; Creating a service function in the management object according to the type of the management service as a thread and executing the function in the created thread; Redefining service functions in the managed object to access a network element to provide a managed object level user code API and an attribute level user code API, respectively; Notifying an administrator of a result of performing the management service; Terminating the thread and sending a blank response to the administrator. The performing of the management service may include verifying whether the management service request is a management object creation request and performing a management object creation function to generate management objects of an initial creation instance; Establishing an information exchange path with a network element to store the connector and notifying the network element of the effect of the creation of the managed objects; Checking whether the generated management objects are a polling service request management object and registering them with a scheduler using a set time, execution time, execution function, and the connector; Periodically performing the designated functions to link the designated functions using the network element and the connector; Registering the created instances with an inclusion tree; And making each node of the include tree have a pointer to the instance to perform access to the MIB.

Hereinafter, with reference to the accompanying drawings will be described as follows.

2 is a block diagram showing the configuration of a network management platform according to an embodiment of the present invention, FIG. 3 is a flowchart showing an overall network management method according to an embodiment of the present invention, and FIG. 4 is an agent initialization in FIG. 5 is a flowchart showing a process, and FIG. 5 is a flowchart showing a connection process with an administrator in FIG. 3, and FIG. 6 is a flowchart showing a management service performing process in FIG.

As shown in FIG. 2, the network management platform according to an embodiment of the present invention includes an agent kernel 20, a dedicated agent 30, an object framework 40, a containment tree 50, and guidelines (GDMOs). for the Definition of Manage Objects) compiler 60 and a lower communication structure 70.

The agent kernel 20 performs connection establishment from an administrator and initialization of internal data structures, and provides dynamic addition of classes to handle the extensibility of agents. In this case, the role of the agent initialization initializes the internal data structures from the external data structures stored in the auxiliary memory by the GDMO compiler 60.

In addition, the agent kernel 20 creates a scheduler and a monitor in the form of a thread, creates an initial creation management object instance, and registers it in the include tree 50. Then, the agent kernel 20 waits for a linkage request from the administrator after the initialization of the agent, and when the linkage request comes in, establishes a linkage and generates the dedicated agent 30 to transfer the linkage number. The management request from the administrator is responsible for the dedicated agent 30, and repeatedly performing the operations while waiting for a new connection request.

Performing the role of dynamic addition of this class adds a new managed object class while providing management service, and guarantees continuity of management.

The dedicated agent 30 exists in the form of a thread and performs a management service by in charge of one administrator, and a plurality of dedicated agents 30 are threaded by the agent kernel 20 when a plurality of managers request a connection. The data structure is generated by using a common MIB (Manager Information Base) 44.

In this case, the management service for the manager in charge includes filter grammar checking, region processing, class level filtering, and blank response to the connection response.

Performing a role for the thread management creates a managed object thread for managed objects that have passed scoping and class level filtering, and executes a function of the managed object, causing termination and errors. In the case of a Get Service, if a plurality of managed objects are selected, a realm processing thread is created and then prepared for a Cancel-Get Service request.

In more detail, the roles of the dedicated agent 30 are examined in detail. After checking whether the filter grammar is correct when a management service is requested from an administrator, the region processing is performed in the inclusion tree 50. The class level filtering is performed to reduce the number of selected management objects. Accordingly, the number of managed objects to which the filter is applied can be reduced, the burden on the entire system, and the overall response time can be shortened.

In addition, actual management services such as get, set, and action are performed by calling a function inside a managed object, and the dedicated agent 30 calls the corresponding function when a single object is selected. In the case of Linked Reply, such as set and operation, it waits for the termination of all threads created by itself, that is, functions in the managed object, and the manager successfully processes the multiple managed objects. It sends a null response indicating that it is, and in the case of a connection response of a get service, the dedicated agent 30 creates a zone processing thread to monitor the termination of threads that perform a function of a managed object. Checks if there is a cancel get request, and when the cancel get request is received, causes the area processing thread to terminate all threads. Respond to those and do until all the threads except the thread handling area will not receive a clear exit geteu request and sends the response space, as in the case of other services.

The object framework 40 provides data and codes related to managed objects, including data structures 41 and 42 for providing data such as attributes and class information, and execution code basic skeletons of managed objects provided at the time of GDMO compilation. It provides a monitor and scheduler 43 that is responsible for concatenation with the actual resources.

Here, the external data structure 41 is files generated by the GDMO compiler 60 based on the GDMO document created by the agent developer, and used when initializing the corresponding internal data structure 42 in the agent initialization process. The tables are created as one independent file and added at the time of compiling a new GDMO document. The tables include object identifier (OID_table; Object Identifier_table), attribute information (attr_info_table), attribute group information (attr_group_info_table), and attribute property list (attribute_property_list). , Action information (action_info_table), package information (package_info_table), homomorphic (allomorph_table), name binding (name_binding_table), management object class information (mo_class_info_table), initial management object instance (initial_mo_instance_table), and the like.

The internal data structure 42 is a data structure managed in memory to provide a management service, each of which is implemented as a global scope array such that the include tree 50, the dedicated agent 30, and the management object are managed. Both are available and are initialized based on the corresponding external data structure 41 at the time of agent initialization, and the structures include ID (Id; Identifier), Domain Name (DN), and Relative DN (RDN). ), Attribute information (Attr_Info), attribute group information (Attr_Group_Info), attribute group (Attr_Group), attribute attribute pair (Attr_Property_Pair), action information (Action_Info), package information (Package_Info), homogeneous variant (Allomorph), name binding (Name_Binding) ), Management object class information (MO_Class_Info), syntax, and the like.

The scheduler among the corresponding monitors and schedulers 43 is responsible for calling a function of a managed object at regular time intervals. The function is created at the agent developer's implementation of a managed object. Examples of functions include interworking with real resources and other functions. Calls, exchanging information with other managed objects, and updating attribute values within a managed object. In addition, the monitor and the scheduler 43 of the monitor is responsible for calling the designated function in the object according to the signal received from the actual resource, the method and functions of the function is similar to the scheduler. However, in addition to using the scheduler and the monitor 43, interworking with the actual resource may be defined by redefining virtual functions related to management services such as get and set.

The code related to the management object is generated by the GDMO compiler 60 based on the GDMO document written by the agent developer, and consists of basic structures and codes for the properties and behaviors of the management object. Top Class) and services such as sets and get are provided as virtual functions in the top class. In class-level user code, if a developer wants to perform an action other than the basic actions such as communicating with a real resource or referencing or changing another managed object value during the get and set service for one administered object, the API provided by the top ( Application Program Interface), for example, in the case of get, describe it in functions such as 'before_get ()' and 'after_get ()'. In attribute-level user code, each attribute is implemented as a class and an API is provided to describe the user code on a per-property basis, with each class providing a 'before_get ()', 'after_get ()', etc. API is provided, and agent developer can change management service for each property. In addition, scheduler, monitor, and persistence APIs are added to the code according to the description of the option when compiling GDMO. Agent developers can specify functions such as registration and cancellation using the APIs.

The inclusion tree 50 is a structure that implements a containment relationship between managed objects, and has a location and domain name of the generated managed object. Therefore, all operations on the managed object are performed through this. Register after creating a managed object.

Here, the corresponding class level filtering is additionally provided. If the filter condition is related to an attribute or a class, the filter processing may be performed only by the internal data structure 42 before the filter is processed in the managed object, and unnecessary management objects may be removed. By primarily excluding, processing of filters within managed objects can be reduced to a minimum, reducing the burden on the system and improving overall speed.

In the tree structure, there are two kinds of data structures separate from the inclusion tree 50 in one node of the inclusion tree 50 having sub-instances. Only managed objects are selected and standard managed object search) and level-specific domain processing (N level or 1 to N levels) are separated for speed improvement. In this case, only the pointer of the actual node is stored in the data structure, which is advantageous in terms of speed improvement.

The GDMO compiler 60 generates a management object code by receiving a description of a management object described by a user, and a class capable of accommodating all information of the management object exists in order to generate the management object code. The new managed object is created using the managed object code generated by the user and the code written by the user, and the addition of the new syntax is performed by generating the C ++ code based on the document described in Abstract Syntax Notation 1 (ASN.1) document. . This requires the support of an ASN.1 ++ compiler consisting of an ASN.1 compiler 61 and a syntax compiler 62. In addition, the code generated by the GDMO compiler 60 exists in the form of a library, and the agent uses the linked code at the time of initial compilation or dynamically. Accordingly, the GDMO compiler 60 generates a new management object class even while the agent is in operation, and notifies the agent after creation of the new management object class so that the agent dynamically extends the management object class.

Here, the ASN.1 compiler 61 generates the necessary data types, encodes, decoders, and print routines based on the user's ASN.1 technical document, and the data types are generated in C code and encoded, decoders, and prints. Routines are generated for each type and use the ASN.1 compiler's own library.

The syntax compiler 62 generates syntax class codes using the data types and encode, decoder, and print routines received from the ASN.1 compiler 61, and the generated syntax class codes are additional required by the GDMO. The APIs, including routines, are provided in the form of virtual functions that can later be modified according to the user's intention, and register the generated classes in the database so that other GDMO technologies can refer to them after the generation of the corresponding syntax class code. .

In addition, the GDMO compiler 60 generates the actual managed object code by using the GDMO technology defined by the user. The syntax class and attribute and the managed object database generated by the syntax compiler 62 are searched for necessary classes. This creates the managed object code, adds the code described by the user for matching with the actual resource and changes in the basic management service, and compiles the added code into a library. In this case, the generated libraries are added at the time of agent system compilation and included in the agent through the dynamic class addition function when a new management object is created during the agent operation.

The lower communication structure 70 is a module that is in charge of communication between the manager and the agent. An association control service element (ACSE) is used for management association and a remote operations service element (ROSE) is used for management information transmission.

Common Management Information Protocol (CMIP), which is a network management protocol, uses ACSE and ROSE as a communication base, and uses the CMIP API to use the ACSE and ROSE.All management such as get and set between manager and agent through the CMIP API The operation is made.

Then, it solves the problem of the waste of system resources and management information, which is the problem of the conventional technology method, is the key to the development of network management platform, supports the management standard of TMN, and the internal information management mechanism considering scalability and portability. Examine the structure.

First, referring to the external data structure 41, the external data structure 41 is information used when initializing the internal data structure 42, that is, when initializing class information and instance information. The developer describes a network element that is actually managed using a GDMO document, and generates the described document as a file for initialization of the internal data structure 42 using the GDMO compiler 60. In this case, the finalizers of the generated files are 'tbl', and the files necessary for initializing the internal data structure 42 include a management object information class file, a package information class file, an attribute information class file, and an operation information class file. .

In addition, the GDMO compiler 60 may refer to the syntax forms output through the ASN.1 compiler 61 and the syntax compiler 62 after being described in the ASN.1 document, and then refer to the syntax forms described in the GDMO document. Parse and generate external files.

The external file, information stored in the external file, and related internal structure data may be represented as shown in Table 1 below.

External file name Storage information Related Internal Data Structures (Class) oid_table.tbl OID_string.int IdId_Tree attr_info_table.tbl OID, int, Syntax [], int Attr_InfoAttr_Info_Tree attr_group_info_table.tbl OID, Bool, int, OID [] Attr_Group_InfoAttr_Group_Info_Tree action_info_table.tbl OID, Bool, Syntax [], Syntax [] Action_InfoAction_Info_Tree package_info_table.tbl OID, OID [], int, OID, int, OID, int, OID Package_InfoPackage_Info_Tree allomorph_table.tbl string, string [] Allomorph initial_mo_instance_table.tbl string, DN none name_binding_table.tbl OID, OID, int, OID, int, OID, Bool, Bool Name_BindingName_Binding_Tree attribute_property_pair_table.tbl OID, OID, int, Syntax, Syntax, Syntax, Syntax, Attr_Property_PairAttr_Property_Pair_Tree mo_class_info_table.tbl OID, OID [], OID [], OID [], OID [], OID [], OID [], bool, int Mo_Class_InfoMo_Class_Info_Tree

Here, the object identifier table (oid_table.tbl) is a file that stores identifier information for all objects. The object identifier table (OID), string type name, and local integer value are used. Are stored in order. At initialization, internal data structure IDs are created in sequence using the stored information, and the created IDs are registered and managed in ID_Tree.

The 'attribute information table (attr_info_table.tbl)' stores information for managed object attributes in the managed object. Each attribute information is read to generate attribute information (Attr_Info), which is an internal data structure, and registered in the attribute information tree (Attr_Info_Tree). The contents include the ID of the attribute, an integer value indicating the attribute's qualifier, parameters of the attribute, and an integer value indicating the number of parameters.

The 'attribute group information table (attr_group_info_table.tbl)' is an external file that stores attribute group information. The attribute group ID, information indicating whether the group can have additional attributes, and the actual attribute group has IDs of attributes and the number of attributes included. The agent reads the file to generate attribute group information (Attr_Group_Info) and registers it in the attribute group information tree (Attr_Info_Tree).

The action information table (action_info_table.tbl) is an ID of an action, a type of action, that is, a Boolean value indicating whether it is a confirmed type or a nonconfirmed type and an action information ( Syntax of Action_Info) and syntax of Action Reply.

The package information table (package_info_table.tbl) contains information for a package in a management object class. The package information table (package_Info_Tree) is generated and initialized in the package information tree (Package_Info_Tree). The components in the file include the package ID, the IDs of the attribute groups to be included in the package and the number of attributes included, the IDs and additional attributes of the added attributes, the IDs and the number of attributes included in the package, the IDs of the incident reports, The number of incident reports included.

The corresponding homomorphic table (allomorph_table.tbl) stores information for supporting the allomorphism function. The information stored in the file has an ID of the homogeneous heterogeneous class and corresponding IDs of the actual classes. This real class is a class that can create a real managed object. The file is described by the user, and at initialization of the agent, the contents are read from the file to create a homogeneous heterogeneous internal data structure.

The 'initial management object instance table (initial_mo_instance_table.tbl)' contains information on management objects to be created at initialization, and the information relates to the domain name of the management object to be created and the management object class. The file is related to the creation of managed objects and not the creation of the actual internal data structure.

The 'name binding table (name_binding_table.tbl)' stores name binding information, and creates and uses a name binding (Name_Binding) and a name binding tree (Name_Binding_Tree) at initialization. The file contains the name binding ID, the upper class ID and the lower class ID, the option information of each subclass, the ID attribute name, the create object modifier (create_modifier), and the delete object modifier (delete_modifier).

The 'attribute_property_pair_table.tbl' stores an attribute attribute pair template that stores attribute information of managed object attributes. Initialization is used to create the internal data structures of the attribute property pair (Attr_Property_Pair) and the attribute property pair tree (Attr_Property_Pair_Tree). The first field of data stored on disk contains the ID of the package to which the property belongs, the ID of the property, and an integer value to indicate the property of the property. The next fields include the default value and initial value of the property. Value, Permitted Value, and Required Value are stored in this order.

In addition, the 'managed object class information table (mo_class_info_table.tbl)' is an external file for the managed object class, and initializes and creates internal data structures of the managed object class information (Mo_Class_Info) and the managed object class information tree (Mo_Class_Info_Tree). In this file, the ID of the object class itself, the IDs of the upper classes in the inheritance tree, the IDs of the subclasses, and the IDs of the name bindings to be used when the actual managed object is created in relation to the managed object class. , IDs of packages, IDs of actual classes that can replace themselves in the case of homogeneous classes, and flag values indicating whether they are real classes or homogeneous classes.

Second, the internal data structure 42 is described as follows.

The managed object maintains the management information of the actual network element. For example, if one network element is assumed as the exchange, the management information of the network element is the characteristics of the telephone line currently in use, the operation state of the exchange, and the data. Their flow states.

The management object information is managed by classifying the instance information, which is the information constituting the inclusion tree 50, and the class information, which is information that the instances have in common. Here, the information on the class of the management object includes information such as attributes, packages, operations, and notifications, and information on the same properties, packages, operations, and notifications may be maintained in various management object classes. The instance information of the management object is information that the management object is registered and used in the inclusion tree 50, and is stored in a management system memory at the start of the operation of the platform. 50) In addition to using another tree, a tree is created for each instance information. At this time, the internal data structure 42 maintains the class information and the instance information.

In addition, the internal data structure 43 is initialized by the external data structure and represents information such as management objects, attributes, attribute groups, packages, actions, notifications, parameters, actions, etc., and the interrelationships between the corresponding information.

As described above, management information required by all management objects is collected and managed in the internal data structure 42 in one space, whereby the structure of the management object is simplified and management of the management information is easy. In addition, information in which management objects are commonly used has the same pointer value to the internal data structure 42, thereby reducing waste of system resources, reusing management information, and improving the information.

The internal data structures 42 are all implemented as classes and use the class member function to obtain management information of the class. Each class is registered and maintained in the Balanced Tree that supports the template, and the agent uses the API provided by the tree to obtain the required class information. The API includes a function to register a new instance (insert ()) and a function to find a registered instance (find ()). The balance tree is placed globally so that anyone can access and use it in an agent-managed area.

Configurations of the network management platform according to an embodiment of the present invention have a close relationship with each other, and the overall operation flow thereof is largely illustrated in FIG. It consists of a second process (S2) for performing the linkage and the third process (S3) for performing the management service.

First, referring to the flowchart of FIG. 4 regarding the agent initialization of the first process S1, the agent kernel 20 is stored from the external data structure 41 stored in the auxiliary storage device when the network management platform starts. ), The necessary data structures are read sequentially (step T1). Here, the external data structure 41 stores information related to the managed object and is additionally generated when the GDMO compiler 60 compiles the GDMO document. The initialization of the internal data structure 42 is performed between the manager and the agent. It refers to the process of resident information exchanged in the memory of the system, and maintains the association between the read files while resident in the memory.

In order to maintain the association between the read files, the agent kernel 20 sequentially reads external files from the external data structure 41 and has pointers to information commonly used with each other (step). T2).

For example, the initialization is started by reading the first external file (OID_table.tbl) and creating instances of ID (Id), and then reading the second external file (Attr_Info. Tbl) to read the instance of attribute information (Attr_Info). Create them. There is an ID that is initialized as a member of the corresponding attribute information instance. The attribute information instance does not have its ID value but has only a pointer to the value.

In addition, the third external file Attr_Group_Info.tbl is read to create instances of attribute group information Attr_Group_Info. The attribute information, which is a member, has only a pointer value of attribute information already initialized.

In the same way, create the instances in the 4th, 5th, and so on, in order of the external files, and have a pointer value as the value of the members they have. And, in the case of the last managed object class information (MO_Class_Info), the member has its ID, its parent managed object, attributes, name binding information, and packages.

To get the information of the members, you need to use the corresponding pointers. For example, to use the information of the packages maintained by the management object, you must have the pointer values of the packages. You must get all the information. In other words, using the pointer values maintained by the package, the pointer can be moved back to the pointer to obtain the information.

As a result, in order to maintain a single management object information, the internal data structure 42 generates a package commonly used, and then manages objects to use the package only with a pointer value indicating the package. That is, it shows that there is only one package, but there can be many usage management objects. In addition to packages, other management information classes have the same mechanism.

Thus, the data structure read from the external data structure 41 is stored in the internal data structure 42 (step T3) and the pointers between the internal data structures 42 are connected (step T4).

In addition, the management object creation function in the management object class information (MO_Class_info) is performed to generate management objects described as initial creation instances (step T5), and in the MIB 44 in the object framework 40, network elements, which are actual resources, are generated. After opening the information exchange path (step T6), the connector is identified and stored (step T7), and in the fifth step (T5), the effect of the creation of the managed objects is transmitted to the corresponding network element (step T8).

Meanwhile, the MIB 44 in the object framework 40 checks whether the managed objects created in the fifth step T5 are managed objects for which a polling service is desired or require a monitor service ( Step T9), if the management objects created in the fifth step (T5) is a management object for the polling service, the object framework using the set time, execution time, execution function and the connector stored in the seventh step (T7) It registers with the scheduler 43 in 40 (step T10). Accordingly, the scheduler 43 periodically performs the designated functions so that the designated functions are interworked using the network element and the connector (step T11).

However, if the management objects created in the fifth step T5 are management objects requesting the service of the monitor, the management objects in the object framework 40 using only the execution function and the connector stored in the seventh step T7 are used. It registers with the monitor 43 (step T12). Accordingly, the monitor 43 monitors the connector from the registered time and performs the designated function when there is an input (step T13).

The instances generated accordingly are registered in the inclusion tree 50 in the MIB 44 (step T14). At this time, each node of the inclusion tree 50 has a pointer to the instance to access the MIB 44, and access to the MIB 44 is always made through the inclusion tree 50 (step). T15).

Second, referring to the flowchart of FIG. 5 for the association with the manager of the second process (S2), when the administrator requests the agent kernel 20 to establish the association, the agent kernel 20 corresponds to the corresponding agent. Check the association setting request of the manager (step T16) and creates a dedicated agent 30 to take care of the manager (step T17).

Then, the agent kernel 20 generates an association number and authorizes it to the dedicated agent 30 (step T18), and the dedicated agent 30 uses the manager in charge of the agent and the corresponding manager using the associated number. Management information is exchanged.

That is, the dedicated agent 30 transmits a response to the manager's association request using the association number received from the agent kernel 20, and starts waiting for a management service request from the administrator (step T19).

Third, referring to the flowchart of FIG. 6 for performing the management service of the third process (S3), when the administrator requests the management service from the dedicated agent 30, the dedicated agent 30 may correspond to the flowchart. The management service request of the manager is checked (step T20), and whether or not a filter error is determined for the management service request (step T21).

The dedicated agent 30 checks whether the management service request is a management object creation request (step T22) and performs the fifth step (S5) during the agent initialization process of the first step (S1) without performing class level filtering. In operation T23, a process from generating and managing a management object generating function of T5 to performing access to the MIB 44 of the fifteenth step T15 is performed (T23). However, if the management service request is not a management object creation request, class level filtering is performed using the internal data structure 42 (step T24).

Thus, the dedicated agent 30 performs management on the include tree 50 and class level filter to select managed objects (step T25), and the include tree 50 requests before accessing the managed object. It is determined using the internal data structure 42 whether permission of the managed service is granted to the corresponding managed object and whether the corresponding value is appropriate (step 26).

Accordingly, the MIB 44 performs a function in the management object according to the type of the management service in the inclusion tree 50, at which time the corresponding service function described in the agent class is generated as a thread (step T27). In the created thread, the function in the managed object is executed (step T28).

For example, if an administrator makes a get service request and a number of managed objects are selected, an administrative thread will be created to manage the threads. At this time, the dedicated agent 30 waits for the cancel get service from the manager.

If necessary, the MIB 44 redefines service functions in the managed object to access a network element (step T29). At this time, the agent developer provides a managed object level user code API and an attribute level user code API, respectively. Give flexibility to

Finally, the MIB 44 terminates the thread after responding to the administrator requesting the result of performing the management service (step T30) (step T31), and if the corresponding connection is answered, the dedicated agent 30 A blank response is sent to the administrator (step T32).

As described above, in providing the OSI network management concept and the TMN concept according to the present invention, parallelism of management operations, efficient concatenation with actual resources, and the like through dedicated agents, schedulers, monitors, dynamic addition of classes, and access to databases, It provides the persistence of management, and also divides the management object information into instance information and class information, and manages all management information in the network management platform by gathering them into one space of the internal data structure, thereby simplifying the structure of the management object and managing the management information. In addition, by reducing the duplication of commonly used management information, it is possible to reduce waste of system resources and to reuse management information, thereby improving agent performance and performance.

Claims (9)

An agent kernel 20 for initializing the agent and establishing and transferring the connection with the manager, and providing dynamic addition of a class to handle agent extensibility; Dedicated agent 30 exists in the form of a thread by the cooperative delivery of the agent kernel 20, responsible for one or more administrators to perform a management service; Provides external and internal data structures (41, 42) that provide data, and a monitor and scheduler (43) responsible for concatenating the execution code base skeleton of managed objects provided at GDMO compilation and actual resources. An object framework 40 for providing data and code; A structure that implements a containment relationship between managed objects, comprising: an inclusion tree 50 having a location and a domain name of the managed object and serving as a reference point for all operations on the managed object; A GDMO compiler 60 for receiving a description of a managed object described by a user to generate a managed object code, creating a new managed object using the corresponding managed object code and a user-written code, and adding a new syntax; And a lower communication structure (70) that is in charge of the communication between the manager and the agent. The method of claim 1, The internal data structure 42 distinguishes and maintains the instance information which is the information constituting the inclusion tree 50 and the class information which is information that the instances have in common, and is initialized and managed by the external data structure 41. A network management platform, comprising information about an object, an attribute, an attribute group, a package, an action, a notification, a parameter, an action, and a correlation between the information. The method of claim 2, The internal data structure (42) is characterized in that after generating the class information, the management objects to use the generated class information having a pointer value indicating the generated class information. Performing initialization of the agent; Performing an association with an administrator according to an association establishment request; Network management method comprising the step of performing the management service according to the management service request. The method of claim 4, wherein The agent initialization process may include assigning a pointer to information commonly used while reading a data structure required by the agent kernel from an external data structure; Storing the read data structure in an internal data structure to connect pointers between the internal data structures; Performing a management object creation function to generate management objects of the initial creation instance; Establishing an information exchange path with a network element to store the connector and notifying the network element of the effect of the creation of the managed objects; Checking whether the generated management objects are a polling service request management object and registering them with a scheduler using a set time, execution time, execution function, and the connector; Periodically performing the designated functions to link the designated functions using the network element and the connector; Registering the created instances with an inclusion tree; And performing access to a MIB by allowing each node of the inclusion tree to have a pointer to the instance. The method of claim 4, wherein The agent initialization process may include checking whether the created management objects are monitor service request management objects and registering them with a monitor using an execution function and the connector; Monitoring the connector from the registered time and performing a designated function only upon input. The method of claim 4, wherein The linking process with the manager may include: checking a request for setting a linkage of the manager to generate a dedicated agent; Generating an association number and authorizing it to the dedicated agent; And exchanging management information with the corresponding manager after transmitting the linkage request response using the associated manager with the link number. The method of claim 4, wherein The performing of the management service may include determining an error of a filter by checking a management service request; Performing class level filtering using the internal data structure; Performing region processing and class level filter processing on the inclusion tree to determine whether the requested management service is permitted and whether the corresponding value is appropriate before selecting the management objects to access the management object by using the internal data structure. Steps; Creating a service function in the management object according to the type of the management service as a thread and executing the function in the created thread; Redefining service functions in the managed object to access a network element to provide a managed object level user code API and an attribute level user code API, respectively; Notifying an administrator of a result of performing the management service; Terminating the thread and sending a blank response to an administrator. The method according to claim 4 or 8, The performing of the management service includes checking whether the management service request is a management object creation request and performing a management object creation function to generate management objects of an initial creation instance; Establishing an information exchange path with a network element to store the connector and notifying the network element of the effect of the creation of the managed objects; Checking whether the generated management objects are a polling service request management object and registering them with a scheduler using a set time, execution time, execution function, and the connector; Periodically performing the designated functions to link the designated functions using the network element and the connector; Registering the created instances with an inclusion tree; And performing access to a MIB by allowing each node of the inclusion tree to have a pointer to the instance.