JP2000250778A - Inter-distributed debugger linkage processing method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To make a distributed debugger system being able to be linked between debuggers independent of a development language for a protocol and an application to many networks. SOLUTION: In this inter-distributed debugger linkage processing method, a server 204 registers the identification information of an object with an object request broker ORB 209, in a client 201, an acquisition function 202 acquires reference (identification information of object), an analyzing part 211 analyzes a command when it is inputted from an input device 210, a remote operation function 203 is carried out if it is a remote operation to the server 204 and a stub 207 puts together interface definition information to be a request to an operation in an object in the server 204 and sends it to the server 204. The request is sent to a skeleton 208 by the ORB 209, and the skeleton 208 accesses an operation execution function to which the server 204 corresponds from the request and executes a debug operation function to an application.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a distributed debugger cooperation processing method in which a debugger for a program operating on a plurality of machines performs processing while cooperating with each other, in relation to a debugging environment for a program operating in a distributed object environment.

[0002]

2. Description of the Related Art In a distributed object environment, a server application and a client application operate on a plurality of machines by repeatedly requesting and responding to each other via an object request broker (ORB). When debugging such a server application or a client application, it is important that information on the server application can be referred to while the client application is being debugged, or vice versa. In this case, the conventional technology (Japanese Patent Laid-Open No. 9-1203)
66) adopts a method in which a communication mechanism is provided in the debugger itself, and debug information is exchanged with each other via messages based on a specific network protocol.
However, in the above method, the debugger needs to recognize various network protocols. A debugger exists for each development language of an application to be debugged. However, there is no general-purpose interface for cooperation between debuggers of different languages. Therefore, when the development languages of the server application and the client application are different, there is a problem that they cannot be debugged.

[0003]

In a distributed object environment, when debugging of a server application and debugging of a client application are performed in cooperation with each other, as described above, in the prior art, it is necessary to provide the debugger with a dedicated communication mechanism. There is a problem that the debugger itself needs to recognize the protocol of the network constituting the distributed object environment, and a problem that the debugger cannot cooperate when the development languages of the server application and the client application are different. An object of the present invention is to provide a debugger capable of debugging a distributed object in a distributed debugger system operating in a distributed object environment without depending on a network protocol or an application development language.

[0004]

In order to achieve the above object, the present invention provides an object-oriented client debugger and an object-oriented debugger for debugging a program operating in cooperation with a client and a server in a distributed object environment. Object request broker (ORB) as a communication mechanism for cooperating server debuggers
Request to the object-oriented server debugger via the ORB in response to the remote-operation instruction input from the input device for the server-side debug target program to the object-oriented client debugger using the ORB. Stub to assemble
A skeleton for receiving a request sent via the ORB and invoking an operation execution function of the object-oriented server debugger corresponding to the request is provided, and a server side debug target program is provided with an operation corresponding to the remote operation. It makes it possible to execute.

The remote operation further includes at least functions of setting a breakpoint, releasing a breakpoint, displaying a data value, setting a data value, and executing a step. The object-oriented client debugger responds to the remote operation instruction. A remote operation call function for calling a remote operation to be passed to the stub is provided, and an object-oriented server debugger is provided with an operation execution function corresponding to the remote operation requested by the request.

In a distributed object environment, an object request broker is used as a communication mechanism for cooperatively operating a non-object-oriented client debugger and an object-oriented server debugger for debugging a program operating in cooperation with a client and a server.
(ORB), in response to a remote operation instruction input from an input device for a server-side debug target program to the non-object-oriented client debugger, a function of invoking a remote operation of the object-oriented debugger corresponding to the instruction. And a stub for assembling a request corresponding to the called remote operation requested to the object-oriented server debugger via the ORB, and sent to the object-oriented server debugger via the ORB. A skeleton for receiving the requested request and calling an operation execution function of the object-oriented server debugger corresponding to the request, and providing the non-object-oriented client to a program to be debugged on the server side. And so as to enable execution of operations corresponding to the remote operation instruction inputted into cement debugger.

[0007]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below with reference to the drawings. FIG. 1 shows a Common Object Request Broker Architecture (CORBA) according to the present invention.
1 is a configuration example of a distributed object system in which two object-oriented debuggers having functions specified in specifications operate. This system consists of an object-oriented debugger (103) for language 1 (eg, COBOL language) and an object-oriented debugger (104) for language 2 (eg, C language) running on different machines (101, 102). An object request broker (ORB) (105), which is a communication mechanism for exchanging information, and a skeleton (106) and a stub (106) generated from interface definition information of remote operation between debuggers defined in the interface definition language (IDL) 107).

