KR20000026293A - Class level filtering mechanism for network management system - Google Patents

Abstract

PURPOSE: A class level filtering mechanism for a network management system is provided to improve a managing objection selection speed through a newly structured tree and a class level filtering. CONSTITUTION: A class level filtering mechanism for a network management system includes a filter processor for analyzing a constitution filter and storing a stack data structure, an initial filter processor, and a filter length inspector. The initial filter processor inspects an initial filter, manages an objection identification, compares the object identification with an internal data of a managing objection class node, calculates a logic equation according to the comparison, and restores the calculated results in the stack data structure. The filter length inspector inspects a length of the filter and returns an overall results of the class level filtering according to the length of the filter.

Description

Class Level Filtering Mechanism in Network Management System

The present invention relates to a class level filtering mechanism of a network management system. In particular, the present invention relates to a class level filtering mechanism in a network management system that improves the speed of selection of managed objects through the inclusion of a new structure and class level filtering. It is about.

In general, a Telecommunication Management Network (TMN) adopts an Open System Interconnection (OSI) network management scheme. The OSI network management scheme uses a manager and an agent model. The administrator is responsible for one or more management operations and requests management operations services from the agent, and the agent manages the management objects in the agent management area, performs the management operations services requested by the administrator, or receives notifications from the management objects. Notification) is informed to the administrator.

The management objects store management information of an actual network element, provide management information to an administrator, and retain the latest management information through interaction with the actual network element. The management objects have a logical relationship of inclusion relations with each other according to name binding information of a management object class in which the management objects are generated. It will keep the containment tree internally. 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.

The agent must first select management objects according to the management service request of the corresponding administrator. For this purpose, a specific area is set on the inclusion tree. The set specific area is designated by the administrator and consists of a Base Managed Object, a Scope Type, and a Scope Level.

Then, when the agent performs the management operation service according to the management request of the manager and briefly examines the operation of notifying the result of the execution, the agent receives the service request information from the manager, analyzes the service request, and prepares to perform the service. Do

At this time, if the service request information is not appropriate, an error is sent to the administrator. When the analysis of the corresponding service request is completed, the management objects that are the targets of the actual management operation should be selected, which goes through two processes, namely, region processing and filtering.

This area processing refers to setting the area on the inclusion tree according to the type and level value of the area processing specified by the administrator. The inclusion tree is a data structure that manages managed objects according to logical inclusion relations in the agent system.

For example, the region processing form on the inclusion tree may be represented as shown in FIG. 1, which briefly illustrates a containment subtree from a base object instance.

In this case, the agent performs filtering on the managed objects belonging to the selected area once again through filtering. At this time, the operation is performed only when the administrator requests the filtering. If the filtering is not required, the operation is not performed.

The filter for performing the filtering is delivered in a structure defined as a Common Management Information Service (CMIS) filter, which is a syntax defined as Abstract Syntax Notation 1 (ASN.1) in the standard.

In addition, the filter is represented by a logical expression. For example, the filter may be represented by 'a AND b', 'a OR ((NOT b) AND c)', and the like. Here, the 'a', 'b' and 'c' represents an item (Item), the internal structure of each item consists of an object identifier (OID), an operator and its value. The OID represents the object identifier of the attributes constituting the managed object, and the operator is 'equal', 'greaterOrEqual', 'lessOrEqual', 'present', 'subSetOf', 'superSetOf', 'nonNullIntersection', etc. String) operator, whose value represents the value of the managed object attribute to be compared.

That is, the filter is a logical expression that combines each item with logical operators 'AND', 'OR', and 'NOT'.

Accordingly, the filtering determines whether the final management operation is included or not by applying the information of the filter to the management object to derive a result of a Boolean value. Then, the agent applies the filter to the management object to perform the last screening operation, the management operation is performed on the management objects that passed the screening task and delivers the result to the manager.

However, in the related art, since the filtering of all managed objects in the selected area after the area processing has to be performed by applying a complex logical expression to each managed object, the share of the total management operation service execution time is turned on. It takes a large part of the management operation time, which greatly affects the overall performance of the network management system.

In order to solve the problems as described above, the present invention reduces the number of times of filtering by using the inclusion tree of the new structure and the class level filtering mechanism in the network management system, thereby reducing the time of filtering managed objects to increase the speed of selecting managed objects. It aims to improve.

BRIEF DESCRIPTION OF THE DRAWINGS Fig. 1 is a diagram illustrating a region processing form on an inclusion tree in a conventional network management system.

