Sun Microsystems, Inc.

Oracle America, Inc.

Thulasiraman Jeyaraman

Ken M Cavanaugh

Mark W Hapner

Harold Carr

Rahul Sharma

Vladimir Matena

Albert C Gondi

William A Shannon

Tony Chun Tung Ng

Linda Gail DeMichiel

Kenneth David Saks

Kathleen A Stout

Qingqing Ouyang

Methods and apparatus for improving the overall performance of a system which processes transactions and provides connections in an enterprise environment are disclosed. According to one aspect of the present invention, a method for processing a transaction in an enterprise environment includes receiving a request to start the transaction, storing information which indicates that the request to start the transaction was received, and accessing a first resource manager associated with the transaction. Typically, a container receives the request to start a transaction from a component such as an enterprise bean. Once the first resource is accessed, the transaction is initiated as a local transaction on the first resource manager, and, eventually, the transaction is completed. In one embodiment, completing the transaction includes using a local transaction mechanism of the first resource manager to complete the local transaction.

Method and apparatus for increasing the efficiency of transactions and connection sharing in an enterprise environment

Method and apparatus for determining data encoding format in RMI-IIOP messages. Embodiments may provide a mechanism to use Java serialization rather than, or as an alternative to, CORBA Common Data Representation (CDR), for the marshaling and unmarshaling of data in RMI-IIOP message exchanges. In one embodiment, a server-side Object Request Broker (ORB) may be configured to support the encoding of data in RMI-IIOP messages in accordance with CDR encoding and Java serialization encoding. In one embodiment, an Interoperable Object References (IOR) published by the server may include information that indicates which encoding type(s) are supported by the server-side ORB on the server that hosts the associated object. A client-side ORB may optionally use Java serialization or CDR as the data encoding format for RMI-IIOP messages to invoke the associated object on the server. Each RMI-IIOP message may include an indication of which encoding type is used in the message.

Method and apparatus for determining data encoding format in RMI-IIOP messages

Method and apparatus for RMI-IIOP implementation using Java serialization as a data encoding mechanism. Embodiments may provide a mechanism to use Java serialization rather than, or as an alternative to, CORBA Common Data Representation (CDR), for the marshaling and unmarshaling of data in RMI-IIOP message exchanges. In one embodiment, a server-side Object Request Broker (ORB) may be configured to support the encoding of data in RMI-IIOP messages in accordance with CDR encoding and Java serialization encoding. A client-side ORB may optionally use Java serialization or CDR as the data encoding format for RMI-IIOP messages to invoke the associated object on the server. Response messages from the server to the client may include data encoded according to Java serialization or CDR.

Method and apparatus for RMI-IIOP implementation with java serialization

A method, apparatus, and system for providing a standard, generic contract between an application server and a message provider which allows the message provider to deliver messages to message endpoints (each of which is associated with a corresponding message application) residing in the application server is disclosed. By generic, it is meant that the contract is independent of the specific messaging style, messaging semantics and messaging infrastructure used to deliver messages. In this way, the contract also serves as the standard message provider pluggability contract that allows any message provider to be plugged into any application server via an associated resource adapter.

Architecture for plugging messaging systems into an application server

A method, apparatus and system arranged to provide a contract between an application server and a resource adapter that allows the resource adapter to do work (monitor network endpoints, call application components, etc) by submitting work instances to an application server for execution. In the described embodiment, the application server dispatches threads to execute submitted work instances thereby allowing the requesting resource adapter to avoid creating or managing threads directly. In this way, a mechanism for the resource adapter to do its work is provided as well as allowing the application server to efficiently pool threads and have more control over its runtime environment.

Callback event listener mechanism for resource adapter work executions performed by an application server thread

Providing a contract between an application server and a resource adapter that allows the application server to manage the lifecycle of the resource adapter. When deploying a resource adapter (or during application server startup), an application server bootstraps a resource adapter instance in an appropriate address space. When a resource adapter is undeployed (or during application server shutdown), the application server notifies the resource adapter instance to stop functioning in order to allow safe unloading. The contract provides a mechanism for an application server to manage the lifecycle of a resource adapter instance, allowing an application server to bootstrap a resource adapter instance during resource adapter deployment or application server startup and to expose some of its useful facilities to the resource adapter instance. It also provides a mechanism to notify the resource adapter instance while it is undeployed or during an orderly shutdown of the application server.

Mechanism to manage the lifecycle of a resource adapter

A method for using a Synchronization Interface in a computer system compliant with a CORBA Object Transaction Service or a Java Transaction API (such as Java 2 Platform Enterprise Edition Reference Implementation) to perform internal state clean up in containers associated with a completed transaction. First, a synchronization object is registered for each new transaction in a container with a Transaction Manager. The Transaction Manager detects a completion of the transaction and then invokes an &ldquo;after_completion&rdquo; operation (method) on the synchronization object. This notifies each container involved in the completed transaction to perform internal memory space clean up. Thus, the method uses an existing Synchronization Interface mechanism to perform internal memory state clean up in containers, without adding additional communication mechanisms.

Method for using a transaction service synchronization interface to perform internal state clean up

One embodiment of the present invention provides a system that efficiently propagates changes in hierarchically organized data to remotely cached copies of the data. The system operates by receiving an access to the data at a client. In response to this access, the system determines if the client contains a copy of the data. If so, the system sends a request to a server for an update to the copy. The server receives the request and determines differences between the current version of the data at the server and an older copy of the data at the client, which the server has stored locally. These differences are used to construct an update for the copy of the data, which may include node insertion and node deletion operations for hierarchically organized nodes in the data. Next, the update is sent to the client where it is applied to the copy of the data to produce an updated copy of the data. Finally, the original access is allowed to proceed on the updated copy of the data. According to one aspect of the present invention, the act of determining differences, and the act of using the differences to construct the update both take place during a single pass through the data. According to another aspect of the present invention, the update for the copy of the data may include node copy, node move, node collapse and node splitting operations.

Propogating updates efficiently in hierarchically structured date

One embodiment of the present invention provides a system that efficiently propagates changes in hierarchically organized data to remotely cached copies of the data. The system operates by receiving changes to the data located on the server, and applying the changes to the data on the server. These changes are propagated to remotely cached copies of the data on a client in response to an event on a server, and independently of events on the client, by (1) determining differences between the current version of the data at the server and an older copy of the data at the client, which the server has stored locally; (2) using the differences to construct an update for the copy of the data, which may include node insertion and node deletion operations for hierarchically organized nodes in the data; and (3) sending the update to the client where the update is applied to the copy of the data to produce an updated copy of the data. According to one aspect of the present invention, the act of determining differences, and the act of using the differences to construct the update both take place during a single pass through the data. According to another aspect of the present invention, the update for the copy of the data may include node copy, node move, node collapse, node split, node swap and node update operations.

Growing community of inventors

San Jose, CA, United States of America

Thulasiraman Jeyaraman