Transport independent invocation and servant interfaces that permit both typecode interpreted and compiled marshaling

• US 6,032,199 A
• Filed: 06/26/1996
• Issued: 02/29/2000
• Est. Priority Date: 06/26/1996
• Status: Expired due to Term

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Kessler, Peter B., Lim, Swee Boon, Brownell, David M.
• Primary Examiner(s): Oberley, Alvin E.
• Assistant Examiner(s): COURTENAY III, ST JOHN
• Application Number:
  US08/673,181
• Time in Patent Office: 1,343 Days
• Field of Search: 395/684, 395/680, 709/300, 709/304, 709/303
• US Class Current: 719/316
• CPC Class Codes: G06F 9/548 Object oriented; Remote method invocation [RMI] non-remote method invocation G06F9/449

Abstract

Data structures, methods, and devices for facilitating servant invocation in a distributed client-server based object oriented operating system are disclosed. In one aspect of the invention, descriptor data structures, which contain a typecode indicator, a marshaling function identifier, and an unmarshaling function identifier, are used to enable modules of application code to be shared between different objects, thereby facilitating servant invocation by increasing the amount of commonized code in the operating system. In another aspect of the invention, a server invocation object is used in the execution of a method call. In still another aspect of the invention, a commonized code base is used to process typecode interpreted and compiled calls to a server process.

Claims

1. In a distributed client/server based computing system, a method of calling a remotely located object, the method comprising the steps of:

receiving a request within a client process;

selecting a transport appropriate to the request, the transport being used to marshal the request;

creating a marshal buffer appropriate to the selected transport, the marshal buffer being used to encapsulate the request;

marshaling an argument using descriptor data structures utilizing a marshal method, the descriptor data structures including a compiled flag used to indicate whether the marshal method is typecode interpreted or compiled, the argument being associated with the request; and

determining whether the compiled flag is set, wherein,

when it is determined that the compiled flag is set, the argument marshaling step is accomplished by invoking a marshal method associated with the argument associated with the request, and

when it is determined that the compiled flag is not set, the argument marshaling step is accomplished by invoking a typecode marshaling routine passing the argument associated with the request to the typecode marshaling routine.

2. In a distributed client/server based computing system, a method of calling a remotely located object, the method comprising the steps of:

receiving a request within a client process, the request including at least one argument stored in a location with an address;

selecting a transport appropriate to the request;

creating a marshal buffer appropriate to the selected transport, the marshal buffer being used to encapsulate the request;

selecting a marshal function appropriate for marshaling the argument in the request using descriptor data structures, the descriptor data structures including an invocation descriptor data structure that includes a compiled flag used to indicate whether the request is typecode interpreted or pre-compiled, and a plurality of parameter descriptors;

determining whether the compiled flag is set; and

marshaling the argument wherein

when it is determined that the compiled flag is set, the argument marshaling step is accomplished by invoking a marshal method identified by a parameter descriptor associated with the argument, and

when it is determined that the compiled flag is not set, the argument marshaling step is accomplished by invoking a marshaling method identified using typecode interpretation.

3. A method as recited in claim 2 further comprising the steps of:

selecting an unmarshal function appropriate for unmarshaling the argument in the request using the descriptor data structures; and

determining whether the compiled flag is set, wherein,

when it is determined that the compiled flag is set, the argument unmarshaling step is accomplished by invoking an unmarshal method identified by the parameter descriptor associated with the argument, and

when it is determined that the compiled flag is not set, the argument unmarshaling step is accomplished by invoking a unmarshal method identified using typecode interpretation.

4. A method as recited in claim 2 wherein:

the marshal method identified by the parameter descriptor is passed the argument; and

the marshal method identified using typecode interpretation is passed the argument and an associated typecode.

5. A method as recited in claim 4 wherein when the request has more than one argument associated therewith:

when it is determined that the compiled flag is set, the argument marshaling step is accomplished by sequentially invoking marshal methods associated with each of the arguments; and

when it is determined that the compiled flag is not set, the argument marshaling step is accomplished by sequentially invoking typecode marshaling routines associated with each of the arguments, passing the arguments to their associated typecode marshaling routines.

6. A method as described in claim 2 further comprising the steps of:

