RaftKVTransaction (JSimpleDB Raft Key/Value Store 2.4.1 API)

java.lang.Object
- org.jsimpledb.kv.raft.RaftKVTransaction

All Implemented Interfaces:: KVStore, KVTransaction

@ThreadSafe
public class RaftKVTransaction
extends Object
implements KVTransaction

RaftKVDatabase transaction.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`adjustCounter(byte[] key, long amount)`
`void`	`commit()`
`void`	`configChange(String identity, String address)` Include a cluster configuration change when this transaction is committed.
`long`	`decodeCounter(byte[] bytes)`
`byte[]`	`encodeCounter(long value)`
`protected void`	`finalize()`
`byte[]`	`get(byte[] key)`
`KVPair`	`getAtLeast(byte[] minKey)`
`KVPair`	`getAtMost(byte[] maxKey)`
`long`	`getBaseIndex()` Get the index of the log entry on which this transaction is based.
`long`	`getBaseTerm()` Get the term of the log entry on which this transaction is based.
`long`	`getCommitIndex()` Get the index of the Raft log entry on which this transaction is waiting to be committed (in the Raft sense) before it can complete.
`long`	`getCommitTerm()` Get the term of the Raft log entry on which this transaction is waiting to be committed (in the Raft sense) before it can complete.
`String[]`	`getConfigChange()` Get the cluster configuration change associated with this transaction, if any.
`Consistency`	`getConsistency()` Get the consistency level for this transaction.
`RaftKVDatabase`	`getKVDatabase()`
`Iterator<KVPair>`	`getRange(byte[] minKey, byte[] maxKey, boolean reverse)`
`TxState`	`getState()` Get the state of this transaction.
`long`	`getTxId()` Get the locally unique ID of this transaction.
`boolean`	`isReadOnly()` Determine whether this transaction is configured as read-only.
`CloseableKVStore`	`mutableSnapshot()`
`void`	`put(byte[] key, byte[] value)`
`void`	`remove(byte[] key)`
`void`	`removeRange(byte[] minKey, byte[] maxKey)`
`void`	`rollback()`
`void`	`setConsistency(Consistency consistency)` Set the consistency level for this transaction.
`void`	`setReadOnly(boolean readOnly)` Set whether this transaction should be read-only.
`void`	`setTimeout(long timeout)` Set the commit timeout for this instance.
`String`	`toString()`
`ListenableFuture<Void>`	`watchKey(byte[] key)`

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

- Method Detail
  - getTxId
```
public long getTxId()
```
    Get the locally unique ID of this transaction.
    
    Returns:
    transaction ID
  - getState
```
public TxState getState()
```
    Get the state of this transaction.
    
    Returns:
    transaction state
  - getBaseTerm
```
public long getBaseTerm()
```
    Get the term of the log entry on which this transaction is based.
    
    Returns:
    associated base log term
  - getBaseIndex
```
public long getBaseIndex()
```
    Get the index of the log entry on which this transaction is based.
    
    Returns:
    associated base log index
  - getCommitTerm
```
public long getCommitTerm()
```
    Get the term of the Raft log entry on which this transaction is waiting to be committed (in the Raft sense) before it can complete.
    
    Returns:
    associated commit log entry index, or zero if this transaction has not yet gotten to TxState.COMMIT_WAITING
  - getCommitIndex
```
public long getCommitIndex()
```
    Get the index of the Raft log entry on which this transaction is waiting to be committed (in the Raft sense) before it can complete.
    
    Returns:
    associated commit log entry term, or zero if this transaction has not yet gotten to TxState.COMMIT_WAITING
  - getConsistency
```
public Consistency getConsistency()
```
    Get the consistency level for this transaction.
    The default consistency level is Consistency.LINEARIZABLE.
    
    Returns:
    transaction consistency level
  - setConsistency
```
public void setConsistency(Consistency consistency)
```
    Set the consistency level for this transaction.
    This setting may be modified freely during a transaction while it is still open; it only determines the behavior of the transaction after commit() is invoked.
    
    Parameters:
    consistency - desired consistency level
    
    Throws:
    
    IllegalStateException - if consistency is different from the currently configured consistency but this transaction is no longer open (i.e., in state TxState.EXECUTING)
    
    IllegalArgumentException - if consistency is null
    See Also:
    Strong consistency models
  - isReadOnly
```
public boolean isReadOnly()
```
    Determine whether this transaction is configured as read-only.
    
    Returns:
    true if this transaction is configured read-only
  - setReadOnly
```
public void setReadOnly(boolean readOnly)
```
    Set whether this transaction should be read-only.
    Read-only transactions support modifications during the transaction, and these modifications will be visible when read back, but they are discarded on commit().
    
    Parameters:
    readOnly - true to discard mutations on commit, false to apply mutations on commit
    
    Throws:
    
    StaleTransactionException - if this transaction is no longer open
  - configChange
