Disabling and enabling transaction committal in transactional application components

• US 6,301,601 B1
• Filed: 07/12/1999
• Issued: 10/09/2001
• Est. Priority Date: 10/28/1997
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Limprecht, Rodney, Helland, Patrick James, Al-Ghosein, Mohsen
• Primary Examiner(s): VU, VIET DUY
• Application Number:
  US09/351,374
• Time in Patent Office: 820 Days
• Field of Search: 709/100, 709/101, 709/102, 709/106, 709/202, 709/203, 709/219, 709/223, 709/224, 709/225, 709/313, 709/318, 709/328, 709/329, 707/103, 707/104
• US Class Current: 718/101
• CPC Class Codes: G06F 9/466 Transaction processing
• CPC Class Codes: Y10S 707/99945 Object-oriented database structure processing
• CPC Class Codes: Y10S 707/99948 Application of database or data structure, e.g. distributed, multimedia, or image
• CPC Class Codes: Y10S 707/99952 Coherency, e.g. same view to multiple users

Abstract

A run-time environment implemented as system services and component integration interfaces provides a capability for components of a component-based server application to reversibly disable committal of a transaction in which the component participates. On return from a call to the component which leaves the component'"'"'s transactional work in an invalid state, the component can disable commit of the transaction so as to avoid premature committal of the component'"'"'s transactional work. On return from a call to the component which renders the component'"'"'s transactional work in a valid state, the component re-enables commit of the transaction. If committal of the transaction is initiated when any component in the transaction disables commit, the transaction is aborted.

Claims

1. In a computer having computer-operating system code, a system code-supplied context object in a system code-created object execution environment wherein a client program interacts with an application component via a sequence of method invocations to cause the application component to perform processing work forming part of a transaction, the context object being associated with the application component and representing a context of execution of the application component within the object execution environment, the context object comprising:

a work state datum for representing a work state of the application component as a commit disabled state or a commit enabled state;

a programming interface exposed to the application component for issuing a call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the call signaling whether the processing work being performed by the application is valid to be committed; and

function code responsive to the application component call to the programming interface and operative to set the work state datum according to validity of the processing work signaled by the application component call.

2. The context object of claim 1 wherein the function code is further operative to reversibly set the work state datum to the commit disable state upon a first call from the application component signaling processing work invalidity at a time preceding a first return from a first client program method invocation, and also operative to set the work state datum to the commit enabled state upon a second call from the application component signaling processing work validity at a later time preceding a second return from a second client program method invocation.

3. The context object of claim 1 further comprising a transaction reference to indicate the transaction.

4. The context object of claim 1 further comprising:

a disable commit function member in the programming interface to which the application component issues the call to signal processing work invalidity; and

an enable commit function member in the programming interface to which the application component issues the call to signal processing work validity.

5. The context object of claim 1 further comprising the function code being operative responsive to the application component'"'"'s call issued to the disable commit function member at a time preceding a first return from a first client program method invocation to reversibly set the work state datum to the commit disable state, and also operative responsive to the application component'"'"'s call issued to the enable commit function member at a later time preceding a second return from a second client program method invocation to set the work state datum to the commit enabled state.

6. The context object of claim 1 wherein the programming interface also is for issuing a further call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the further call signaling successful completion of the processing work, the context object further comprising function code responsive to this further call to cause the computer-operating system code to deactivate the application component.

7. The context object of claim 1 wherein the programming interface also is for issuing a further call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the further call signaling unsuccessful completion of the processing work, the context object further comprising function code responsive to this further call to cause abort of the transaction.

8. The context object of claim 7 wherein the function code operates responsive to the further call to also cause the computer-operating system code to deactivate the application component.

9. The context object of claim 1 further comprising:

a disable commit function member in the programming interface to which the application component issues the call to signal processing work invalidity; and

an enable commit function member in the programming interface to which the application component issues the call to signal processing work validity;

a completion function member in the programming interface to which the application component may issue a further call at a time preceding a return by the application component from a method invocation of the client program to signal successfull completion of the processing work; and

an abort function member in the programming interface to which the application component may issue a yet further call at a time preceding a return by the application component from a method invocation of the client program to signal unsuccessful completion of the processing work.