2 is a diagram illustrating a structure of an inclusion tree in a network management system according to an embodiment of the present invention.

FIG. 3 is a diagram showing the configuration of a managed object node in FIG. 2; FIG.

4 is a diagram showing the configuration of a managed object class node in FIG.

FIG. 5 is a diagram showing the configuration of a managed object information node in FIG. 2; FIG.

FIG. 6 illustrates class level filtering on an inclusion tree in FIG. 2; FIG.

FIG. 7 is a diagram illustrating a filter used for class level filtering in FIG. 6.

Explanation of symbols on the main parts of the drawings

20: Administered Object Node 30: Administered Object Class Node

40: managed object information node 50: internal data structure

51: class information 52: package information

53: property information

In the network management system according to an embodiment of the present invention for achieving the above object, the class level filtering mechanism includes a configuration filter processing portion for analyzing, decomposing and storing the configuration filter in a stack data structure; An initial filter processing portion that examines an initial filter, compares the OID stored in the examined initial filter with internal data structure information of a managed object class node, calculates a logical expression, and re-stores the calculated result in the stack data structure; And a filter length investigation part for examining the length of the filter and returning the entire result of class level filtering according to the value of the investigated filter length.

Here, the component filter processing part is recursively processed according to the priority level value of the filter, and when the regression call is performed, a logical operation is performed by reading a filter stored in the stack according to a logical operator. The filter length is a priority level of an expression, and when the corresponding priority level is large, recursive calls of class level filtering are increased.

Alternatively, the process of performing the class level filtering mechanism in the network management system according to an embodiment of the present invention for achieving the above object includes the steps of decomposing the filter; Processing the components of each of the decomposed filters; It is characterized by including the process of checking and returning whether the termination condition.

Here, the filter decomposition process may include checking a case of decomposing a basic filter element having the same priority and checking whether an attribute in the basic filter element exists in a class before performing the filter decomposition process; Restoring the test results to a filter stack; Requesting reassembly with a recursive call if there is a basic filter component of the same level previously processed. Alternatively, the filter decomposition process may include storing a logical operator on a stack that identifies a case of decomposing a base filter component having a different priority and binds the base filter components; And repeating the filter decomposition process through recursive recall.

The filter processing may include storing a result of processing the components of each of the decomposed filters on a stack; Calculating a logical expression using the stack; Storing all of the final results at the top of the stack upon completion of all processing. The logical calculation step may include reading each operator one by one using a switch statement; Calculating a logical expression by reading a Boolean value belonging to the read operator; And restoring the calculation result to a stack.

The return process may include checking a case where the input filter is zero; Checking the case where the value of the filter length is an initial value by disassembling and processing the input filter through a recursive call; Confirming that all operations have been completed, and reading and returning the final result from the top of the stack to terminate all operations.

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

2 is a diagram illustrating a structure of an inclusion tree in a network management system according to an exemplary embodiment of the present invention, FIG. 3 is a diagram illustrating a configuration of a managed object node in FIG. 2, and FIG. 4 is a managed object class in FIG. 2. 5 is a diagram showing the configuration of a node, FIG. 5 is a diagram showing a configuration of a managed object information node in FIG. 2, FIG. 6 is a diagram showing class level filtering on an inclusion tree in FIG. 2, and FIG. Shows an example of a filter used for class level filtering in FIG.

As shown in FIG. 2, the network management system according to the embodiment of the present invention forms an inclusion tree of a structure for reducing the execution time of the overall management operation service, and the inclusion tree largely represents actual management objects. Managed object class nodes with managed object class information such as attributes, actions, and notifications that can be created by the created managed object. (Part shown in a square, 30), a node forming a binary search tree, a managed object information node having a relative distinguished name (RDN), which is a key value of the corresponding binary search tree, and a pointer of the managed object node. Field (parts indicated by circles, 40). Here, the corresponding managed object nodes and managed object class nodes are managed as bidirectional linked lists at each level and utilized in area processing.

Let's take a closer look at each component of the include tree above:

The managed object node 20 is a node representing a managed object, and as illustrated in FIG. 3, a managed object (mo), a binary search tree (bst), and an identification name (dn; distinguished name), a previous managed object node (previous), a subsequent managed object node (next), and a first node (classnode).

