Uses of Class
com.atomikos.icatch.SysException

Packages that use SysException
com.atomikos.datasource   
com.atomikos.datasource.xa   
com.atomikos.icatch   
com.atomikos.icatch.admin   
com.atomikos.icatch.admin.jmx   
com.atomikos.icatch.config   
com.atomikos.icatch.config.imp   
com.atomikos.icatch.imp   
com.atomikos.icatch.jaxws   
com.atomikos.icatch.jaxws.atomikos   
com.atomikos.icatch.jta   
com.atomikos.icatch.msg   
com.atomikos.icatch.system   
com.atomikos.icatch.trmi   
 

Uses of SysException in com.atomikos.datasource
 

Subclasses of SysException in com.atomikos.datasource
 class HeuristicException
           
 class ResourceException
          Exception on the level of the resource manager.
 

Uses of SysException in com.atomikos.datasource.xa
 

Methods in com.atomikos.datasource.xa that throw SysException
 HeuristicMessage[] XAResourceTransaction.commit(boolean onePhase)
           
 int XAResourceTransaction.prepare()
           
 boolean XAResourceTransaction.recover()
           
 HeuristicMessage[] XAResourceTransaction.rollback()
           
 void XAResourceTransaction.setCascadeList(Dictionary allParticipants)
           
 

Uses of SysException in com.atomikos.icatch
 

Methods in com.atomikos.icatch that throw SysException
 void Extent.add(Extent extent)
          Merges another extent into this one.
 void Extent.add(Participant participant, int count)
          Adds a participant to the extent.
 void ExportingTransactionManager.addExtent(Extent extent)
          Should be called after call returns successfully: adds the extent of the call to the current transaction.
 RecoveryCoordinator CompositeTransaction.addParticipant(Participant participant)
           
 void CompositeTransaction.addSubTxAwareParticipant(SubTxAwareParticipant subtxaware)
          Resources that support lock inheritance can use this feature to be notified whenever a lock should be inherited.
 void CompositeTransaction.commit()
          Commits the composite transaction.
 void CompositeTerminator.commit()
          Deprecated. Commit the composite transaction.
 HeuristicMessage[] Participant.commit(boolean onePhase)
          Commits the participant's work.
 CompositeTransaction TransactionService.createCompositeTransaction(long timeout)
          Starts a new transaction.
 CompositeTransaction CompositeTransactionManager.createCompositeTransaction(long timeout)
          Starts a new (sub)transaction (not an activity) for the current thread.
 CompositeTransaction TransactionControl.createSubTransaction()
          Deprecated. Create a subtx for this transaction.
 CompositeTransaction CompositeTransaction.createSubTransaction()
           
 CompositeCoordinator CompositeTransaction.getCompositeCoordinator()
           
 CompositeCoordinator TransactionService.getCompositeCoordinator(String root)
          Gets a composite coordinator for the given root.
 CompositeTransaction CompositeTransactionManager.getCompositeTransaction()
           
 CompositeTransaction CompositeTransactionManager.getCompositeTransaction(String tid)
          Gets the composite transaction with the given id.
 Participant TransactionService.getParticipant(String root)
          Gets a participant handle for the given root.
 Propagation ExportingTransactionManager.getPropagation()
          Gets the propagation info of the transaction for the calling thread.
 CompositeTransaction ImportingTransactionManager.importTransaction(Propagation propagation, boolean orphancheck, boolean heur_commit)
          Imports the transaction propagation obtained from an incoming request.
 void TransactionService.init(Properties properties)
          Initializes the TM, and recovers.
 int Participant.prepare()
          Prepares the participant.
 boolean Participant.recover()
          Called by the transaction manager (TM) at recovery time, and this should reconstruct the internal state.
 CompositeTransaction TransactionService.recreateCompositeTransaction(Propagation context, boolean orphancheck, boolean heur_commit)
          Recreates a composite transaction based on an imported context.
 void CompositeTransaction.registerSynchronization(Synchronization sync)
           
 void CompositeTransactionManager.resume(CompositeTransaction compositeTransaction)
          Re-maps the calling thread to the given transaction.
 HeuristicMessage[] Participant.rollback()
          Rollback of the participant's work.
 void CompositeTransaction.rollback()
          Rollback of the current transaction.
 void CompositeTerminator.rollback()
          Deprecated. Rollback the current transaction.
 void Participant.setCascadeList(Dictionary allParticipants)
          For cascading 2PC, this method sets the information needed to cascade.
 void TransactionControl.setSerial()
          Deprecated. Set serial mode for root.
 void CompositeTransaction.setSerial()
          Sets the serial mode.
 void TransactionService.shutdown(boolean force)
          Shuts down the server in a clean way.
 CompositeTransaction CompositeTransactionManager.suspend()
          Suspends the transaction context for the current thread.
 Extent ImportingTransactionManager.terminated(boolean commit)
          Signals that the incoming request is done processing, in order to terminate the transaction context for the calling thread.
 

