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

All Implemented Interfaces:

TransactionalComponent
```
public class TransLogger
extends java.lang.Object
implements TransactionalComponent
```
Logging for transaction steps. This class is stateless in the transaction. When operations are called in the TransactionalComponent lifecycle, it logs the event.

Constructor Summary

Constructors
Constructor	Description
`TransLogger()`	Create a logger for begin-commit/abort-end
`TransLogger(org.slf4j.Logger logger)`	Create a logger, either just begin-commit/abort-end or all steps
`TransLogger(org.slf4j.Logger logger, boolean all)`	Create a logger, either just begin-commit/abort-end or all steps

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
`ComponentId`	`getComponentId()`	Every component instance must supplied a unique number.
`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`	`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

- Constructor Detail
  - TransLogger
```
public TransLogger()
```
    Create a logger for begin-commit/abort-end
  - TransLogger
```
public TransLogger(org.slf4j.Logger logger)
```
    Create a logger, either just begin-commit/abort-end or all steps
  - TransLogger
```
public TransLogger(org.slf4j.Logger logger,
                   boolean all)
```
    Create a logger, either just begin-commit/abort-end or all steps
- Method Detail
  - 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 TransLogger

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TransLogger

TransLogger

TransLogger

Method Detail

getComponentId

startRecovery

recover

finishRecovery

cleanStart

begin

promote

commitPrepare

commit

commitEnd

abort

complete

detach

attach

shutdown