Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
LocalRecoveryDirectoryProvider
Provides directories for local recovery.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
AbstractKeyedStateBackendBuilder
An abstract base implementation of the
StateBackendBuilder interface. |
AbstractManagedMemoryStateBackend
Abstract base class for state backends that use managed memory.
|
AbstractStateBackend
An abstract base implementation of the
StateBackend interface. |
BackendBuildingException
Exceptions which indicate that a state backend building has failed.
|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
CheckpointedStateScope
The scope for a chunk of checkpointed state.
|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
CompletedCheckpointStorageLocation
The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
|
ConfigurableStateBackend
An interface for state backends that pick up additional parameters from a configuration.
|
IncrementalRemoteKeyedStateHandle
The handle to states of an incremental snapshot.
|
InternalPriorityQueue
Interface for collection that gives in order access to elements w.r.t their priority.
|
Keyed
Interface for objects that have a key attribute.
|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
KeyedStateFactory
This factory produces concrete internal state objects.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupedInternalPriorityQueue
This interface exists as (temporary) adapter between the new
InternalPriorityQueue and
the old way in which timers are written in a snapshot. |
KeyGroupRange
This class defines a range of key-group indexes.
|
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
PriorityQueueSetFactory
Factory for
KeyGroupedInternalPriorityQueue instances. |
RegisteredStateMetaInfoBase
Base class for all registered state in state backends.
|
SavepointResources
Savepoint resources for a
KeyedStateBackend . |
SerializedCompositeKeyBuilder
Responsible for serialization of currentKey, currentGroup and namespace.
|
Snapshotable
Interface for objects that can snapshot its state (state backends currently).
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateBackendBuilder
A mutable builder to build a state backend instance.
|
StateBackendFactory
A factory to create a specific state backend.
|
StateHandleID
Unique ID that allows for logical comparison between state handles.
|
StateSnapshotTransformer.StateSnapshotTransformFactory
This factory creates state transformers depending on the form of values to transform.
|
StreamCompressionDecorator
Implementations of this interface decorate streams with a compression scheme.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
TestableKeyedStateBackend
A keyed state backend interface for internal testing purpose.
|
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
KeyValueStateIterator
Iterator that over all key-value state entries in a
KeyedStateBackend . |
StateSnapshotTransformer
Transformer of state values which are included or skipped in the snapshot.
|
Class and Description |
---|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
RestoreOperation
Interface for restore operation.
|
StateHandleID
Unique ID that allows for logical comparison between state handles.
|
StateSerializerProvider
A
StateSerializerProvider wraps logic on how to obtain serializers for registered state,
either with the previous schema of state in checkpoints or the current schema of state. |
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
FullSnapshotResources
A
SnapshotResources to be used with the backend-independent FullSnapshotAsyncWriter . |
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
KeyValueStateIterator
Iterator that over all key-value state entries in a
KeyedStateBackend . |
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
SnapshotDirectory
This class represents a directory that is the target for a state snapshot.
|
SnapshotResources
A set of resources produced in the synchronous part of a snapshot required to finish the
snapshot.
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
SnapshotStrategy
Interface for different snapshot approaches in state backends.
|
SnapshotStrategy.SnapshotResultSupplier
A supplier for a
SnapshotResult with an access to a CloseableRegistry for io
tasks that need to be closed when cancelling the async part of the checkpoint. |
StateHandleID
Unique ID that allows for logical comparison between state handles.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StreamCompressionDecorator
Implementations of this interface decorate streams with a compression scheme.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
RegisteredStateMetaInfoBase
Base class for all registered state in state backends.
|
Class and Description |
---|
RetrievableStateHandle
Handle to state that can be read back again via
RetrievableStateHandle.retrieveState() . |
SharedStateRegistryFactory
Simple factory to produce
SharedStateRegistry objects. |
Class and Description |
---|
SharedStateRegistryFactory
Simple factory to produce
SharedStateRegistry objects. |
Class and Description |
---|
AbstractChannelStateHandle
Abstract channel state handle.
|
ChainedStateHandle
Handle to state handles for the operators in an operator chain.
|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageCoordinatorView
This interface creates a
CheckpointStorageLocation to which an individual checkpoint or
savepoint is stored. |
CheckpointStorageLocation
A storage location for one particular checkpoint, offering data persistent, metadata persistence,
and lifecycle/cleanup methods.
|
CheckpointStorageLocationReference
A reference to a storage location.
|
CompletedCheckpointStorageLocation
The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
|
CompositeStateHandle
Base of all snapshots that are taken by
StateBackend s and some other components in tasks. |
InputChannelStateHandle
Handle to an InputChannel state. |
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
OperatorStateHandle
Interface of a state handle for operator state.
|
ResultSubpartitionStateHandle
Handle to a ResultSubpartition state. |
SharedStateRegistry
This registry manages state that is shared across (incremental) checkpoints, and is responsible
for deleting shared state that is no longer used in any valid checkpoint.
|
SharedStateRegistryFactory
Simple factory to produce
SharedStateRegistry objects. |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
CheckpointStorageWorkerView
This interface implements the durable storage of checkpoint data and metadata streams.
|
InputChannelStateHandle
Handle to an InputChannel state. |
ResultSubpartitionStateHandle
Handle to a ResultSubpartition state. |
Class and Description |
---|
InputChannelStateHandle
Handle to an InputChannel state. |
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
OperatorStateHandle
Interface of a state handle for operator state.
|
ResultSubpartitionStateHandle
Handle to a ResultSubpartition state. |
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
SharedStateRegistryFactory
Simple factory to produce
SharedStateRegistry objects. |
Class and Description |
---|
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
TaskStateManager
This interface provides methods to report and retrieve state for a task.
|
Class and Description |
---|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
Class and Description |
---|
RetrievableStateHandle
Handle to state that can be read back again via
RetrievableStateHandle.retrieveState() . |
Class and Description |
---|
RetrievableStateHandle
Handle to state that can be read back again via
RetrievableStateHandle.retrieveState() . |
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
Class and Description |
---|
AbstractChannelStateHandle
Abstract channel state handle.
|
AbstractChannelStateHandle.StateContentMetaInfo
Describes the underlying content.
|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
AbstractKeyedStateBackend.PartitionStateFactory |
AbstractStateBackend
An abstract base implementation of the
StateBackend interface. |
ArrayListSerializer |
AsyncSnapshotCallable.AsyncSnapshotTask
FutureTask that wraps a AsyncSnapshotCallable and connects it with
cancellation and closing. |
BackendBuildingException
Exceptions which indicate that a state backend building has failed.
|
BackendWritableBroadcastState
An interface with methods related to the interplay between the
Broadcast
State and the OperatorStateBackend . |
ChainedStateHandle
Handle to state handles for the operators in an operator chain.
|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
CheckpointBoundKeyedStateHandle
KeyedStateHandle that is bound to a specific checkpoint. |
CheckpointedStateScope
The scope for a chunk of checkpointed state.
|
CheckpointMetadataOutputStream
An output stream for checkpoint metadata.
|
CheckpointStateOutputStream
A dedicated output stream that produces a
StreamStateHandle when closed. |
CheckpointStateToolset
A toolset of operations that can be performed on a location embedded within the class.
|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
CheckpointStorageCoordinatorView
This interface creates a
CheckpointStorageLocation to which an individual checkpoint or
savepoint is stored. |
CheckpointStorageLocation
A storage location for one particular checkpoint, offering data persistent, metadata persistence,
and lifecycle/cleanup methods.
|
CheckpointStorageLocationReference
A reference to a storage location.
|
CheckpointStorageWorkerView
This interface implements the durable storage of checkpoint data and metadata streams.
|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
CheckpointStreamWithResultProvider
Interface that provides access to a CheckpointStateOutputStream and a method to provide the
SnapshotResult . |
CheckpointStreamWithResultProvider.KeyedStateHandleFactory
Factory method for a
KeyedStateHandle to be used in CheckpointStreamWithResultProvider.toKeyedStateHandleSnapshotResult(SnapshotResult, KeyGroupRangeOffsets,
KeyedStateHandleFactory) . |
CompletedCheckpointStorageLocation
The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
|
CompositeStateHandle
Base of all snapshots that are taken by
StateBackend s and some other components in tasks. |
DefaultOperatorStateBackend
Default implementation of OperatorStateStore that provides the ability to make snapshots.
|
DirectoryKeyedStateHandle
This class is a keyed state handle based on a directory.
|
DirectoryStateHandle
This state handle represents a directory.
|
DoneFuture
A
Future that is always done and will just yield the object that was given at creation
time. |
DuplicatingCheckpointOutputStream
A CheckpointStateOutputStream that wraps a primary and a secondary CheckpointStateOutputStream
and duplicates all writes into both streams.
|
FullSnapshotResources
A
SnapshotResources to be used with the backend-independent FullSnapshotAsyncWriter . |
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
HeapBroadcastState
A
Broadcast State backed a heap-based Map . |
IncrementalKeyedStateHandle
Common interface to all incremental
KeyedStateHandle . |
IncrementalRemoteKeyedStateHandle
The handle to states of an incremental snapshot.
|
InternalPriorityQueue
Interface for collection that gives in order access to elements w.r.t their priority.
|
Keyed
Interface for objects that have a key attribute.
|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
KeyedStateBackend.KeySelectionListener
Listener is given a callback when
KeyedStateBackend.setCurrentKey(K) is called (key context changes). |
KeyedStateCheckpointOutputStream
Checkpoint output stream that allows to write raw keyed state in a partitioned way, split into
key-groups.
|
KeyedStateFactory
This factory produces concrete internal state objects.
|
KeyedStateFunction
A function to be applied to all keyed states.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyExtractorFunction
Function to extract a key from a given object.
|
KeyGroupedInternalPriorityQueue
This interface exists as (temporary) adapter between the new
InternalPriorityQueue and
the old way in which timers are written in a snapshot. |
KeyGroupPartitioner.ElementReaderFunction
This functional interface defines how one element is read from a
DataInputView . |
KeyGroupPartitioner.ElementWriterFunction
This functional interface defines how one element is written to a
DataOutputView . |
KeyGroupPartitioner.KeyGroupElementsConsumer
Functional interface to consume elements from a key group.
|
KeyGroupPartitioner.PartitioningResult
This represents the result of key-group partitioning.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
KeyGroupRangeOffsets
This class combines a key-group range with offsets that correspond to the key-groups in the
range.
|
KeyGroupsList
This interface offers ordered random read access to multiple key group ids.
|
KeyGroupsStateHandle
A handle to the partitioned stream operator state after it has been checkpointed.
|
KeyGroupStatePartitionStreamProvider
This class provides access to an input stream that contains state data for one key group and the
key group id.
|
KeyValueStateIterator
Iterator that over all key-value state entries in a
KeyedStateBackend . |
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
LocalRecoveryDirectoryProvider
Provides directories for local recovery.
|
ManagedInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
ManagedSnapshotContext
This interface provides a context in which operators that use managed state (i.e.
|
NonClosingCheckpointOutputStream
Abstract class to implement custom checkpoint output streams which should not be closable for
user code.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateCheckpointOutputStream
Checkpoint output stream that allows to write raw operator state in a partitioned way.
|
OperatorStateHandle
Interface of a state handle for operator state.
|
OperatorStateHandle.Mode
The modes that determine how an
OperatorStreamStateHandle is assigned to tasks during
restore. |
OperatorStateHandle.StateMetaInfo
Meta information about the operator state handle.
|
OwnedTaskLocalStateStore
This interface represents the administrative interface to
TaskLocalStateStore , that only
the owner of the object should see. |
PartitionableListState
Implementation of operator list state.
|
PhysicalStateHandleID
Unique ID that allows for physical comparison between state handles.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
PriorityComparator
This interface works similar to
Comparable and is used to prioritize between two objects. |
PriorityQueueSetFactory
Factory for
KeyGroupedInternalPriorityQueue instances. |
RegisteredBroadcastStateBackendMetaInfo |
RegisteredKeyValueStateBackendMetaInfo
Compound meta information for a registered state in a keyed state backend.
|
RegisteredOperatorStateBackendMetaInfo
Compound meta information for a registered state in an operator state backend.
|
RegisteredPriorityQueueStateBackendMetaInfo
Meta information about a priority queue state in a backend.
|
RegisteredStateMetaInfoBase
Base class for all registered state in state backends.
|
RestoreOperation
Interface for restore operation.
|
RetrievableStateHandle
Handle to state that can be read back again via
RetrievableStateHandle.retrieveState() . |
SavepointKeyedStateHandle
A
KeyedStateHandle that points to a savepoint taken in the unified format. |
SavepointResources
Savepoint resources for a
KeyedStateBackend . |
SharedStateRegistry
This registry manages state that is shared across (incremental) checkpoints, and is responsible
for deleting shared state that is no longer used in any valid checkpoint.
|
SharedStateRegistryFactory
Simple factory to produce
SharedStateRegistry objects. |
SharedStateRegistryKey
This class represents a key that uniquely identifies (on a logical level) state handles for
registration in the
SharedStateRegistry . |
Snapshotable
Interface for objects that can snapshot its state (state backends currently).
|
SnapshotDirectory
This class represents a directory that is the target for a state snapshot.
|
SnapshotExecutionType
Determines how the write-part of a snapshot should be executed.
|
SnapshotResources
A set of resources produced in the synchronous part of a snapshot required to finish the
snapshot.
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
SnapshotStrategy
Interface for different snapshot approaches in state backends.
|
SnapshotStrategy.SnapshotResultSupplier
A supplier for a
SnapshotResult with an access to a CloseableRegistry for io
tasks that need to be closed when cancelling the async part of the checkpoint. |
SnapshotStrategyRunner
A class to execute a
SnapshotStrategy . |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateBackendBuilder
A mutable builder to build a state backend instance.
|
StateEntry
Interface of entries in a state backend.
|
StateHandleID
Unique ID that allows for logical comparison between state handles.
|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StatePartitionStreamProvider
This class provides access to input streams that contain data of one state partition of a
partitionable state.
|
StateSerializerProvider
A
StateSerializerProvider wraps logic on how to obtain serializers for registered state,
either with the previous schema of state in checkpoints or the current schema of state. |
StateSnapshot
General interface for state snapshots that should be written partitioned by key-groups.
|
StateSnapshot.StateKeyGroupWriter
Interface for writing a snapshot that is partitioned into key-groups.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
StateSnapshotKeyGroupReader
Interface for state de-serialization into
StateTable s by key-group. |
StateSnapshotTransformer
Transformer of state values which are included or skipped in the snapshot.
|
StateSnapshotTransformer.CollectionStateSnapshotTransformer.TransformStrategy |
StateSnapshotTransformer.StateSnapshotTransformFactory
This factory creates state transformers depending on the form of values to transform.
|
StateSnapshotTransformers.StateSnapshotTransformFactoryWrapAdaptor |
StreamCompressionDecorator
Implementations of this interface decorate streams with a compression scheme.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
TaskExecutorStateChangelogStoragesManager
This class holds the all
StateChangelogStorage objects for a task executor (manager). |
TaskLocalStateStore
Classes that implement this interface serve as a task-manager-level local storage for local
checkpointed state.
|
TaskLocalStateStoreImpl
Main implementation of a
TaskLocalStateStore . |
TaskStateManager
This interface provides methods to report and retrieve state for a task.
|
TestableKeyedStateBackend
A keyed state backend interface for internal testing purpose.
|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
VoidNamespaceSerializer
Serializer for
VoidNamespace . |
VoidNamespaceTypeInfo |
Class and Description |
---|
CheckpointBoundKeyedStateHandle
KeyedStateHandle that is bound to a specific checkpoint. |
CompositeStateHandle
Base of all snapshots that are taken by
StateBackend s and some other components in tasks. |
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
SharedStateRegistry
This registry manages state that is shared across (incremental) checkpoints, and is responsible
for deleting shared state that is no longer used in any valid checkpoint.
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
StateHandleID
Unique ID that allows for logical comparison between state handles.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
CompositeStateHandle
Base of all snapshots that are taken by
StateBackend s and some other components in tasks. |
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
SharedStateRegistry
This registry manages state that is shared across (incremental) checkpoints, and is responsible
for deleting shared state that is no longer used in any valid checkpoint.
|
StateHandleID
Unique ID that allows for logical comparison between state handles.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
Class and Description |
---|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
AbstractStateBackend
An abstract base implementation of the
StateBackend interface. |
BackendBuildingException
Exceptions which indicate that a state backend building has failed.
|
CheckpointedStateScope
The scope for a chunk of checkpointed state.
|
CheckpointMetadataOutputStream
An output stream for checkpoint metadata.
|
CheckpointStateOutputStream
A dedicated output stream that produces a
StreamStateHandle when closed. |
CheckpointStateToolset
A toolset of operations that can be performed on a location embedded within the class.
|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
CheckpointStorageCoordinatorView
This interface creates a
CheckpointStorageLocation to which an individual checkpoint or
savepoint is stored. |
CheckpointStorageLocation
A storage location for one particular checkpoint, offering data persistent, metadata persistence,
and lifecycle/cleanup methods.
|
CheckpointStorageLocationReference
A reference to a storage location.
|
CheckpointStorageWorkerView
This interface implements the durable storage of checkpoint data and metadata streams.
|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
CompletedCheckpointStorageLocation
The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
|
ConfigurableStateBackend
An interface for state backends that pick up additional parameters from a configuration.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
PhysicalStateHandleID
Unique ID that allows for physical comparison between state handles.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateBackendFactory
A factory to create a specific state backend.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
AbstractStateBackend
An abstract base implementation of the
StateBackend interface. |
BackendBuildingException
Exceptions which indicate that a state backend building has failed.
|
ConfigurableStateBackend
An interface for state backends that pick up additional parameters from a configuration.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateBackendFactory
A factory to create a specific state backend.
|
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
AbstractKeyedStateBackend.PartitionStateFactory |
AbstractKeyedStateBackendBuilder
An abstract base implementation of the
StateBackendBuilder interface. |
BackendBuildingException
Exceptions which indicate that a state backend building has failed.
|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
InternalPriorityQueue
Interface for collection that gives in order access to elements w.r.t their priority.
|
IterableStateSnapshot
A
StateSnapshot that can return an iterator over all contained StateEntries . |
Keyed
Interface for objects that have a key attribute.
|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
KeyedStateFactory
This factory produces concrete internal state objects.
|
KeyedStateFunction
A function to be applied to all keyed states.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyExtractorFunction
Function to extract a key from a given object.
|
KeyGroupedInternalPriorityQueue
This interface exists as (temporary) adapter between the new
InternalPriorityQueue and
the old way in which timers are written in a snapshot. |
KeyGroupRange
This class defines a range of key-group indexes.
|
KeyValueStateIterator
Iterator that over all key-value state entries in a
KeyedStateBackend . |
LocalRecoveryConfig
This class encapsulates the completed configuration for local recovery, i.e.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
PriorityComparator
This interface works similar to
Comparable and is used to prioritize between two objects. |
PriorityQueueSetFactory
Factory for
KeyGroupedInternalPriorityQueue instances. |
RegisteredKeyValueStateBackendMetaInfo
Compound meta information for a registered state in a keyed state backend.
|
RegisteredPriorityQueueStateBackendMetaInfo
Meta information about a priority queue state in a backend.
|
RestoreOperation
Interface for restore operation.
|
SavepointResources
Savepoint resources for a
KeyedStateBackend . |
Snapshotable
Interface for objects that can snapshot its state (state backends currently).
|
SnapshotExecutionType
Determines how the write-part of a snapshot should be executed.
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
StateBackendBuilder
A mutable builder to build a state backend instance.
|
StateEntry
Interface of entries in a state backend.
|
StateSnapshot
General interface for state snapshots that should be written partitioned by key-groups.
|
StateSnapshot.StateKeyGroupWriter
Interface for writing a snapshot that is partitioned into key-groups.
|
StateSnapshotKeyGroupReader
Interface for state de-serialization into
StateTable s by key-group. |
StateSnapshotRestore
Interface to deal with state snapshot and restore of state.
|
StateSnapshotTransformer
Transformer of state values which are included or skipped in the snapshot.
|
StateSnapshotTransformer.StateSnapshotTransformFactory
This factory creates state transformers depending on the form of values to transform.
|
StateTransformationFunction
Interface for a binary function that is used for push-down of state transformation into state
backends.
|
StreamCompressionDecorator
Implementations of this interface decorate streams with a compression scheme.
|
TestableKeyedStateBackend
A keyed state backend interface for internal testing purpose.
|
Class and Description |
---|
StateEntry
Interface of entries in a state backend.
|
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
AbstractStateBackend
An abstract base implementation of the
StateBackend interface. |
BackendBuildingException
Exceptions which indicate that a state backend building has failed.
|
CheckpointedStateScope
The scope for a chunk of checkpointed state.
|
CheckpointMetadataOutputStream
An output stream for checkpoint metadata.
|
CheckpointStateOutputStream
A dedicated output stream that produces a
StreamStateHandle when closed. |
CheckpointStateToolset
A toolset of operations that can be performed on a location embedded within the class.
|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
CheckpointStorageCoordinatorView
This interface creates a
CheckpointStorageLocation to which an individual checkpoint or
savepoint is stored. |
CheckpointStorageLocation
A storage location for one particular checkpoint, offering data persistent, metadata persistence,
and lifecycle/cleanup methods.
|
CheckpointStorageLocationReference
A reference to a storage location.
|
CheckpointStorageWorkerView
This interface implements the durable storage of checkpoint data and metadata streams.
|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
ConfigurableStateBackend
An interface for state backends that pick up additional parameters from a configuration.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
PhysicalStateHandleID
Unique ID that allows for physical comparison between state handles.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateBackendFactory
A factory to create a specific state backend.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StreamStateHandle
A
StateObject that represents state that was written to a stream. |
Class and Description |
---|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupRange
This class defines a range of key-group indexes.
|
RestoreOperation
Interface for restore operation.
|
StateSerializerProvider
A
StateSerializerProvider wraps logic on how to obtain serializers for registered state,
either with the previous schema of state in checkpoints or the current schema of state. |
Class and Description |
---|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
CompletedCheckpointStorageLocation
The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
|
ConfigurableCheckpointStorage
An interface for checkpoint storage types that pick up additional parameters from a
configuration.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
TaskExecutorLocalStateStoresManager
This class holds the all
TaskLocalStateStoreImpl objects for a task executor (manager). |
TaskExecutorStateChangelogStoragesManager
This class holds the all
StateChangelogStorage objects for a task executor (manager). |
Class and Description |
---|
KeyGroupRange
This class defines a range of key-group indexes.
|
Class and Description |
---|
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
TaskStateManager
This interface provides methods to report and retrieve state for a task.
|
Class and Description |
---|
SharedStateRegistryFactory
Simple factory to produce
SharedStateRegistry objects. |
StateObject
Base of all handles that represent checkpointed state in some form.
|
Class and Description |
---|
RetrievableStateHandle
Handle to state that can be read back again via
RetrievableStateHandle.retrieveState() . |
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
OperatorStateHandle
Interface of a state handle for operator state.
|
Class and Description |
---|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
Class and Description |
---|
TaskStateManager
This interface provides methods to report and retrieve state for a task.
|
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
CheckpointStorageWorkerView
This interface implements the durable storage of checkpoint data and metadata streams.
|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
ConfigurableStateBackend
An interface for state backends that pick up additional parameters from a configuration.
|
InternalPriorityQueue
Interface for collection that gives in order access to elements w.r.t their priority.
|
Keyed
Interface for objects that have a key attribute.
|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
KeyedStateBackend.KeySelectionListener
Listener is given a callback when
KeyedStateBackend.setCurrentKey(K) is called (key context changes). |
KeyedStateFactory
This factory produces concrete internal state objects.
|
KeyedStateFunction
A function to be applied to all keyed states.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupedInternalPriorityQueue
This interface exists as (temporary) adapter between the new
InternalPriorityQueue and
the old way in which timers are written in a snapshot. |
KeyGroupRange
This class defines a range of key-group indexes.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
PriorityQueueSetFactory
Factory for
KeyGroupedInternalPriorityQueue instances. |
SavepointResources
Savepoint resources for a
KeyedStateBackend . |
Snapshotable
Interface for objects that can snapshot its state (state backends currently).
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateSnapshotTransformer.StateSnapshotTransformFactory
This factory creates state transformers depending on the form of values to transform.
|
TestableKeyedStateBackend
A keyed state backend interface for internal testing purpose.
|
Class and Description |
---|
AbstractKeyedStateBackend
Base implementation of KeyedStateBackend.
|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
Keyed
Interface for objects that have a key attribute.
|
KeyGroupedInternalPriorityQueue
This interface exists as (temporary) adapter between the new
InternalPriorityQueue and
the old way in which timers are written in a snapshot. |
KeyGroupRange
This class defines a range of key-group indexes.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
TaskStateManager
This interface provides methods to report and retrieve state for a task.
|
Class and Description |
---|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
Class and Description |
---|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
KeyedStateFunction
A function to be applied to all keyed states.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
FullSnapshotResources
A
SnapshotResources to be used with the backend-independent FullSnapshotAsyncWriter . |
InputChannelStateHandle
Handle to an InputChannel state. |
Keyed
Interface for objects that have a key attribute.
|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
KeyedStateCheckpointOutputStream
Checkpoint output stream that allows to write raw keyed state in a partitioned way, split into
key-groups.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyExtractorFunction
Function to extract a key from a given object.
|
KeyGroupStatePartitionStreamProvider
This class provides access to an input stream that contains state data for one key group and the
key group id.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
PriorityComparator
This interface works similar to
Comparable and is used to prioritize between two objects. |
ResultSubpartitionStateHandle
Handle to a ResultSubpartition state. |
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
SnapshotStrategyRunner
A class to execute a
SnapshotStrategy . |
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateObject
Base of all handles that represent checkpointed state in some form.
|
StatePartitionStreamProvider
This class provides access to input streams that contain data of one state partition of a
partitionable state.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
CheckpointableKeyedStateBackend
Interface that combines both, the
KeyedStateBackend interface, which encapsulates methods
responsible for keyed state management and the Snapshotable which tells the system how to
snapshot the underlying state. |
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageAccess
Implementations of this interface should implement methods acting as an administration role for
checkpoint storage, which defined in
CheckpointStorageCoordinatorView . |
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
CompletedCheckpointStorageLocation
The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
|
Keyed
Interface for objects that have a key attribute.
|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
KeyedStateBackend.KeySelectionListener
Listener is given a callback when
KeyedStateBackend.setCurrentKey(K) is called (key context changes). |
KeyedStateCheckpointOutputStream
Checkpoint output stream that allows to write raw keyed state in a partitioned way, split into
key-groups.
|
KeyedStateFactory
This factory produces concrete internal state objects.
|
KeyedStateFunction
A function to be applied to all keyed states.
|
KeyedStateHandle
Base for the handles of the checkpointed states in keyed streams.
|
KeyGroupedInternalPriorityQueue
This interface exists as (temporary) adapter between the new
InternalPriorityQueue and
the old way in which timers are written in a snapshot. |
KeyGroupRange
This class defines a range of key-group indexes.
|
KeyGroupStatePartitionStreamProvider
This class provides access to an input stream that contains state data for one key group and the
key group id.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
OperatorStateHandle
Interface of a state handle for operator state.
|
PriorityComparable
Interface for objects that can be compared by priority.
|
PriorityQueueSetFactory
Factory for
KeyGroupedInternalPriorityQueue instances. |
SavepointResources
Savepoint resources for a
KeyedStateBackend . |
Snapshotable
Interface for objects that can snapshot its state (state backends currently).
|
SnapshotResult
This class contains the combined results from the snapshot of a state backend:
A state object representing the state that will be reported to the Job Manager to
acknowledge the checkpoint.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
StateSnapshotTransformer.StateSnapshotTransformFactory
This factory creates state transformers depending on the form of values to transform.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
DefaultKeyedStateStore
Default implementation of KeyedStateStore that currently forwards state registration to a
RuntimeContext . |
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
CheckpointStorage
CheckpointStorage defines how
StateBackend 's store their state for fault tolerance in
streaming applications. |
CheckpointStorageWorkerView
This interface implements the durable storage of checkpoint data and metadata streams.
|
CheckpointStreamFactory
A factory for checkpoint output streams, which are used to persist data for checkpoints.
|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
Class and Description |
---|
OperatorStateBackend
Interface that combines both, the user facing
OperatorStateStore interface and the system
interface Snapshotable |
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
StateBackend
A State Backend defines how the state of a streaming application is stored locally within
the cluster.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e.
|
FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
VoidNamespace
Singleton placeholder class for state without a namespace.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e.
|
StateSnapshotContext
This interface provides a context in which operators that use managed (i.e.
|
Class and Description |
---|
KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Copyright © 2014–2022 The Apache Software Foundation. All rights reserved.