transmitting the request over the selected transport to an identified endpoint, the endpoint being associated with a server process; and

receiving a reply from the server process.

7. A method as recited in claim 3 wherein:

the unmarshal method identified by the parameter descriptor is passed the argument; and

the unmarshal method identified using typecode interpretation is passed the argument and an associated typecode.

8. A method as recited in claim 4 wherein each argument that is passed to one of the marshal methods takes the form of an address that defines the memory location which stores the argument.

9. A method as described in claim 6 wherein the step of receiving a reply from the server process further comprises the steps of encapsulating the reply in the marshal buffer using the marshal function identified by the parameter descriptor.

10. A method as recited in claim 7 wherein each argument that is passed to one of the unmarshal methods takes the form of an address that defines the memory location which stores the argument.

11. In a distributed client/server based computing system, a method of handling an exception received as part of a reply, the reply being received by a client from a server in response to a request made by the client to the server, the exception handling method comprising the steps of:

receiving a reply within a marshal buffer on a host machine associated with the client;

determining whether an argument in the reply is a system exception raised by the server in the form of a predefined exception return pointer;

searching an exception descriptor repository for a key that matches a value set forth in the exception return pointer when it is determined that the argument in the reply is a system exception that was raised by the server in the form of a exception return pointer; and

when a matching key is found, calling a throw function associated with the matched key passing a pointer to the marshal buffer with the throw function call.

12. A computer program product for invoking an object method defined on a distributed server object within a distributed object computing system, the computer program product comprising:

computer code for receiving a request within a client process, the request including at least one argument stored in a location with an address;

computer code for selecting a transport appropriate to the request;

computer code for creating a marshal buffer appropriate to the selected transport, the marshal buffer being used to encapsulate the request;

computer code for selecting a marshal function appropriate for marshaling the argument in the request using descriptor data structures, the descriptor data structures including an invocation descriptor data structure that includes a compiled flag used to indicate whether the request is typecode interpreted or pre-complied, and a plurality of parameter descriptors;

computer code for determining whether the compiled flag is set;

computer code for marshaling the argument, wherein,

when it is determined that the compiled flag is set, the argument marshaling step is accomplished by invoking a marshal method identified by a parameter descriptor associated with the argument, and

when it is determined that the compiled flag is not set, the argument marshaling step is accomplished by invoking a marshaling method identified using typecode interpretation; and

a computer-readable medium that stores the computer codes.

13. A computer program product as recited in claim 12 further including:

computer code for selecting an unmarshal function appropriate for unmarshaling the argument in the request using the descriptor data structures; and

computer code for determining whether the compiled flag is set, wherein,

when it is determined that the compiled flag is set, the computer code for argument unmarshaling includes computer code for invoking an unmarshal method identified by the parameter descriptor associated with the argument, and

when it is determined that the compiled flag is not set, the argument unmarshaling step is accomplished by invoking a unmarshal method identified using typecode interpretation.

14. A computer program product as recited in claim 12 further including:

computer code for passing the argument to the marshal method identified by the parameter descriptor; and

computer code for passing the argument and an associated typecode to the marshal method identified using typecode interpretation.

15. A computer program product as recited in claim 12 further including:

computer code for transmitting the request over the selected transport to an identified endpoint, the endpoint being associated with a server process; and

computer code for receiving a reply from the server process.

16. A computer program product as recited in claim 12 wherein when the request has more than one argument associated therewith:

when it is determined that the compiled flag is set, the argument marshaling is accomplished by computer code that is arranged for sequentially invoking marshal methods associated with each of the arguments; and

when it is determined that the compiled flag is not set, the argument marshaling is accomplished by computer code that is arranged for sequentially invoking typecode marshaling routines associated with each of the arguments, passing the arguments to their associated typecode marshaling routines.

17. A computer program product as recited in claim 13 further including:

computer code for passing the argument to the unmarshal method identified by the parameter descriptor; and

computer code for passing the argument and an associated typecode to the unmarshal method identified using typecode interpretation.

18. A computer program product as recited in claim 14 wherein each argument that is passed to one of the marshal methods takes the form of an address that defines the memory location which stores the argument.

