RaftKVDatabase (JSimpleDB Raft Key/Value Store 2.4.1 API)

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

All Implemented Interfaces:: KVDatabase

public class RaftKVDatabase
extends Object
implements KVDatabase

A distributed KVDatabase based on the Raft consensus algorithm.

Raft defines a distributed consensus algorithm for maintaining a shared state machine. Each Raft node maintains a complete copy of the state machine. Cluster nodes elect a leader who collects and distributes updates and provides for consistent reads. As long as as a node is part of a majority, the state machine is fully operational.

RaftKVDatabase turns this into a transactional key/value database with linearizable ACID semantics.

Implementation Details

The Raft state machine is the key/value store data.
Unapplied log entries are stored on disk as serialized mutations, and also cached in memory.
Concurrent transactions are supported through a simple optimistic locking MVCC scheme (same as used by SnapshotKVDatabase):
- Transactions execute locally until commit time, using a MutableView to collect mutations. The MutableView is based on the local node's most recent log entry (whether committed or not); this is called the base term and index for the transaction.
- On commit, the transaction's Reads, Writes, base index and term, and any config change are sent to the leader.
- The leader confirms that the log entry corresponding to the transaction's base index is either not yet applied, or was its most recently applied log entry. If this is not the case, then the transaction's base log entry is too old (older than T_max, or was applied and discarded early due to memory pressure), and so the transaction is rejected with a RetryTransactionException.
- The leader verifies that the the log entry term matches the transaction's base term; if not, the base log entry has been overwritten, and the transaction is rejected with a RetryTransactionException.
- The leader confirms that the Writes associated with log entries after the transaction's base log entry do not create conflicts when compared against the transaction's Reads. If so, the transaction is rejected with a RetryTransactionException.
- The leader adds a new log entry consisting of the transaction's Writes (and any config change) to its log. The associated term and index become the transaction's commit term and index; the leader then replies to the follower with this information.
- If/when the follower sees a committed (in the Raft sense) log entry appear in its log matching the transaction's commit term and index, then the transaction is complete.
- As an optimization, when the leader sends a log entry to the same follower who committed the corresponding transaction in the first place, only the transaction ID is sent, because the follower already has the data.
- Upon receipt of a new log entry, both followers and leaders will "rebase" any open guaranteed-up-to-date transactions on the new log entry if there are no conflicts, or else mark it for retry if there are.
- If a transaction's base log entry is overwritten in the Raft log, the transaction fails with a retry.
For transactions occurring on a leader, the logic is similar except of course no network communication occurs.
On leaders, committed log entries are not applied to the state machine immediately; instead they kept around until all followers have confirmed receipt. The point of waiting is to avoid incoming follower transactions being rejected because their base log entry has already been compacted. Assuming message reordering is unlikely or impossible and each node is rebasing committed entries as described above, once a follower has confirmed receipt of a committed log entry there should be no further commit requests from that follower for transactions based on earlier log entries. The time the leader will wait for confirmation is limited, and this caching is subject to M_max, which limits the total memory used.
For read-only transactions, the leader does not create a new log entry; instead, the transaction's commit term and index are set to the base term and index, and the leader also calculates its current "leader lease timeout", which is the earliest time at which it is possible for another leader to be elected. This is calculated as the time in the past at which the leader sent AppendRequest's to a majority of followers who have since responded, plus the minimum election timeout, minus a small adjustment for possible clock drift (this assumes all nodes have the same minimum election timeout configured). If the current time is prior to the leader lease timeout, the transaction may be committed as soon as log entry corresponding to the commit term and index is committed (it may already be); otherwise, the current time is returned to the follower as minimum required leader lease timeout before the transaction may be committed.
Every AppendRequest includes the leader's current timestamp and leader lease timeout, so followers can commit any waiting read-only transactions. Leaders keep track of which followers are waiting on which leader lease timeout values, and when the leader lease timeout advances to allow a follower to commit a transaction, the follower is immediately notified.
Optional weaker consistency guarantees are availble on a per-transaction bases; see RaftKVTransaction.setConsistency().

