Supporting interactions between different versions of software for accessing remote objects

• US 20040172462A1
• Filed: 02/28/2003
• Published: 09/02/2004
• Est. Priority Date: 02/28/2003
• Status: Active Grant

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Iterum, Skef F., Campbell, Ralph B.
• Granted Patent: US 7,055,147 B2
• Time in Patent Office: Days
• US Class Current: 709/223
• CPC Class Codes: G06F 9/465 Distributed object oriented systems remote method invocation [RMI] G06F9/548
• CPC Class Codes: Y10S 707/99953 Recoverability
• CPC Class Codes: Y10S 707/99954 Version management

Abstract

One embodiment of the present invention provides a system that facilitates interactions between different versions of software that support remote object invocations. During operation, the system receives a reference to an object that is implemented on a server. Next, the system identifies one or more versions of the object supported by the reference, wherein each successive version of the object inherits methods from a preceding version of the object. The system then invokes a method on the object that is supported by the one or more versions of the object.

Claims

1. A method for supporting interactions between different versions of software for performing remote object invocations within a distributed computing system, comprising:

receiving a reference to an object, wherein the object is implemented on a server;

identifying one or more versions of the object supported by the reference;

wherein each successive version of the object inherits methods from a preceding version of the object; and

invoking a method on the object that is supported by the one or more versions of the object.

2. The method of claim 1, wherein identifying the one or more versions of the object supported by the reference involves calling a version function that returns a highest version of the object supported by the reference.

3. The method of claim 1, wherein identifying the one or more versions of the object supported by the reference involves:

invoking a method on the object, wherein the method is implemented by a version of the object; and

if an unsupported version exception is returned by the method, concluding the version of the object supported by the reference is lower than the version of the object that implements the method.

4. The method of claim 1, wherein the reference operates through an Interface Definition Language (IDL) framework that is supported by an IDL compiler, wherein the IDL compiler compiles interface definitions that specify methods associated with the object.

5. The method of claim 4, further comprising performing a narrow function on the reference, wherein the narrow function succeeds and returns a non-NULL pointer if version 0 of an interface being narrowed to is supported by the reference.

6. The method of claim 4, wherein the IDL compiler supports annotating a method with a version number that identifies a version of an object that implements the method.

7. The method of claim 4, wherein the IDL compiler supports annotating an object with a version number to facilitate specifying inheritance relationships between versions of objects.

8. The method of claim 4, wherein the IDL compiler supports server only interfaces, wherein references cannot be narrowed to a server only interface, and wherein objects cannot specify their own methods;

wherein the server only interface can be used to create an intermediate object that inherits from two incompatible interfaces to facilitate upgrading to an incompatible major version of software.

9. The method of claim 1, wherein identifying the one or more versions of the object supported by the reference involves examining an object type associated with the reference.

10. The method of claim 9, wherein identifying the one or more versions of the object supported by the reference involves looking up an entry for a deep type associated with the reference in a schema cache, wherein the entry for a deep type in the schema cache specifies versions of the object that are supported by the deep type.

11. The method of claim 10, wherein the schema cache is a multi-level cache that includes:

a client schema cache located at the client;

a client-kernel schema cache located within the kernel of operating system hosting the client; and

a server-kernel schema cache located within the kernel of an operating system hosting the server for the object;

wherein the lookup is first performed in the client schema cache;

wherein if the lookup in the client schema cache fails, the lookup is performed in the client-kernel schema cache;

wherein if the lookup in the server-kernel schema cache fails, the lookup is performed in the server-kernel schema cache;

wherein if the lookup in the server-kernel schema cache fails, the lookup is performed by asking the server to specify which versions of the object are supported by the reference.

12. A computer-readable storage medium storing instructions that when executed by a computer cause the computer to perform a method for supporting interactions between different versions of software for performing remote object invocations within a distributed computing system, the method comprising:

receiving a reference to an object, wherein the object is implemented on a server;

identifying one or more versions of the object supported by the reference;

wherein each successive version of the object inherits methods from a preceding version of the object; and

invoking a method on the object that is supported by the one or more versions of the object.

13. The computer-readable storage medium of claim 12, wherein identifying the one or more versions of the object supported by the reference involves calling a version function that returns a highest version of the object supported by the reference.

14. The computer-readable storage medium of claim 12, wherein identifying the one or more versions of the object supported by the reference involves:

invoking a method on the object, wherein the method is implemented by a version of the object; and

if an unsupported version exception is returned by the method, concluding the version of the object supported by the reference is lower than the version of the object that implements the method.

15. The computer-readable storage medium of claim 12, wherein the reference operates through an Interface Definition Language (IDL) framework that is supported by an IDL compiler, wherein the IDL compiler compiles interface definitions that specify methods associated with the object.