Here, the management object mo represents the management objects actually generated and has management information of network resources to be managed. The binary search tree (bst) represents a binary search tree for each managed object and exists for basic managed object search. Nodes constituting the binary tree collect managed objects of the lower first level of the managed object. The distinguished name (dn) stores the DN value, which is the name of the managed object. The previous managed object node (previous) and the subsequent managed object node (next) have pointers to both siblings on the list. The first node (classnode) points to the first node of the lower first level managed object class list.

The managed object class node 30 represents an managed object class and is an intermediate management node for separating and managing managed objects for each class. As shown in FIG. 4, an object identifier (oid) and class information (classinfo) And a previous management object class node (previous), a subsequent management object class node (next), and a management object node list (monode).

Here, the object identifier (oid) represents an object identifier (OID) that can be regarded as a name of a management object class. The classinfo (classinfo) stores the information of the management object class of attributes, operation notifications. The previous managed object class node (previous) and the subsequent managed object class node (next) have pointers to both siblings on the list. The corresponding managed object node list (monode) represents a list of subordinate managed object nodes.

As shown in the internal data structure 50 with respect to the class information of the management object class node 30, the class information 51 represents each management object class, and the management object classes correspond to a package and naming. ), And each package information 52 is composed of attributes, notifications, actions, etc., and is connected by pointers. Each attribute information 53 has its own OID and syntax information. Has That is, the management object classes represent all the attributes of the class through the information provided by the corresponding internal data structure 50. Also, the management object class node 40 has information related to the class and thus class-level filtering. This will be the node being executed.

The managed object information node 40 is a node forming a binary search tree. As shown in FIG. 5, an RDN value rdn, which is a key value of a search, and left and right nodes representing left and right lower nodes on the tree, as shown in FIG. 5. And a managed object node (Monode) having a pointer of the corresponding managed object node.

In this case, since the RDN values of the management object nodes having the same level on the inclusion tree are different from each other, the management object nodes are used as key values of a binary search tree for searching for management objects. The binary search tree is a data structure that exhibits excellent performance in search operations. In the include tree, each managed object node manages its subordinate managed object nodes in the corresponding binary search tree, and the base managed object search that is the starting point of region processing. It is used in poetry.

In addition, finding a particular node among the managed object nodes of one level is much more efficient to search in a binary search tree than on a list.

Conventional filtering is a form of performing an expression by applying the filter's OID, its value, and an operator to an attribute in a managed object. However, the class level filtering mechanism in the network management system according to an embodiment of the present invention uses only the filter's OID. In this case, managed objects are selected while being processed simultaneously with the region processing in the include tree.

For example, as shown in FIG. 6, if the condition of the filter is '(a = 1 OR b> 10) AND id = "panzee"' and the area processing type is the nth level and the area processing level value is 1. When there is no 'id' attribute, which is an attribute of a managed object to be filtered in a managed object class, the entire filtering result is false, so managed objects created in the class can be excluded from filtering.

That is, unless only class B nodes have an id attribute and class A and C nodes do not have an id attribute, managed objects created from classes A and C that do not have a corresponding id attribute will not perform filtering. Since it is meaningless, if the class level filtering is performed only on the A class node which is the selected managed object class node after the realm processing, the realm can be further reduced.

And, as shown in Figure 7, the filter is represented by a number of components. Here, the component is a basic unit that constitutes the CMIS filter, and can be divided into operators and items such as 'OR', 'AND', and 'NOT', and the item is the content used to perform the actual filtering. These operators are responsible for binding the items together.

(A) of FIG. 7 shows a case where the filter condition is' (test = "adc") ', and (b) shows' ((testInteger = 1) and (testString = "adc")) or (testReal = 1.234) ', (C) indicates' (testInteger = 1) and ((testString = "adc") or (testReal = 1.234)) ', and (d) means' (testInteger = 1) and ( A diagram showing a case where testString = "adc") '.

Here, (a) of FIG. 7 consists of one component, and thus, a filter composed of one item without an operator is called a primitive filter, and the rest of FIGS. 7 (b) and ( c) and (d) correspond to the constructed filter.

Then, looking at the class level filtering mechanism in the network management system according to an embodiment of the present invention, it can be divided into three parts, constituent filter processing portion, initial filter processing portion, and filter length (filter_depth) investigation portion.

First, the constituent filter processing part analyzes the constituent filter, decomposes the analyzed constituent filter, and stores the analyzed constituent filter in a stack data structure. The constituent filter processing part is recursive according to the filter's priority level value. When returning from a regression call, the logical operator retrieves the filter stored on the stack and performs the logical operation.

