| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| Class and Description |
|---|
| StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| Class and Description |
|---|
| StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| Class and Description |
|---|
| StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| 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.
|
| IncrementalKeyedStateHandle.HandleAndLocalPath
A Holder of StreamStateHandle and the corresponding localPath.
|
| 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| 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.
|
| 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.
|
| 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 |
|---|
| IncrementalKeyedStateHandle.HandleAndLocalPath
A Holder of StreamStateHandle and the corresponding localPath.
|
| 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 |
|---|
| 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. |
| IncrementalKeyedStateHandle.HandleAndLocalPath
A Holder of StreamStateHandle and the corresponding localPath.
|
| 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| 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. |
| 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 |
|---|
| 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
StateBackends 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 |
|---|
| AbstractChannelStateHandle.StateContentMetaInfo
Describes the underlying content.
|
| CheckpointStorage
CheckpointStorage defines how
StateBackend's store their state for fault tolerance in
streaming applications. |
InputChannelStateHandle
Handle to an InputChannel state. |
ResultSubpartitionStateHandle
Handle to a ResultSubpartition state. |
| StreamStateHandle
A
StateObject that represents state that was written to a stream. |
| Class and Description |
|---|
| CheckpointedStateScope
The scope for a chunk of checkpointed 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 |
|---|
| KeyGroupRange
This class defines a range of key-group indexes.
|
| Class and Description |
|---|
| PriorityComparable
Interface for objects that can be compared by priority.
|
| 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
StateBackends 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| HeapBroadcastState
A
Broadcast State backed a heap-based Map. |
| IncrementalKeyedStateHandle
Common interface to all incremental
KeyedStateHandle. |
| IncrementalKeyedStateHandle.HandleAndLocalPath
A Holder of StreamStateHandle and the corresponding localPath.
|
| 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| LocalRecoveryDirectoryProvider
Provides directories for local recovery.
|
| ManagedInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends).
|
| ManagedSnapshotContext
This interface provides a context in which operators that use managed state (i.e. state that is
managed by state backends) can perform a snapshot.
|
| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| 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. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| StateSnapshotKeyGroupReader
Interface for state de-serialization into
StateTables 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
StateBackends 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| 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
StateBackends 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| 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. the root directories
into which all file-based snapshots can be written and the general mode for the local recover
feature.
|
| 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
StateTables 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 |
|---|
| TaskExecutorChannelStateExecutorFactoryManager
This class holds the all
ChannelStateWriteRequestExecutorFactory objects for a task
executor (manager). |
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| 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. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| Class and Description |
|---|
| StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| 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 |
|---|
| StateInitializationContext
This interface provides a context in which operators can initialize by registering to managed
state (i.e. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| Class and Description |
|---|
| FunctionInitializationContext
This interface provides a context in which user functions can initialize by registering to
managed state (i.e. state that is managed by state backends).
|
| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| 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. state that is managed by state backends).
|
| FunctionSnapshotContext
This interface provides a context in which user functions that use managed state (i.e. state that
is managed by state backends) can participate in a snapshot.
|
| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| 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. state that is managed by state backends) or iterating over streams of state
partitions written as raw state in a previous snapshot.
|
| StateSnapshotContext
This interface provides a context in which operators that use managed (i.e. state that is managed
by state backends) or raw (i.e. the operator can write it's state streams) state can perform a
snapshot.
|
| Class and Description |
|---|
| KeyedStateBackend
A keyed state backend provides methods for managing keyed state.
|
Copyright © 2014–2024 The Apache Software Foundation. All rights reserved.