StreamConfig (Flink : 1.17-SNAPSHOT API)

java.lang.Object
- org.apache.flink.streaming.api.graph.StreamConfig

All Implemented Interfaces:

Serializable
```
@Internal
public class StreamConfig
extends Object
implements Serializable
```
Internal configuration for a StreamOperator. This is created and populated by the StreamingJobGraphGenerator.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`StreamConfig.InputConfig` Interface representing chained inputs.
`static class`	`StreamConfig.InputRequirement` Requirements of the different inputs of an operator.
`static class`	`StreamConfig.NetworkInputConfig` A representation of a Network `StreamConfig.InputConfig`.
`static class`	`StreamConfig.SourceInputConfig` A serialized representation of an input.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`SERIALIZED_UDF`
`static String`	`SERIALIZED_UDF_CLASS_NAME` Introduce serializedUdfClassName to avoid unnecessarily heavy `getStreamOperatorFactory(java.lang.ClassLoader)`.

Constructor Summary

Constructors
Constructor and Description

StreamConfig(Configuration config)

Constructors
Constructor and Description
`StreamConfig(Configuration config)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`java.time.Duration`	`getAlignedCheckpointTimeout()`
`List<StreamEdge>`	`getChainedOutputs(ClassLoader cl)`
`int`	`getChainIndex()`
`CheckpointingMode`	`getCheckpointMode()`
`CheckpointStorage`	`getCheckpointStorage(ClassLoader cl)`
`Configuration`	`getConfiguration()`
`List<StreamEdge>`	`getInPhysicalEdges(ClassLoader cl)`
`StreamConfig.InputConfig[]`	`getInputs(ClassLoader cl)`
`String`	`getIterationId()`
`long`	`getIterationWaitTime()`
`double`	`getManagedMemoryFractionOperatorUseCaseOfSlot(ManagedMemoryUseCase managedMemoryUseCase, Configuration taskManagerConfig, ClassLoader cl)` Fraction of total managed memory in the slot that this operator should use for the given use case.
`int`	`getMaxConcurrentCheckpoints()`
`int`	`getMaxSubtasksPerChannelStateFile()`
`int`	`getNumberOfNetworkInputs()`
`int`	`getNumberOfOutputs()`
`OperatorID`	`getOperatorID()`
`String`	`getOperatorName()`
`List<NonChainedOutput>`	`getOperatorNonChainedOutputs(ClassLoader cl)`
`Path`	`getSavepointDir(ClassLoader cl)`
`CompletableFuture<StreamConfig>`	`getSerializationFuture()`
`StateBackend`	`getStateBackend(ClassLoader cl)`
`<K> TypeSerializer<K>`	`getStateKeySerializer(ClassLoader cl)`
`<IN,K extends Serializable> KeySelector<IN,K>`	`getStatePartitioner(int input, ClassLoader cl)`
`<T extends StreamOperator<?>> T`	`getStreamOperator(ClassLoader cl)`
`<T extends StreamOperatorFactory<?>> T`	`getStreamOperatorFactory(ClassLoader cl)`
`String`	`getStreamOperatorFactoryClassName()`
`TimeCharacteristic`	`getTimeCharacteristic()`
`InternalTimeServiceManager.Provider`	`getTimerServiceProvider(ClassLoader cl)`
`Map<Integer,StreamConfig>`	`getTransitiveChainedTaskConfigs(ClassLoader cl)`
`Map<Integer,StreamConfig>`	`getTransitiveChainedTaskConfigsWithSelf(ClassLoader cl)`
`<T> TypeSerializer<T>`	`getTypeSerializerIn(int index, ClassLoader cl)`
`<T> TypeSerializer<T>`	`getTypeSerializerIn1(ClassLoader cl)` Deprecated.
`<T> TypeSerializer<T>`	`getTypeSerializerIn2(ClassLoader cl)` Deprecated.
`<T> TypeSerializer<T>`	`getTypeSerializerOut(ClassLoader cl)`
`<T> TypeSerializer<T>`	`getTypeSerializerSideOut(OutputTag<?> outputTag, ClassLoader cl)`
`Integer`	`getVertexID()`
`List<NonChainedOutput>`	`getVertexNonChainedOutputs(ClassLoader cl)`
`boolean`	`isChainEnd()`
`boolean`	`isChainStart()`
`TernaryBoolean`	`isChangelogStateBackendEnabled(ClassLoader cl)`
`boolean`	`isCheckpointingEnabled()`
`boolean`	`isExactlyOnceCheckpointMode()`
`boolean`	`isGraphContainingLoops()`
`boolean`	`isUnalignedCheckpointsEnabled()`
`static boolean`	`requiresSorting(StreamConfig.InputConfig inputConfig)`
`void`	`serializeAllConfigs()` Serialize all object configs synchronously.
`void`	`setAlignedCheckpointTimeout(java.time.Duration alignedCheckpointTimeout)`
`void`	`setAndSerializeTransitiveChainedTaskConfigs(Map<Integer,StreamConfig> chainedTaskConfigs)`
`void`	`setChainedOutputs(List<StreamEdge> chainedOutputs)`
`void`	`setChainEnd()`
`void`	`setChainIndex(int index)`
`void`	`setChainStart()`
`void`	`setChangelogStateBackendEnabled(TernaryBoolean enabled)`
`void`	`setCheckpointingEnabled(boolean enabled)`
`void`	`setCheckpointMode(CheckpointingMode mode)`
`void`	`setCheckpointStorage(CheckpointStorage storage)`
`void`	`setGraphContainingLoops(boolean graphContainingLoops)`
`void`	`setInPhysicalEdges(List<StreamEdge> inEdges)`
`void`	`setInputs(StreamConfig.InputConfig... inputs)`
`void`	`setIterationId(String iterationId)`
`void`	`setIterationWaitTime(long time)`
`void`	`setManagedMemoryFractionOperatorOfUseCase(ManagedMemoryUseCase managedMemoryUseCase, double fraction)` Fraction of managed memory reserved for the given use case that this operator should use.
`void`	`setMaxConcurrentCheckpoints(int maxConcurrentCheckpoints)`
`void`	`setMaxSubtasksPerChannelStateFile(int maxSubtasksPerChannelStateFile)`
`void`	`setNumberOfNetworkInputs(int numberOfInputs)`
`void`	`setNumberOfOutputs(int numberOfOutputs)`
`void`	`setOperatorID(OperatorID operatorID)`
`void`	`setOperatorName(String name)`
`void`	`setOperatorNonChainedOutputs(List<NonChainedOutput> nonChainedOutputs)` Sets the operator level non-chained outputs.
`void`	`setSavepointDir(Path directory)`
`void`	`setStateBackend(StateBackend backend)`
`void`	`setStateBackendUsesManagedMemory(boolean usesManagedMemory)`
`void`	`setStateKeySerializer(TypeSerializer<?> serializer)`
`void`	`setStatePartitioner(int input, KeySelector<?,?> partitioner)`
`void`	`setStreamOperator(StreamOperator<?> operator)`
`void`	`setStreamOperatorFactory(StreamOperatorFactory<?> factory)`
`void`	`setTimeCharacteristic(TimeCharacteristic characteristic)`
`void`	`setTimerServiceProvider(InternalTimeServiceManager.Provider timerServiceProvider)`
`void`	`setTransitiveChainedTaskConfigs(Map<Integer,StreamConfig> chainedTaskConfigs)`
`void`	`setTypeSerializerOut(TypeSerializer<?> serializer)`
`void`	`setTypeSerializerSideOut(OutputTag<?> outputTag, TypeSerializer<?> serializer)`
`void`	`setUnalignedCheckpointsEnabled(boolean enabled)`
`void`	`setupNetworkInputs(TypeSerializer<?>... serializers)`
`void`	`setVertexID(Integer vertexID)`
`void`	`setVertexNonChainedOutputs(List<NonChainedOutput> nonChainedOutputs)` Sets the job vertex level non-chained outputs.
`String`	`toString()`
`CompletableFuture<StreamConfig>`	`triggerSerializationAndReturnFuture(Executor ioExecutor)` Trigger the object config serialization and return the completable future.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail
- SERIALIZED_UDF
```
public static final String SERIALIZED_UDF
```
  See Also:
  
  Constant Field Values
- SERIALIZED_UDF_CLASS_NAME
```
public static final String SERIALIZED_UDF_CLASS_NAME
```
  Introduce serializedUdfClassName to avoid unnecessarily heavy getStreamOperatorFactory(java.lang.ClassLoader).
  
  See Also:
  
  Constant Field Values

Constructor Detail

StreamConfig

public StreamConfig(Configuration config)

Method Detail

getConfiguration

public Configuration getConfiguration()

getSerializationFuture

public CompletableFuture<StreamConfig> getSerializationFuture()

triggerSerializationAndReturnFuture
```
public CompletableFuture<StreamConfig> triggerSerializationAndReturnFuture(Executor ioExecutor)
```
Trigger the object config serialization and return the completable future.

serializeAllConfigs
```
public void serializeAllConfigs()
```
Serialize all object configs synchronously. Only used for operators which need to reconstruct the StreamConfig internally or test.

setAndSerializeTransitiveChainedTaskConfigs

@VisibleForTesting
public void setAndSerializeTransitiveChainedTaskConfigs(Map<Integer,StreamConfig> chainedTaskConfigs)

setVertexID

public void setVertexID(Integer vertexID)

getVertexID
```
public Integer getVertexID()
```

setManagedMemoryFractionOperatorOfUseCase

public void setManagedMemoryFractionOperatorOfUseCase(ManagedMemoryUseCase managedMemoryUseCase,
                                                      double fraction)

Fraction of managed memory reserved for the given use case that this operator should use.

getManagedMemoryFractionOperatorUseCaseOfSlot

public double getManagedMemoryFractionOperatorUseCaseOfSlot(ManagedMemoryUseCase managedMemoryUseCase,
                                                            Configuration taskManagerConfig,
                                                            ClassLoader cl)

Fraction of total managed memory in the slot that this operator should use for the given use case.

setTimeCharacteristic

public void setTimeCharacteristic(TimeCharacteristic characteristic)

getTimeCharacteristic

public TimeCharacteristic getTimeCharacteristic()

setTypeSerializerOut

public void setTypeSerializerOut(TypeSerializer<?> serializer)

getTypeSerializerOut

public <T> TypeSerializer<T> getTypeSerializerOut(ClassLoader cl)

setTypeSerializerSideOut

public void setTypeSerializerSideOut(OutputTag<?> outputTag,
                                     TypeSerializer<?> serializer)

getTypeSerializerSideOut

public <T> TypeSerializer<T> getTypeSerializerSideOut(OutputTag<?> outputTag,
                                                      ClassLoader cl)

setupNetworkInputs

public void setupNetworkInputs(TypeSerializer<?>... serializers)

setInputs

public void setInputs(StreamConfig.InputConfig... inputs)

getInputs

public StreamConfig.InputConfig[] getInputs(ClassLoader cl)

getTypeSerializerIn1

@Deprecated
public <T> TypeSerializer<T> getTypeSerializerIn1(ClassLoader cl)

Deprecated.

getTypeSerializerIn2

@Deprecated
public <T> TypeSerializer<T> getTypeSerializerIn2(ClassLoader cl)

Deprecated.

getTypeSerializerIn

public <T> TypeSerializer<T> getTypeSerializerIn(int index,
                                                 ClassLoader cl)

setStreamOperator

@VisibleForTesting
public void setStreamOperator(StreamOperator<?> operator)

setStreamOperatorFactory

public void setStreamOperatorFactory(StreamOperatorFactory<?> factory)

getStreamOperator

@VisibleForTesting
public <T extends StreamOperator<?>> T getStreamOperator(ClassLoader cl)

getStreamOperatorFactory

public <T extends StreamOperatorFactory<?>> T getStreamOperatorFactory(ClassLoader cl)

getStreamOperatorFactoryClassName

public String getStreamOperatorFactoryClassName()

setIterationId

public void setIterationId(String iterationId)

getIterationId
```
public String getIterationId()
```

setIterationWaitTime

public void setIterationWaitTime(long time)

getIterationWaitTime
```
public long getIterationWaitTime()
```

setNumberOfNetworkInputs

public void setNumberOfNetworkInputs(int numberOfInputs)

getNumberOfNetworkInputs
```
public int getNumberOfNetworkInputs()
```

setNumberOfOutputs

public void setNumberOfOutputs(int numberOfOutputs)

getNumberOfOutputs
```
public int getNumberOfOutputs()
```

setOperatorNonChainedOutputs

public void setOperatorNonChainedOutputs(List<NonChainedOutput> nonChainedOutputs)

Sets the operator level non-chained outputs.

getOperatorNonChainedOutputs

public List<NonChainedOutput> getOperatorNonChainedOutputs(ClassLoader cl)

setChainedOutputs

public void setChainedOutputs(List<StreamEdge> chainedOutputs)

getChainedOutputs

public List<StreamEdge> getChainedOutputs(ClassLoader cl)

setInPhysicalEdges

public void setInPhysicalEdges(List<StreamEdge> inEdges)

getInPhysicalEdges

public List<StreamEdge> getInPhysicalEdges(ClassLoader cl)

setCheckpointingEnabled

public void setCheckpointingEnabled(boolean enabled)

isCheckpointingEnabled

public boolean isCheckpointingEnabled()

setCheckpointMode

public void setCheckpointMode(CheckpointingMode mode)

getCheckpointMode

public CheckpointingMode getCheckpointMode()

setUnalignedCheckpointsEnabled

public void setUnalignedCheckpointsEnabled(boolean enabled)

isUnalignedCheckpointsEnabled

public boolean isUnalignedCheckpointsEnabled()

isExactlyOnceCheckpointMode

public boolean isExactlyOnceCheckpointMode()

getAlignedCheckpointTimeout

public java.time.Duration getAlignedCheckpointTimeout()

setAlignedCheckpointTimeout

public void setAlignedCheckpointTimeout(java.time.Duration alignedCheckpointTimeout)

setMaxConcurrentCheckpoints

public void setMaxConcurrentCheckpoints(int maxConcurrentCheckpoints)

getMaxConcurrentCheckpoints

public int getMaxConcurrentCheckpoints()

getMaxSubtasksPerChannelStateFile

public int getMaxSubtasksPerChannelStateFile()

setMaxSubtasksPerChannelStateFile

public void setMaxSubtasksPerChannelStateFile(int maxSubtasksPerChannelStateFile)

setVertexNonChainedOutputs
```
public void setVertexNonChainedOutputs(List<NonChainedOutput> nonChainedOutputs)
```
Sets the job vertex level non-chained outputs. The given output list must have the same order with JobVertex.getProducedDataSets().

getVertexNonChainedOutputs

public List<NonChainedOutput> getVertexNonChainedOutputs(ClassLoader cl)

setTransitiveChainedTaskConfigs

public void setTransitiveChainedTaskConfigs(Map<Integer,StreamConfig> chainedTaskConfigs)

getTransitiveChainedTaskConfigs

public Map<Integer,StreamConfig> getTransitiveChainedTaskConfigs(ClassLoader cl)

getTransitiveChainedTaskConfigsWithSelf

public Map<Integer,StreamConfig> getTransitiveChainedTaskConfigsWithSelf(ClassLoader cl)

setOperatorID

public void setOperatorID(OperatorID operatorID)

getOperatorID
```
public OperatorID getOperatorID()
```

setOperatorName

public void setOperatorName(String name)

getOperatorName
```
public String getOperatorName()
```

setChainIndex
```
public void setChainIndex(int index)
```

getChainIndex
```
public int getChainIndex()
```

setStateBackend

public void setStateBackend(StateBackend backend)

setChangelogStateBackendEnabled

public void setChangelogStateBackendEnabled(TernaryBoolean enabled)

setStateBackendUsesManagedMemory

@VisibleForTesting
public void setStateBackendUsesManagedMemory(boolean usesManagedMemory)

getStateBackend

public StateBackend getStateBackend(ClassLoader cl)

isChangelogStateBackendEnabled

public TernaryBoolean isChangelogStateBackendEnabled(ClassLoader cl)

setSavepointDir

public void setSavepointDir(Path directory)

getSavepointDir

public Path getSavepointDir(ClassLoader cl)

setCheckpointStorage

public void setCheckpointStorage(CheckpointStorage storage)

getCheckpointStorage

public CheckpointStorage getCheckpointStorage(ClassLoader cl)

setTimerServiceProvider

public void setTimerServiceProvider(InternalTimeServiceManager.Provider timerServiceProvider)

getTimerServiceProvider

public InternalTimeServiceManager.Provider getTimerServiceProvider(ClassLoader cl)

setStatePartitioner

public void setStatePartitioner(int input,
                                KeySelector<?,?> partitioner)

getStatePartitioner

public <IN,K extends Serializable> KeySelector<IN,K> getStatePartitioner(int input,
                                                                         ClassLoader cl)

setStateKeySerializer

public void setStateKeySerializer(TypeSerializer<?> serializer)

getStateKeySerializer

public <K> TypeSerializer<K> getStateKeySerializer(ClassLoader cl)

setChainStart
```
public void setChainStart()
```

isChainStart
```
public boolean isChainStart()
```

setChainEnd
```
public void setChainEnd()
```

isChainEnd
```
public boolean isChainEnd()
```

toString
```
public String toString()
```
Overrides:

toString in class Object

setGraphContainingLoops

public void setGraphContainingLoops(boolean graphContainingLoops)

isGraphContainingLoops

public boolean isGraphContainingLoops()

requiresSorting

public static boolean requiresSorting(StreamConfig.InputConfig inputConfig)

Back to Flink Website

Class StreamConfig