```
public void configChange(String identity,
                String address)
```
    Include a cluster configuration change when this transaction is committed.
    The change will have been applied once this transaction is successfully committed.
    Raft supports configuration changes that add or remove one node at a time to/from the cluster. If this method is invoked more than once in a single transaction, all but the last invocation are ignored.
    Initially, nodes are unconfigured. An unconfigured node becomes configured in one of two ways:
    - By receiving a message from a leader of some existing cluster, in which case the node joins that cluster based on the provided configuration; or
    - By this method being invoked with identity equal to this node's identity and a non-null address, which creates a new cluster and adds this node to it.
    Therefore, this method must be used to intialize a new cluster.
    Parameters:
    identity - the identity of the node to add or remove
    address - the network address of the node if adding, or null if removing
    
    Throws:
    
    IllegalStateException - if this method has been invoked previously on this instance
    
    IllegalArgumentException - if identity is null
  - getConfigChange
```
public String[] getConfigChange()
```
    Get the cluster configuration change associated with this transaction, if any.
    The returned array has length two and contains the identity and address parameters passed to configChange().
    The returned array is a copy; changes have no effect on this instance.
    
    Returns:
    cluster config change, or null if there is none
  - get
```
public byte[] get(byte[] key)
```
    Specified by:
    
    get in interface KVStore
  - getAtLeast
```
public KVPair getAtLeast(byte[] minKey)
```
    Specified by:
    
    getAtLeast in interface KVStore
  - getAtMost
```
public KVPair getAtMost(byte[] maxKey)
```
    Specified by:
    
    getAtMost in interface KVStore
  - getRange
```
public Iterator<KVPair> getRange(byte[] minKey,
                        byte[] maxKey,
                        boolean reverse)
```
    Specified by:
    
    getRange in interface KVStore
  - put
```
public void put(byte[] key,
       byte[] value)
```
    Specified by:
    
    put in interface KVStore
  - remove
```
public void remove(byte[] key)
```
    Specified by:
    
    remove in interface KVStore
  - removeRange
```
public void removeRange(byte[] minKey,
               byte[] maxKey)
```
    Specified by:
    
    removeRange in interface KVStore
  - adjustCounter
```
public void adjustCounter(byte[] key,
                 long amount)
```
    Specified by:
    
    adjustCounter in interface KVStore
  - encodeCounter
```
public byte[] encodeCounter(long value)
```
    Specified by:
    
    encodeCounter in interface KVStore
  - decodeCounter
```
public long decodeCounter(byte[] bytes)
```
    Specified by:
    
    decodeCounter in interface KVStore
  - getKVDatabase
```
public RaftKVDatabase getKVDatabase()
```
    Specified by:
    
    getKVDatabase in interface KVTransaction
  - setTimeout
```
public void setTimeout(long timeout)
```
    Set the commit timeout for this instance.
    RaftKVTransactions do not block while the transaction is open; the configured value is used as a timeout for the commit() operation only. If commit() takes longer than timeout milliseconds, a RetryTransactionException is thrown.
    The default value for all transactions is configured by RaftKVDatabase.setCommitTimeout(int).
    
    Specified by:
    
    setTimeout in interface KVTransaction
    
    Parameters:
    timeout - transaction commit timeout in milliseconds, or zero for unlimited
    
    Throws:
    
    IllegalArgumentException - if timeout is negative
    
    StaleTransactionException - if this transaction is no longer open
  - watchKey
```
public ListenableFuture<Void> watchKey(byte[] key)
```
    Key watches are supported by RaftKVTransaction.
    Raft key watches are compatible with all Consistency levels, in that if a key watch fires due to a mutation to some key, then a subsequent transaction will see that mutation, no matter what Consistency level is configured for that transaction.
    Listeners registered on the returned ListenableFuture must not perform any long running or blocking operations.
    
    Specified by:
    
    watchKey in interface KVTransaction
    
    Parameters:
    key -
    
    Returns:
    
    Throws:
    
    StaleTransactionException
    
    RetryTransactionException
    
    KVDatabaseException
    
    UnsupportedOperationException
    
    IllegalArgumentException
  - commit
```
public void commit()
```
    Specified by:
    
    commit in interface KVTransaction
  - rollback
```
public void rollback()
```
    Specified by:
    
    rollback in interface KVTransaction
  - mutableSnapshot
```
public CloseableKVStore mutableSnapshot()
```
    Mutable snapshots are supported by RaftKVTransaction.
    
    Specified by:
    
    mutableSnapshot in interface KVTransaction
    
    Returns:
    
    Throws:
    
    UnsupportedOperationException
    
    StaleTransactionException
    
    RetryTransactionException
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable

Class RaftKVTransaction

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getTxId

getState

getBaseTerm

getBaseIndex

getCommitTerm

getCommitIndex

getConsistency

setConsistency

isReadOnly

setReadOnly

configChange

getConfigChange

get

getAtLeast

getAtMost

getRange

put

remove

removeRange

adjustCounter

encodeCounter

decodeCounter

getKVDatabase

setTimeout

watchKey

commit

rollback

mutableSnapshot

toString

finalize