KR100500837B1 - Method for managing common database in network operating systems - Google Patents

Abstract

The present invention relates to a method of managing shared information between operating systems that can observe the integrity rule (integrity rule) for information shared between the operating system, the operation in a state in which a plurality of nodes corresponding to the operating system is connected through a network A method of managing sharing information between systems, the method in which a specific node (managed node) among the nodes collects log information about shared information changed in each node at predetermined intervals and stores the log information in a database constructed for each node in the managed node. 1 course; A second step of detecting reference data to be applied to each node sequentially from the first node using log information stored in the database constructed for each node; And a third process of handling sharing information stored in a database constructed at each node by using the reference data.

According to the above-described configuration, the integrity of the shared information can be ensured without having to install a program for applying the integrity rule for the shared information to each node corresponding to the operating system. Even if it is reset, the log information is automatically recovered to improve the stability of the system.

Description

Method for managing common database in network operating systems

The present invention relates to a method of managing shared information between operating systems, and more particularly, to comply with an integrity rule for information shared between operating systems.

The network management system that manages the operation status of network resources scattered locally stores data shared with other network management systems for efficient network resource management. Such data is called shared information.

Since the shared information is a data that is accessed and used by a plurality of network management systems, integrity must be guaranteed, and two or more DB servers operate to comply with the integrity rules applied to ensure such integrity. Although it is common to use replication options that exist on the server at the same time and are always synchronous, these features are stable at the Database Management System (DBMS) level, but they are costly but expensive. There is a limitation to use, and there is a disadvantage that it cannot be linked with other DBMS.

Accordingly, the present invention has been made to solve the above-mentioned conventional problems, and the specific system managing the operating system collects the changed state of the shared information generated in each operating system so that each operating system has the same shared information. The purpose is to provide a method of managing shared information among management systems.

Shared information management method between the operating system according to a preferred embodiment of the present invention to achieve the above object,

In the shared information management method between operating systems in a state that a plurality of nodes corresponding to the operating system is connected through a network,

A first step in which a specific node (managed node) among the nodes collects log information about shared information changed in each node at predetermined intervals and stores the log information in a database constructed for each node in the managed node;

A second step of detecting reference data to be applied to each node sequentially from the first node using log information stored in the database constructed for each node; And

And a third process of handling sharing information stored in a database constructed at each node by using the reference data.

Hereinafter, with reference to the accompanying drawings will be described an embodiment of the present invention in more detail.

1 is a configuration diagram of a system to which a method for managing sharing information between operating systems according to an embodiment of the present invention is applied.

As shown in FIG. 1, while the A node, the B node, the C node, and the N node are connected to each other through a network, the N node operates by applying an integrity rule to shared information changed in the A node, the B node, and the C node. Manage shared information between systems.

Node in the present invention means a network management system, if one network management system is composed of several systems to build an independent DB in each system corresponds to each independent server. In addition, the system in which the program of the present invention is operated also becomes a node.

Nodes A, B, and C have a DB that stores log information corresponding to changes to shared information.

On the other hand, buffer management of the concept of a queue by triggering is performed for each node, and the data change contents are recorded in real time. The construction form of the real-time data is composed of data, act_type, and act_time. . Here, data means a record / struct type of data of shared information, and act_type indicates the type of DML (Data Manipultaion Language) applied to the data. Updating a particular primary key is done by sequentially entering two pieces of data: delete and insert. Act_time represents the time at which DML was performed on the N node. For reference, DML means other SQL statements except select statements. For example, DML includes insert, delete, and update.

In the above configuration, in the state where N nodes have constructed databases N_A, N_B, N_C, ... to store log information as many as the number of nodes, periodically log patches stored in each node and store them in the database constructed for each node. Once moved, the data is deleted from the node's database.

Subsequently, the N node periodically clicks log information stored for each node at a specific time, and directly performs changes included in the log information to each node.

For example, if data change from node A to a → b occurs, and the log information is moved to node N, the node N directly changes the data of a stored in node B and node C to b. When all changes are completed, log information corresponding to a → b stored in node A of node N is deleted.

Hereinafter, a method of managing sharing information between operating systems according to an embodiment of the present invention will be described in more detail with reference to the flowcharts illustrated in FIGS. 2 to 6.

In the method of managing sharing information between operating systems according to an exemplary embodiment of the present invention, a process of collecting N nodes from target nodes will be described with reference to the flowchart shown in FIG. 2.

