Package io.camunda.zeebe.broker.system.partitions.impl

Class AsyncSnapshotDirector

java.lang.Object

io.camunda.zeebe.scheduler.Actor

io.camunda.zeebe.broker.system.partitions.impl.AsyncSnapshotDirector

All Implemented Interfaces:

RaftCommittedEntryListener, AsyncClosable, ConcurrencyControl, HealthMonitorable, AutoCloseable

public final class AsyncSnapshotDirector
extends Actor
implements RaftCommittedEntryListener, HealthMonitorable

Nested Class Summary

Nested classes/interfaces inherited from class io.camunda.zeebe.scheduler.Actor

Actor.ActorBuilder

Field Summary

Fields

Modifier and Type	Field	Description
static final Duration	MINIMUM_SNAPSHOT_PERIOD

Fields inherited from class io.camunda.zeebe.scheduler.Actor

actor, ACTOR_PROP_NAME, ACTOR_PROP_PARTITION_ID

Method Summary

Modifier and Type	Method	Description
void	addFailureListener(FailureListener listener)
ActorFuture<Void>	closeAsync()
protected Map<String,String>	createContext()
CompletableActorFuture<PersistedSnapshot>	forceSnapshot()	Directly take a snapshot, independently of the scheduled snapshots.
HealthReport	getHealthReport()
String	getName()
protected void	handleFailure(Throwable failure)
void	newPositionCommitted(long currentCommitPosition)
static AsyncSnapshotDirector	ofProcessingMode(int nodeId, int partitionId, StreamProcessor streamProcessor, StateController stateController, Duration snapshotRate, Callable<CompletableFuture<Void>> flushLog)	Create an AsyncSnapshotDirector that can take snapshot when the StreamProcessor is in processing mode
static AsyncSnapshotDirector	ofReplayMode(int nodeId, int partitionId, StreamProcessor streamProcessor, StateController stateController, Duration snapshotRate, Callable<CompletableFuture<Void>> flushLog)	Create an AsyncSnapshotDirector that can take snapshot when the StreamProcessor is in continuous replay mode.
protected void	onActorStarting()
void	onCommit(IndexedRaftLogEntry indexedRaftLogEntry)
void	removeFailureListener(FailureListener failureListener)

Methods inherited from class io.camunda.zeebe.scheduler.Actor

buildActorName, call, close, getContext, isActorClosed, newActor, onActorClosed, onActorCloseRequested, onActorClosing, onActorFailed, onActorStarted, run, runOnCompletion, schedule, wrap

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.camunda.zeebe.scheduler.ConcurrencyControl

createCompletedFuture, createFuture

Field Details

MINIMUM_SNAPSHOT_PERIOD

public static final Duration MINIMUM_SNAPSHOT_PERIOD

Method Details

createContext

protected Map<String,String> createContext()

Overrides:

createContext in class Actor

getName

public String getName()

Specified by:

getName in interface HealthMonitorable

Overrides:

getName in class Actor

onActorStarting

protected void onActorStarting()

Overrides:

onActorStarting in class Actor

closeAsync

public ActorFuture<Void> closeAsync()

Specified by:

closeAsync in interface AsyncClosable

Overrides:

closeAsync in class Actor

handleFailure

protected void handleFailure(Throwable failure)

Overrides:

handleFailure in class Actor

ofReplayMode

public static AsyncSnapshotDirector ofReplayMode(int nodeId,
 int partitionId,
 StreamProcessor streamProcessor,
 StateController stateController,
 Duration snapshotRate,
 Callable<CompletableFuture<Void>> flushLog)

Create an AsyncSnapshotDirector that can take snapshot when the StreamProcessor is in continuous replay mode.

Parameters:

nodeId - id of this broker

partitionId - partition id

streamProcessor - stream processor for the partition

stateController - state controller that manages state

snapshotRate - rate at which the snapshot is taken

Returns:

snapshot director

ofProcessingMode

public static AsyncSnapshotDirector ofProcessingMode(int nodeId,
 int partitionId,
 StreamProcessor streamProcessor,
 StateController stateController,
 Duration snapshotRate,
 Callable<CompletableFuture<Void>> flushLog)

Create an AsyncSnapshotDirector that can take snapshot when the StreamProcessor is in processing mode

Parameters:

nodeId - id of this broker

partitionId - partition id

streamProcessor - stream processor for the partition

stateController - state controller that manages state

snapshotRate - rate at which the snapshot is taken

Returns:

snapshot director

forceSnapshot

public CompletableActorFuture<PersistedSnapshot> forceSnapshot()

Directly take a snapshot, independently of the scheduled snapshots.

Returns:

A future that is completed successfully when the snapshot was taken. If the snapshot was skipped, the future is also completed successfully but with a null.

getHealthReport

public HealthReport getHealthReport()

Specified by:

getHealthReport in interface HealthMonitorable

addFailureListener

public void addFailureListener(FailureListener listener)

Specified by:

addFailureListener in interface HealthMonitorable

removeFailureListener

public void removeFailureListener(FailureListener failureListener)

Specified by:

removeFailureListener in interface HealthMonitorable

onCommit

public void onCommit(IndexedRaftLogEntry indexedRaftLogEntry)

Specified by:

onCommit in interface RaftCommittedEntryListener

newPositionCommitted

public void newPositionCommitted(long currentCommitPosition)