FIG. 2 shows the configuration of the two object-oriented debuggers. The two debuggers (201, 204) usually have a function defined by the Common Object Request Broker Architecture (CORBA) specification, in addition to a command analysis unit (211) provided with a debugger and a debug operation function (212). In other words, a language 1 compatible client debugger
(201) has an object reference acquisition function (202),
Equipped with a function (203) for calling a remote operation using an object reference, and a stub (207),
The language 2 compliant server debugger (204) has a function of registering a server with an object request blocker (ORB) (205), a function of executing a requested operation (206),
And a skeleton (208). It is to be noted that the functions of the respective debuggers for performing the control for sequentially executing the respective functions are not shown.

The stub (207) assembles interface definition information which is a request for the object reference when the language 1 compatible client debugger (201) invokes a remote operation using the object reference. The skeleton (208) converts the sent interface definition information into a call for the corresponding operation execution function of the language 2 compatible server debugger (204). After the debug operation for the application is completed, the response to the operation execution result is returned. Assemble interface definition information. Here, stub and skeleton are terms generally used in CORBA.

FIG. 3 is a diagram showing a processing flow of the two object-oriented debuggers of FIG. First, language 2
The corresponding server debugger (204) executes the server registration function (205), registers the identification information of the object in the object request broker (ORB) (209) (S301, S302), and starts the application to be debugged (S303). ). All server debuggers connected to the object request broker (ORB) (209) register object identification information in this ORB, and the ORB manages object identification information for each server debugger.

Next, a language 1 compatible client debugger (2
01) executes the object reference acquisition function (202) and the object request of the language 2-compatible server debugger (204) from the object request broker (ORB) (209), that is, the language-compatible server debugger (204)
The debugger acquires the identification information of the object registered in, and starts the debug target application (S308, S309). When a command is input from the command input device (210) of the language 1 compatible client debugger (201), the command analysis unit
Analyzed by (211) (S310), the language 2 compatible server debugger (20
In the case of the remote operation for 4) (S311), execute the remote operation call function (203) (213),
The stub (207) sends the interface definition information as a request for the operation of the object of the language 2 compatible server debugger (204) to the assembly language 2 compatible server debugger (204) (S312, S313). As a result of the command analysis, if the command is not a command for the remote operation (S311), the debug operation function (212) is executed for the normal current application (214) (S316).

The request is skeletonized by an object request broker (ORB) (209) to a language-compatible server debugger (204) corresponding to the object reference.
It is sent via (208) (S313, S304). skeleton
At (208), the corresponding operation execution function of the language 2 compatible server debugger (204) is called from the transmitted request, and the debug operation function for the application is executed (S305, S306). The execution result is the skeleton (2
At 08), it is assembled into the interface definition information, and sent as a response to the language-compatible client debugger (201) via the stub (207) (S307). The language 1 compatible client debugger (201) receives the response and displays the content of the response on the command input device (210) (S3
14, S315). As described above, in the present embodiment, the language 1 compatible client debugger (201) and the language 2 compatible server debugger
(204) operate in parallel with each other while being synchronized by the request of the language 1 compatible client debugger (201) and the response of the language 2 compatible server debugger (204).

FIG. 4 shows interface definition information that defines the interface of the operation of the debugger on the server side. In this embodiment, the operation is a basic operation, and as an operation function common to all language debuggers,
Breakpoint setting (401), breakpoint release (40
2), data value display (403), data value setting (404), and step execution (405) are defined. From the viewpoint of the client-side debugger, these operations correspond to remote operations, and are characterized in that the client-side debugger can execute a remote operation for the server-side debugger. In the present embodiment, the language 1 compatible object-oriented debugger (103)
A remote operation call function is implemented based on the interface defined in the interface definition information of FIG.
04) implements each operation execution function having the interface defined in the interface definition information. Here, the language-independent operation is 5
Although the types of operations have been defined, it is also possible to define additional operations specific to a particular language (for example, a COBOL file allocation command).

FIG. 5 shows a flow of a request for one operation example of the distributed debugger developed by this method. When a command for setting a breakpoint is input from the command input device (508) to the 100th line of the application (509) operating at a remote location, the language-oriented object-oriented debugger (501) analyzes the command, An operation call process (503) for an object of the language-oriented object-oriented debugger (502) is executed, a corresponding request is assembled by a stub (504), and the request is sent to the language 2 via an object request broker (ORB) (505). Supported object-oriented debugger (502)
The operation (503) for setting a breakpoint at the 100th line of the application (509) to be debugged is called from the skeleton (506), and a breakpoint is set for the application that operates remotely. Obj1 in FIG. 5 is an object reference of the language 2 compatible object-oriented debugger (502).