After inserting the current time of the N node into the Ntime variable (S2), and creating a cursor for the shared information toward an arbitrary target node (for example, A node) to establish a connection with the A node (S4), The log information stored in the DB of the node A is read (S6).

The N node stores log information read from the A node in a queue allocated to the A node (S8), wherein the queue maintains an arbitrary data structure and is constructed in a separate storage location for each node. . Data types stored in the queue are data, act_type, act_time, real_time, and s_type. Here, real_time becomes act_time + (current time of N node-current time of A node) in order to eliminate standard time error between N node and A node when all modes have different system time on their server. It is a reference between several nodes. In addition, s_type is an item that distinguishes whether the data is simply read data or data that has been stopped due to an error on the network while working. In the case of data read from a target node, s_type is marked as global and the work is stopped. In the case of data, it is written as privacy.

The N node storing the log information of node A through step S8 deletes log information stored in node A using DML (S10), and after determining whether there is more log information stored in node A (S14), If there is more stored log information as a result of the determination (Yes), the process proceeds to reading log information repeatedly, and if there is no stored log information (No), it is determined whether the current time has passed the reference time. (S16). The step S16 is a step of checking whether a time interval is satisfied by comparing a current time at which a work is completed with a reference time. When the current time passes a reference time (No), the process proceeds to the initial step and has been described above. While repeating the process from step S2 to step S16, if the current time does not reach the reference time (Yes), Ntimer waits for the time minus the cycle time at the current time, and then proceeds to the initial step and the above-described step S2 The process from to step S16 is repeatedly performed.

The above-described process is performed by N nodes independently for each target node, and log information collected from each target node as described above is stored in a storage area reserved for each target node in the N node.

Next, a process in which the N node detects reference data using log information stored in the storage area will be described with reference to the flowchart shown in FIG. 3.

First, by declaring an integer variable i to be used for a node array (No array), the reference data detection process is sequentially performed for 1 to N nodes, and the first node is defined as a V node (S300 and S302).

A cursor is declared for the data fetched from each node and the data is fetched again (S304), and the data is assigned to the corresponding variable (S306).

Subsequently, the N node determines whether the Vtype indicating the data characteristic is global (S308). If the Vtype is global, the N node searches for the latest Vdata among the searched Vdata by searching for the same data as the Vdata at each node ( S310).

If the search result exists (Yes in S312), the searched node, data, act_type, real_time, and s_type are substituted into the variables Tnode, Vdata, Vact, Vtime, and Ttype (S314).

If the Vtype is not global (No), that is, if the Vtype is private, the data change procedure is performed (S320). The data change procedure will be described in detail with reference to FIG. 5. . For reference, the data property is the data of the data when the data with global data property is stopped due to a network interrupt or a delay caused by a lock and an interrupt caused by a specific value occurs while executing the integrity rules. The property is changed to private and stored on the N node.

After performing the data change procedure through the step S320, delete the Vdata from the database of the V node built in the N node (S330), and determines the existence of the cursor (S232), if the cursor exists (Yes in S332) In step S306, the reference data detection process is performed on the next log information stored in the database of the i-th node.

Through the above steps, when the process of detecting the reference data for all log information stored in the database of the i-th node is finished, the cursor for the i-th node is closed, and the cursor is closed to determine the existence of the cursor. If not (No in S332), the variable i is incremented by one (S334) so that the reference data detection process is performed for the node corresponding to the next step (S334), and the flow proceeds to step S302.

When the reference data detection process is finished through FIG. 3, the reference data application process is performed, and a flowchart thereof is shown in FIG. 4.

First, j to be used as a node array (node array) is declared (S400), and if the corresponding array value exists (S402), if it does not exist, the existence of a cursor is checked (S422). As a result of the check, if the cursor does not exist (No in S422), the variable i is incremented by 1 so as to perform the reference data detection process for the node corresponding to the next order (S424), and the flow proceeds to step 302.

However, if it is determined in step S402 that the array value exists (Yes), it is determined whether the array value is a T node (S404). Here, the T node is a node whose latest data has been retrieved in step S314 of FIG.

As a result of the determination in step S404, if the node corresponding to the array value is not a T node (No in S404), the data change procedure is performed after assigning the array value to the V node, which is shown in FIG. As shown.

Subsequently, the N node deletes Vdata from the database of the V node built in the N node (S410), and increases the variable j by 1 so that the reference data application process is performed for the node corresponding to the next order (S412). Proceed to step S402.