Limitations

A transaction's mutations must fit in memory.
An AtomicKVStore is required to store local persistent state.
All nodes must be configured with the same minimum election timeout. This guarantees that the leader's lease timeout calculation is valid.
Due to the optimistic locking approach used, this implementation will perform poorly when there is a high rate of conflicting transactions; the result will be many transaction retries.
Performance will suffer when the amount of data associated with a typical transaction cannot be delivered quickly and reliably over the network.

In general, the algorithm should function correctly under all non-Byzantine conditions. The level of difficultly the system is experiencing, due to contention, network errors, etc., can be measured in terms of:

The average amount of time it takes to commit a transaction
The frequency of RetryTransactionException's

Cluster Configuration

Instances support dynamic cluster configuration changes at runtime.

Initially, all nodes are in an unconfigured state, where nothing has been added to the Raft log yet and no cluster is defined. Unconfigured nodes are passive: they stay in follower mode (i.e., they will not start elections), and they disallow local transactions that make any changes other than as described below to create a new cluster.

An unconfigured node becomes configured when either:

RaftKVTransaction.configChange() is invoked and committed within a local transaction, which creates a new single node cluster and commits the first log entry; or
An AppendRequest is received from a leader of some existing cluster, in which case the node records the cluster ID thereby joining the cluster (see below), and applies the received cluster configuration.

A node is configured if and only if it has recorded one or more log entries. The very first log entry always contains the initial cluster configuration (containing only the node that created it, whether local or remote), so any node that has a non-empty log is configured.

