Abstract:
Mechanisms for executing a transaction such that it may be undone after being committed. The mechanism maintains a mapping between each of a number of groups of one or more direct methods with a corresponding group of one or more inversion methods, that, when executed, causes the computing system to at least partially undo the effects of the execution of the corresponding group of direct methods. Upon beginning a transaction, the computing system runs a one or more groups of one or more direct methods that are part of the transaction. The mapping is then used to identify the corresponding group(s) of inversion methods. The identities of each corresponding group of inversion methods are then saved to a compensation record. The transaction is then committed, and the compensation record is saved to a persistent media along with a transaction identifier.
Abstract:
Mechanisms for adaptively entering and exiting recovery mode. When a message is received from a particular message transaction, the appropriate processing instance is loaded from persistent memory to system memory. The processing instance then determines from its own state information whether or not it is in recovery mode. This indication of recovery or normal mode may be set by a system-wide recovery detection module. If the processing instance determines that it is in normal mode, then the processing instance executes code appropriate for normal operation without needing to execute any recovery code at all. If, on the other hand, the processing instance determines that it is in recovery mode, then it executes recovery code. Once the recovery code has completed successfully, the processing instance may then cause its own normal mode.
Abstract:
Mechanisms for enforcing a message exchange pattern. When two computing systems communicate in order to accomplish a particular task, they engage in a particular message exchange pattern. Given certain progress through the message exchange pattern, the message exchange pattern may restrict which computing system may send what kind of messages. Each computing system tracks progress through the message exchange pattern by, for example, using a state transition tree in which each node represents a state of the message exchange pattern, and in which transmission or receipt of certain messages may cause state transitions. A computing system then only transmits messages if appropriate given the current tracked progress through the message exchange pattern.
Abstract:
Mechanisms for automatically generating code that tests capabilities of a test computing system to simulate a message exchange pattern. The code generation computing system uses a message exchange pattern definition to generate the simulation code. For each state in which the message exchange pattern definition allows valid messages to be transmitted, code is generated for that state that at least simulates the transmission of a valid transmission message. For each state in which the message exchange pattern definition allows valid messages to be received, code is generated for that state that simulates the receipt of a valid receipt message. If the transmission or receipt of the message causes a state transition to occur, code is generated that causes the appropriate state transition in the message exchange pattern.
Abstract:
Mechanisms for adaptively entering and exiting recovery mode. When a message is received from a particular message transaction, the appropriate processing instance is loaded from persistent memory to system memory. The processing instance then determines from its own state information whether or not it is in recovery mode. This indication of recovery or normal mode may be set by a system-wide recovery detection module. If the processing instance determines that it is in normal mode, then the processing instance executes code appropriate for normal operation without needing to execute any recovery code at all. If, on the other hand, the processing instance determines that it is in recovery mode, then it executes recovery code. Once the recovery code has completed successfully, the processing instance may then cause its own normal mode.
Abstract:
Deterministic rule-based dispatch of the data structure to a group of one or more methods. After accessing the data structure to be processed, a list of rules is evaluated to identify multiple rules that apply to the dispatch of the data structure. Each of these multiple rules specifies a different group of one or more methods to which the data structure should be dispatched. The multiple rules are resolved to a single prevailing rule that will be applied for the dispatch of the data structure. Then, the computing system dispatches the data structure to the group of one or more methods specified by the prevailing rule. The rule evaluation and prioritization is deterministic for ease in debugging since it may be determined which group of one or more methods processed a data structure should a performance problem arise during the processing. Furthermore, rules may be added, amended, or deleted dynamically.
Abstract:
Mechanisms for adaptively entering and exiting recovery mode. When a message is received from a particular message transaction, the appropriate processing instance is loaded from persistent memory to system memory. The processing instance then determines from its own state information whether or not it is in recovery mode. This indication of recovery or normal mode may be set by a system-wide recovery detection module. If the processing instance determines that it is in normal mode, then the processing instance executes code appropriate for normal operation without needing to execute any recovery code at all. If, on the other hand, the processing instance determines that it is in recovery mode, then it executes recovery code. Once the recovery code has completed successfully, the processing instance may then cause its own normal mode.
Abstract:
Mechanisms for operating in recovery mode while ensuring reliable message processing for messages received during the recovery operation mode. Upon receiving a message corresponding to a particular message transaction, the instance responsible for that message transaction determines from state information corresponding to the transaction, whether or not that instance is operating in normal mode, or recovery mode. If the state information reflects normal operation mode, then the instance processes the message. If recover mode, then the instance evaluates whether or not the message is a normal message suitable for normal operation mode, or a recovery message suitable for recovery operation mode. If the message is a normal message, then the message is placed in a persistent queue for later processing. If the message is a recovery message, the message is processed. Upon completion of recovery, the normal message in the queue may be processed.
Abstract:
Mechanisms in which upon receiving a message, the message is passed through one or more receiving path components that are positioned in the receiving path of the message prior to being passed to a dispatching component. One or more of the receiving path components may modify the message to include information that may be helpful to the dispatching component in order to perform the dispatch. The dispatching component receives modified message, and uses information from the modified message (including potentially the modification itself) to perform the dispatch. Since the message is modified to include additional information helpful to the dispatching component, the dispatching component may be more flexible in identifying the processing that should occur with the message. Accordingly, specialized and flexible processing may be enabled that is ideally suited for the message.
Abstract:
A system consistency management module that performs consistency checking on behalf of an instance. The module identifies data fields of state information corresponding to the instance that are to be subject to consistency checking. The instance may identify this data fields to the system module. The system module may also identify an event that will prompt the consistency checking. When the event occurs, the system module performs the consistency checking on the identified fields. If the system module detects an inconsistency, it may set the state information to reflect that the instance is operating in recovery mode. If the instance itself was to perform the consistency checking, the instance may inform the system module that an inconsistency has been detected. The system module then sets the state information for the instance to reflect that the instance is operating in recovery mode.