io.atomix.protocols.raft

Interface RaftStateMachine

All Superinterfaces:

java.lang.AutoCloseable

public interface RaftStateMachine
extends java.lang.AutoCloseable

Method Summary

Modifier and Type	Method and Description
<T> java.util.concurrent.CompletableFuture<T>	apply(io.atomix.storage.journal.Indexed<? extends io.atomix.protocols.raft.storage.log.entry.RaftLogEntry> entry) Applies an entry to the state machine.
<T> java.util.concurrent.CompletableFuture<T>	apply(long index) Applies the entry at the given index to the state machine.
void	applyAll(long index) Applies all commits up to the given index.
void	close() Close any opened resources; note however that the thread context should NOT be closed, as it is managed by the Raft server.
java.util.concurrent.CompletableFuture<java.lang.Void>	compact() Compacts Raft logs.
io.atomix.utils.concurrent.ThreadContext	executor() The state machine thread context; can be used to sequence operations on the state machine.
long	getCompactableIndex() Returns the current compactable index.
long	getCompactableTerm() Returns the term of the entry with the current compactable index.
default void	setCompactablePosition(long index, long term) Updates the compactable position; by default does nothing as the default behaviour is to use the last applied index and term.

Method Detail

executor

io.atomix.utils.concurrent.ThreadContext executor()

The state machine thread context; can be used to sequence operations on the state machine.

Returns:

the state machine thread context

compact

java.util.concurrent.CompletableFuture<java.lang.Void> compact()

Compacts Raft logs.

Returns:

a future to be completed once logs have been compacted

applyAll

void applyAll(long index)

Applies all commits up to the given index.

Calls to this method are assumed not to expect a result. This allows some optimizations to be made internally since linearizable events don't have to be waited to complete the command.

Parameters:

index - The index up to which to apply commits.

apply

<T> java.util.concurrent.CompletableFuture<T> apply(long index)

Applies the entry at the given index to the state machine.

Calls to this method are assumed to expect a result. This means linearizable session events triggered by the application of the command at the given index will be awaited before completing the returned future.

Parameters:

index - The index to apply.

Returns:

A completable future to be completed once the commit has been applied.

apply

<T> java.util.concurrent.CompletableFuture<T> apply(io.atomix.storage.journal.Indexed<? extends io.atomix.protocols.raft.storage.log.entry.RaftLogEntry> entry)

Applies an entry to the state machine.

Calls to this method are assumed to expect a result. This means linearizable session events triggered by the application of the given entry will be awaited before completing the returned future.

Parameters:

entry - The entry to apply.

Returns:

A completable future to be completed with the result.

close

void close()

Close any opened resources; note however that the thread context should NOT be closed, as it is managed by the Raft server.

Specified by:

close in interface java.lang.AutoCloseable

setCompactablePosition

default void setCompactablePosition(long index,
                                    long term)

Updates the compactable position; by default does nothing as the default behaviour is to use the last applied index and term.

Parameters:

index - index up to which the log can be compacted

term - term of the entry with that index, used when snapshotting

getCompactableIndex

long getCompactableIndex()

Returns the current compactable index.

Returns:

the current compactable index

getCompactableTerm

long getCompactableTerm()

Returns the term of the entry with the current compactable index.

Returns:

the term of the entry with the current compactable index