JPH11154138A - Server - Google Patents

Abstract

PROBLEM TO BE SOLVED: To safely enable version-up of a module without having to stop a system concerning a client/server system in a distributed object environment. SOLUTION: A global parameter and its structure information are backed up in a backup file 42 on a disk 4. The structure information of the global parameter on a module 41 is written out in the load module 41 on the disk 4 as well. At the time of start-up, two pieces of said structure information are compared. When both pieces of structure information are coincident as a result of comparison, start-up is made successful, When both pieces of structure information are not coincident by the version-up of the module, on the other hand, fail information is reported to a client or according to the structure information on the side of the module 41, the global parameter is defined again.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a server, and in particular, reconfigures a global variable when a global variable does not match before and after updating a server program in a distributed object environment and continues processing. Regarding the server that can.

[0002]

2. Description of the Related Art In a client-server type distributed object environment, generally, a plurality of host computers existing on a network constitute a client-server type computer system. In this computer system, each server is located without depending on a specific host computer, and the client requests (requests) processing without being aware of the host computer on which the server that executes the target server processing exists. Can be. In such a system, objects distributed over many computers are typically represented by C
ommon Object Request Broker Architecture (CORB
A standard). CORBA
Under standard environment, Object Request Broker (ORB)
A system program called is installed in each host computer and manages the exchange between the client and the server.

An interface between a client and a server must be defined in advance in a description language called Interface Definition Language (IDL). The interface defined in this description language can be interpreted by ORBs on all host computers, and requests from the client to the server are managed according to this definition. JP-A-8-272725 discloses a system and method for determining and operating server configuration information in a distributed object environment based on the CORBA standard.

In the above computer system, it is desirable that all servers existing on the system are always in an active state so as to be able to immediately respond to a request from a client. However, keeping all servers active at all times wastes resources on the computer.

Therefore, when there is no request from the client, the server process is shut down under the management of the ORB. That is, resources such as memory and tables are released to erase the process control block.

When a new request is issued, the ORB assigns (assigns) a new process to the server and activates the server. When the server enters the active state, the storage space of the server becomes a new storage space different from that before the shutdown, and the value of the global variable such as the counter value existing in the storage space earlier is not guaranteed.

In view of such a problem, the server has a configuration in which a global variable is duplicated in a file on a disk, and the global variable of the duplicate is read out at startup after shutdown. This backup method of global variables can be used for system crashes,
For example, it can be used as a backup method for global variables at the time of recovery after a process stop due to a bug or the like.

[0008] In a distributed object environment, there is an advantage that it is not necessary to stop the entire system even when maintaining a specific server. For example, when updating a module, that is, an application file, when the server is in a shutdown state, the correspondence between the process and the server is lost.
The server becomes active when a new request is received simply by replacing the program.

[0009]

However, in the method of responding to a new request using the backed up global variables, the method of normalizing only when there is no change in the structure of the backed up global variables in a file on the disk. Startup is possible. That is, when updating the module, if the global variable structure is changed in the new server before the shutdown, the server cannot be activated simply by replacing the server executable file on the disk.

SUMMARY OF THE INVENTION It is an object of the present invention to solve the above problems and to provide a server which can be easily started up even when a global variable is changed before and after shutdown when updating a module.

[0011]

SUMMARY OF THE INVENTION In order to solve the above-mentioned problems and achieve the object, the present invention provides a server arranged in a client-server type distributed object environment.
A backup file storing a copy of the global variable on the server and its structure information (first structure information);
An executable file storing an application program of the server and structure information (second structure information) of global variables on the application program;
Global variable structure comparing means for judging whether the first structure information and the second structure information match or not at the start-up of the server process, and indicating a startup failure when the first structure information and the second structure information do not match. It is characterized in that a fail processing unit for notifying the client of fail information is provided.

According to the above feature, the executable file has the structure information of the global variables of the application program. Therefore, when the structure of the global variable is changed by updating the application program, it can be determined by comparing the first and second structure information. When the global variables are changed, the startup cannot be performed as it is, so that the startup failure can be notified to the client to prompt the operator to intervene.

