Package org.apache.flink.runtime.state
package org.apache.flink.runtime.state
-
ClassDescriptionAbstract channel state handle.Describes the underlying content.Abstract superclass for all
IncrementalKeyedStateHandle.Base implementation of KeyedStateBackend.An abstract base implementation of theStateBackendBuilderinterface.Abstract base class for state backends that use managed memory.An abstract base implementation of theStateBackendinterface.Snapshot class for theArrayListSerializer.An async keyed state backend provides methods supporting to access keyed state asynchronously and in batch.Base class that outlines the strategy for asynchronous snapshots.Exceptions which indicate that a state backend building has failed.An interface with methods related to the interplay between theBroadcast Stateand theOperatorStateBackend.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.Changelog's implementation of aTaskLocalStateStore.Interface that combines both, theKeyedStateBackendinterface, which encapsulates methods responsible for keyed state management and theSnapshotablewhich tells the system how to snapshot the underlying state.KeyedStateHandlethat is bound to a specific checkpoint.The scope for a chunk of checkpointed state.An output stream for checkpoint metadata.A dedicated output stream that produces aStreamStateHandlewhen closed.A toolset of operations that can be performed on a location embedded within the class.CheckpointStorage defines howStateBackend's store their state for fault tolerance in streaming applications.Implementations of this interface should implement methods acting as an administration role for checkpoint storage, which defined inCheckpointStorageCoordinatorView.This interface creates aCheckpointStorageLocationto which an individual checkpoint or savepoint is stored.CheckpointStorageFactory<T extends CheckpointStorage>A factory to create a specificCheckpointStorage.This class contains utility methods to load checkpoint storage from configurations.A storage location for one particular checkpoint, offering data persistent, metadata persistence, and lifecycle/cleanup methods.A reference to a storage location.This interface implements the durable storage of checkpoint data and metadata streams.A factory for checkpoint output streams, which are used to persist data for checkpoints.Interface that provides access to a CheckpointStateOutputStream and a method to provide theSnapshotResult.Factory method for aKeyedStateHandleto be used inCheckpointStreamWithResultProvider.toKeyedStateHandleSnapshotResult(SnapshotResult, KeyGroupRangeOffsets, KeyedStateHandleFactory).Implementation ofCheckpointStreamWithResultProviderthat creates both, the primary/remote/jm-owned state and the secondary/local/tm-owned state.Implementation ofCheckpointStreamWithResultProviderthat only creates the primary/remote/jm-owned state.The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.Utils for RocksDB state serialization and deserialization.Base of all snapshots that are taken byStateBackends and some other components in tasks.FSDataInputStreamthat delegates all reading operations to a wrappingStreamCompressionDecorator.FSDataOutputStreamthat delegates all writing operations to a wrappingStreamCompressionDecorator.An interface for checkpoint storage types that pick up additional parameters from a configuration.An interface for state backends that pick up additional parameters from a configuration.Default implementation of KeyedStateStore that currently forwards state registration to aRuntimeContext.Default implementation of OperatorStateStore that provides the ability to make snapshots.Builder class forDefaultOperatorStateBackendwhich handles all necessary initializations and clean ups.This state handle represents a directory.DoneFuture<T>AFuturethat is always done and will just yield the object that was given at creation time.A CheckpointStateOutputStream that wraps a primary and a secondary CheckpointStateOutputStream and duplicates all writes into both streams.A wrapper that wrapsFileMergingSnapshotManagerand aCloseable.An asynchronous writer that can write a full snapshot/savepoint from aFullSnapshotResources.ASnapshotResourcesto be used with the backend-independentFullSnapshotAsyncWriter.Utility methods and constants around creating and restoring full snapshots usingFullSnapshotAsyncWriter.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).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<K,V> ABroadcast Statebacked a heap-basedMap.Manages creating heap priority queues along with their counterpart meta info.Common interface to all incrementalKeyedStateHandle.A Holder of StreamStateHandle and the corresponding localPath.State handle for local copies ofIncrementalRemoteKeyedStateHandle.The handle to states of an incremental snapshot.Handleto anInputChannelstate.This interface is the current context of a keyed state.The defaultInternalKeyContextimplementation.Interface for collection that gives in order access to elements w.r.t their priority.IterableStateSnapshot<K,N, S> AStateSnapshotthat can return an iterator over all containedStateEntries.JavaSerializer<T extends Serializable>ATypeSerializerthat uses Java serialization.Serializer configuration snapshot for compatibility and format evolution.Keyed<K>Interface for objects that have a key attribute.Serialization proxy for all meta data in keyed state backends.A keyed state backend provides methods for managing keyed state.Listener is given a callback whenKeyedStateBackend.setCurrentKey(K)is called (key context changes).Internal POJO implementingStateBackend.KeyedStateBackendParametersCheckpoint output stream that allows to write raw keyed state in a partitioned way, split into key-groups.This factory produces concrete internal state objects.KeyedStateFunction<K,S extends org.apache.flink.api.common.state.State> A function to be applied to all keyed states.Base for the handles of the checkpointed states in keyed streams.Function to extract a key from a given object.This interface exists as (temporary) adapter between the newInternalPriorityQueueand the old way in which timers are written in a snapshot.Class that contains the base algorithm for partitioning data into key-groups.This functional interface defines how one element is read from aDataInputView.This functional interface defines how one element is written to aDataOutputView.Functional interface to consume elements from a key group.This represents the result of key-group partitioning.This class defines a range of key-group indexes.This class combines a key-group range with offsets that correspond to the key-groups in the range.This interface offers ordered random read access to multiple key group ids.AKeyGroupsStateHandlethat describes a savepoint in the unified format.A handle to the partitioned stream operator state after it has been checkpointed.This class provides access to an input stream that contains state data for one key group and the key group id.Iterator that over all key-value state entries in aKeyedStateBackend.Encapsulates a logic of serialization and deserialization of a list with a delimiter.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.Provides directories for local backup or local recovery.Implementation ofLocalSnapshotDirectoryProvider.This interface provides a context in which operators can initialize by registering to managed state (i.e. state that is managed by state backends).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.Abstract class to implement custom checkpoint output streams which should not be closable for user code.This class implements aTaskLocalStateStorewith no functionality and is used when local recovery is disabled.An empty implementation ofCheckpointStateToolset.Serialization proxy for all meta data in operator state backends.Interface that combines both, the user facingOperatorStateStoreinterface and the system interfaceSnapshotable.Internal POJO implementingStateBackend.OperatorStateBackendParametersCheckpoint output stream that allows to write raw operator state in a partitioned way.Interface of a state handle for operator state.The modes that determine how anOperatorStreamStateHandleis assigned to tasks during restore.Meta information about the operator state handle.Implementation of operator state restore operation.State handle for partitionable operator state.This interface represents the administrative interface toTaskLocalStateStore, that only the owner of the object should see.Implementation of operator list state.Unique ID that allows for physical comparison between state handles.A placeholder state handle for shared state that will replaced by an original that was created in a previous checkpoint.Interface for objects that can be compared by priority.This interface works similar toComparableand is used to prioritize between two objects.Factory forKeyGroupedInternalPriorityQueueinstances.Compound meta information for a registered state in a keyed state backend.Compound meta information for a registered state in an operator state backend.Meta information about a priority queue state in a backend.Base class for all registered state in state backends.Wrapper class that can be used to represent the wrappedRegisteredStateMetaInfoBaseas key in aMap.Interface for restore operation.Handleto aResultSubpartitionstate.RetrievableStateHandle<T extends Serializable>Handle to state that can be read back again viaRetrievableStateHandle.retrieveState().RetrievableStreamStateHandle<T extends Serializable>Wrapper around aStreamStateHandleto make the referenced state object retrievable trough a simple get call.AKeyedStateHandlethat points to a savepoint taken in the unified format.Savepoint resources for aKeyedStateBackend.ASnapshotStrategythat produces unified savepoints.Responsible for serialization of currentKey, currentGroup and namespace.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.Simple factory to produceSharedStateRegistryobjects.SharedStateRegistryimplementation.An object with empty discardState for registering.This class represents a key that uniquely identifies (on a logical level) state handles for registration in theSharedStateRegistry.This implementation decorates the stream with snappy compression.Snapshotable<S extends StateObject>Interface for objects that can snapshot its state (state backends currently).This class represents a directory that is the target for a state snapshot.Determines how the write-part of a snapshot should be executed.A set of resources produced in the synchronous part of a snapshot required to finish the snapshot.SnapshotResult<T extends StateObject>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.Interface for different snapshot approaches in state backends.A supplier for aSnapshotResultwith an access to aCloseableRegistryfor io tasks that need to be closed when cancelling the async part of the checkpoint.A class to execute aSnapshotStrategy.A State Backend defines how the state of a streaming application is stored locally within the cluster.Parameters passed toStateBackend.createKeyedStateBackend(KeyedStateBackendParameters).Parameters passed toStateBackend.createOperatorStateBackend(OperatorStateBackendParameters).StateBackendBuilder<T,E extends Throwable> A mutable builder to build a state backend instance.StateBackendFactory<T extends StateBackend>A factory to create a specific state backend.This class contains utility methods to load state backends from configurations.StateEntry<K,N, S> Interface of entries in a state backend.StateEntry.SimpleStateEntry<K,N, S> Unique ID that allows for logical comparison between state handles.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.Default implementation ofStateInitializationContext.Base of all handles that represent checkpointed state in some form.Enum for state locations.Collector for size and location stats from a state object viaStateObject.collectSizeStats(StateObjectSizeStatsCollector).This class provides access to input streams that contain data of one state partition of a partitionable state.AStateSerializerProviderwraps logic on how to obtain serializers for registered state, either with the previous schema of state in checkpoints or the current schema of state.General interface for state snapshots that should be written partitioned by key-groups.Interface for writing a snapshot that is partitioned into key-groups.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.This class is a default implementation for StateSnapshotContext.Interface for state de-serialization intoStateTables by key-group.Interface to deal with state snapshot and restore of state.Transformer of state values which are included or skipped in the snapshot.Collection state specific transformer which says how to transform entries of the collection.This factory creates state transformers depending on the form of values to transform.Collection of common state snapshot transformers and their factories.General implementation of list state transformer.General implementation of map state transformer.Interface for a binary function that is used for push-down of state transformation into state backends.Helpers forStateObjectrelated code.Implementations of this interface decorate streams with a compression scheme.AStateObjectthat represents state that was written to a stream.This class holds the allChannelStateWriteRequestExecutorFactoryobjects for a task executor (manager).There is oneFileMergingSnapshotManagerfor each job per task manager.This class holds the allTaskLocalStateStoreImplobjects for a task executor (manager).This class holds the allStateChangelogStorageobjects for a task executor (manager).Classes that implement this interface serve as a task-manager-level local storage for local checkpointed state.Main implementation of aTaskLocalStateStore.This interface provides methods to report and retrieve state for a task.This class is the default implementation ofTaskStateManagerand collaborates with the job manager throughCheckpointResponder) as well as a task-manager-local state store.A keyed state backend interface for internal testing purpose.This implementation does not decorate the stream with any compression.Singleton placeholder class for state without a namespace.Serializer forVoidNamespace.Serializer configuration snapshot for compatibility and format evolution.TypeInformationforVoidNamespace.