Uses of SysException in com.atomikos.icatch.admin
 

Methods in com.atomikos.icatch.admin that throw SysException
 void AdminTransaction.forceCommit()
          Forces commit of the transaction.
 void AdminTransaction.forceRollback()
          Forces rollback of the transaction.
 

Uses of SysException in com.atomikos.icatch.admin.jmx
 

Methods in com.atomikos.icatch.admin.jmx that throw SysException
 void JmxPreparedTransactionMBean.forceCommit()
          Forces commit of the transaction.
 void JmxPreparedTransaction.forceCommit()
           
 void JmxPreparedTransactionMBean.forceRollback()
          Forces rollback of the transaction.
 void JmxPreparedTransaction.forceRollback()
           
 

Uses of SysException in com.atomikos.icatch.config
 

Methods in com.atomikos.icatch.config that throw SysException
 void UserTransactionServiceImp.init(Properties properties)
           
 void UserTransactionService.init(Properties properties)
           
 void UserTransactionServiceImp.init(TSInitInfo info)
           
 void UserTransactionService.init(TSInitInfo info)
          Deprecated. Use the property-based init method instead.
 

Uses of SysException in com.atomikos.icatch.config.imp
 

Methods in com.atomikos.icatch.config.imp that throw SysException
 void AbstractUserTransactionService.init(Properties properties)
           
 void AbstractUserTransactionService.init(TSInitInfo info)
           
 

Uses of SysException in com.atomikos.icatch.imp
 

Methods in com.atomikos.icatch.imp that throw SysException
 void ExtentImp.add(Extent extent)
           
 void ExtentImp.add(Participant participant, int count)
           
 RecoveryCoordinator CoordinatorImp.addParticipant(Participant participant)
           
 RecoveryCoordinator CompositeTransactionImp.addParticipant(Participant participant)
           
 RecoveryCoordinator AbstractCompositeTransaction.addParticipant(Participant participant)
           
 void ExtentImp.addRemoteParticipants(Dictionary participants)
           
 void CompositeTransactionImp.addSubTxAwareParticipant(SubTxAwareParticipant subtxaware)
           
 void AbstractCompositeTransaction.addSubTxAwareParticipant(SubTxAwareParticipant subtxaware)
           
 void CompositeTransactionImp.commit()
           
 void AbstractCompositeTransaction.commit()
           
 HeuristicMessage[] SubTransactionCoordinatorParticipant.commit(boolean onePhase)
           
 HeuristicMessage[] RollbackOnlyParticipant.commit(boolean onePhase)
           
 HeuristicMessage[] ReadOnlyParticipant.commit(boolean onePhase)
           
 HeuristicMessage[] CoordinatorImp.commit(boolean onePhase)
           
 HeuristicMessage[] CoordinatorImp.commitHeuristically()
           
 CompositeTransaction TransactionServiceImp.createCompositeTransaction(long timeout)
           
 CompositeTransaction BaseTransactionManager.createCompositeTransaction(long timeout)
           
 CompositeTransaction CompositeTransactionImp.createSubTransaction()
           
 CompositeTransaction AbstractCompositeTransaction.createSubTransaction()
           
protected  String TransactionServiceImp.createTid()
          Create a new tid.
protected  void CompositeTransactionImp.doCommit()
          Successfully end the composite transaction.