On the other hand, if it is determined in step 404 that the node corresponding to the array value is a T node (Yes), it is determined whether the characteristics of the T node are global (S414), and if it is global, the N node is a V node constructed in the N node. The Vdata is deleted from the database of (S418), the variable j is increased by 1 so that the reference data is applied to the nodes corresponding to the next sequence (S420), and the flow proceeds to step S402.

In particular, in step S404, it is determined whether the node No [j] to which the reference data is applied is a node (T node) in which the latest data is stored. If the node is a T node and the characteristic is global, the reference data application process for the node is performed. By not doing this, no data change is performed for the node whose data has changed recently.

Next, the data change procedure performed in step S320 of FIG. 3 and S408 of FIG. 4 will be described in detail with reference to the flowchart shown in FIG. 5.

First, it is determined whether the Vact is deleted from the V node log information including Vdata, Vact, and Vtime (S502). If the Vact is deleted, the data is stored in the V node corresponding to the array value connected through the network through DML. Vdata is deleted (S504).

If the result of the determination in step S502 is that Vact is not deleted, it is checked whether the Vdata exists in the V node (S506). If present, the N node updates Vdata in the V node through DML. In operation S508, if the Vdata is not present in the V node, the N node newly stores Vdata in the V node through DML (S510).

Hereinafter, a privacy processing procedure will be described in detail with reference to the flowchart shown in FIG. 6.

Referring to FIG. 6, after transmitting the DML for handling data stored in the V nodes connected to the network in steps S504, S508, and S510 shown in FIG. 5, if a result value is not transmitted from the V node within a reference time. (N in S602) The N node releases the connection with the V node and stores 1 in a flag variable indicating failure (S604).

Then, the N node checks whether the Vtype included in the log information stored in the database of the V node built in the N node is stored as privacy (S606), and if the Vtype is not stored as privacy, fry the Vtype. Change to the tee and store (S608).

In addition, although not described in the above-described process, when the deletion of the Vdata is requested by the steps S601 and S602, only the data of the log information is deleted, the Vtype of the log information is not privacy.

Through the above-described process, if an interrupt occurs due to a network failure or lock while the N node handles data stored in the V node through DML, the corresponding data is not immediately deleted and is periodically executed. Priority is given during the detection and application of reference data.

According to the present invention as described above, it is possible to ensure the integrity of the shared information without having to install a program for applying the integrity rule for the shared information to each node corresponding to the operating system, the network between the specific operating system Even if it is reset, the log information is automatically recovered to improve the stability of the system.

On the other hand, the present invention is not limited to the above-described embodiment, but can be modified and modified within the scope not departing from the gist of the present invention, such modifications and changes should be regarded as belonging to the following claims. will be.

1 is a configuration diagram of a system to which the sharing information management method between operating systems according to an embodiment of the present invention is applied.

2 to 6 is a flowchart for explaining a method for managing sharing information between operating systems according to an embodiment of the present invention.

Claims (7)

In the shared information management method between operating systems in a state that a plurality of nodes corresponding to the operating system is connected through a network, A first step in which a specific node (managed node) among the nodes collects log information about shared information changed in each node at predetermined intervals and stores the log information in a database constructed for each node in the managed node; A second step of detecting reference data to be applied to each node sequentially from the first node using log information stored in the database constructed for each node; And And a third process of handling sharing information stored in a database constructed at each node by using the reference data. The method of claim 1, The management node is a method for managing shared information between operating systems, characterized in that to collect log information independently for each node except itself. The method of claim 1, Log information collected in the first process is "Data" in which the changed data is recorded, "act_type" in which the data change type is recorded, "act_time" in which the time at which the management node reads the log information is recorded; When storing the log information in the database, " data " in which the changed data is recorded, " act_type " in which the data change form is recorded, " real_time " in which the time error is corrected for the " act_time " Method of managing shared information between operating systems, characterized in that for storing the recorded "s_type". The method of claim 3, wherein In the second process If the data property of the log information is "global" and the latest data for the data exists in another node (T node), the log information including the latest data is selected as reference data for the data, and the log information. If the data characteristic of the "privacy" is characterized in that the data is selected as reference data. The method of claim 4, wherein And deleting the data from the database of the node constructed on the management node without performing the third process on the node whose data selected as the reference data is changed. The method of claim 3, wherein In the third process If the data change type of the reference data is "delete", the data corresponding to the reference data stored in the corresponding node is deleted. If the data change type is not "delete", it is determined whether the data is already stored in the node. If the data is updated and stored, and if the data has not been stored previously, the shared information management method between operating systems, characterized in that for storing new data. The method of claim 1, Following the third process, And a fourth process of deleting the data from the database.