16. The computer-readable storage medium of claim 15, wherein the method further comprises performing a narrow function on the reference, wherein the narrow function succeeds and returns a non-NULL pointer if version 0 of an interface being narrowed to is supported by the reference.

17. The computer-readable storage medium of claim 15, wherein the IDL compiler supports annotating a method with a version number that identifies a version of an object that implements the method.

18. The computer-readable storage medium of claim 15, wherein the IDL compiler supports annotating an object with a version number to facilitate specifying inheritance relationships between versions of objects.

19. The computer-readable storage medium of claim 15, wherein the IDL compiler supports server only interfaces, wherein references cannot be narrowed to a server only interface, and wherein objects cannot specify their own methods;

wherein the server only interface can be used to create an intermediate object that inherits from two incompatible interfaces to facilitate upgrading to an incompatible major version of software.

20. The computer-readable storage medium of claim 12, wherein identifying the one or more versions of the object supported by the reference involves examining an object type associated with the reference.

21. The computer-readable storage medium of claim 20, wherein identifying the one or more versions of the object supported by the reference involves looking up an entry for a deep type associated with the reference in a schema cache, wherein the entry for a deep type in the schema cache specifies versions of the object that are supported by the deep type.

22. The computer-readable storage medium of claim 21, wherein the schema cache is a multi-level cache that includes:

a client schema cache located at the client;

a client-kernel schema cache located within the kernel of operating system hosting the client; and

a server-kernel schema cache located within the kernel of an operating system hosting the server for the object;

wherein the lookup is first performed in the client schema cache;

wherein if the lookup in the client schema cache fails, the lookup is performed in the client-kernel schema cache;

wherein if the lookup in the server-kernel schema cache fails, the lookup is performed in the server-kernel schema cache;

wherein if the lookup in the server-kernel schema cache fails, the lookup is performed by asking the server to specify which versions of the object are supported by the reference.

23. An apparatus that supports interactions between different versions of software for performing remote object invocations within a distributed computing system, comprising:

a receiving mechanism configured to receive a reference to an object, wherein the object is implemented on a server;

an identification mechanism configured to identify one or more versions of the object supported by the reference;

wherein each successive version of the object inherits methods from a preceding version of the object; and

an invocation mechanism configured to invoke a method on the object that is supported by the one or more versions of the object.

24. The apparatus of claim 23, wherein the identification mechanism is configured to invoke a version function that returns a highest version of the object supported by the reference.

25. The apparatus of claim 23, wherein the identification mechanism is configured to:

invoke a method on the object, wherein the method is implemented by a version of the object; and

if an unsupported version exception is returned by the method, to conclude the version of the object supported by the reference is lower than the version of the object that implements the method.

26. The apparatus of claim 23, further comprising an Interface Definition Language (IDL) compiler, wherein the reference operates through an IDL framework that is supported by the IDL compiler, wherein the IDL compiler compiles interface definitions that specify methods associated with the object.

27. The apparatus of claim 26, wherein the identification mechanism is configured to provide a narrow function for the reference, wherein the narrow function succeeds and returns a non-NULL pointer if version 0 of an interface being narrowed to is supported by the reference.

28. The apparatus of claim 26, wherein the IDL compiler supports annotating a method with a version number that identifies a version of an object that implements the method.

29. The apparatus of claim 26, wherein the IDL compiler supports annotating an object with a version number to facilitate specifying inheritance relationships between versions of objects.

30. The apparatus of claim 26, wherein the IDL compiler supports server only interfaces, wherein references cannot be narrowed to a server only interface, and wherein objects cannot specify their own methods;

wherein the server only interface can be used to create an intermediate object that inherits from two incompatible interfaces to facilitate upgrading to an incompatible major version of software.

31. The apparatus of claim 23, wherein the identification mechanism is configured to identify an object type associated with the reference.

32. The apparatus of claim 31, wherein the identification mechanism is configured to look up an entry for a deep type associated with the reference in a schema cache, wherein the entry for a deep type in the schema cache specifies versions of the object that are supported by the deep type.

33. The apparatus of claim 32, wherein the schema cache is a multi-level cache that includes:

a client schema cache located at the client;

a client-kernel schema cache located within the kernel of operating system hosting the client; and

a server-kernel schema cache located within the kernel of an operating system hosting the server for the object;

wherein the lookup is first performed in the client schema cache;

wherein if the lookup in the client schema cache fails, the lookup is performed in the client-kernel schema cache;

wherein if the lookup in the server-kernel schema cache fails, the lookup is performed in the server-kernel schema cache;

wherein if the lookup in the server-kernel schema cache fails, the lookup is performed by asking the server to specify which versions of the object are supported by the reference.