protected  void CompositeTransactionImp.doRollback()
           
 CompositeCoordinator CompositeTransactionImp.getCompositeCoordinator()
           
 CompositeCoordinator CompositeTransactionAdaptor.getCompositeCoordinator()
           
 CompositeCoordinator AbstractCompositeTransaction.getCompositeCoordinator()
           
 CompositeCoordinator TransactionServiceImp.getCompositeCoordinator(String root)
           
 CompositeTransaction BaseTransactionManager.getCompositeTransaction()
           
 CompositeTransaction BaseTransactionManager.getCompositeTransaction(String tid)
           
 Participant TransactionServiceImp.getParticipant(String root)
           
 void TransactionServiceImp.init(Properties properties)
           
 void BaseTransactionManager.init(TransactionServiceImp service, Properties properties)
          Initialize the TM.
 int SubTransactionCoordinatorParticipant.prepare()
           
 int RollbackOnlyParticipant.prepare()
           
 int ReadOnlyParticipant.prepare()
           
 int CoordinatorImp.prepare()
           
 boolean SubTransactionCoordinatorParticipant.recover()
           
 boolean RollbackOnlyParticipant.recover()
           
 boolean ReadOnlyParticipant.recover()
           
 boolean CoordinatorImp.recover()
           
protected  void TransactionServiceImp.recoverCoordinators()
          Recover instances from a given recovery manager.
 CompositeTransaction TransactionServiceImp.recreateCompositeTransaction(Propagation context, boolean orphancheck, boolean heur_commit)
           
protected  CompositeTransaction BaseTransactionManager.recreateCompositeTransaction(Propagation context, boolean orphancheck, boolean heur_commit)
          Recreate a composite transaction based on an imported context.
 void CompositeTransactionImp.registerSynchronization(Synchronization sync)
           
 void AbstractCompositeTransaction.registerSynchronization(Synchronization sync)
           
 void BaseTransactionManager.resume(CompositeTransaction ct)
           
 HeuristicMessage[] SubTransactionCoordinatorParticipant.rollback()
           
 HeuristicMessage[] RollbackOnlyParticipant.rollback()
           
 HeuristicMessage[] ReadOnlyParticipant.rollback()
           
 HeuristicMessage[] CoordinatorImp.rollback()
           
 void CompositeTransactionImp.rollback()
           
 void AbstractCompositeTransaction.rollback()
           
 HeuristicMessage[] CoordinatorImp.rollbackHeuristically()
           
 void SubTransactionCoordinatorParticipant.setCascadeList(Dictionary allParticipants)
           
 void RollbackOnlyParticipant.setCascadeList(Dictionary allParticipants)
           
 void ReadOnlyParticipant.setCascadeList(Dictionary allParticipants)
           
 void CoordinatorImp.setCascadeList(Dictionary allParticipants)
           
 void CompositeTransactionImp.setSerial()
           
 void AbstractCompositeTransaction.setSerial()
           
 void TransactionServiceImp.shutdown(boolean force)
           
 void BaseTransactionManager.shutdown(boolean force)
          Shut down the server in a clean way.
protected  void BaseTransactionManager.startlistening(CompositeTransaction transaction)
           
 CompositeTransaction BaseTransactionManager.suspend()
           
protected  void CoordinatorImp.terminate(boolean commit)
          Terminate the work, on behalf of Terminator.
 

Uses of SysException in com.atomikos.icatch.jaxws
 

Methods in com.atomikos.icatch.jaxws that throw SysException
 void SOAPImportingTransactionManager.terminated(String tid, javax.xml.soap.SOAPMessage msg, boolean commit)
          Terminates the local work and inserts the extent information into a SOAP message.
 void GenericSOAPImportingTransactionManager.terminated(String tid, javax.xml.soap.SOAPMessage msg, boolean commit)
           
 

Uses of SysException in com.atomikos.icatch.jaxws.atomikos
 

Methods in com.atomikos.icatch.jaxws.atomikos that throw SysException
 void SOAPExportingTransactionManagerImp.insertPropagation(String tid, javax.xml.soap.SOAPMessage msg)
           
 

Uses of SysException in com.atomikos.icatch.jta
 

Methods in com.atomikos.icatch.jta that throw SysException
 void UserTransactionServerImp.init(String tmUniqueName, Properties properties)
          Initializes the server object.
 void AbstractJtaUserTransactionService.init(TSInitInfo info)
           
 void UserTransactionServerImp.shutdown()
          Performs shutdown of the server.
 

Uses of SysException in com.atomikos.icatch.msg
 

Methods in com.atomikos.icatch.msg that throw SysException
 HeuristicMessage[] MessageParticipant.commit(boolean onePhase)
           
 void CommitServer.init(TransactionService service, Transport[] transports)
          Initializes the instance.
 int MessageParticipant.prepare()
           
 boolean MessageParticipant.recover()
           
 HeuristicMessage[] MessageParticipant.rollback()
           
 void MessageParticipant.setCascadeList(Dictionary allParticipants)
           
 