10. The context object of claim 1 further comprising function code responsive to the further call issued to the completion function member to cause the computer-operating system code to deactivate the application component.

11. The context object of claim 1 further comprising function code responsive to the yet further call issued to the abort function member to cause abort of the transaction.

12. The context object of claim 1 wherein the function code responsive to the yet further call issued to the abort function member also causes the computer-operating system code to deactivate the application component.

13. The context object of claim 1 wherein the computer further has transaction management code operative upon completion of the transaction to abort the transaction if the work state datum is in the commit disabled state.

14. In a computer, a computer-operating system for creating the context object of claim 1.

15. The computer-operating system of claim 14 wherein the function code of the context object is further operative to reversibly set the work state datum to the commit disable state upon a first call from the application component signaling processing work invalidity at a time preceding a first return from a first client program method invocation, and also operative to set the work state datum to the commit enabled state upon a second call from the application component signaling processing work validity at a later time preceding a second return from a second client program method invocation.

16. The computer-operating system of claim 14 wherein the programming interface of the context object also is for issuing a further call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the further call signaling successful completion of the processing work, the context object further comprising function code responsive to this further call to cause the computer-operating system code to deactivate the application component.

17. The computer-operating system of claim 14 wherein the programming interface of the context object also is for issuing a further call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the further call signaling unsuccessful completion of the processing work, the context object further comprising function code responsive to this further call to cause abort of the transaction.

18. The computer-operating system of claim 14 wherein the function code of the context object operates responsive to the further call to also cause the computer-operating system code to deactivate the application component.

19. The computer-operating system of claim 14 further comprising transaction management code operative upon completion of the transaction to abort the transaction if the work state datum is in the commit disabled state.

20. A computer-readable storage medium having computer-executable program code stored thereon for implementing the context object of claim 1.

21. The computer-readable storage medium of claim 20 wherein the function code of the context object is further operative to reversibly set the work state datum to the commit disable state upon a first call from the application component signaling processing work invalidity at a time preceding a first return from a first client program method invocation, and also operative to set the work state datum to the commit enabled state upon a second call from the application component signaling processing work validity at a later time preceding a second return from a second client program method invocation.

22. The computer-readable storage medium of claim 20 wherein the programming interface of the context object also is for issuing a further call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the further call signaling successful completion of the processing work, the context object further comprising function code responsive to this further call to cause the computer-operating system code to deactivate the application component.

23. The computer-readable storage medium of claim 20 wherein the programming interface of the context object also is for issuing a further call by the application component to the context object at a time preceding a return by the application component from a method invocation of the client program, the further call signaling unsuccessful completion of the processing work, the context object further comprising function code responsive to this further call to cause abort of the transaction.

24. The computer-readable storage medium of claim 20 wherein the function code of the context object operates responsive to the further call to also cause the computer-operating system code to deactivate the application component.

25. The computer-readable storage medium of claim 20 further comprising transaction management code operative upon completion of the transaction to abort the transaction if the work state datum is in the commit disabled state.

26. In a computer, a transaction management system operable in an object execution environment wherein a client program interacts with an application component via a sequence of method invocations to cause the application component to perform processing work forming part of a transaction, the transaction management system comprising:

a storage structure containing a datum to represent a work state of the application component'"'"'s processing work in the non-committable work state;

a disable commit programming interface operating to set the datum to represent a non-committable work state in response to a call by the application component prior to return from a method invocation of the client program that leaves the application component'"'"'s processing work in the non-committable work state;

an enable commit programming interface operating to set the datum to represent a committable work state in response to a call by the application component prior to return from a method invocation of the client program that leaves the application component'"'"'s processing work in the committable work state; and

transaction managing code operating responsive to the datum to prevent committal of the transaction while the datum is set to represent the non-committable work state, whereby the transaction management system avoids committal of the transaction between method invocations in which the application component'"'"'s processing work is left in the non-committable work state.

27. The transaction management system of claim 26 further comprising a component context object encapsulating the storage structure and programming interfaces.

28. The transaction management system of claim 26 wherein the transaction managing code operates to abort the transaction in response to a request of the client program to commit the transaction while the datum represents the non-committable work state.

