Method and apparatus for allowing generic stubs to marshal and unmarshal data in object reference specific data formats

• US 5,737,607 A
• Filed: 09/28/1995
• Issued: 04/07/1998
• Est. Priority Date: 09/28/1995
• Status: Expired due to Term

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Kessler, Peter B., Radia, Sanjay R., Hamilton, Graham, Lim, Swee Boon, Nisewanger, Jeffrey D.
• Primary Examiner(s): Lall, Parshotam S.
• Assistant Examiner(s): VU, VIET DUY
• Application Number:
  US08/534,966
• Time in Patent Office: 922 Days
• Field of Search: 395/500, 395/701, 395/712, 395/614, 395/615, 395/670, 395/705
• US Class Current: 719/316
• CPC Class Codes: G06F 9/547 Remote procedure calls [RPC]; Web services
• CPC Class Codes: G06F 9/548 Object oriented; Remote method invocation [RMI] non-remote method invocation G06F9/449

Abstract

The invention provides solutions to the problems which are encountered by object oriented systems designers when attempting to implement schemes for object invocation and for argument passing in distributed systems wherein the arguments may be objects, and wherein the system supports a multiplicity of ORB-specific data formats, in ways which do not lock the object oriented base system into methods which may be difficult to change at a later time. Moreover, the invention disclosed describes a "Marshal Buffer mechanism" which contains methods for marshaling data for a specific ORB; a "Multi-ORB Marshaling system" which permits a Client Application and related stub to invoke an operation on a target object without any knowledge or concern about which ORB this target object uses or what data format the ORB requires for the arguments of the operation invoked; and a "Computer system for multi-ORB communication" comprising an ORB independent layer which contains Client Applications and stubs; an ORB dependent-OS independent layer which contains ORB dependent code/Subcontract code mechanisms as well as ORB specific Marshal Buffers for a multiplicity of ORBs; and an Operating System (OS) layer.

Claims

1. A computer system having a processor, a memory, a display device, an input/output device, an operating system (OS), for processing program code mechanism invocations which are directed to one of a multiplicity of remote Object Request Brokers (ORBs), the computer system comprising:

an ORB independent layer of code mechanisms including program applications and related stubs; and

an ORB dependent layer of code mechanisms, coupled to the ORB independent layer, the ORB dependent layer comprising

program code mechanisms which are ORB-specific and which are configured to generate a marshal code mechanism to marshal data in an ORB required format and,

program code mechanisms configured to use a specific network protocol code whereby a program application code mechanism from the ORB independent layer can invoke a call on a remote implementation program code mechanism and the ORB-specific program code mechanisms in the ORB dependent layer will determine an appropriate marshal code mechanism to marshal data in an ORB required format;

thereby providing a computer system capable of communicating with a multiplicity of ORBs wherein each ORB requires data to be in a specific format.

2. A computer system as defined in claim 1 wherein the ORB independent layer of code mechanisms including program applications and related stubs comprise object applications and related stubs.

3. A computer system as defined in claim 1 wherein the marshal code mechanism to marshal data in an ORB required format which is located in the ORB-dependent layer is a MarshalBuffer Object configured to execute operations to marshal data in an ORB specific format.

4. A computer system as defined in claim 1 wherein the program code mechanism configured to use a specific network protocol code communicates with a server computer comprising:

a receiving program code mechanism comprising ORB dependent code configured to receive an object invocation from a remote computer system; and

an ORB independent server application whereby the receiving program code mechanism calls into the ORB independent server application, passing in a MarshalBuffer that allows the server application to unmarshal arguments and marshal results without having to know which ORB a call came from.

19. A computer system as defined in claim 1 wherein the ORB-dependent layer is also independent of the Operating System (OS) layer.

5. A multi-ORB marshaling system for use in a computer node which contains client applications and related stubs for communicating with remote computer nodes which contain object implementations, the multi-ORB marshaling system comprising:

an ORB-specific program code mechanism configured to receive an invocation of a target object implementation by an invoking client application, the invocation being received from a stub related to the invoking client application, wherein the invoking client application and the related stub have no knowledge of an ORB which must process the invocation, the ORB-specific program code mechanism configured to select one of a multiplicity of MarshalBuffer program code mechanisms; and

a MarshalBuffer program code mechanism, coupled to said ORB-specific program code mechanism configured to receive an invocation of a target object implementation, said MarshalBuffer program code mechanism configured to marshal arguments and data into a specific format required by the ORB which must process the invocation.

6. A MarshalBuffer program code mechanism for use in a computer node which contains client applications and related stubs for communication with remote computer nodes which contain object implementation, the MarshalBuffer program code mechanism comprising:

program code mechanisms configured to format arguments and data related to an object implementation invocation made by a client application having a related stub, wherein said invocation and said client application and said related stub have no knowledge of an ORB which can process said invocation and wherein said invocation and said client application and said related stub have no knowledge of a data format required by said ORB which can process said invocation.

7. A method of operating a computer system having a processor, a memory, a display, an input/output mechanism, an operating system and at least one client application program, one or more stub programs related to the client application, the method performed by the computer comprising the steps of:

invoking a call on a program implementation code mechanism, the call invocation being made by a client application wherein the call includes a reference to the program implementation code mechanism;

using a stub program code mechanism which is related to the client application to receive the call invocation, wherein the stub program code mechanism has no knowledge of a format required for marshaling data provided by the client application in connection with the call invocation;

