org.apache.ratis.statemachine.impl

Class BaseStateMachine

java.lang.Object

org.apache.ratis.statemachine.impl.BaseStateMachine

All Implemented Interfaces:

Closeable, AutoCloseable, StateMachine, StateMachine.DataApi

public class BaseStateMachine
extends Object
implements StateMachine, StateMachine.DataApi

Base implementation for StateMachines.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static interface	BaseStateMachine.Task

Nested classes/interfaces inherited from interface org.apache.ratis.statemachine.StateMachine

StateMachine.DataApi, StateMachine.DataStream, StateMachine.Registry

Field Summary

Fields inherited from interface org.apache.ratis.statemachine.StateMachine

LOG

Fields inherited from interface org.apache.ratis.statemachine.StateMachine.DataApi

DEFAULT

Constructor Summary

Constructors

Constructor and Description
BaseStateMachine()

Method Summary

Modifier and Type	Method and Description
CompletableFuture<Message>	applyTransaction(TransactionContext trx) Apply a committed log entry to the state machine.
TransactionContext	applyTransactionSerial(TransactionContext trx) Called for transactions that have been committed to the RAFT log.
TransactionContext	cancelTransaction(TransactionContext trx) Called to notify the state machine that the Transaction passed cannot be appended (or synced).
void	close()
RaftGroupId	getGroupId()
RaftPeerId	getId()
TermIndex	getLastAppliedTermIndex()
SnapshotInfo	getLatestSnapshot() Returns the information for the latest durable snapshot.
LifeCycle	getLifeCycle()
LifeCycle.State	getLifeCycleState() Returns the lifecycle state for this StateMachine.
CompletableFuture<RaftServer>	getServer()
StateMachineStorage	getStateMachineStorage()
void	initialize(RaftServer raftServer, RaftGroupId raftGroupId, RaftStorage storage) Initializes the State Machine with the given server, group and storage.
void	notifyIndexUpdate(long term, long index) Called to notify state machine about indexes which are processed internally by Raft Server, this currently happens when conf entries are processed in raft Server.
void	notifyNotLeader(Collection<TransactionContext> pendingEntries) Notify the state machine that the raft peer is no longer leader.
void	pause() Pauses the state machine.
TransactionContext	preAppendTransaction(TransactionContext trx) This is called before the transaction passed from the StateMachine is appended to the raft log.
CompletableFuture<Message>	query(Message request) Query the state machine.
CompletableFuture<Message>	queryStale(Message request, long minIndex) Query the state machine, provided minIndex <= commit index.
protected CompletableFuture<Message>	recordTime(com.codahale.metrics.Timer timer, BaseStateMachine.Task task)
void	reinitialize() Re-initializes the State Machine in PAUSED state.
protected void	setLastAppliedTermIndex(TermIndex newTI)
TransactionContext	startTransaction(RaftClientRequest request) Validate/pre-process the incoming update request in the state machine.
long	takeSnapshot() Dump the in-memory state into a snapshot file in the RaftStorage.
String	toString()
protected boolean	updateLastAppliedTermIndex(long term, long index)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.ratis.statemachine.StateMachine

data, notifyExtendedNoLeader, notifyGroupRemove, notifyInstallSnapshotFromLeader, notifyLeaderChanged, notifyLogFailed, notifySlowness, toStateMachineLogEntryString

Methods inherited from interface org.apache.ratis.statemachine.StateMachine.DataApi

flush, link, read, stream, truncate, write

Constructor Detail

BaseStateMachine

public BaseStateMachine()

Method Detail

getId

public RaftPeerId getId()

getLifeCycle

public LifeCycle getLifeCycle()

getServer

public CompletableFuture<RaftServer> getServer()

getGroupId

public RaftGroupId getGroupId()

getLifeCycleState

public LifeCycle.State getLifeCycleState()

Description copied from interface: StateMachine

Returns the lifecycle state for this StateMachine.

Specified by:

getLifeCycleState in interface StateMachine

Returns:

the lifecycle state.

initialize

public void initialize(RaftServer raftServer,
                       RaftGroupId raftGroupId,
                       RaftStorage storage)
                throws IOException

Description copied from interface: StateMachine

Initializes the State Machine with the given server, group and storage. The state machine is responsible reading the latest snapshot from the file system (if any) and initialize itself with the latest term and index there including all the edits.

Specified by:

initialize in interface StateMachine

Throws:

IOException

getLatestSnapshot

public SnapshotInfo getLatestSnapshot()

Description copied from interface: StateMachine

Returns the information for the latest durable snapshot.

Specified by:

getLatestSnapshot in interface StateMachine

notifyNotLeader

public void notifyNotLeader(Collection<TransactionContext> pendingEntries)
                     throws IOException

Description copied from interface: StateMachine

Notify the state machine that the raft peer is no longer leader.

Specified by:

notifyNotLeader in interface StateMachine

Throws:

IOException

pause

public void pause()

Description copied from interface: StateMachine

Pauses the state machine. On return, the state machine should have closed all open files so that a new snapshot can be installed.

Specified by:

pause in interface StateMachine

reinitialize

public void reinitialize()
                  throws IOException

Description copied from interface: StateMachine