[0013]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 2 is a block diagram showing the configuration of the client server system according to one embodiment of the present invention. In the figure, workstations WS1, WS2 and WS3 are connected on a network such as a LAN. Workstation WS1, WS2, WS
3 has an ORB as a system program. Here, the client 1 exists in the workstation WS1, and the workstations WS2 and WS3
It is assumed that servers 2 and 3 exist in the server.

FIG. 3 is a diagram showing the structure of the interface of the client server system. In the figure, workstations WS1 to WS3 exchange data via an interface defined by a description language IDL and an ORB as a system program. That is, the request REQ issued by the client 1 on the workstation WS1 is transmitted to the servers 2 and 3 on the workstations WS2 and WS3 via the IDL and ORB.
Will be notified. Further, the processing results of the servers 2 and 3 are notified to the client 1 via the IDL 5 and the ORB 6.

The operation of the server 2 when the client 1 issues a request to the server 2 will be described with reference to FIG. The server 2 has a computer and a memory for loading an application program executed on the computer. The disk 4 has an executable file 41 storing an application program and a backup file 42 of global variables. The global variables are stored in the backup file 42, that is, backed up every time the variables are rewritten by the execution of the service in the server 2. Therefore, at the time of shutdown, the global variables are surely backed up, and at the time of restarting again, the global variables of the backup file 42 can be used. It should be noted that the backup file 42 stores not only global variables but also structural information I1 of the variables. The executable file 41 also has structure information I2 of global variables on the application program.

The server 2 is in a shutdown state until receiving the request REQ. Server 2 requests R
When the EQ is received, the executable file 41 on the disk 4 is loaded on the memory of the server 3 by the management operation of the ORB. When the executable file 41 is loaded, the server 2 starts its own startup processing. In the start-up processing, for example, local variables and resources, that is, memories and I / O are initialized. The startup process includes a process of loading a copy of the global variable stored in the backup file 42 on the disk 4 to restore the state before the shutdown.

In the restoration processing in the server 2, global variables are rearranged as necessary. That is,
Application programs may be updated during the shutdown state. In this case, before and after the shutdown, the structure information I1 of the global variables in the backup file 42 and the structure information I2 of the global variables in the application program may be different. Therefore, in the relocation of the global variables, the structure information I1 of the global variables included in the backup file 42 of the global variables and the execution format file 4
1 is compared with the structure information I2 of the global variable included in the global variable. As a result of the comparison, if they match, the state before the shutdown is restored, and the processing of the request REQ from the client 1 is started.

On the other hand, if the executable file 41 has been updated while the server 2 is in the shutdown state and the two do not match, the processing of the request REQ is started after the global variable is corrected.

When the structure information I1 and I2 of the global variables do not match, the restoration processing differs depending on the mode of the mismatch. Hereinafter, a case where the position of the global variable on the disk 4 is different and a case where a new global variable is added will be described. FIG. 4A shows an example of the global variable structure information I1 that has been backed up, and FIG. 4B shows an example of the global variable structure information I2 included in the executable file 41. The structure information I1 and I2 include the type, size, position, and dependency of each global variable.

From the structural information I1 and I2 in FIG. 4, it can be seen that before and after the shutdown, the positions of the variables A and C are changed and the variable B is added.
Further, it is described that the added variable B has a dependency on the program on the variable. As an example of the dependency, for example, when calculating the variable A, the variable B may be used. Therefore, when such a dependency exists, the variable B is initialized when the variable A is initialized.
Also needs to be initialized at the same time.

Note that the structure information including the dependency can be generated by an extended function of a compiler that compiles the executable file 41. For example, in the algorithm, “A.table = K + B; If A.tab
le> 4 then A. If "seat = TRUE" is set, FIG.
Is generated.

A process of restoring a global variable having different structural information before and after shutdown will be described with reference to a flowchart. In FIG. 5, after startup, in step S1, the structure information I1 and I2 are compared. In step S2, it is determined whether or not the structure information I1 and I2 match. If they do not match, the process proceeds to step S3, and it is determined whether there is any added global variable. If a global variable has been added, the process proceeds to step S4, and the added global variable is initialized. In this embodiment, since the variable B is added and the variable B is not loaded from the backup file 42, the variable B is initialized.
The initialization of the global variable is performed by enabling the constructor in the object of the variable B. For example, when the variable B is a counter value, for an object for which the counter value is to be incremented and decremented, the constructor becomes valid when the object is generated (installed), and “0” is set to the global variable counter value. , Is initialized.