Newly created clusters are assigned a random 32-bit cluster ID (option #1 above). This ID is included in all messages sent over the network, and adopted by unconfigured nodes that join the cluster (via option #2 above). Configured nodes discard incoming messages containing a cluster ID different from the one they have joined. This prevents data corruption that can occur if nodes from two different clusters are inadvertently "mixed" together.

Once a node joins a cluster with a specific cluster ID, it cannot be reassigned to a different cluster without first returning it to the unconfigured state; to do that, it must be shut it down and its persistent state deleted.

Configuration Changes

Once a node is configured, a separate issue is whether the node is included in its own configuration, i.e., whether the node is a member of its cluster according to the current cluster configuration. A node that is not a member of its cluster does not count its own vote to determine committed log entries (if a leader), and does not start elections (if a follower). However, it will accept and respond to incoming AppendRequests and RequestVotes.

In addition, leaders follow these rules with respect to configuration changes:

If a leader is removed from a cluster, it remains the leader until the corresponding configuration change is committed (not counting its own vote), and then steps down (i.e., reverts to follower).
If a follower is added to a cluster, the leader immediately starts sending that follower AppendRequests.
If a follower is removed from a cluster, the leader continues to send that follower AppendRequests until the follower acknowledges receipt of the log entry containing the configuration change.
Leaders defer configuration changes until they have committed at least one log entry in the current term (see this discussion).
Configuration changes that remove the last node in a cluster are disallowed.
Only one configuration change may take place at a time.

Follower Probes

This implementation includes a modification to the Raft state machine to avoid unnecessary, disruptive elections when a node or nodes is disconnected from, and then reconnected to, the majority.

When a follower's election timeout fires, before converting into a candidate, the follower is required to verify communication with a majority of the cluster using PingRequest messages. Only when the follower has successfully done so may it become a candidate. While in this intermediate "probing" mode, the follower responds normally to incoming messages. In particular, if the follower receives a valid AppendRequest from the leader, it reverts back to normal operation.

This behavior is optional, but enabled by default (see setFollowerProbingEnabled());

Key Watches

Key watches and mutable snapshots are supported.

Spring Isolation Levels

In Spring applications, the transaction Consistency level may be configured through the Spring org.jsimpledb.spring.JSimpleDBTransactionManager by (ab)using the transaction isolation level setting, for example, via the @Transactional annotation's isolation() property. All Raft consistency levels are made available this way, though the mapping from Spring's isolation levels to RaftKVDatabase's consistency levels is only semantically approximate:

Spring isolation level	`RaftKVDatabase` consistency level
`Isolation`	`Consistency.LINEARIZABLE`
`Isolation`	`Consistency.LINEARIZABLE`
`Isolation`	`Consistency.EVENTUAL`
`Isolation`	`Consistency.EVENTUAL_COMMITTED`
`Isolation`	`Consistency.UNCOMMITTED`

See Also:: The Raft Consensus Algorithm

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_COMMIT_TIMEOUT` Default transaction commit timeout (5000).
`static int`	`DEFAULT_HEARTBEAT_TIMEOUT` Default heartbeat timeout (200ms).
`static int`	`DEFAULT_MAX_ELECTION_TIMEOUT` Default maximum election timeout (1000ms).
`static int`	`DEFAULT_MAX_TRANSACTION_DURATION` Default maximum supported outstanding transaction duration (5000ms).
`static long`	`DEFAULT_MAX_UNAPPLIED_LOG_MEMORY` Default maximum supported applied log entry memory usage (104857600L bytes).
`static int`	`DEFAULT_MIN_ELECTION_TIMEOUT` Default minimum election timeout (750ms).
`static int`	`DEFAULT_TCP_PORT` Default TCP port (9660) used to communicate with peers.
`static String`	`OPTION_CONSISTENCY` Option key for `createTransaction(Map)`.

Constructor Summary

Constructors
Constructor and Description

RaftKVDatabase()

Constructors
Constructor and Description
`RaftKVDatabase()`

Method Summary

Methods
Modifier and Type	Method and Description
`RaftKVTransaction`	`createTransaction()` Create a new transaction.
`RaftKVTransaction`	`createTransaction(Consistency consistency)` Create a new transaction with the specified consistency.
`RaftKVTransaction`	`createTransaction(Map<String,?> options)`
`int`	`getClusterId()` Retrieve the unique 32-bit ID for this node's cluster.
`long`	`getCommitIndex()` Get this instance's current commit index..
`int`	`getCommitTimeout()` Get the configured default transaction commit timeout.
`Map<String,String>`	`getCurrentConfig()` Retrieve the current cluster configuration as understood by this node.
`Role`	`getCurrentRole()` Get this instance's current role: leadeer, follower, or candidate.
`long`	`getCurrentTerm()` Get this instance's current term.
`long`	`getCurrentTermStartTime()` Get the time at which this instance's current term advanced to its current value.
`int`	`getHeartbeatTimeout()` Get the configured heartbeat timeout.
`String`	`getIdentity()` Get this node's Raft identity.
`long`	`getLastAppliedIndex()` Get this instance's last applied log entry index.
`long`	`getLastAppliedTerm()` Get this instance's last applied log entry term.
`File`	`getLogDirectory()` Get the directory in which uncommitted log entries are stored.
`int`	`getMaxElectionTimeout()` Get the configured maximum election timeout.
`int`	`getMaxTransactionDuration()` Get the configured maximum supported duration for outstanding transactions.
`long`	`getMaxUnappliedLogMemory()` Get the configured maximum allowed memory used for unapplied log entries.
`int`	`getMinElectionTimeout()` Get the configured minimum election timeout.
`List<RaftKVTransaction>`	`getOpenTransactions()` Get the set of open transactions associated with this database.
`List<LogEntry>`	`getUnappliedLog()` Get the unapplied `LogEntry`s in this instance's Raft log.
`long`	`getUnappliedLogMemoryUsage()` Get the estimated total memory used by unapplied log entries.
`boolean`	`isClusterMember()` Determine whether this node thinks that it is part of its cluster, as determined by its current configuration.
`boolean`	`isClusterMember(String node)` Determine whether this node thinks that the specified node is part of the cluster, as determined by its current configuration.
`boolean`	`isConfigured()` Determine whether this instance is configured.
`boolean`	`isFollowerProbingEnabled()` Determine whether follower probing prior to becoming a candidate is enabled.
`void`	`setCommitTimeout(int timeout)` Configure the default transaction commit timeout.
`void`	`setFollowerProbingEnabled(boolean followerProbingEnabled)` Configure whether followers should be required to probe for network connectivity with a majority of the cluster after an election timeout prior to becoming a candidate.
`void`	`setHeartbeatTimeout(int timeout)` Configure the heartbeat timeout.
`void`	`setIdentity(String identity)` Configure the Raft identity.
`void`	`setKVStore(AtomicKVStore kvstore)` Configure the `AtomicKVStore` in which local persistent state is stored.
`void`	`setLogDirectory(File directory)` Configure the directory in which uncommitted log entries are stored.
`void`	`setMaxElectionTimeout(int timeout)` Configure the maximum election timeout.
`void`	`setMaxTransactionDuration(int duration)` Configure the maximum supported duration for outstanding transactions.
`void`	`setMaxUnappliedLogMemory(long memory)` Configure the maximum allowed memory used for unapplied log entries.
`void`	`setMinElectionTimeout(int timeout)` Configure the minimum election timeout.
`void`	`setNetwork(Network network)` Configure the `Network` to use for inter-node communication.
`void`	`start()`
`void`	`stop()`
`String`	`toString()`

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

- Field Detail
  - DEFAULT_MIN_ELECTION_TIMEOUT
```
public static final int DEFAULT_MIN_ELECTION_TIMEOUT
```
    Default minimum election timeout (750ms).
    
    See Also:
    setMinElectionTimeout(int), Constant Field Values
  - DEFAULT_MAX_ELECTION_TIMEOUT
```
public static final int DEFAULT_MAX_ELECTION_TIMEOUT
```
    Default maximum election timeout (1000ms).
    
    See Also:
    setMaxElectionTimeout(int), Constant Field Values
  - DEFAULT_HEARTBEAT_TIMEOUT
```
public static final int DEFAULT_HEARTBEAT_TIMEOUT
```
    Default heartbeat timeout (200ms).
    
    See Also:
    setHeartbeatTimeout(int), Constant Field Values
  - DEFAULT_MAX_TRANSACTION_DURATION
```
public static final int DEFAULT_MAX_TRANSACTION_DURATION
```
    Default maximum supported outstanding transaction duration (5000ms).
    
    See Also:
    setMaxTransactionDuration(int), Constant Field Values
  - DEFAULT_MAX_UNAPPLIED_LOG_MEMORY
```
public static final long DEFAULT_MAX_UNAPPLIED_LOG_MEMORY
```
    Default maximum supported applied log entry memory usage (104857600L bytes).
    
    See Also:
    setMaxUnappliedLogMemory(long), Constant Field Values
  - DEFAULT_COMMIT_TIMEOUT
```
public static final int DEFAULT_COMMIT_TIMEOUT
```
    Default transaction commit timeout (5000).
    
    See Also:
    setCommitTimeout(int), RaftKVTransaction.setTimeout(long), Constant Field Values
  - DEFAULT_TCP_PORT
```
public static final int DEFAULT_TCP_PORT
```
    Default TCP port (9660) used to communicate with peers.
    
    See Also:
    Constant Field Values
  - OPTION_CONSISTENCY
```
public static final String OPTION_CONSISTENCY
```
    Option key for createTransaction(Map). Value should be a Consistency instance, or the name() thereof.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - RaftKVDatabase
```
public RaftKVDatabase()
```
- Method Detail
  - setKVStore
```
public void setKVStore(AtomicKVStore kvstore)
```
    Configure the AtomicKVStore in which local persistent state is stored.
    Required property.
    
    Parameters:
    kvstore - local persistent data store
    
    Throws:
    
    IllegalStateException - if this instance is already started
  - setLogDirectory
```
public void setLogDirectory(File directory)
```
    Configure the directory in which uncommitted log entries are stored.
    Required property.
    
    Parameters:
    directory - log directory
    
    Throws:
    
    IllegalStateException - if this instance is already started
  - getLogDirectory
```
public File getLogDirectory()
```
    Get the directory in which uncommitted log entries are stored.
    
    Returns:
    configured log directory
  - setNetwork
```
public void setNetwork(Network network)
```
    Configure the Network to use for inter-node communication.
    By default, a TCPNetwork instance communicating on DEFAULT_TCP_PORT is used.
    
    Parameters:
    network - network implementation; must not be started
    
    Throws:
    
    IllegalStateException - if this instance is already started
  - setIdentity
```
public void setIdentity(String identity)
```
    Configure the Raft identity.
    Required property.
    
    Parameters:
    identity - unique Raft identity of this node in its cluster
    
    Throws:
    
    IllegalStateException - if this instance is already started
  - getIdentity
```
public String getIdentity()
```
    Get this node's Raft identity.
    
    Returns:
    the unique identity of this node in its cluster
  - setMinElectionTimeout
```
public void setMinElectionTimeout(int timeout)
```
    Configure the minimum election timeout.
    This must be set to a value greater than the heartbeat timeout.
    Default is DEFAULT_MIN_ELECTION_TIMEOUT.
    Warning: currently all nodes must have the same configured minimum election timeout, otherwise read-only transactions are not guaranteed to be completely up-to-date.
    
    Parameters:
    timeout - minimum election timeout in milliseconds
    
    Throws:
    
    IllegalStateException - if this instance is already started
    
    IllegalArgumentException - if timeout <= 0
  - getMinElectionTimeout
```
public int getMinElectionTimeout()
```
    Get the configured minimum election timeout.
    
    Returns:
    minimum election timeout in milliseconds
  - setMaxElectionTimeout
```
public void setMaxElectionTimeout(int timeout)
```
    Configure the maximum election timeout.
    Default is DEFAULT_MAX_ELECTION_TIMEOUT.
    
    Parameters:
    timeout - maximum election timeout in milliseconds
    
    Throws:
    
    IllegalStateException - if this instance is already started
    
    IllegalArgumentException - if timeout <= 0
  - getMaxElectionTimeout
```
public int getMaxElectionTimeout()
```
    Get the configured maximum election timeout.
    
    Returns:
    maximum election timeout in milliseconds
  - setHeartbeatTimeout
```
public void setHeartbeatTimeout(int timeout)
```
    Configure the heartbeat timeout.
    This must be set to a value less than the minimum election timeout.
    Default is DEFAULT_HEARTBEAT_TIMEOUT.
    
    Parameters:
    timeout - heartbeat timeout in milliseconds
    
    Throws:
    
    IllegalStateException - if this instance is already started
    
    IllegalArgumentException - if timeout <= 0
  - getHeartbeatTimeout
```
public int getHeartbeatTimeout()
```
    Get the configured heartbeat timeout.
    
    Returns:
    heartbeat timeout in milliseconds
  - setMaxTransactionDuration
```
public void setMaxTransactionDuration(int duration)
```
    Configure the maximum supported duration for outstanding transactions.
    This value is the T_max value from the overview. A larger value means more memory may be used.
    This value may be changed while this instance is already running.
    Default is DEFAULT_MAX_TRANSACTION_DURATION.
    
    Parameters:
    duration - maximum supported duration for outstanding transactions in milliseconds
    
    Throws:
    
    IllegalArgumentException - if duration <= 0
    See Also:
    setMaxUnappliedLogMemory(long)
  - getMaxTransactionDuration
```
public int getMaxTransactionDuration()
```
    Get the configured maximum supported duration for outstanding transactions.
    
    Returns:
    maximum supported duration for outstanding transactions in milliseconds
  - setMaxUnappliedLogMemory
```
public void setMaxUnappliedLogMemory(long memory)
```
    Configure the maximum allowed memory used for unapplied log entries.
    This value is the M_max value from the overview. A higher value means transactions may be larger and/or stay open longer without causing a RetryTransactionException.
    This value is approximate, and only affects leaders; followers always apply committed log entries immediately.
    This value may be changed while this instance is already running.
    Default is DEFAULT_MAX_UNAPPLIED_LOG_MEMORY.
    
    Parameters:
    memory - maximum allowed memory usage for cached applied log entries
    
    Throws:
    
    IllegalArgumentException - if memory <= 0
    See Also:
    setMaxTransactionDuration(int)
  - getMaxUnappliedLogMemory
```
public long getMaxUnappliedLogMemory()
```
    Get the configured maximum allowed memory used for unapplied log entries.
    
    Returns:
    maximum allowed memory usage for cached applied log entries
  - setCommitTimeout
```
public void setCommitTimeout(int timeout)
```
    Configure the default transaction commit timeout.
    This value determines how transactions will wait once commit() is invoked for the commit to succeed before failing with a RetryTransactionException. This can be overridden on a per-transaction basis via RaftKVTransaction.setTimeout(long).
    This value may be changed while this instance is already running.
    Default is DEFAULT_COMMIT_TIMEOUT.
    
    Parameters:
    timeout - transaction commit timeout in milliseconds, or zero for unlimited
    
    Throws:
    
    IllegalArgumentException - if timeout is negative
    See Also:
    RaftKVTransaction.setTimeout(long)
  - getCommitTimeout
```
public int getCommitTimeout()
```
    Get the configured default transaction commit timeout.
    
    Returns:
    transaction commit timeout in milliseconds, or zero for unlimited
  - setFollowerProbingEnabled
```
public void setFollowerProbingEnabled(boolean followerProbingEnabled)
```
    Configure whether followers should be required to probe for network connectivity with a majority of the cluster after an election timeout prior to becoming a candidate.
    This value may be changed at any time.
    The default is enabled.
    
    Parameters:
    followerProbingEnabled - true to enable, false to disable
  - isFollowerProbingEnabled
```
public boolean isFollowerProbingEnabled()
```
    Determine whether follower probing prior to becoming a candidate is enabled.
    
    Returns:
    true if follower probing is enabled, otherwise false
  - getClusterId
```
public int getClusterId()
```
    Retrieve the unique 32-bit ID for this node's cluster.
    A value of zero indicates an unconfigured system. Usually the reverse true, though an unconfigured system can have a non-zero cluster ID in the rare case where an error occurred persisting the initial log entry.
    
    Returns:
    the unique ID of this node's cluster, or zero if this node is unconfigured
  - getCurrentConfig
```
public Map<String,String> getCurrentConfig()
```
    Retrieve the current cluster configuration as understood by this node.
    Configuration changes are performed and committed in the context of a normal transaction; see RaftKVTransaction.configChange().
    If this system is unconfigured, an empty map is returned (and vice-versa).
    The returned map is a copy; changes have no effect on this instance.
    
    Returns:
    current configuration mapping from node identity to network address, or empty if this node is not started or unconfigured
  - isConfigured
```
public boolean isConfigured()
```
    Determine whether this instance is configured.
    A node is configured if and only if it has at least one log entry. The first log entry always includes a configuration change that adds the node that created it to the (previously empty) cluster.
    
    Returns:
    true if this instance is started and configured, otherwise false
  - isClusterMember
```
public boolean isClusterMember()
```
    Determine whether this node thinks that it is part of its cluster, as determined by its current configuration.
    
    Returns:
    true if this instance is started and part of the cluster, otherwise false
  - isClusterMember
```
public boolean isClusterMember(String node)
```
    Determine whether this node thinks that the specified node is part of the cluster, as determined by its current configuration.
    
    Parameters:
    node - node identity
    
    Returns:
    true if this instance is started and the specified node is part of the cluster, otherwise false
  - getCurrentRole
```
public Role getCurrentRole()
```
    Get this instance's current role: leadeer, follower, or candidate.
    
    Returns:
    current Role, or null if not running
  - getCurrentTerm
```
public long getCurrentTerm()
```
    Get this instance's current term.
    
    Returns:
    current term, or zero if not running
  - getCurrentTermStartTime
```
public long getCurrentTermStartTime()
```
    Get the time at which this instance's current term advanced to its current value.
    
    Returns:
    current term's start time in milliseconds since the epoch, or zero if unknown
  - getCommitIndex
```
public long getCommitIndex()
```
    Get this instance's current commit index..
    
    Returns:
    current commit index, or zero if not running
  - getLastAppliedTerm
```
public long getLastAppliedTerm()
```
    Get this instance's last applied log entry term.
    
    Returns:
    last applied term, or zero if not running
  - getLastAppliedIndex
```
public long getLastAppliedIndex()
```
    Get this instance's last applied log entry index.
    
    Returns:
    last applied index, or zero if not running
  - getUnappliedLog
```
public List<LogEntry> getUnappliedLog()
```
    Get the unapplied LogEntrys in this instance's Raft log.
    The returned list is a copy; changes have no effect on this instance.
    
    Returns:
    unapplied log entries; or null if this instance is not running
  - getUnappliedLogMemoryUsage
```
public long getUnappliedLogMemoryUsage()
```
    Get the estimated total memory used by unapplied log entries.
    
    Returns:
    unapplied log entry memory usage, or zero if this instance is not running
  - getOpenTransactions
```
public List<RaftKVTransaction> getOpenTransactions()
```
    Get the set of open transactions associated with this database.
    The returned set is a copy; changes have no effect on this instance.
    
    Returns:
    all open transactions
  - start
```
@PostConstruct
public void start()
```
    Specified by:
    
    start in interface KVDatabase
  - stop
```
@PreDestroy
public void stop()
```
    Specified by:
    
    stop in interface KVDatabase
  - createTransaction
```
public RaftKVTransaction createTransaction()
```
    Create a new transaction.
    Equivalent to: createTransaction(Consistency.LINEARIZABLE).
    
    Specified by:
    
    createTransaction in interface KVDatabase
    
    Throws:
    
    IllegalStateException - if this instance is not started or in the process of shutting down
  - createTransaction
```
public RaftKVTransaction createTransaction(Map<String,?> options)
```
    Specified by:
    
    createTransaction in interface KVDatabase
  - createTransaction
```
public RaftKVTransaction createTransaction(Consistency consistency)
```
    Create a new transaction with the specified consistency.
    Transactions that wish to use Consistency.EVENTUAL_COMMITTED must be created using this method, because the log entry on which the transaction is based is determined at creation time.
    
    Parameters:
    consistency - consistency level
    
    Returns:
    newly created transaction
    
    Throws:
    
    IllegalArgumentException - if consistency is null
    
    IllegalStateException - if this instance is not started or in the process of shutting down
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class RaftKVDatabase

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_MIN_ELECTION_TIMEOUT

DEFAULT_MAX_ELECTION_TIMEOUT

DEFAULT_HEARTBEAT_TIMEOUT

DEFAULT_MAX_TRANSACTION_DURATION

DEFAULT_MAX_UNAPPLIED_LOG_MEMORY

DEFAULT_COMMIT_TIMEOUT

DEFAULT_TCP_PORT

OPTION_CONSISTENCY

Constructor Detail

RaftKVDatabase

Method Detail

setKVStore

setLogDirectory

getLogDirectory

setNetwork

setIdentity

getIdentity

setMinElectionTimeout

getMinElectionTimeout

setMaxElectionTimeout

getMaxElectionTimeout

setHeartbeatTimeout

getHeartbeatTimeout

setMaxTransactionDuration

getMaxTransactionDuration

setMaxUnappliedLogMemory

getMaxUnappliedLogMemory

setCommitTimeout

getCommitTimeout

setFollowerProbingEnabled

isFollowerProbingEnabled

getClusterId

getCurrentConfig

isConfigured

isClusterMember

isClusterMember

getCurrentRole

getCurrentTerm

getCurrentTermStartTime

getCommitIndex

getLastAppliedTerm

getLastAppliedIndex

getUnappliedLog

getUnappliedLogMemoryUsage

getOpenTransactions

start

stop

createTransaction

createTransaction

createTransaction

toString