| Interface | Description |
|---|---|
| CheckpointListener |
This interface must be implemented by functions/operations that want to receive
a commit notification once a checkpoint has been completely acknowledged by all
participants.
|
| CheckpointStreamFactory | |
| CompositeStateHandle |
Base of all snapshots that are taken by
StateBackends and some other
components in tasks. |
| 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.
|
| KeyedBackendStateMetaInfoSnapshotReaderWriters.KeyedBackendStateMetaInfoReader<N,S> | |
| KeyedBackendStateMetaInfoSnapshotReaderWriters.KeyedBackendStateMetaInfoWriter | |
| KeyedStateBackend<K> |
A keyed state backend provides methods for managing keyed state.
|
| KeyedStateHandle |
Base for the handles of the checkpointed states in keyed streams.
|
| KeyGroupsList |
This interface offers ordered random read access to multiple key group ids.
|
| 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.
|
| OperatorBackendStateMetaInfoSnapshotReaderWriters.OperatorBackendStateMetaInfoReader<S> | |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.OperatorBackendStateMetaInfoWriter | |
| OperatorStateBackend |
Interface that combines both, the user facing
OperatorStateStore interface and the system interface
Snapshotable |
| RetrievableStateHandle<T extends Serializable> |
Handle to state that can be read back again via
RetrievableStateHandle.retrieveState(). |
| Snapshotable<S extends StateObject> |
Interface for operators that can perform snapshots of their state.
|
| StateBackend |
A State Backend defines how the state of a streaming application is stored and
checkpointed.
|
| StateBackendFactory<T extends StateBackend> |
A factory to create a specific state backend.
|
| 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.
|
| StateSnapshotContext |
This interface provides a context in which operators that use managed (i.e.
|
| StateTransformationFunction<S,T> |
Interface for a binary function that is used for push-down of state transformation into state backends.
|
| StreamStateHandle |
A
StateObject that represents state that was written to a stream. |
| Class | Description |
|---|---|
| AbstractKeyedStateBackend<K> |
Base implementation of KeyedStateBackend.
|
| AbstractStateBackend |
An abstract base implementation of the
StateBackend interface. |
| ArrayListSerializer<T> | |
| BoundedInputStream |
Wrapper around a FSDataInputStream to limit the maximum read offset.
|
| ChainedStateHandle<T extends StateObject> |
Handle to state handles for the operators in an operator chain.
|
| CheckpointStreamFactory.CheckpointStateOutputStream |
A dedicated output stream that produces a
StreamStateHandle when closed. |
| DefaultKeyedStateStore |
Default implementation of KeyedStateStore that currently forwards state registration to a
RuntimeContext. |
| DefaultOperatorStateBackend |
Default implementation of OperatorStateStore that provides the ability to make snapshots.
|
| DoneFuture<T> |
A
Future that is always done and will just yield the object that was given at creation
time. |
| HashMapSerializer<K,V> |
A serializer for
HashMap. |
| IncrementalKeyedStateHandle |
The handle to states of an incremental snapshot.
|
| KeyedBackendSerializationProxy<K> |
Serialization proxy for all meta data in keyed state backends.
|
| KeyedBackendStateMetaInfoSnapshotReaderWriters |
Readers and writers for different versions of the
RegisteredKeyedBackendStateMetaInfo.Snapshot. |
| KeyedStateCheckpointOutputStream |
Checkpoint output stream that allows to write raw keyed state in a partitioned way, split into key-groups.
|
| KeyGroupRange |
This class defines a range of key-group indexes.
|
| KeyGroupRangeAssignment | |
| KeyGroupRangeOffsets |
This class combines a key-group range with offsets that correspond to the key-groups in the range.
|
| 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.
|
| MultiStreamStateHandle |
Wrapper class that takes multiple
StreamStateHandle and makes them look like a single one. |
| NonClosingCheckpointOutputStream<T extends StreamStateHandle> |
Abstract class to implement custom checkpoint output streams which should not be closable for user code.
|
| OperatorBackendSerializationProxy |
Serialization proxy for all meta data in operator state backends.
|
| OperatorBackendStateMetaInfoSnapshotReaderWriters |
Readers and writers for different versions of the
RegisteredOperatorBackendStateMetaInfo.Snapshot. |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.AbstractOperatorBackendStateMetaInfoReader<S> | |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.AbstractOperatorBackendStateMetaInfoWriter<S> | |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.OperatorBackendStateMetaInfoReaderV1<S> | |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.OperatorBackendStateMetaInfoReaderV2<S> | |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.OperatorBackendStateMetaInfoWriterV1<S> | |
| OperatorBackendStateMetaInfoSnapshotReaderWriters.OperatorBackendStateMetaInfoWriterV2<S> | |
| OperatorStateCheckpointOutputStream |
Checkpoint output stream that allows to write raw operator state in a partitioned way.
|
| OperatorStateHandle |
State handle for partitionable operator state.
|
| OperatorStateHandle.StateMetaInfo | |
| PlaceholderStreamStateHandle |
A placeholder state handle for shared state that will replaced by an original that was
created in a previous checkpoint.
|
| RegisteredKeyedBackendStateMetaInfo<N,S> |
Compound meta information for a registered state in a keyed state backend.
|
| RegisteredKeyedBackendStateMetaInfo.Snapshot<N,S> |
A consistent snapshot of a
RegisteredKeyedBackendStateMetaInfo. |
| RegisteredOperatorBackendStateMetaInfo<S> |
Compound meta information for a registered state in an operator state backend.
|
| RegisteredOperatorBackendStateMetaInfo.Snapshot<S> |
A consistent snapshot of a
RegisteredOperatorBackendStateMetaInfo. |
| RetrievableStreamStateHandle<T extends Serializable> |
Wrapper around a
StreamStateHandle to make the referenced state object retrievable trough a simple get call. |
| SerializedCheckpointData |
This class represents serialized checkpoint data for a collection of elements.
|
| 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.
|
| SharedStateRegistry.Result |
The result of an attempt to (un)/reference state
|
| SharedStateRegistryKey |
This class represents a key that uniquely identifies (on a logical level) state handles for
registration in the
SharedStateRegistry. |
| StateHandleID |
Unique ID that allows for logical comparison between state handles.
|
| StateInitializationContextImpl |
Default implementation of
StateInitializationContext. |
| StatePartitionStreamProvider |
This class provides access to input streams that contain data of one state partition of a partitionable state.
|
| StateSnapshotContextSynchronousImpl |
This class is a default implementation for StateSnapshotContext.
|
| StateUtil |
Helpers for
StateObject related code. |
| TaskStateHandles |
This class encapsulates all state handles for a task.
|
| VoidNamespace |
Singleton placeholder class for state without a namespace.
|
| VoidNamespaceSerializer |
Serializer for
VoidNamespace. |
| Enum | Description |
|---|---|
| OperatorStateHandle.Mode |
The modes that determine how an
OperatorStateHandle is assigned to tasks during restore. |
Copyright © 2014–2017 The Apache Software Foundation. All rights reserved.