java.lang.Object
- org.apache.jena.dboe.transaction.TransMonitor

All Implemented Interfaces:

TransactionalComponent
```
public class TransMonitor
extends java.lang.Object
implements TransactionalComponent
```
This class is stateless in the transaction but it records counts of every TransactionalComponent operations. For each operation called "ABC" there is a member field "counterABC".

Field Summary

Fields
Modifier and Type	Field	Description
`java.util.concurrent.atomic.LongAdder`	`counterAbort`
`java.util.concurrent.atomic.LongAdder`	`counterAttach`
`java.util.concurrent.atomic.LongAdder`	`counterBegin`
`java.util.concurrent.atomic.LongAdder`	`counterCleanStart`
`java.util.concurrent.atomic.LongAdder`	`counterCommit`
`java.util.concurrent.atomic.LongAdder`	`counterCommitEnd`
`java.util.concurrent.atomic.LongAdder`	`counterCommitPrepare`
`java.util.concurrent.atomic.LongAdder`	`counterComplete`
`java.util.concurrent.atomic.LongAdder`	`counterDetach`
`java.util.concurrent.atomic.LongAdder`	`counterFinishRecovery`
`java.util.concurrent.atomic.LongAdder`	`counterGetComponentId`
`java.util.concurrent.atomic.LongAdder`	`counterPromote`
`java.util.concurrent.atomic.LongAdder`	`counterRecover`
`java.util.concurrent.atomic.LongAdder`	`counterShutdown`
`java.util.concurrent.atomic.LongAdder`	`counterStartRecovery`

Constructor Summary

Constructors
Constructor Description

TransMonitor(ComponentId cid)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`abort(Transaction transaction)`	Abort a transaction (undo the effect of a transaction)
`void`	`attach(SysTransState systemState)`	Set the current thread to be in the transaction.
`void`	`begin(Transaction transaction)`	Start a transaction; return an identifier for this components use.
`void`	`cleanStart()`	Indicate that no recovery is being done (the journal thinks everything was completed last time)
`void`	`commit(Transaction transaction)`	Commit a transaction (make durable).
`void`	`commitEnd(Transaction transaction)`	Signal all commits on all components are done and replay from the journal will not happen.
`java.nio.ByteBuffer`	`commitPrepare(Transaction transaction)`	Prepare for a commit.
`void`	`complete(Transaction transaction)`	Finalization - the coordinator will not mention the transaction again.
`SysTransState`	`detach()`	Detach this component from the transaction of the current thread and return some internal state that can be used in a future call of `TransactionalComponent.attach(SysTransState)`
`void`	`finishRecovery()`	End of the recovery phase
`java.util.Map<java.lang.String,java.lang.Long>`	`getAll()`	Get a copy of the counters with current values.
`ComponentId`	`getComponentId()`	Every component instance must supplied a unique number.
`void`	`print()`	Print the counters state.
`void`	`print(java.io.PrintStream ps)`	Print the counters state.
`boolean`	`promote(Transaction transaction)`	Promote a component in a transaction.
`void`	`recover(java.nio.ByteBuffer ref)`	Notification that `ref` was really committed and is being recovered.
`void`	`reset()`	Reset all counters to zero
`void`	`shutdown()`	Shutdown component, aborting any in-progress transactions.
`void`	`startRecovery()`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - counterGetComponentId
```
public java.util.concurrent.atomic.LongAdder counterGetComponentId
```
  - counterStartRecovery
```
public java.util.concurrent.atomic.LongAdder counterStartRecovery
```
  - counterRecover
```
public java.util.concurrent.atomic.LongAdder counterRecover
```
  - counterFinishRecovery
```
public java.util.concurrent.atomic.LongAdder counterFinishRecovery
```
  - counterCleanStart
```
public java.util.concurrent.atomic.LongAdder counterCleanStart
```
  - counterBegin
```
public java.util.concurrent.atomic.LongAdder counterBegin
```
  - counterPromote
```
public java.util.concurrent.atomic.LongAdder counterPromote
```
  - counterCommitPrepare
```
public java.util.concurrent.atomic.LongAdder counterCommitPrepare
```
  - counterCommit
```
public java.util.concurrent.atomic.LongAdder counterCommit
```
  - counterCommitEnd
```
public java.util.concurrent.atomic.LongAdder counterCommitEnd
```
  - counterAbort
```
public java.util.concurrent.atomic.LongAdder counterAbort
```
  - counterComplete
```
public java.util.concurrent.atomic.LongAdder counterComplete
```
  - counterDetach
```
public java.util.concurrent.atomic.LongAdder counterDetach
```
  - counterAttach
```
public java.util.concurrent.atomic.LongAdder counterAttach
```
  - counterShutdown
```
public java.util.concurrent.atomic.LongAdder counterShutdown
```
- Constructor Detail
  - TransMonitor
```
public TransMonitor(ComponentId cid)
```
- Method Detail
  - reset
```
public void reset()
```
    Reset all counters to zero
  - getAll