Secondly, the initial filter processing part examines the initial filter and compares the OID stored in the examined initial filter with internal data structure information of a managed object class node, and calculates a logical expression, and the calculated result is again stacked data structure. Store in

Third, the filter length investigation part examines the filter length and returns the entire result of class level filtering if the value of the inspected filter length is '1'. Here, the filter length indicates the priority level of the expression. If the priority level of the filter is large, the value of the filter length is increased and the recursive invocation of class level filtering is increased.

In addition, the process of performing the class-level filtering mechanism in the network management system according to an embodiment of the present invention is to largely decompose the filter, process the components of each decomposed filter, and confirm whether the termination condition is returned. There is a process.

Looking at the first filter decomposition process, we first determine whether to decompose a base filter component with the same priority or a base filter component with a different priority.

Therefore, when decomposing a basic filter element having the same priority, it is checked whether an attribute in the basic filter element exists in a class and stores the result of the check in the filter stack before performing the filter decomposition process. However, if there is a basic filter element of the same level that was previously processed, the process of disassembling and processing again as a recursive call is repeated.

On the other hand, when decomposing basic filter components having different priorities, the logical operator that binds the basic filter components is stored on the stack, and the decomposition process is repeated through a regression call.

In the process of processing the components of each second factorized filter, the filter stack stores boolean values and logical operators, and each stack item type stored in the filter stack is defined as a structure to store both values. By doing so, the stack will store the results of the current filter process, and once all processing is complete, the final result will be stored at the top of the stack.

In addition, the logical calculation process using the stack uses a switch statement to process each case of 'AND', 'OR', and 'NOT' and stores the result on the stack. That is, one logical operator is read, a Boolean value belonging to the logical operator is calculated, the logical expression is calculated, and the result is stored on the stack.

In the process of checking for and returning a third terminating condition, the class-level filtering mechanism uses a recursive invocation method, which continues to operate until the terminating condition is satisfied. ), And also through continuous regression call, when the decomposition and processing of the corresponding input filter is finished and the filter length value reaches the initial value of '1', all the operations are finished and the result is determined from the top of the stack. Read and return and terminate all actions.

As described above, according to the present invention, the number of times of filtering is reduced through the structure of the inclusion tree having class information and the class level filtering, thereby reducing the time of filtering the managed object, thereby improving the speed of selecting the managed object.

Claims (9)

A component filter processing portion for analyzing, decomposing and storing the component filters in a stack data structure; An initial filter processing portion that examines an initial filter, compares the OID stored in the examined initial filter with internal data structure information of a managed object class node, calculates a logical expression, and stores the calculated result in the stack data structure; And a filter length investigation part for investigating the length of the filter and returning the entire result of class level filtering according to the value of the inspected filter length. The method of claim 1, The constituent filter processing part is recursively processed according to a priority level value of a filter, and performs a logical operation by reading a filter stored in the stack according to a logical operator when a regression is called. Class-level filtering mechanisms. The method of claim 1, The filter length is a priority level of an expression, and when the corresponding priority level is large, the class level filtering mechanism in the network management system, characterized in that a large number of recursive calls of class level filtering. Disassembling the filter; Processing the components of each of the decomposed filters; A class-level filtering mechanism in a network management system comprising the step of confirming and returning a termination condition. The method of claim 4, wherein The filter decomposition process may include checking a case of decomposing a base filter element having the same priority and checking whether an attribute in the base filter element exists in a class before performing the filter decomposition process; Restoring the test results to a filter stack; A class level filtering mechanism in a network management system comprising the step of requesting reassembly with a recursive call if the same level of basic filter components previously processed exist. The method of claim 4, wherein The filter decomposition process may include: storing a logical operator on a stack that identifies a case of decomposing basic filter elements having different priorities and binds the basic filter components; A class level filtering mechanism in a network management system, comprising repeating the filter decomposition process through recursive recall. The method of claim 4, wherein The filter process includes storing the results of processing the components of each of the decomposed filters on a stack; Calculating a logical expression using the stack; And storing the final result at the top position of the stack when all of the processing is completed. The method of claim 7, wherein The logical calculation step includes reading each operator one by one using a switch statement; Calculating a logical expression by reading a Boolean value belonging to the read operator; And classifying the result of the calculation on a stack. The method of claim 4, wherein The return process may include identifying a case where an input filter is zero; Checking the case where the value of the filter length is an initial value by disassembling and processing the input filter through a recursive call; The class level filtering mechanism in the network management system, comprising the step of confirming that all operations have been completed, reading the final result from the top of the stack, and returning to terminate all operations.