Service-oriented middleware for managing interoperability of heterogeneous elements of integrated systems

• US 20060159077A1
• Filed: 11/17/2005
• Published: 07/20/2006
• Est. Priority Date: 08/20/2004
• Status: Abandoned Application

• Current Assignee: uXcomm, Inc. (Virtugo Software, Inc.)
• Original Assignee: uXcomm, Inc. (Virtugo Software, Inc.)
• Inventors: Vanecek, George Jr.
• Application Number:
  US11/282,307
• Publication Number:
  US 20060159077A1
• Time in Patent Office: Days
• US Class Current: 370/360
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/427 Parsing

Abstract

A method and system for creating integrated systems from diverse computer-based elements is provided. The integration system provides a service-oriented methodology based on a notion of services as operational abstractions to required middleware that encapsulate an element'"'"'s built-in capabilities, establish a communication context with other services and client applications, and translate data to and from the native interfaces and protocols of the elements. A service is based on a service specification which defines the service'"'"'s operations and the format for sending service requests to the service. The integration system is based on the existence of a distributed set of individually customized run-time environments running as service agents, which support the exchange of service specifications and the processing of service requests sent from other services and from client applications.

Claims

1. A system for creating integrated systems from multiple heterogeneous computer-based elements, comprising:

a software architecture based on functions or services configured as operational abstractions to required middleware, wherein the services;

encapsulate built-in capabilities of a given computer-based element,

establish a communication context with other services and client applications, and

translate data to and from native interfaces and protocols of the multiple heterogeneous computer-based elements;

a predefined service specification for available operations of each service, wherein each service specification describes a format for sending request messages to access the operations of each service, wherein each service specification also describes how service operations are mapped to built-in capabilities of the multiple heterogeneous computer-based elements;

a distributed set of individually customizable run-time environments which support the exchange of service specifications and the processing of service requests sent from other services and from client applications, wherein the run-time environments compile service specifications and translate the operations described in the service specifications to the built-in capabilities of the multiple heterogeneous computer-based elements;

wherein the system is configured to be employed in a variety of scenarios and frameworks, without requiring extensive computer programming, compiling, debugging, testing, and redeploying of embedded core capabilities, to thereby implement functionality of a network management system having multiple computer-based elements and to generate embedded management applications in data processing environments to implement integrated systems consisting of various hardware, operating systems, middleware, and applications, or to enhance a given set of core capabilities or add missing capabilities to form an integrated system in a flexible manner, or to extend and modify such systems.

2. An integrated system for managing computer-based elements, comprising:

at least one service specification component for describing one or more service operations of a service, wherein the service specification permits access to one or more actions using meta-language primitives;

at least one run-time environment component for receiving service requests, reading service specifications, and invoking adapters to perform requests; and

one or more adapter components that provide the primitives of the meta-language and perform translation and mediation of the one or more actions to the built-in capabilities of the computer-based elements.

3. The system of claim 2 wherein the service specification component uses XML to describe the service.

4. The system of claim 2 wherein the system contains multiple run-time environment components that define a hierarchy of services.

5. The system of claim 2 wherein the service exposes additional capabilities not described by the service specification.

6. The system of claim 2 wherein the run-time environment component supports static scope rules to maintain state information between actions.

7. The system of claim 2 wherein the run-time environment component is multi-threaded and supports the execution of multiple service requests simultaneously.

8. The system of claim 2 wherein the run-time environment component creates channels that allow an adapter to share state information in a service request session.

9. The system of claim 2 wherein the run-time environment component downloads the service specification component based on a service request.

10. The system of claim 9 wherein the run-time environment component includes a service specification cache component for storing downloaded service specifications for use by subsequent service requests.

11. The system of claim 2 wherein the service is a health monitoring service that monitors the health of an integrated system.

12. The system of claim 2 wherein the service specification component provides an SNMP interface to the service.

13. The system of claim 2 wherein the service specification component provides an HTTP interface to the service.

14. The system of claim 2 wherein the service specification component provides a command-line interface over Telnet to the service.

15. The system of claim 2 wherein the run-time environment is located on a different computer-based element than the computer-based element having the built-in capabilities for which the run-time environment receives requests and the adapters invoked by the run-time environment remotely perform requests.

16. A computer-implemented method of performing service operations at a service agent, comprising:

receiving a request to perform a service operation at a run-time engine;

accessing a service specification in a meta-language containing a mapping of the service operation to one or more meta-language primitives;

loading the service specification using one or more adapters to interpret the meta-language primitives;