```
public java.util.Map<java.lang.String,java.lang.Long> getAll()
```
    Get a copy of the counters with current values. The values are as of the point of this being called and are not changed by any later calls to monitored operations.
  - print
```
public void print()
```
    Print the counters state.
  - print
```
public void print(java.io.PrintStream ps)
```
    Print the counters state.
  - getComponentId
```
public ComponentId getComponentId()
```
    Description copied from interface: TransactionalComponent
    
    Every component instance must supplied a unique number. It is used to route journal entries to subsystems, including across restarts/recovery. Uniqueness scope is within the same TransactionCoordinator, and the same across restarts.
    If a component imposes the rule of one-per-TransactionCoordinator, the same number can be used (if different from all other component type instances).
    If a component can have multiple instances per TransactionCoordinator, for example indexes, each must have a unique instance id.
    
    Specified by:
    
    getComponentId in interface TransactionalComponent
  - startRecovery
```
public void startRecovery()
```
    Specified by:
    
    startRecovery in interface TransactionalComponent
  - recover
```
public void recover(java.nio.ByteBuffer ref)
```
    Description copied from interface: TransactionalComponent
    
    Notification that ref was really committed and is being recovered.
    
    Specified by:
    
    recover in interface TransactionalComponent
    
    Parameters:
    
    ref - Same bytes as were written during prepare originally.
  - finishRecovery
```
public void finishRecovery()
```
    Description copied from interface: TransactionalComponent
    
    End of the recovery phase
    
    Specified by:
    
    finishRecovery in interface TransactionalComponent
  - cleanStart
```
public void cleanStart()
```
    Description copied from interface: TransactionalComponent
    
    Indicate that no recovery is being done (the journal thinks everything was completed last time)
    
    Specified by:
    
    cleanStart in interface TransactionalComponent
  - begin
```
public void begin(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Start a transaction; return an identifier for this components use.
    
    Specified by:
    
    begin in interface TransactionalComponent
  - promote
```
public boolean promote(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Promote a component in a transaction.
    May return "false" for "can't do that" if the transaction can not be promoted.
    May throw UnsupportedOperationException if promotion is not supported.
    
    Specified by:
    
    promote in interface TransactionalComponent
  - commitPrepare
```
public java.nio.ByteBuffer commitPrepare(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Prepare for a commit. Returns some bytes that will be written to the journal. The journal remains valid until TransactionalComponent.commitEnd(org.apache.jena.dboe.transaction.txn.Transaction) is called.
    
    Specified by:
    
    commitPrepare in interface TransactionalComponent
  - commit
```
public void commit(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Commit a transaction (make durable). The transaction will commit and not abort. Other components may not have committed yet and recovery may occur still causing replay of the commit step.
    
    Specified by:
    
    commit in interface TransactionalComponent
  - commitEnd
```
public void commitEnd(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Signal all commits on all components are done and replay from the journal will not happen. The component can clear up now.
    
    Specified by:
    
    commitEnd in interface TransactionalComponent
  - abort
```
public void abort(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Abort a transaction (undo the effect of a transaction)
    
    Specified by:
    
    abort in interface TransactionalComponent
  - complete
```
public void complete(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Finalization - the coordinator will not mention the transaction again.
    
    Specified by:
    
    complete in interface TransactionalComponent
  - detach
```
public SysTransState detach()
```
    Description copied from interface: TransactionalComponent
    
    Detach this component from the transaction of the current thread and return some internal state that can be used in a future call of TransactionalComponent.attach(SysTransState)
    After this call, the component is not in a transaction but the existing transaction still exists. The thread may start a new transaction; that transaction is completely independent of the detached transaction.
    Returns null if the current thread not in a transaction. The component may return null to indicate it has no state. The return system state should be used in a call to TransactionalComponent.attach(SysTransState) and the transaction ended in the usual way.
    
    Specified by:
    
    detach in interface TransactionalComponent
  - attach
```
public void attach(SysTransState systemState)
```
    Description copied from interface: TransactionalComponent
    
    Set the current thread to be in the transaction. The systemState must be obtained from a call of TransactionalComponent.detach(). This method can only be called once per systemState.
    
    Specified by:
    
    attach in interface TransactionalComponent
  - shutdown
```
public void shutdown()
```
    Description copied from interface: TransactionalComponent
    
    Shutdown component, aborting any in-progress transactions. This operation is not guaranteed to be called.
    
    Specified by:
    
    shutdown in interface TransactionalComponent

Class TransMonitor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

counterGetComponentId

counterStartRecovery

counterRecover

counterFinishRecovery

counterCleanStart

counterBegin

counterPromote

counterCommitPrepare

counterCommit

counterCommitEnd

counterAbort

counterComplete

counterDetach

counterAttach

counterShutdown

Constructor Detail

TransMonitor

Method Detail

reset

getAll

print

print

getComponentId

startRecovery

recover

finishRecovery

cleanStart

begin

promote

commitPrepare

commit

commitEnd

abort

complete

detach

attach

shutdown