Next, a second embodiment of the present invention will be described with reference to the drawings. FIG. 6 shows a client-side non-object-oriented debugger (603) according to the present invention.
(609), the server-side object-oriented debugger (604) and the object request broker (ORB) (605)
1 is an example of a configuration of a distributed debugger system that cooperates via the Internet. This system consists of an object-oriented debugger (604) and a non-object-oriented debugger (603) that operate on different machines (601, 602), and an object request broker (O) that is a communication mechanism for exchanging debug information.
RB) (605) and the function of acquiring an object reference to the server-side object-oriented debugger (604), and converting a command from the non-object-oriented debugger (603) into an operation call of the object-oriented debugger as a remote operation. Features and
A converter (609) having a stub (606) generated from interface information defining an interface for remote operation of the server-side debugger is provided.

The outline of the operation in this embodiment is as follows. A command for the debugger is input from the command input device (608), and the non-object-oriented debugger (60
The input command is analyzed by the command analysis unit (610) of 3),
If the input command is a command for remote operation of the server-side object-oriented debugger (604) operating on the remote machine, the converter (6
09), the converter (609) converts the command into an operation call of the object-oriented debugger, and sends a request for the operation of the server-side object-oriented debugger (604) via the object request broker (ORB).

FIG. 7 shows a program configuration (70
1). The converter (701) is an object reference acquisition function of the server-side object-oriented debugger.
(702), an operation call function (703) of an object-oriented debugger on the server side, and a stub (704) generated from interface definition information. The converter (701) obtains an object reference of the server-side object-oriented debugger, and prepares to operate according to the procedure specified in the Common Object Request Broker Architecture (CORBA) specification. Further, when a command to the server-side object-oriented debugger is sent from the non-object-oriented debugger (705), the command is converted into a corresponding remote operation call by the operation call function (703), and the request is assembled by the stub (704). , Object request broker (OR
Send it to the server-side object-oriented debugger via B).

FIG. 8 is a processing flow in which a non-object-oriented debugger operates as an object-oriented debugger using a converter. First, the non-object-oriented debugger (603) calls the object reference acquisition function (702) of the converter (609) (S801), and the object request broker (ORB) (605) sends the server-side object-oriented debugger (604). ) Object reference, that is, the language 2 compatible server debugger (204)
Obtain the identification information of the object registered in the RB (S80
2), start the application to be debugged (S803).
When a command is input from the command input device (608) of the non-object-oriented debugger (603), the command analysis unit
Analyzed by (610) (S804), object-oriented debugger
In the case of remote operation for (604) (S805),
The remote operation call function (703) of the converter (609) is executed (S806). The converter (609) is used in the remote operation call function (703) of the converter (609).
The operation of the object-oriented debugger (604) is called using the object request acquired by the object reference acquisition function (702) (S809), and the operation on the object of the language 2 compatible server debugger (604) is performed by the stub (607). Is transmitted to the assembly language 2 compatible server debugger (604) (S810). If the command analysis indicates that the command is not a command for remote operation (S80
5) The debug operation function is executed for the normal current application (612) (S808). The execution result of the server-side object-oriented debugger (604) is sent to the non-object-oriented debugger (603) via the stub (607) of the converter (609) (S811, S806), and the result is displayed. (S807). Because the converter has the functions specified in the Common Object Request Broker Architecture (CORBA) specification, the non-object-oriented debugger calls the converter function as an extension of the conventional processing, and the server-side object-oriented Cooperate with debugger.

An example of the flow of processing in which the converter inputs one command of the non-object-oriented debugger and converts it into an operation call for the object-oriented debugger will be described with reference to the above-mentioned drawings.

For example, a command (for example, sb 100) for setting a breakpoint at the 100th line of an application (611) operating at a remote place from the command input device (608)
Is input, the command analysis unit (610) of the non-object oriented debugger (603) analyzes the input command and calls the operation call function (703) of the converter that calls the operation for setting a breakpoint in the server-side application. In the operation call function (703), using the object reference of the server-side object-oriented debugger, that is, the language 2 compliant server debugger (204) converts the operation into a breakpoint setting operation using the identification information of the object registered in the ORB. Then, the stub (704) assembles interface definition information as a request for this operation and sends it to the server-side object-oriented debugger.