invoking the service specification to perform the service request by using the one or more adapters to translate the one or more metalangauge primitives for the service operation to the built-in capabilities of a computer-based element.

17. The method of claim 16 wherein the service specification contains a hierarchy of service operations.

18. The method of claim 17 wherein invoking the service specification includes traversing the hierarchy of service operations and performing pre-action blocks for an ancestor service operation before performing the action blocks of its descendants.

19. The method of claim 17 wherein invoking the service specification includes traversing the hierarchy of service operations and performing post-action blocks for an ancestor service operation after performing the action blocks of its descendants.

20. The method of claim 16 wherein the request is in XML.

21. The method of claim 16 wherein the request is received over HTTP.

22. The method of claim 16 wherein the request is received over CLI.

23. The method of claim 16 wherein the service specification is divided into an interface portion and an implementation portion.

24. The method of claim 20 wherein only the interface portion is accessible to the author of a service request.

25. The method of claim 16 including generating a reply to the service request.

26. The method of claim 16 wherein run-time engine and adapters are implemented using the Java programming language.

27. The method of claim 16 wherein accessing a service specification includes checking a cache for the service specification, and if the service specification is not present in the cache, downloading the service specification from a repository of service specifications.

28. The method of claim 16 wherein loading the service specification includes checking a cache of adapters for adapters referenced in the service specification, and if an adapter is not present in the cache, downloading the adapter from a repository of adapters.

29. The method of claim 28 wherein downloading the adapter includes sending information about a platform on which the service agent is running to the adapter repository so that the repository can provide an adapter suitable for the platform.

30. A computer-implemented method of creating a service request in a meta-language, comprising:

enumerating available service specifications from a repository of known services that translate service operations in the meta-language to built-in capabilities of one or more computer-based elements;

selecting one or more service operations from among the available service operations to be requested in the service request; and

storing the service request in the meta-language containing a description of the selected service operations and a reference to the service specifications that define the selected service operations.

31. The method of claim 30 including editing one or more properties of the service operations and storing the edited properties in the service request.

editing one or more properties of the selected service operations

receiving an action to be exposed in a common format wherein the action includes a name, and mapping information for translating requests into calls to one or more adapters.

32. The method of claim 30 wherein enumerating available service specifications includes automatically discovering available services by querying one or more service agents and retrieving one or more interfaces for the services.

33. A computer-implemented method of exposing built-in capabilities of a computer-based element through a common meta-language, comprising:

enumerating available meta-language primitives from a repository of adapters that translate the meta-language primitives to the built-in capabilities of the computer based element; and

for each of one or more service operations,

defining an interface for the service operation;

associating adapters needed to perform the service operation with the service operation; and

storing in a service specification the service operation interface, a name for the service operation, and one or more actions that implement the service operation using the meta-language primitives of the associated adapters.

34. The method of claim 33 including for at least one of the one or more service operations, defining a schema for replies to the service operation and wherein storing the service specification includes storing a reference to the schema for replies in the service specification.

35. The method of claim 33 wherein the interface for at least one of the service operations includes arguments that modify the behavior of the service operation.

36. The method of claim 33 wherein the one or more service operations include a description.

37. The method of claim 33 wherein the actions include generating a service request to another service.

38. One or more computer memories collectively storing a data structure for describing a service, comprising:

a reference to one or more adapters that define primitives used to implement the service in a common meta-language;

a name of a service operation; and

one or more actions that implement the service operation using the primitives defined by the referenced adapters.

39. The data structure of claim 38 wherein the service operations are arranged hierarchically and the actions of each service operation are grouped into one or more of a pre-action block, a do-action block, and a post-action block.

40. The data structure of claim 39 wherein each service operation includes an exception handling block.

41. The data structure of claim 39 including a reference to a schema for replies to the service operation.

42. One or more computer memories collectively storing a data structure for requesting that a service operation be performed, comprising:

a reference to a service specification that defines the service operation to be performed;

a name of the service operation to be performed; and

one or more arguments to be passed to the service operation.

43. A system for translating server management requests in a common format to one or more native protocols, comprising:

a specification compiler for receiving a specification of a management request that contains mapping information for translating the request into user-modifiable functionality provided by one or more adapters;

a request processor for interpreting the compiled specification and invoking the one or more adapters in response to a management request; and

an adapter loading component for enumerating a list of available adapters, importing programmatic extensions from the adapters to the request processor to provide user-modifiable functionality, and exposing the adapters for use by a specification.