JPH09330223A - Method and device for executing processing to event-driven type server by corba - Google Patents

Abstract

PROBLEM TO BE SOLVED: To improve the productivity by providing a request to an event-driven type server and an answer from the event-driven type server as a series of servers by a single function call from a client. SOLUTION: A CORBA server object(SO) 2 is placed so as to request services of the even-driven type server 3 by using CORBA. A function defined in the CORBA-SO is called from a CORBA client 1 and actuated as a new thread. The CORBA-SO 2 uses a pipe 5 as a means for passing the request to the event-driven type server 3. The event-driven type server 3 receives an event, processes it, and returns its result asynchronously. As a means for returning the result to the CORBA-SO 2, the completion of processing for writing the processing result in a memory 6 is reported to the CORBA-SO 2. The CORBA-SO 2 reads the result out of the memory 6 and returns it as a return of the function to the client 1.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a CORBA processing method and apparatus for an asynchronous service of an event driven program, and more particularly to a synchronous processing method and apparatus.

[0002]

COR to a conventional event driven server
The processing method by BA will be described with reference to FIG.

When the service provided by the event-driven server 3 is provided by using the CORBA server object 2, the event-driven server 3 returns a response asynchronously. Therefore, the method 41 of the CORBA server object 2
No. 42 cannot be realized by one function because it is necessary to return a response in a synchronous type. Therefore, the CORBA server object 2 is also defined on the CORBA client 1 side, and CO
The request from the RBA client 1 is sent to the COR on the server side.
The method 41 of the BA server object 2 is used, and the response from the server side is sent to the CORBA of the client side.
This is performed using the method 42 of the server object 2.

[0004]

The first problem is that two service definitions are required to fulfill one request.

The reason is that two service definitions are actually 1
This is because the user needs to be aware that it is for fulfilling one request, and the number of functions to be defined is doubled.

The second problem is that the client side also has CO
It is to implement the server object of RBA.

The reason is that the server object is originally installed only in a place where the client function is required, so that the configuration becomes complicated and it is difficult to distinguish it from the original server object.

It is an object of the present invention to define one request for an event driven server as one request for a CORBA server object to improve productivity.

Another object of the present invention is to simplify the structure and improve reliability.

[0010]

A method of processing an event-driven server by CORBA according to the present invention is distributed and different from an event-driven server that serves a client by an event-driven program that asynchronously returns a response. A method of processing service provision using CORBA, which is a common object-oriented language between computers, in which a single request from a client to an event-driven server and a response from the event-driven server are performed in series. There is a step of providing as a service of.

In the step of providing a request to the event driven server and a response from the event driven server as a series of services by one function call from the client, a CORBA server object for which a service is defined is set. Steps, the client invokes a service function on the CORBA server object, the CORBA server object writes the parameters contained in the function to the memory of the CORBA server object, and the parameters are event-driven through a pipe. Issuing the event to the type server, stopping the function, and the event driven server receiving the event via a pipe,
COR which processes the event by another process based on the parameter and writes the result to the memory when returning the processed result asynchronously
There is the step of restarting the function of the BA server object and the restarted CORBA server object returning the result to the client.

Further, the processing device by CORBA for the event-driven server of the present invention is common to distributed and different computers for the event-driven server which services the client by the event-driven program which returns a response asynchronously. COR, an object-oriented language
A device for processing service provision using a BA,
It has means for providing a request to the event driven server and a response from the event driven server as a series of services by one function call from the client.

Furthermore, means for providing a request to the event driven server and a response from the event driven server as a series of services by one function call from the client is a CORBA server object defined as a service, Means for the client to invoke a function of a service on the CORBA server object, memory for the CORBA server object in which the CORBA server object writes the parameters contained in the function, and a pipe for passing the parameters as events to the event driven server. And means for stopping the function after issuing as an event to the event driven server,
When the event-driven server that receives an event via a pipe and processes the event by another process based on the parameter and the result processed asynchronously is returned, the result is written to the memory and stopped CORBA It has means for restarting the function of the server object and means for the restarted CORBA server object to return a result to the client.

[0014]

BEST MODE FOR CARRYING OUT THE INVENTION Next, embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram of an embodiment of the present invention.
Since the service is requested to the event driven server 3 using CORBA, the CORBA server object 2 is placed. The function defined in the CORBA server object is called from the CORBA client 1 and activated as a new thread. The CORBA server object 2 uses a pipe 5 as a means for passing a request to the event driven server 3. The event-driven server 3 receives an event from the pipe 5, processes it, and asynchronously returns a result. As a means for returning the result to the CORBA server object 2, the CORBA server object 2 is notified that the processing result has been written in the memory 6 and the processing has been completed. CO
The RBA server object 2 reads the result from the memory 6 and returns it to the CORBA client 1 as a function return.

FIG. 2 is a processing sequence diagram of an embodiment of the present invention. The CORBA client 1 calls the function of the CORBA server object 2 (S1). CO
The RBA server object 2 writes the parameter in the memory 4 (S2), issues an event via the pipe 5, and then stops (S3). The event driven server 3 is a pipe 5
An event is received via the server and processing is performed based on the parameters (S4). When the result is returned asynchronously (S5), the result is written to the memory 6 (S6), and the suspended thread of the CORBA server object 2 is restarted (S7).
The restarted CORBA server object 2 returns the result to the CORBA client 1 (S8).