In this embodiment, a non-object-oriented debugger operating on the client side is provided with a converter for converting a command of the non-object-oriented debugger into an operation of the server-side object-oriented debugger. In the same way, a non-object-oriented debugger that operates on the server side is provided with a converter that converts requests for operations into non-object-oriented debugger commands. It is also possible to do so. Further, by providing converters on both the client side and the server side, it goes without saying that a remote operation can be executed even if both debuggers are non-object-oriented debuggers.

[0022]

As described above, according to the present invention,
In a distributed object environment, a distributed debugger system that can cooperate between debuggers can be made independent of protocols for various networks and application development languages.

[Brief description of the drawings]

FIG. 1 is a diagram showing a configuration example of a distributed debugger system according to the present invention.

FIG. 2 is a diagram illustrating a configuration example of an object-oriented debugger on the client side and an object-oriented debugger on the server side.

FIG. 3 is a diagram showing a processing flow of an object-oriented debugger on the client side and an object-oriented debugger on the server side.

FIG. 4 is a diagram showing interface definition information for a remote operation of a server-side debugger.

FIG. 5 is a diagram for explaining the flow of requests between distributed debuggers.

FIG. 6 is a diagram illustrating another configuration example of the distributed debugger system.

FIG. 7 is a diagram showing a program configuration of a converter.

FIG. 8 is a diagram showing a processing flow of a converter and a non-object-oriented debugger.

[Explanation of symbols]

 Reference Signs List 101 current machine 102 remote machine 103 language 1 compatible object oriented debugger 104 language 2 compatible object oriented debugger 105 object request broker (ORB) 106 skeleton 107 stub 108 command input / output device 201 language 1 compatible client debugger 202 object reference acquisition function 203 Remote operation call function 204 Language 2 compatible server debugger 205 Server registration function 206 Operation execution function 207 Stub 208 Skeleton 209 Object request broker (ORB) 210 Command input device 211 Command analysis unit 212 Debug operation function 501 Language 1 compatible object oriented debugger 502 Object-oriented debugger for language 2 03 Operation call processing 504 Stub 505 Object request broker (ORB) 506 Skeleton 507 Operation execution function 508 Command input device 509 Application to be debugged 601 Current machine 602 Remote machine 603 Non-object oriented debugger 604 Object oriented debugger 605 Object request broker (ORB) ) 606 skeleton 607 stub 608 command input / output device 609 converter 610 command analyzer 611, 612 debug target application 701 converter 702 object reference acquisition function 703 operation call function 704 stub 705 non-object oriented debugger

 ──────────────────────────────────────────────────続 き Continuing from the front page (72) Inventor: Shoichiro Sakanishi 5030 Totsuka-cho, Totsuka-ku, Yokohama-shi, Kanagawa Prefecture F-term in the Software Division, Hitachi, Ltd. 5B042 GA08 GA12 GC10 HH13 HH23 HH25 LA01 NN04 NN40 5B045 GG01 JJ49

Claims (3)

[Claims] An object request broker (1) is provided as a communication mechanism for cooperatively operating an object-oriented client debugger and an object-oriented server debugger for debugging a program operating in cooperation with a client and a server in a distributed object environment. ORB)
A request corresponding to the object-oriented client debugger, which is requested via the ORB to the object-oriented server debugger via the ORB in response to a remote operation instruction input from an input device for a program to be debugged on the server side. A skeleton for receiving the request sent via the ORB and invoking the operation execution function of the object-oriented server debugger corresponding to the request, and providing a debugger on the server side. A method for processing cooperation between distributed debuggers, wherein an operation corresponding to the remote operation can be executed on a target program. 2. The method according to claim 1, wherein at least each function of a breakpoint setting, a breakpoint release, a data value display, a data value setting, and a step execution is provided as the remote operation. The directional client debugger has a remote operation calling function for calling a remote operation to be passed to the stub in response to the remote operation instruction. The object-oriented server debugger has an operation execution function corresponding to the remote operation requested by the request. And a distributed debugger cooperation processing method. 3. An object request broker as a communication mechanism for cooperatively operating a non-object-oriented client debugger and an object-oriented server debugger for debugging a program operating in cooperation with a client and a server in a distributed object environment. (OR
B) using, in response to a remote operation instruction input from an input device for a program to be debugged on the server side to the non-object-oriented client debugger, a function of invoking a remote operation of the object-oriented debugger corresponding to the instruction. And a stub for assembling a request corresponding to the called remote operation requested to the object-oriented server debugger via the ORB. A skeleton for receiving the request, and invoking the operation execution function of the object-oriented server debugger corresponding to the request, and providing the non-object-oriented client to a server-side debug target program. Distributed debugger between cooperative processing method characterized in that to enable execution of operations corresponding to the remote operation instruction inputted into cement debugger.