Uses of SysException in com.atomikos.icatch.system
 

Constructors in com.atomikos.icatch.system that throw SysException
SubTxThread(Waiter w, SubTxCode code, HeuristicMessage tag)
          Creates a new instance for a given waiter, with a given subtx code.
 

Uses of SysException in com.atomikos.icatch.trmi
 

Methods in com.atomikos.icatch.trmi that throw SysException
 void TrmiTransactionManager.addExtent(Extent extent)
           
 com.atomikos.icatch.trmi.RecoveryCoordinatorProxy TrmiTransactionManager_Stub.addParticipant(Participant $param_Participant_1, String $param_String_2)
           
 com.atomikos.icatch.trmi.RecoveryCoordinatorProxy TrmiTransactionManager.addParticipant(Participant participantproxy, String txid)
           
 com.atomikos.icatch.trmi.RecoveryCoordinatorProxy CompositeTransactionServer.addParticipant(Participant participant, String txid)
          Add a new participant to the transaction of the given tid.
 void TrmiTransactionManager_Stub.addSubTxAwareParticipant(SubTxAwareParticipant $param_SubTxAwareParticipant_1, String $param_String_2)
           
 void TrmiTransactionManager.addSubTxAwareParticipant(SubTxAwareParticipant subtxaware, String txid)
           
 void CompositeTransactionServer.addSubTxAwareParticipant(SubTxAwareParticipant subtxaware, String txid)
          Add a subtx aware participant to the given tx.
 HeuristicMessage[] TrmiTransactionManager_Stub.commit(String $param_String_1)
           
 HeuristicMessage[] TrmiTransactionManager.commit(String root)
           
 void TerminationServer.commit(String root)
          Commit the composite transaction.
 HeuristicMessage[] ParticipantServer.commit(String root)
          Commit the participant of the given root, after prepare was sent.
 HeuristicMessage[] TrmiTransactionManager_Stub.commitOnePhase(String $param_String_1, int $param_int_2, Dictionary $param_Dictionary_3)
           
 HeuristicMessage[] TrmiTransactionManager.commitOnePhase(String root, int siblings, Dictionary cascadeList)
           
 HeuristicMessage[] ParticipantServer.commitOnePhase(String root, int siblings, Dictionary cascadeList)
          Perform one-phase commit for the given root.
protected  CompositeTransaction TrmiTransactionManager.createProxy(CompositeTransaction current)
           
 void TrmiTransactionManager_Stub.forget(String $param_String_1)
           
 void TrmiTransactionManager.forget(String root)
           
 void ParticipantServer.forget(String root)
          Forget all about a given root.
 Propagation TrmiTransactionManager.getPropagation()
           
 CompositeTransaction TrmiTransactionManager.importTransaction(Propagation propagation, boolean orphancheck, boolean heur_commit)
           
 void TrmiTransactionManager.init(Properties properties)
          Should be called as first method, to initialize the internal state.
 int TrmiTransactionManager_Stub.prepare(String $param_String_1, int $param_int_2, Dictionary $param_Dictionary_3)
           
 int TrmiTransactionManager.prepare(String root, int siblings, Dictionary cascadelist)
           
 int ParticipantServer.prepare(String root, int siblings, Dictionary cascadelist)
          Prepare the participant of the given root.
 Boolean TrmiTransactionManager_Stub.replayCompletion(String $param_String_1, Participant $param_Participant_2)
           
 Boolean TrmiTransactionManager.replayCompletion(String root, Participant participant)
           
 Boolean RecoveryServer.replayCompletion(String root, Participant participant)
          Replay completion for given root, on given participant.
 HeuristicMessage[] TrmiTransactionManager_Stub.rollback(String $param_String_1)
           
 HeuristicMessage[] TrmiTransactionManager.rollback(String root)
           
 void TerminationServer.rollback(String root)
          Rollback the current transaction.
 HeuristicMessage[] ParticipantServer.rollback(String root)
          Rollback the participant for the given root.
 void TrmiTransactionManager.shutdown(boolean force)
          Shuts down the server.
 Extent TrmiTransactionManager.terminated(boolean commit)
           
 



Copyright © 2012. All Rights Reserved.