All Classes and Interfaces
Class
Description
Aborted: the participant has aborted and the transaction should also
attempt to do so.
This class loads properties according to the file location, substitution and override rules described in the docs.
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
The ActionBean needs access to the participant lists maintained by an AtomicAction but these
lists are protected.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Class that represents the transaction hierarchy.
The various state changes that a transaction can go through.
The basic transaction log implementation.
The two types of transactions, nested, and top-level.
Wrapper around low level Activation Coordinator messaging.
The Activation Coordinator processor.
The activity is active.
Thrown if an attempt is made to complete an activity that has active
child activities and at least one of the registered HLSs determines
the it is an invalid condition.
ActivityHandle is used as a representation of a single activity
when it is suspended from a running thread and may be later
resumed.
This class represents a handle on a stack of activities.
The activity manager is the way in which an HLS can register
itself with the activity service.
Return the ActivityManager implementation to use.
The possible outcomes when trying to add an AbstractRecord as
a participant within a transaction.
This class is a plug-in module for the recovery manager.
This class is a plug-in module for the recovery manager.
Obtains a unique value to represent the process id via sockets and
ports.
Needs further consideration and then completion.
Property manager wrapper for the Arjuna module.
To get the formatID used to represent JBoss transactions
to the system.
i18n log messages for the arjuna module.
OTS implementation class.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Transaction relic of a committed transaction that did not get committed responses from
all resources/subordinates.
Transaction relic of a committed transaction that did not get committed
responses from all resources/subordinates.
Class that manages the asynchronous calls when using ReplyTo.
This class is a plug-in module for the recovery manager.
This is a user-level transaction class, unlike BasicAction.
This class is a plug-in module for the recovery manager.
This class is a plug-in module for the recovery manager.
An array of basic types.
An extension of the AtomicTransaction class so we can create new instances
without having to create a new transaction.
Similar to CosTransactions::Current.
helper to support retrieval of durable AT participant recovery state from participant
This class is a plug-in module for the recovery manager.
asbstract class used to implement save, recover and reactivate API for durable
XTS participants.
recovery record specific to WS-AT 1.1 protocol participants.
Classes to be called before or after the OA is initialised.
Classes to be called before or after the ORB is initialised.
Interface for pluggable internal implementations of the SlotStore backend.
This class is a plug-in module for the recovery manager.
helper to support retrieval of durable BA participant recovery state from participant
When a Business Activity participant registers with a BA transaction it
gets a reference to the transaction coordinator that lets it callback
into the transaction and drive the state-transition.
This class is a plug-in module for the recovery manager.
asbstract class used to implement save, recover and reactivate API for durable
XTS participants.
recovery record specific to WS-AT 1.1 protocol participants.
The BasicStore provides core methods that all implementations MUST provide.
abstract MBean implementation of a BaseStore MBean
Some common methods for UserTransaction and TransactionManager.
Deprecated.
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
This class is a base class for an
ExpiryScanner for expired
BasicAction items using creation time to evaluate if items are
considered too old.A very basic lock store implementation.
An implementation of the lock store which saves locks into files on the local
machine.
This class implements the XAResourceRecovery interface for XAResources.
Utility class that configures *EnvironmentBean objects using a PropertyManager, which is usually
backed by a -properties.xml file.
The coordination protocol failed to start.
Provides method call mapping between WS-AT Durable Participant interface
and an underlying JTA subtransaction coordinator.
Provides method call mapping between JTA parent coordinator and WS-AT subordinate transaction.
Provides method call mapping between WS-AT Volatile Participant interface
and an underlying JTA subtransaction coordinator.
Provides method call mapping between JTA parent coordinator and WS-AT subordinate transaction.
This is the interface that the core exposes in order to allow different
types of participants to be enrolled.
Not in the 1.1 specification.
Not in the 1.1 specification.
Any transaction that is identified by the recovery system to
require recovery is manipulated through
CachedRecoveredTransactions.
A cached object store implementation.
Cadaver records are created whenever a persistent object is deleted while
still in the scope of an atomic action.
Cancel: the participant is in an unknown state and should be rolledback.
A fail occurred during a Business Agreement cancel operation -- only applies in WSBA 1.1.
The coordinator has cancelled and completed the protocol.
The coordinator has cancelled and completed the protocol.
The coordinator is in the process of cancelling.
The coordinator is in the process of cancelling.
The status of the coordination is such that it will eventually cancel.
The status of the coordination is such that it will eventually cancel.
If an action attempts to terminate with threads still active we call an
instance of this class to determine what to do.
Manages the CheckedAction instances on a per transaction basis.
Return a checked action instance.
A class which represents a child OA
This synchronization is responsible for removing the JTA transaction
from the internal table.
This interceptor redirects requests towards the RecoveryCoordinator returned on register_resource
to another target, a Recovery Coordinator located in the Recovery Manager, by throwing a ForwardRequest
exception.
This class registers the ClientForwardInterceptor
with the ORB.
A class used to perform all 1.1 client side initialisation
A class used to perform all 1.1 client side initialisation
The coordinator has confirmed and completed the protocol.
The coordinator is in the process of confirming the participants.
When a SRA has preparesd successfully any bean resource classes that were invoked in its context
will be notified by calling methods marked with the @Commit annotation.
The CommitMarkableResourceRecord does not support nested transactions
If the database is down forever that a CommitMarkableResourceRecord is linked
to, it will have the side effect of never expiring a RecoverAtomicAction.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
This CommitMarkableResourceRecord assumes the following table has been
created:
create table xids (xid varbinary(255), transactionManagerID varchar(255))
(ora/syb/mysql) create table xids (xid bytea, transactionManagerID
varchar(255)) (psql) sp_configure "lock scheme",0,datarows (syb)
The CommitMarkableResourceRecord does not support nested transactions
TODO you have to set max_allowed_packet for large reaps on mysql
The transaction has committed.
The transaction is in the process of committing.
i18n log messages for the jta module.
The coordinator has prepared.
There is no coordinator associated with the target.
The coordinator is preparing.
The activity has completed.
The activity is in the process of completing.
The Completion Coordinator processor.
The Completion Coordinator processor.
Implementations of this interface represent the various ways in which
an activity can terminate.
Annotation used to set the common name prefix of a list type property.
Utility class providing access to build time and runtime configuration reporting functions.
This interface can be implemented by a BA participant in order to allow it to perform
its complete operation in two phases.
The coordinator has confirmed and completed the protocol.
The coordinator is in the process of confirming the participants.
The various types of lock conflict that can occur when
trying to set a lock.
Synchronization to close JMS connection at the end of the transaction.
Proxy connection factory to wrap around provided
XAConnectionFactory.Instances of this class enable us to work around problems
in certain databases (specifically Oracle).
Proxy connection to wrap around provided
XAConnection.Instances of this class represent the transactional memory within which user objects
can be placed and managed.
The sharing MODEL of the objects created by this instance.
The TYPE of the objects created by this instance.
The context is formed by the various HLSs that are present.
The context factory mapper.
This class is responsible for managing the thread-to-transaction
context mappings.
Handling asynchronous context propagation calls.
Registers the appropriate filter with the ORB.
An implementation of CosTransactions::Control
Helper class for serialising Coordination Contexts into SOAP headers.
Initialise the coordination services.
The CoordinationOutcome represents the final outcome of the coordination
event.
The CoordinationOutcome represents the final outcome of the coordination
event.
The final coordination result.
The final coordination result.
There is no coordinator associated with the target.
There is no coordinator associated with the target.
The coordinator completion coordinator state engine
The Coordinator Completion Coordinator processor.
The coordinator completion participant state engine
The Coordinator Completion Participant processor.
There is no coordinator associated with the target.
There is no coordinator associated with the target.
The coordinator state engine
A JavaBean containing configuration properties for the core transaction coordinator.
A JMX MBean interface containing configuration for the core transaction coordinator.
Implementations of this interface provide globally unique identifications
for coordinators.
The CoordinatorManager is the way in which services can enlist
participants with the current coordinator.
The CoordinatorManager is the way in which services can enlist
participants with the current coordinator.
The factory to return the specific CoordinatorManager implementation.
The factory to return the specific CoordinatorManager implementation.
The Coordinator processor.
manager allowing XTS coordinator recovery modules to be registered at startup and unregistered at shutdown.
A class used to perform all 1.1 coordinator side initialisation
A JavaBean containing assorted configuration properties for the core transaction system.
A JMX MBean interface containing assorted configuration for the core transaction system.
The activity has been created and is yet to start executing.
This interface gives access to the Arjuna specific extensions
to Current.
The implementation of CosTransactions::Current.
Whereas TxAssociation classes are on a per
thread basis, insances of this type apply to all threads.
An
abstract TransactionManager implementation that
delegates all method invocations to another TransactionManager.An
abstract TransactionSynchronizationRegistry
implementation that delegates all method invocations to another
TransactionSynchronizationRegistry.Access mechanism for supplying a DataSource instance at runtime
This handler is used when
default-context-propagation is disabled.This handler is used when
default-context-propagation is disabled.File backed implementation of the SlotStore backend.
There was an attempt to register the same participant with the coordinator.
There is no coordinator associated with the target.
There is no coordinator associated with the target.
The Durable2PCParticipant.
JDBC store implementation driver-specific code.
Only allows the movement of heuristic participants to the prepared list.
This handler is used when
default-context-propagation is enabled.This handler is used when
default-context-propagation is enabled.JDBC store implementation driver-specific code.
The current implementation will invoke all registered handlers
whenever an object is connected and disconnected.
Various exception values that we use in the OTS in a number of
situations, particularly if the ORB does not support some of
the standard OTS SystemExceptions.
In most cases resources defer exceptions and return an arjuna specific error code.
Some exception values we may set.
Obtains a unique value to represent the process id via reflection.
Implementation of
for removing
relics of transactions that have been assumed complete.
invalid reference
com.arjuna.CosRecovery.ExpiryScannerThis class is a plug-in module for the recovery manager.
Threaded object to run
ExpiryScanner implementations to scan
the action store to remove items deemed expired by some algorithm.Refinement of the expired assumed scanner for Server transactions.
Refinement of the expired assumed scanner for toplevel transactions.
This class is a plug-in module for the recovery manager.
This class is a plug-in module for the recovery manager.
Interface for Expiry scanner plug-ins.
This class is responsible for doing interposition in the case where implicit
context propagation is not possible.
An interface that adds extra behaviour to RecoveryModules.
This abstract record is used whenever resources are derived from the
ArjunaOTS module's AbstractRecord interface.
Create a persistent entry in the ActionStore to allow the RecoveryManager to
know which ArjunaFactory is in which JVM.
Different transaction factories can be added dynamically
to the system to deal with specific interposition types.
Maintains the list of known transaction interposition factories.
The activity has terminated in a failed state.
The activity has terminated in a failure state.
This error is thrown if a fatal error occurs which would prevent further
progress without possibly compromising consistency.
Thrown if there is a fault during complete or compensation.
Sometimes it is necessary to lock a file at the disk level.
An refinement of the basic FileSystemStore which provides file-level locking.
Obtains a unique value to represent the process id via the filesystem.
The basic class for file system object stores.
Annotation used to set the name of a property corresponding to a bean field.
This provides the ORB-independent recovery coordinator
functionality.
Implementation of
RecoveryCreator.Implementations of this interface provide globally unique identifications
for activities.
JDBC store implementation driver-specific code.
The basic action store implementations store the object states in a separate
file within the same directory in the object store, determined by the
object's type.
The basic shadowing store implementations store the object states in
a separate file within the same directory in the object store, determined
by the object's type.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
All of the coordiantor's participants cancelled when they were asked to
confirm.
There is no coordinator associated with the target.
All of the coordinator's participants confirmed when they were asked to
cancel.
There is no coordinator associated with the target.
Some of the coordinator's participants cancelled, some confirmed and the
status of others is indeterminate.
There is no coordinator associated with the target.
Deprecated.
as of 5.2.2.Final In a subsequent release we will be providing this functionality via JMX MBeans
Some of the coordinator's participants cancelled and some confirmed.
There is no coordinator associated with the target.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
An HLS is registered with activities to be informed of their lifecycle
and to augment the basic notion of what an activity is.
An HLS may throw this error whenever a serious problem is encountered.
Thrown the HLS completion fails.
A JavaBean containing assorted configuration properties for the Journal based transaction logging system.
A JMX MBean interface containing configuration for the HornetQ Journal based transaction logging system.
Implementation of the tx store backed by the Artemis journal.
Adaptor class that wraps the store to make it look like an ObjectStore.
Maps an HttpResponseException to the HTTP code embedded in the exception
JDBC store implementation driver-specific code.
Deprecated.
this class should no longer be relied upon as it can be expected to be removed from distribution in a later release.
Deprecated.
this class should no longer be relied upon as it can be expected to be removed from distribution in a later release.
Deprecated.
this class should no longer be relied upon as it can be expected to be removed from distribution in a later release.
Exception may be thrown under certain circumstances.
Manages Thread association of the interposed coordinator.
Maintains the mapping data that relates WS-AT transactions to JTA subordinate transactions and related objects.
Integrates with JBossAS MC lifecycle and JBossTS recovery manager to provide
recovery services for inbound bridged transactions.
Implementation of the InboundTransactionCurrent interface of the app server's
transaction integration SPI.
This Initializer is used to register our InboundTransactionCurrent implementation
so that the app server can find it.
This interface can be implemented by classes which have been registered as pre/post-initialisation
classes.
An InputBuffer is used to retrieve various Java types from a byte stream
created using an OutputBuffer.
InputObjectState provides some additional methods to
a basic InputBuffer.
Runtime configuration information for the interceptors.
Thrown if an attempt is made to utilise an unknown activity.
Typically thrown when save_state and restore_state are not present and they should be.
Thrown if an attempt is made to unregister an unknown HLS from the activity.
The parent activity was invalid in the scope it was intended to be
used.
The specified participant is invalid in the context used.
There is no coordinator associated with the target.
There is no coordinator associated with the target.
Exception may be thrown under certain circumstances.
Thrown if the timeout value associated with the invoking thread
which should be applied to newly created activities is invalid.
Implementation of RecoveryCreator for JavaIdl orb
Handles the creation of RecoveryCoordinator objects for
JavaIdl orb.
Initialises JavaIdl ORB RecoveryCoordinator creation subsystem
and provides the JavaIdl specific implementations of stuff
All orbs are likely to be the same, constructing a GenericRecoveryCreator,
but with an orb-specific manager
Initialises Java IDL orb RecoveryCoordinator IOR creation mechanism
An instance of this class is constructed by RecoveryEnablement and
registered as an OAAttribute whose initialise method is called after
root POA is set up
All orbs are likely to be the same, constructing a GenericRecoveryCreator,
but with an orb-specific manager
The class is used to perform WS-Transaction context insertion
and extraction for application level SOAP messages using JaxWS.
The class is used to perform WS-Transaction context insertion
and extraction for application level SOAP messages using JaxWS.
specialised version which creates and interposes a subordinate AT transaction when
it finds an incoming AT context in the message headers
A handler that sits in the server side JAX-WS processing pipeline between the XTS header
context processor and the web service.
A handler that sits in the client side JAX-WS processing pipeline between the application
and the XTS header context processor.
i18n log messages for the atsintegration module.
Warning this class consists of generated code.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
This class is purely used by the recovery system to load the transactions into memory so we can be sure
that bottom-up recovery could find a serverControl if the EIS has not called XATerminator::recover yet
JDBC store implementation driver-specific code.
To perform recovery on arbitrary connections we may need to recreate those
connections.
Do not return a connection which participates within the
transaction 2-phase commit protocol! All connections will have
auto-commit set to true, or we will not be able to use them.
A JavaBean containing configuration properties for the JDBC subsystem.
A JMX MBean interface containing configuration for the JDBC subsystem.
i18n log messages for the jdbc module.
An object store implementation which uses a JDBC database for maintaining
object states.
Property manager wrapper for the JDBC module.
An object store implementation which uses a JDBC database for maintaining
object states.
This provides recovery for compliant JDBC drivers.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
JavaBean for binding a Reference into JNDI.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
An XAResourceOrphanFilter which vetos rollback for xids which have an in-flight transaction.
A JavaBean containing configuration properties for the JTA subsystem.
A JMX MBean interface containing configuration for the JTA system.
Some useful utility routines.
i18n log messages for the jta module.
Implementation of the marker interface used to distinguish Synchronizations that
should be interposed in the JTA 1.1 TransactionSynchronizationRegistry sense of the term.
An XAResourceOrphanFilter for JTA top level transactions, which uses node name information
encoded in the xid to determine if they should be rolled back or not.
Web service feature is used to enable or disable JTA context propagation over WS-AT.
Property manager wrapper for the JTA module.
An XAResourceOrphanFilter which vetos rollback for xids owned by top level JTA transactions.
i18n log messages for the jtax module.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
A JavaBean containing configuration properties for the JTS system.
A JMX MBean interface containing configuration for the JTS system.
i18n log messages for the jts module.
Property manager wrapper for the JTS module.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Created by tom on 01/11/2016.
Marker interface for Last Resource Commit Optimisation.
AbstractRecord that helps us do the last resource commit optimization.
XAResourceRecord implementing the Last Resource Commit Optimisation.
This synchronization is responsible for removing the JTA transaction
from the internal table.
Instances of this class (or derived user classes) are used when trying to set
a lock.
Thrown when an error occurs during lock acquisition or release.
No locks will be obtained on this method, though
any transaction context will still be on the thread.
This class provides (transactional) concurrency control for application
objects.
The types of lock which can exist.
The various results which can occur when setting a lock.
Essentially an enumeration of the status a lock may
be in.
The lock store interface is the application's route to using a specific lock
store implementation.
Exception that can be thrown when attempting to access
the lock store.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Obtains a unique value to represent the process id via configuration.
Memory-mapped file implementation of the SlotStore backend.
JDBC store implementation driver-specific code.
Obtains a unique value to represent the process id via ManagementFactory.getRuntimeMXBean().getName().
A simple message id generator, used when UID is inaccessible.
Implements an ObjectStoreEnvironmentBean instance that propagates all ObjectStoreEnvironmentBean
updates to all named instances of ObjectStoreEnvironmentBean.
JDBC store implementation driver-specific code.
Keep track of any "modifiers" we may require to run
transactions over specific databases.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
JDBC store implementation driver-specific code.
JDBC store implementation driver-specific code.
Defines that the container will create a new transaction
for each method invocation, regardless of whether there is
already a transaction associated with the caller.
Defines that the container will create a new transaction
for each method invocation, regardless of whether there is
already a transaction associated with the caller.
There is no activity associated with the invoking thread.
Thrown if there is no activity associated with the invoking
thread and one needs to be in order to execute the operation.
There is no coordinator associated with the target.
An XAResourceOrphanFilter which uses node name information encoded in the xid to determine if
they should be rolled back or not.
The invoking thread does not have permission to attempt to use the
operation.
404 mapper
Exception may be thrown under certain circumstances.
There is no transaction associated with the current thread.
Marks member variables that should not be saved/restored during a transaction.
A null implementation.
An attempt at some ORB portable ways of interacting with the OA.
An instance of this class provides access to the ORB specific Object Adapter
class.
This class prints out all of the parameters passed to it.
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.jboss.jbossts.star.util.media.txstatusext package.
An enumeration of the types of object model supported.
Wrapper for ObjectInputState and ObjectOutputState to facilitate use in JMX invocations
A transactional object may go through a number of different states
once it has been created.
The object store interface is the application's route to using
a specific object store implementation.
Created by IntelliJ IDEA.
A JavaBean containing configuration properties for the objectstore and various implementations thereof.
A JMX MBean interface containing configuration for the objectstore and various implementations thereof.
Error that can be thrown when attempting to access
the object store.
Exception that can be thrown when attempting to access
the object store.
Class that allows us to iterate through instances of objects that may be
stored within a specific object store.
The various types of StateManager object which can exist.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
If a bean class contains a method marked with this annotation is invoked in the context of an SRA that only
contains a single participant then the annotated method will be invoked when the SRA is asked to commit.
Property manager wrapper for the ORB Portability module.
Use optimistic concurrency control.
An attempt at some ORB portable ways of interacting with the ORB.
An instance of this class provides access to the ORB specific
ORB implementation object.
This class prints out all of the parameters passed to it.
The base class from which all ORB implementations are derived.
ORB specific data objects implement this interface to provide
runtime information about the ORB.
The Object Request Broker interface.
This class queries the ORB specific ORBData object for information
about the ORB.
A JavaBean containing assorted configuration properties for the Orb Portability layer.
A JMX MBean interface containing assorted configuration for the Orb Portability layer.
i18n log messages for the orbportability module.
Setup the ORB and POA used by the transaction system.
The various types of ORB that are supported.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
This class is essentially here for convenience purposes, and until
all ORBs provide a means to set their initial references for Current
and the TransactionFactory.
Create an OTS transactional thread.
Manages Thread association of the interposed coordinator.
Maintains the mapping data that relates JTA transactions to WS-AT subordinate transactions and related objects.
Integrates with JBossAS MC lifecycle and JBossTS recovery manager to provide
recovery services for outbound bridged transactions.
The Outcome represents the final outcome of the activity.
An OuptputBuffer is used to store various Java types as a byte stream.
OutputObjectState provides some additional methods to a
basic OutputBuffer.
Wrapper for ObjectOutputState to facilitate use in JMX invocations
This is the interface that all two-phase aware participants must define.
This is the interface that all two-phase aware participants must define.
The base Participant.
When a bean method executes in the context of an LRA any methods in the bean class that are annotated with
There is no coordinator associated with the target.
The participant completion coordinator state engine
The Participant Completion Coordinator processor.
The participant completion participant state engine
The Participant Completion Participant processor.
The participant state engine
The Participant processor.
manager allowing XTS participant recovery moduels to be registered at startup and unregistered at shutdown.
A class used to perform all 1.1 participant side initialisation
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
The status of a compensator.
Transactional participants MUST use this type of ObjectStore.
implementation of the JMX interface to the JBossTS participant store
JMX interface to the JBossTS participant store
OutputObjectState and InputObjectState are wrapped since they are not convertible to
open MBean types.
Remote proxy to a ParticipantStore
This is the interface that all two-phase aware participants must define.
Threaded object to perform the periodic recovery.
state values indicating operating mode of scanning process for ad hoc threads and controlling behaviour of
singleton periodic recovery thread.
state values indicating whether or not some thread is currently scanning.
an interface which can be implemented by AT participants which wish to save recovery state at prepare
which they can subsequently use to restore the participant state if a crash happnes bteween prepare and
commit/rollback
an interface which can be implemented by BA participants which wish to save recovery state at prepare
which they can subsequently use to restore the participant state if a crash happnes bteween prepare and
commit/rollback
The interface for a persistable resource.
A PersistenceRecord is created whenever a persistent object is
created/read/modified within the scope of a transaction.
Instances of this class represent the transactional memory within which persistent user objects
can be placed and managed.
Specifies that pessimistic concurrency control
should be used.
Implementation of the SlotStore backend interface that uses the mashona logwriting library
to support fs-dax mode persistent memory storage.
The Portable Object Adapter interface.
JDBC store implementation driver-specific code.
JDBC store implementation driver-specific code.
Objects to be called after the OA has shutdown should implement
this class.
Objects which should be invoked after the ORB has shutdown should
be derived from this class.
When a SRA is asked to commit any bean resource classes that were invoked in its context will
be notified by calling methods marked with the @Prepare annotation.
The coordinator has prepared.
Prepared: it is prepared to commit or rollback depending on the final
transaction outcome, and it has made sufficient state updates persistent
to accomplish this.
The coordinator is preparing.
Instances of classes derived from this interface can be registered with
the system and do any tidy-up necessary after the ORB has
been shutdown.
Provides a configurable way to get a unique process id.
This class is a wrapper around a PropagationContext object allowing it to be serialized.
A dynamic class that reads from a properties file and uses the information to
instantiate and configure an XADataSource.
Annotation used to set the default property name prefix for EnvironmentBean classes
The ProtocolManager is the way in which protocol implementations may be
registered with the system.
An attempt was made to act on a protocol that the protocol factory had
no knowledge of.
Thrown if the underlying protocol is violated in some way during
termination.
A qualifier for the core coordination engine to use.
Interface to handle the creation of RecoveryCoordinator IORs.
Grab a read lock for this method.
ReadOnly: does not need to be informed of the transaction outcome as no
state updates were made.
An instance of this interface will be called whenever a transaction is either timed-out
or set rollback-only by the transaction reaper.
Class to record transactions with non-zero timeout values, and
class to implement a transaction reaper thread which terminates
these transactions once their timeout elapses.
Class to reap timed out transactions on behalf of the transaction reaper
thread which is dispatched to terminate a series of transactions when their
timeout elapses.
RecoveryActivators are dynamically loaded.
This class manages instances of the classes derived from AbstractRecord in
the form of an ordered doubly-linked list.
A basic iterator for RecordList instances.
The following enumerated type defines the types of record that are derived
from AbstractRecord.
This allows users to define a mapping between record type integers
and specific Class-es.
This allows users to define a mapping between record type integers
and specific Class-es.
Instances of this class represent the transactional memory within which non-persistent user objects
can be placed and managed.
XA connection implementations must provide an implementation
of this class.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Transaction type only instantiated at recovery time.
Transaction type only instantiated at recovery time.
Transaction type only instantiated at recovery time.
TransactionalObject shell instantiated at recovery time.
Threaded object used to replay phase 2 of the commit protocol in a
background thread.
interface for cachable recoveredtransactions
Needed because the different types of recovered transaction inherit from
(non-recovery) base types by different routes
used by @{link TransactionCache}
Some methods are present only in the Recovered[*]Transactions.
Construct a recovery IOR for use with the default ORB bundled with the default JDK
Interface for Recovery manager plug-in module.
This class is a plug-in module for the recovery manager.
This class is a plug-in module for the recovery manager.
An instance of this object is registered so as to be invoked when any
CORBA object is constructed, but ignores everything except the first ArjunaFactory
On seeing an ArjunaFactory, it causes a FactoryContactItem to be saved and
deregisters itself
(and thus relies on the fact (true for 2.1) that any ArjunaFactory can be used to
find the status of any transaction.
Holds and manipulates the fields used to identify which branch of which transaction
a RecoveryCoordinator is concerned with.
This abstract class is used to allow dynamic registration of creators
for RecoveryCoordinators.
Registers the appropriate classes with the ORB.
Deprecated.
use JTSEnvironmentBean instead
A JavaBean containing configuration properties for the recovery system.
bean storing recovery implementation configuration values derived from the xts properties file,
system property settings and, in case we are running inside JBossAS the xts bean.xml file
A JMX MBean interface containing configuration for the recovery system.
i18n log messages for the xtsrecovery module.
Registers the appropriate classes with the ORB.
The RecoveryManager daemon.
The RecoveryManagerImple - does the real work.
JBoss Transaction Recovery Service.
JBoss Transaction Recovery Service.
Exposes the current status of the periodic recovery thread as reported by
RecoveryManagerImple.trySuspendScan(boolean)Interface for Recovery manager plug-in module.
Property manager wrapper for the recovery system.
Interface for users to receive a callback whenever a recovery
scan completes.
All ObjectStore implementations that are used to drive recovery
MUST implement this interface.
implementation of the JMX interface to the JBossTS recovery store
JMX interface to the JBossTS recovery store
OutputObjectState and InputObjectState are wrapped since they are not convertible to
open MBean types.
Remote proxy to a RecoveryStore
This class is a plug-in module for the recovery manager.
This class is a plug-in module for the recovery manager.
The registrar mapper.
Wrapper around low level Registration Coordinator messaging.
The Registration Coordinator processor.
Threaded object used to terminate a prepared Resource after a
failure.
404 exception
Arjuna abstract record to handle CORBA (SubtransactionAware)Resource
interface.
Used to define the specific restore_state method for the class.
Log record for driving participants through 2PC and recovery
If pessimistic concurrency control is being used then a conflict will
immediately cause the operation to fail and the application can do something
else.
When a SRA rolls back any bean resource classes that were invoked in its context will be notified by
calling methods marked with this Rollback annotation.
Thrown by TransactionSynchronizationRegistry implementation if the
transaction has rolled back.
The transaction is in a state which means that the only eventual outcome
is for it to rollback.
The transaction has rolled back.
The transaction is rolling back.
RootOA class which represents a RootPOA
Functional interface for 'run' method
that throws a checked exception.
Used to define the specific save_state method for the class.
This is an additional recovery helper that allows clients of the transaction
manager to provide a deserializer for their Serializable XAResources.
As with ControlImple, the transaction is maintained until the control object
is deleted.
This class attempts to mask the local/remote control issue.
This is a server-side factory used for creating server transactions.
This class registers the ServerForwardInterceptor
with the ORB.
This looks like an atomic action, but is not actually derived from
BasicAction or OTS_Transaction.
This interceptor looks for the content of the Service Context field and extract the data that
contains information identifying the transaction and the process Id.
The base class from which interposed resources derive.
This looks like an atomic action, but is not actually derived from
BasicAction or Transaction.
This looks like an Transaction, but is only created for importing
transactions via JCA.
This looks like an Transaction, but is only created for interposition
purposes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
This class is a plug-in module for the recovery manager.
a service is used to serve one or more requests from an input stream and post results on an output stream.
An attempt at some ORB portable ways of accessing ORB services.
Synchronization to close JMS session at the end of the transaction.
Proxy session to wrap around provided
XASession.A shadowing file store implementation.
Almost the same as the ShadowingStore implementation, but assumes all
concurrency control is provided by the object.
Common methods for OA shutdown.
Some common methods for the ORB shutdown classes.
A storage system presenting a key-value API, implemented (conceptually) using a fixed sized array.
Adaptor class that wraps the SlotStore to make it look like an ObjectStore.
A JavaBean containing configuration properties for the SlotStore based transaction logging system.
A JMX MBean interface containing configuration for the SlotStore transaction logging system.
A immutable POJO used as a unique key for records in the SlotStore.
An utility class which makes possible to throw any exception as a
RuntimeException.Utility class for SOAP.
Obtains a unique value to represent the process id via sockets and
ports.
An annotation for controlling the lifecycle of Short Running Actions (SRAs).
A utility class for controlling the lifecycle of Long Running Actions (SRAs) but the prefered mechanism is to use
the annotation in the
org.jboss.jbossts.star.annotation packageDeprecated.
This interface is replaced by org.jboss.tm.FirstResource in the SPI
State that will be written to the log (or restored).
The root of the Arjuna class hierarchy.
Some StateManager methods really shouldn't be available to users to call inadvertently.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
The status of states in the ObjectStore.
The type of the state in the ObjectStore.
This interface is the basis for all statuses that the activity can go
through.
In order to support recovery, participants must be able to report their status once the completion
part of the protocol starts.
Checks the status of a transaction as known to the original process that
created it - assuming the transaction still exists.
Some useful utility routines.
Single point of control for the management of storage instances.
Miscellaneous methods for obtaining remote proxies to the JBossTS Recovery and Participant stores
A utility class for replacing properties in strings.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
This class is a plug-in module for the recovery manager.
A subordinate JTA transaction; used when importing another transaction
context via JCA.
A subordinate JTA transaction; used when importing another transaction
context.
This class is purely used by the recovery system to load the transactions into memory so we can be sure
that orphan detection can find the TransactionImple if the EIS has not called XATerminator::recover yet
At the time of writing this module is utilized by the SubordinationManagerXAResourceOrphanFilter to ensure that
it can check with the SubordinationManager if the transaction is in flight during orphan detection.
A subordinate JTA transaction; used when importing another
transaction context.
A subordinate JTA transaction; used when importing another
transaction context.
This class is a plug-in module for the recovery manager.
A coordinator completion participant registered on behalf of an interposed WS-BA coordinator in order
to ensure that durable participants in the interposed transaction are completed, closed or cancelled
when requested from the parent transaction.
A durable participant registered on behalf of an interposed WS-AT coordinator in order to ensure that
durable participants in the subtransaction prepared, committed and aborted at the right time.
An XAResourceOrphanFilter which uses detects orphaned subordinate XA
Resources.
Subordinate transactions are those designed to be driven by a foreign controller,
so they expose methods for driving each of the termination phases individually.
A volatile participant registered on behalf of an interposed WS-AT coordinator in order to ensure that
volatile participants in the subtransaction are prepared at the right time.
Utility factory class to return appropriate implementations of the TransactionImporter and
XATerminator interfaces.
An XAResourceOrphanFilter which vetos rollback for xids which have an in-flight subordinate transaction.
The activity has terminated in a success state.
Business Activities don't expose synchronizations but they are used internally to ensure
that the transcation association is cleaned up and this interface is used to define the
behaviour of the synchronization.
This is the interface that all synchronization participants must define.
Whenever a synchronization is registered, an instance of this class
is used to wrap it.
Whenever a synchronization is registered, an instance of this class
is used to wrap it.
CosTransactions::Synchronizations are maintained in a separate list
from the standard transaction intentions list.
Marker interface for exceptions e.g.
Marker interface for exceptions e.g.
Thrown if an error occurs which is not met by another specific exception.
Thrown if a general exception is encountered (one not supported by
any other exception.)
The Terminator Participant processor.
The Terminator Participant processor.
This class maintains a mapping between a thread and its notion of the current
transaction.
Used to process thread associations.
Instances of TxAssociation can be added on
a per thread basis, or for all threads.
Implementations of this class can be registered with the low-level
transaction-threading system to set up any thread data that is needed
for thread-to-transaction tracking to be done correctly.
Provides utilities to manage thread ids.
If pessimistic concurrency control is being used then a conflict will
immediately cause the operation to fail and the application can do something
else.
Unable to contact the REST based Transaction Coordinator
Map service unavailable exceptions
Deprecated.
as of 5.0.5.Final - no longer required
This class provides a (nested) top-level transaction.
Creates a nested top-level transaction.
This class is a plug-in module for the recovery manager.
This class is a plug-in module for the recovery manager.
This is a user-level transaction class.
Defines that implementations of the interface are to be managed within a transactional
container.
Transactional JDBC 2.0 driver.
The transaction cache ensures that there is no interference between
different threads that may be working with the same
transaction.
Thrown if an error occurs during transaction processing, e.g., commit fails.
An implementation of ArjunaOTS::ArjunaFactory.
Means that the method is not transactional, so no context on
the thread or locks acquired/released.
Utility class to make transaction status checking and resources registration easier.
An implementation of jakarta.transaction.Transaction.
A TransactionImporter is used to manager the relationship with external SubordinateTransactions.
This is the interface that the core exposes in order to allow different
types of participants to be enrolled.
Deprecated.
An implementation of jakarta.transaction.TransactionManager.
JBoss Transaction Manager Service.
JBoss Transaction Manager Service.
The MBean interface for the TransactionManager JBoss service.
The MBean interface for the TransactionManager JBoss service.
Class to record transactions with non-zero timeout values, and class to
implement a transaction reaper thread which terminates these transactions
once their timeout elapses.
This class is a plug-in module for the recovery manager.
Thrown if the transaction rolls back rather than commits.
transaction status exception
map transaction status exceptions
Implementation of the TransactionSynchronizationRegistry interface, in line with the JTA 1.1 specification.
Implementation of the TransactionSynchronizationRegistry interface, in line with the JTA 1.1 specification.
Only allows the movement of heuristic participants to the prepared list.
Adds support for synchronizations to BasicAction.
The outcomes which can be generated when a transaction
attempts to prepare/commit/rollback.
The outcomes which can be generated when a two-phase coordinator
attempts to prepare/commit/rollback.
The outcomes which can be generated when a two-phase coordinator
attempts to prepare/commit/rollback.
Two phase volatile store.
Instances of these classes are informed whenever a
transaction is begun/suspended/resumed/ended.
i18n log messages for the txbridge module.
Warning this class consists of generated code.
Module logger for the txbridge.
This class represents a handle on a stack of transactions.
Transaction configuration object.
Error that may be thrown during transaction processing.
All transaction logs MUST implement this interface.
abstract implementation of the TxLog MBean
Remote proxy to a TxLog Store
A JavaBean containing configuration properties for the transactional object system.
A JMX MBean interface containing configuration for the transactional object system.
i18n log messages for the txoj module.
Property manager wrapper for the TXOJ module.
This class is used to maintain statistics on transactions that have been
created.
MBean interface for monitoring transaction statistics.
Implements a unique identity class.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Exception may be thrown under certain circumstances when we are
forced to throw a SystemException but want to give more information.
A general error has occurred.
The completion status is unknown.
The current status of the activity is unknown.
Thrown if the transaction is unknown.
The user portion of the activity API.
Return the UserActivity implementation to use.
This is the interface that allows BAs to be started and terminated.
The user portion of the coordinator API.
The user portion of the coordinator API.
The factory which returns the UserCoordinator implementation to use.
The factory which returns the UserCoordinator implementation to use.
This interface defines the operations that implementations of coordination
protocols must provide.
This is the interface that allows transactions to be started and terminated.
An implementation of jakarta.transaction.UserTransaction.
Various useful functions that we wrap in a single class.
Some useful utility functions for the OTS.
Obtains a unique value to represent the process id via UUID.
The Volatile2PCParticipant.
Trivial in-memory backend for the SlotStore, useful for benchmarking but not much else.
An in-memory ObjectStore that never writes to stable storage.
When asked to prepare, a 2PC participant returns one of three types of
vote:
ReadOnly: does not need to be informed of the transaction outcome as no
state updates were made.
The inferior votes that is has cancelled.
The inferior votes that is can confirm.
The inferior votes that it has done no work that requires to be involved
any further in the two-phase protocol.
Register a single instance of this thing when the first JCA worker is
imported.
Register a single instance of this thing when the first JCA worker is
imported.
Grab a write lock for this method.
Thrown if the state of the activity is such that it disallows the
attempted operation.
Thrown if the state of the transaction is incompatible with the
operation attempted.
This is the base class from which all WSAS related exceptions
inherit.
i18n log messages for the wsas module.
bean storing WS-C implementation configuration values derived from the xts properties file, system property
settings and, in case we are running inside JBossAS the xts bean.xml file
bean storing WSCF implementation configuration values derived from the xts properties file, system property
settings and, in case we are running inside JBossAS the xts bean.xml file
i18n log messages for the wscf module.
Initialise WSCF.
Initialise the transaction coordinator services.
bean storing WS-T 1.0 implementation configuration values derived from the xts properties file, system property
settings and, in case we are running inside JBossAS the xts bean.xml file
Initialise the transaction participant services.
Web service feature is used to enable or disable WS-AT/WS-BA context propagation for specific port.
i18n log messages for the wstx module.
Initialise WSTX.
A simple wrapper class that uses reflection to load and configure an XADataSource.
Some useful utility routines.
Instances of this class enable us to work around problems
in certain databases (specifically Oracle).
One Phase resource wrapper for XAResources.
Designed to be able to recover any XAResource.
Designed to be able to recover any XAResource.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Interface used by the XARecoveryModule to allow plugins to vote in the handling of in-doubt Xids.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Deprecated.
as of 5.0.5.Final In a subsequent release we will change packages names in order to
provide a better separation between public and internal classes.
Callback interface to allow customisable population of XAResourceRecord metadata.
A plugin implementation for copying resource metadata from the JBoss AS
specific XAResourceWrapper class to an XAResourceRecord.
To perform recovery on arbitrary XAResources we may need
to obtain new instances.
Interface to be implemented by external entities that instantiate
and supply their own XAResources to the recovery system.
Simple adaptor class that converts the JBossAS transaction integration SPI
version of the recovery interface (org.jboss.tm.XAResourceRecovery) into
the ArjunaJTA version (com.arjuna.ats.jta.recovery.XAResourceRecoveryHelper)
so it can then be registered with the Recovery system (XARecoveryModule)
The implementation of JBossXATerminator using the purely local (ArjunaCore)
implementation of the JTA.
The implementation of JBossXATerminator using the JTS implementation of the
JTA.
Extensions to the basic XATerminator spi interface.
The XATerminator implementation.
The XATerminator implementation.
An X/Open XID implementation.
Implementation of javax.transaction.xa.Xid.
Utility functions for JTS (i.e.
A class used to perform all 1.0 initialisation
Abstract class defining API for managing both paritcipant and coordinator recovery
On hteparticipant this is responsible for saving WS-AT participant recovery records
during prepare, deleting them at commit and recreating and reactivating them during
recovery.
A class which manages the table of recovered participant records.
an interface implemented by applications which wish to be involved in recovering
saved participants after a crash.
A recovery module which recovers durable participants registered by subordinate coordinators
Abstract class defining API for managing both participant and coordinator recovery
On the participant this is responsible for saving WS-BA participant recovery records
during prepare, deleting them at commit and recreating and reactivating them during
recovery.
A class which manages the table of recovered participant records.
an interface implemented by applications which wish to be involved in recovering
saved participants after a crash.
A recovery module which recovers durable participants registered by subordinate coordinators
bean holding the configuration proeprty settings which identify intiialisation routines
to be run during XTS startup and shutdown
i18n log messages for the xts service module.
interface allowing initialisation code to eb ;plugged into the XTS Service startup
Class used to do logging in the XTS Service code
Created by IntelliJ IDEA.
class which ensures XTS properties are installed into the environment beans when they are created
and provides access to those beans
extension of JBossTS recovery module interface adding install and uninstall lifecycle methods
$Id$
$Id$