calling a first specific program code mechanism by the stub program code mechanism, requesting the first specific program code mechanism to provide a MarshalBuffer code mechanism that knows how to format data provided by the client application in connection with the call invocation;

marshaling the data provided by the client application in connection with the call invocation, the marshaling being done by the stub program code mechanism using the MarshalBuffer code mechanism; and

sending the call invocation to a server containing the program implementation code mechanism which is the target of the call.

8. The method described in claim 7 comprising the additional step of unmarshalling results from the MarshalBuffer, the results supplied by the program implementation code mechanism which was called by the invocation.

9. The method described in claim 7 wherein the first specific program code mechanism called by the stub program code mechanism is an Object Request Broker (ORB) specific code mechanism.

10. The method described in claim 8 wherein the stub program code mechanism which calls the ORB specific code mechanism has no knowledge of the ORB which will process the call.

11. The method described in claim 7 wherein the Object Request Broker (ORB) is an Object Management Group (OMG) Common Object Request Broker (CORBA) compliant ORB.

20. The method of claim 7 comprising the additional steps of:

receiving an object invocation from a remote computer system by a server-side ORB dependent code mechanism; and

issuing a call into an ORB independent server application, the call made by the server-side ORB dependent code mechanism which passes in a MarshalBuffer that allows the server application to unmarshal arguments and marshal results without having to know which ORB a call came from.

12. A computer program product comprising a computer system usable storage medium having computer readable code embodied therein for causing a computer system to process program code mechanism invocations which are directed to one of a multiplicity of remote Object Request Brokers (ORBs), the computer program product comprising:

a first computer readable program code mechanism configured to comprise an ORB-independent layer of code mechanisms including client applications and related stub program code mechanisms; and

a second computer readable program code mechanism configured to comprise an ORB dependent layer of code mechanisms, coupled to the ORB independent layer, the ORB dependent layer comprising program code mechanisms which are ORB-specific and which are configured to generate a marshal code mechanism to marshal data in an ORB required format and program code mechanisms configured to use a specific network protocol code whereby a program application code mechanism from the ORB independent layer can invoke a call on a remote implementation program code mechanism and the ORB-specific program code mechanisms in the ORB dependent layer will determine an appropriate marshal code mechanism to marshal data in an ORB required format, thereby providing a computer system capable of communicating with a multiplicity of ORBs wherein each ORB requires data to be in a specific format.

13. A computer program product as defined in claim 12 wherein the ORB independent layer of code mechanisms including program applications and related stubs comprise object applications and related stubs.

14. A computer program product as defined in claim 12 wherein the marshal code mechanism to marshal data in an ORB required format which is located in the ORB-dependent layer is a MarshalBuffer Object configured to execute operations to marshal data in an ORB specific format.

15. A computer program product as defined in claim 12 wherein the program code mechanism configured to use a specific network protocol code which is located in the ORB-dependent layer is configured to use a network protocol code mechanism selected from a group consisting of Spring network protocol code and DOE network protocol code.

16. A computer program product as defined in claim 12 wherein the marshal code mechanism to marshal data in an ORB required format which is located in the ORB-dependent layer is also configured to unmarshal results returned to it.

17. A method for use in a computer node which contains client applications and related stubs for communicating with remote computer nodes which contain object implementations wherein the computer implementations require invocation data to be in specific formats, the method, performed by the computer, comprising the steps of:

using an Object Request Broker (ORB)-specific program code mechanism configured to receive an invocation of a target object implementation by an invoking client application, the invocation being received from a stub related to the invoking client application, wherein the invoking client application and the related stub have no knowledge of an ORB which must process the invocation, the ORB-specific program code mechanism configured to select one of a multiplicity of MarshalBuffer program code mechanisms; and

using a MarshalBuffer program code mechanism configured to marshal arguments and data into a specific format required by the ORB which must process the invocation.

18. A method for marshaling data into a specific format for use in a computer node which contains client applications and related stubs for communicating with remote computer nodes which contain object implementations, the method for marshaling data, performed by a computer, comprising the steps of:

providing marshal program code mechanisms associated with a plurality of Object Request Brokers (ORBs) which require distinct data formats, the marshal program code mechanisms being configured to format arguments and data related to an object implementation invocation made by a client application, wherein said invocation and said client application have no knowledge of an Object Request Broker (ORB) which can process said invocation and wherein said invocation and said client application have no knowledge of a data format required by said ORB which can process said invocation;

selecting a particular marshal program code mechanism from the marshal program code mechanisms based upon a particular invocation; and

using said selected marshal program code mechanism to marshal and unmarshal said arguments and said data.

21. A computer-implemented method of operating a computer system having a processor, a memory, an operating system, and a client application, the method comprising:

invoking a call on a target object, the call invocation being made by the client application wherein the call includes a reference to the target object, the target object being associated with a server application, the server application being associated with the computer system;

using a stub which is related to the client application to receive the call invocation, wherein the stub has no knowledge of a specific format required for marshaling data provided by the client application in connection with the call invocation, the specific format required for marshaling data being associated with the server application;

calling a specific code mechanism using the stub;

requesting a MarshalBuffer object from the specific code mechanism, the MarshalBuffer object being arranged to format the data provided by the client application into the specific format in connection with the call invocation;

marshaling the data provided by the client application in connection with the call invocation, the marshaling being done using the MarshalBuffer object, wherein marshaling the data formats the data in the specific format; and

sending the call invocation to the server application containing the target object.