19. A computer program product as recited in claim 15 wherein computer code for receiving a reply from the server process further includes computer code for encapsulating the reply in the marshal buffer using the marshal function identified by the parameter descriptor.

20. A computer program product as recited in claim 17 wherein each argument that is passed to one of the unmarshal methods takes the form of an address that defines the memory location which stores the argument.

21. A computer program product for handling an exception received as part of a reply, the reply being received by a client from a server in response to a request made by the client to the server within a distributed object computing system, the computer program product comprising:

computer code for receiving a reply within a marshal buffer on a host machine associated with the client;

computer code for determining whether an argument in the reply is a system exception raised by the server in the form of a predefined exception return pointer;

computer code for searching an exception descriptor repository for a key that matches a value set forth in the exception return pointer when a system exception was raised by the server in the form of a exception return pointer;

computer code for calling a throw function associated with the matched key passing a pointer to the marshal buffer with the throw function call when the matching key is found; and

a computer readable medium that stores the computer codes.

22. In a distributed client/server based computing system, a method for calling a remotely located object, the method comprising:

receiving a request within a client process;

selecting a transport appropriate to the request, the transport being arranged to marshal the request;

creating a marshal buffer appropriate to the selected transport, the marshal buffer being arranged to encapsulate the request;

marshaling an argument using descriptor data structures utilizing a marshal method, the descriptor data structures including an invocation data structure that is arranged to provide information associated with invoking a method, a method data structure that is arranged to describe the method, and a parameter data structure, the invocation data structure including a compiled flag used to indicate whether the marshal method is non-compiled or compiled, the argument being associated with the request; and

determining whether the compiled flag is set, wherein,

when it is determined that the compiled flag is set, the argument marshaling step is accomplished by invoking a marshal method associated with the argument associated with the request; and

when it is determined that the compiled flag is not set, the argument marshaling step is accomplished by invoking a typecode marshaling routine passing the argument associated with the request to the typecode marshaling routine.

23. In a distributed client/server based computing system, a method of calling a remotely located object, the method comprising:

receiving a request within a client process, the request including at least one argument stored in a location with an address;

selecting a transport appropriate to the request;

creating a marshal buffer appropriate to the selected transport, the marshal buffer being used to encapsulate the request;

selecting a marshal function appropriate for marshaling the argument in the request using descriptor data structures, the descriptor data structures including an invocation descriptor data structure that includes a compiled flag used to indicate whether the request is typecode interpreted or pre-compiled, and a plurality of parameter descriptors which describe characteristics of parameters associated with the invocation descriptor data structure, wherein the invocation descriptor data structure further includes a first pointer to the plurality of parameter descriptors and a second pointer to an array of pointers to exception descriptor data structures, the exception descriptor data structures being arranged to describe characteristics of exceptions associated with the invocation descriptor data structure;

determining whether the compiled flag is set; and

marshaling the argument wherein when it is determined that the compiled flag is set, the argument marshaling step is accomplished by invoking a marshal method identified by a parameter descriptor associated with the argument, the parameter descriptor being selected from the plurality of parameter descriptors, and when it is determined that the compiled flag is not set, the argument marshaling step is accomplished by invoking a marshaling method identified using typecode interpretation.

24. A method as recited in claim 23 further including:

selecting an unmarshal function appropriate for unmarshaling the argument in the request using the descriptor data structures; and

determining whether the compiled flag is set, wherein when it is determined that the compiled flag is set, the argument unmarshaling step is accomplished by invoking an unmarshal method identified by the parameter descriptor associated with the argument, and when it is determined that the compiled flag is not set, the argument unmarshaling step is accomplished by invoking a unmarshal method identified using typecode interpretation.

25. A server invocation object for use in executing a method call in a distributed operating environment that utilizes an object request broker for facilitating communications between different objects, the server invocation object comprising:

a first identifier arranged to identify an associated marshal buffer for the server invocation object;

a second identifier arranged to identify an associated method descriptor for the server invocation object, wherein the associated method descriptor includes substantially only non-invocation information related to the method call; and

a third identifier arranged to identify an associated invocation descriptor for the server invocation object, the invocation descriptor including arguments, wherein the associated invocation descriptor includes invocation information associated with the method call.