In step S5, it is determined whether or not the added variable has a dependency on another global variable. If there are any dependencies, initialize the dependent variables. In this embodiment, the element of the global variable A “tab”
Since there are dependencies with "le" and "seat", these variables are initialized. Steps S4 to S6 are skipped when there is no addition of a global variable, and when there is no dependency even if it is added.

In step S7, it is determined whether or not the position of the global variable has been changed. If this determination is affirmative, the process proceeds to step S8, where the global variables are relocated on the disk 4. In this embodiment, the global variables are reconfigured according to the structure information I2. That is, the value placed at position (Location) 1 as variable A is rearranged at position 3 as variable A. Similarly, the value placed at position 3 as variable C is rearranged at position 1 as variable C. The global variables thus rearranged are loaded into the memory of the server 2. In step S9, the service requested by the client 1 is started. If the position of the global variable has not been changed, step S1
It is determined whether or not a global variable has been added at 0. If the determination is affirmative, the restoration process has been completed, and the process proceeds to step S9. If step S10 is negative, there is no inconsistency between the additional structure information I1 and I2, so the flow proceeds to step S11 to notify the client 1 of the fail information and ends with the startup failure.

In the above-described embodiment, an example has been described in which the position of a variable is changed and a variable is added. The present invention is not limited to these, and can also be applied to the case where the type of the variable or the size of the variable has been changed, by similarly initializing the corresponding global variable.

In the present embodiment, an example has been described in which, when the structure information I1 and I2 of the global variables are different, the global variables are rearranged and loaded. However, the present invention is not limited to this, and when a mismatch between global variables is detected, processing for starting a service may be interrupted, and fail information requesting intervention by an operator may be notified to the client 1.
This allows the client 1 to enter the recovery process. Also, the mismatched global variable is
The failure information may be notified only when the variable is a predetermined specific variable.

As described above, according to the present embodiment, when the structure of a global variable is changed due to the update of the server program, that is, the application program of the server, the client is notified and the intervention of the operator is prompted. Can be. In addition, since global variables can be automatically redefined in response to changes in the structure of global variables due to server program updates, the executable files can be safely replaced without stopping the system, and the server program can be redefined. Updates can be made.

[0028]

As is apparent from the above description, according to the present invention, when the structure of a global variable is changed due to a version upgrade of a server program or the like, the change in the structure is determined and notified to the client. An appropriate recovery process can be performed.

[Brief description of the drawings]

FIG. 1 is a diagram showing a data flow of a client-server system according to an embodiment of the present invention.

FIG. 2 is a block diagram illustrating a configuration of a client server system according to an embodiment of the present invention.

FIG. 3 is a diagram showing a structure of an interface of a client server system in a distributed object environment.

FIG. 4 is a diagram showing an example of global variable structure information.

FIG. 5 is a flowchart of redefining global variables.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 ... Client, 2, 3 ... Server, 4 ... Disk device, 41 ... Executable file, 42 ... Backup file, I1, I2 ... Configuration information

Claims (4)

[Claims] 1. A server arranged in a client-server type distributed object environment, comprising: a backup file storing a copy of a global variable on the server and its structure information (first structure information); An executable file storing structural information (second structure information) of global variables on the application program; and a global for determining whether the first structure information and the second structure information match or not at the start-up of the server process. A server comprising: variable structure comparing means; and fail processing means for notifying a client of fail information indicating startup failure when the first structure information and the second structure information do not match. 2. The server according to claim 1, further comprising a rearrangement means for rearranging the global variable according to the second structure information when the mismatch occurs due to a change in the position of the global variable. . 3. The server according to claim 1, further comprising initialization means for initializing the added global variable when the mismatch occurs due to a new addition of a global variable. 4. The apparatus according to claim 1, further comprising an initializing unit for initializing all the global variables having the dependency when the dependency is newly generated between the global variables and the inconsistency occurs. Item 7. The server according to Item 1.