29. In a distributed objects computing environment having a transaction manager responsive to a disable commit signal to disallow committal of a transaction and responsive to an enable commit signal to again allow committal of the transaction, a method of operation of an application component with which a client program interacts via a sequence of method invocations to cause the application component to perform processing work forming part of a transaction, the method comprising:

performing at least some of the processing work in response to a method invocation of the client program;

at a time prior to return from the method invocation,

determining whether the processing work is in a committable state;

issuing the disable commit signal if the processing work is not in the committable state;

issuing the enable commit signal if the processing work is in the committable state; and

returning from the method invocation;

whereby the application component prevents committal of the transaction while the processing work is not in the committable state.

30. The method of application component operation of claim 29 further comprising:

issuing the disable commit signal at a time prior to return from a first method invocation of the client program when the processing work is not in the committable state; and

issuing the enable commit signal at a later time prior to return from a second method invocation of the client program when the processing work is in the committable state.

31. The method of application component operation of claim 29 further comprising:

calling a disable commit programming interface of the distributed object computing environment to thereby issue the disable commit signal; and

calling an enable commit programming interface of the distributed object computing environment to thereby issue the enable commit signal.

32. The method of application component operation of claim 29 wherein the distributed object computing environment provides a context object associated with the application component, the context object providing an interface with disable commit and enable commit method members, the method further comprising:

calling the disable commit method member on the context object'"'"'s interface to thereby issue the disable commit signal; and

calling the enable commit method member on the context object'"'"'s interface to thereby issue the enable commit signal.

33. A computer-readable storage medium having computer-executable application program code stored thereon that operates when executed on a computer to provide the application component having the method of operation recited in claim 29.

34. In a distributed objects computing environment wherein a client program interacts with an application component via a sequence of method invocations to cause the application component to perform processing work forming part of a transaction, a method of operation of a transaction management system to prevent premature committal of the transaction before successful completion of the application component'"'"'s processing work, the method comprising:

receiving a disable commit method call from the application component, the disable commit method call being indicative of the application component'"'"'s processing work being in a non-committable state; and

until an enable commit method call is received from the application component, disallowing committal of the transaction.

35. The method of transaction management system operation of claim 34 wherein the action of disallowing committal of the transaction comprises:

upon receiving a request to commit the transaction at a time after receiving the disable commit method call and the enable commit method call has not been received, aborting the transaction.

36. The method of transaction management system operation of claim 34 further comprising:

receiving the enable commit method call from the application component, the enable commit method call being indicative of the application component'"'"'s processing work being in a committable state; and

after receipt of the enable commit method call, again allowing committal of the transaction.

37. The method of transaction management system operation of claim 36 further comprising:

receiving a request to commit the transaction;

aborting the transaction if the request to commit the transaction is received after the disable commit method call and before the enable commit method call; and

committing the transaction if the request to commit the transaction is received after the enable commit method call and all other participants in the transaction have successfully completed their processing in the transaction.

38. A computer-readable storage medium having computer-executable application program code stored thereon that operates when executed on a computer to implement the transaction management system having the method of operation recited in claim 34.

40. The method of transaction management system operation of claim 36 further comprising:

upon receipt of a first method call signaling to disable committal for a first application component, setting the data to represent that committal is disabled for the first application component; and

upon receipt of a later method call signaling to enable committal for the first application component, setting the data to represent that committal is again enabled for the first application component.

39. In a distributed objects computing environment wherein a client program interacts with a plurality of application components via a sequence of method invocations to cause the application components to perform portions of processing work in the transaction, a method of operation of a transaction management system to prevent committal of the transaction while the processing work of any of the application components is left incomplete between the client program'"'"'s method invocations on such application component, the method comprising:

maintaining data to track whether committal is disabled or enabled individually per application component participating in the transaction;

receiving method calls from the application components prior to their return from the client program'"'"'s method invocations, the method calls signaling to disable or enable committal for the respective application component;

receiving a request to commit the transaction; and

causing the transaction to abort if committal is disabled for any of the application components participating in the transaction.

41. A computer-readable storage medium having computer-executable application program code stored thereon that operates when executed on a computer to implement the transaction management system having the method of operation recited in claim 39.