The present invention provides a method and apparatus for realizing a request and response of an event driven service as one service by CORBA. Run the event-driven service as a single thread. This thread operates by triggering an event from an external port. A pipe 5 for receiving an event from the CORBA server object 2 is registered as an external port. The CORBA server object 2 is installed in the same process as the event driven server 3. When the CORBA server object 2 receives the request from the CORBA client 1, the method of the CORBA server object 2 is activated as a new thread 11, and the event-driven server 3
Asynchronous processing in 1. is realized as one function in the CORBA server object 2.

CORBA Client 1 to CORBA
When the function of the server object 2 is activated, an event is caused by using the pipe 5 registered in the event driven server 3, and the function of the CORBA server object 2 is stopped. The event-driven server 3 performs asynchronous processing, and when the processing is completed, writes the processing result in the memory 6,
Restart the stopped function. The restarted function is
The processing result is read from the memory 6, and the result is returned to the CORBA client 1 as the return of the function.

[0019]

EXAMPLE FIG. 3 shows a more specific example of the present invention.

The event driven server 3 provides a function of writing the parameters passed from the memory 4 to a file. When this is provided as a CORBA service, the IDL definition of CORBA is performed as shown in 31. CO
When the function defined by the RBA client 1 is called, the function of the CORBA server object 2 is called as a new thread by the function of CORBA. C
In the function of the ORBA server object 2, the parameter is written to the memory 4 and the data is sent to the pipe 5, and the thread is suspended. The event-driven server 3 receives an event from the pipe 5, refers to the parameter from the memory 4, requests the file writing process to another process 7, and waits for the event. When the event driven server 3 receives the write end from another process 7, the result is written in the memory 6 and the suspended thread is restarted (continue). The function of the restarted CORBA server object 2 refers to the result from the memory 6, sets the result as an output parameter or a return value of the function, and returns the function. retur
As a result of n, the CORBA client terminates the called function.

[0021]

According to the present invention, it is possible to define one request for an event-driven server as a single request to a CORBA server object, and to implement an event-driven service as a synchronous CORBA object service. Therefore, there is an effect that the productivity is improved and the request from the client is simplified.

[Brief description of drawings]

FIG. 1 is a configuration diagram of an embodiment of the present invention.

FIG. 2 is a processing sequence diagram of an embodiment of the present invention.

FIG. 3 is a diagram showing a specific example of the present invention.

FIG. 4 is a configuration diagram of a conventional technique.

[Explanation of symbols]

1 CORBA Client 2 CORBA Server Object 3 Event Driven Server 4 Memory (Parameter) 5 Pipe 6 Memory (Result) 7 Another Process 11 Process up to Suspend 12 Event Activation by Pipe 13 Asynchronous Process by Another Process of Event Driven Server 14 Process Stored in result memory 15 Resume thread by continue and transfer processing result 31 IDL definition of CORBA 32 Thread activation 41 First method (asynchronous processing) 42 Second method (asynchronous processing)

Claims (4)

[Claims] 1. Using CORBA, which is a common object-oriented language among distributed and different computers, for an event-driven server that provides services to clients by an event-driven program that returns responses asynchronously,
A method of processing a service offering to an event driven server comprising the steps of providing a request to the event driven server and a response from the event driven server as a series of services with a single function call from the client. Treatment method by CORBA. 2. The step of providing a request to an event driven server and a response from the event driven server as a series of services by one function call from the client sets a CORBA server object having a service defined. A step in which the client invokes a function of a service in the CORBA server object; a step in which the CORBA server object writes a parameter included in the function into a memory of a CORBA server object; and an event driving the parameter through a pipe. After issuing as an event to the type server, stopping the function, the event driven server receives the event via a pipe, and processes the event by another process based on the parameter. When returning the processed result asynchronously, writing the result to the memory and restarting the function of the stopped CORBA server object, and the restarted CORBA server object returns the result to the client. A method for processing an event-driven server according to claim 1 by CORBA. 3. A CORBA, which is a common object-oriented language distributed among different computers, is used for an event-driven server that provides a client service with an event-driven program that asynchronously returns a response.
A device for processing service provision, which includes means for providing a request to the event-driven server and a response from the event-driven server as a series of services by one function call from the client. Processing device by CORBA. 4. A means for providing a request to an event driven server and a response from the event driven server as a series of services by one function call from the client, a CORBA server object in which a service is defined, and Means for a client to invoke a function of a service on the CORBA server object, memory for the CORBA server object in which the CORBA server object writes the parameters contained in the function, and a pipe for passing the parameters as events to the event driven server A means for stopping the function after issuing as an event to an event driven server, and an event driven server for receiving the event via a pipe and processing the event by another process based on the parameter And a means for writing the result to the memory and restarting the function of the stopped CORBA server object when returning the result processed by the method, and a means for the restarted CORBA server object to return the result to the client. Item 3. A processing device by CORBA for the event driven server according to item 3.