Re-initializes the State Machine in PAUSED state. The state machine is responsible reading the latest snapshot from the file system (if any) and initialize itself with the latest term and index there including all the edits.

Specified by:

reinitialize in interface StateMachine

Throws:

IOException

applyTransactionSerial

public TransactionContext applyTransactionSerial(TransactionContext trx)

Description copied from interface: StateMachine

Called for transactions that have been committed to the RAFT log. This step is called sequentially in strict serial order that the transactions have been committed in the log. The SM is expected to do only necessary work, and leave the actual apply operation to the applyTransaction calls that can happen concurrently.

Specified by:

applyTransactionSerial in interface StateMachine

Parameters:

trx - the transaction state including the log entry that has been committed to a quorum of the raft peers

Returns:

The Transaction context.

applyTransaction

public CompletableFuture<Message> applyTransaction(TransactionContext trx)

Description copied from interface: StateMachine

Apply a committed log entry to the state machine. This method can be called concurrently with the other calls, and there is no guarantee that the calls will be ordered according to the log commit order.

Specified by:

applyTransaction in interface StateMachine

Parameters:

trx - the transaction state including the log entry that has been committed to a quorum of the raft peers

getLastAppliedTermIndex

public TermIndex getLastAppliedTermIndex()

Specified by:

getLastAppliedTermIndex in interface StateMachine

setLastAppliedTermIndex

protected void setLastAppliedTermIndex(TermIndex newTI)

notifyIndexUpdate

public void notifyIndexUpdate(long term,
                              long index)

Description copied from interface: StateMachine

Called to notify state machine about indexes which are processed internally by Raft Server, this currently happens when conf entries are processed in raft Server. This keep state machine to keep a track of index updates.

Specified by:

notifyIndexUpdate in interface StateMachine

Parameters:

term - term of the current log entry

index - index which is being updated

updateLastAppliedTermIndex

protected boolean updateLastAppliedTermIndex(long term,
                                             long index)

takeSnapshot

public long takeSnapshot()
                  throws IOException

Description copied from interface: StateMachine

Dump the in-memory state into a snapshot file in the RaftStorage. The StateMachine implementation can decide 1) its own snapshot format, 2) when a snapshot is taken, and 3) how the snapshot is taken (e.g., whether the snapshot blocks the state machine, and whether to purge log entries after a snapshot is done). In the meanwhile, when the size of raft log outside of the latest snapshot exceeds certain threshold, the RaftServer may choose to trigger a snapshot if RaftServerConfigKeys.Snapshot.AUTO_TRIGGER_ENABLED_KEY is enabled. The snapshot should include the latest raft configuration.

Specified by:

takeSnapshot in interface StateMachine

Returns:

the largest index of the log entry that has been applied to the state machine and also included in the snapshot. Note the log purge should be handled separately.

Throws:

IOException

getStateMachineStorage

public StateMachineStorage getStateMachineStorage()

Specified by:

getStateMachineStorage in interface StateMachine

Returns:

StateMachineStorage to interact with the durability guarantees provided by the state machine.

queryStale

public CompletableFuture<Message> queryStale(Message request,
                                             long minIndex)

Description copied from interface: StateMachine

Query the state machine, provided minIndex <= commit index. The request must be read-only. Since the commit index of this server may lag behind the Raft service, the returned result may possibly be stale. When minIndex > StateMachine.getLastAppliedTermIndex(), the state machine may choose to either (1) return exceptionally, or (2) wait until minIndex <= StateMachine.getLastAppliedTermIndex() before running the query.

Specified by:

queryStale in interface StateMachine

query

public CompletableFuture<Message> query(Message request)

Description copied from interface: StateMachine

Query the state machine. The request must be read-only.

Specified by:

query in interface StateMachine

startTransaction

public TransactionContext startTransaction(RaftClientRequest request)
                                    throws IOException

Description copied from interface: StateMachine

Validate/pre-process the incoming update request in the state machine.

Specified by:

startTransaction in interface StateMachine

Returns:

the content to be written to the log entry. Null means the request should be rejected.

Throws:

IOException - thrown by the state machine while validation

cancelTransaction

public TransactionContext cancelTransaction(TransactionContext trx)
                                     throws IOException

Description copied from interface: StateMachine

Called to notify the state machine that the Transaction passed cannot be appended (or synced). The exception field will indicate whether there was an exception or not.

Specified by:

cancelTransaction in interface StateMachine

Parameters:

trx - the transaction to cancel

Returns:

cancelled transaction

Throws:

IOException

preAppendTransaction

public TransactionContext preAppendTransaction(TransactionContext trx)
                                        throws IOException

Description copied from interface: StateMachine

This is called before the transaction passed from the StateMachine is appended to the raft log. This method will be called from log append and having the same strict serial order that the transactions will have in the RAFT log. Since this is called serially in the critical path of log append, it is important to do only required operations here.

Specified by:

preAppendTransaction in interface StateMachine

Returns:

The Transaction context.

Throws:

IOException

close

public void close()
           throws IOException

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Throws:

IOException

toString

public String toString()

Overrides:

toString in class Object

recordTime

protected CompletableFuture<Message> recordTime(com.codahale.metrics.Timer timer,
                                                BaseStateMachine.Task task)