How to use

setRestartStrategy

method

in

org.apache.flink.api.common.ExecutionConfig

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

public static StreamExecutionEnvironment prepareExecutionEnv(ParameterTool parameterTool)
  throws Exception {
  if (parameterTool.getNumberOfParameters() < 5) {
    System.out.println("Missing parameters!\n" +
      "Usage: Kafka --input-topic <topic> --output-topic <topic> " +
      "--bootstrap.servers <kafka brokers> " +
      "--zookeeper.connect <zk quorum> --group.id <some id>");
    throw new Exception("Missing parameters!\n" +
      "Usage: Kafka --input-topic <topic> --output-topic <topic> " +
      "--bootstrap.servers <kafka brokers> " +
      "--zookeeper.connect <zk quorum> --group.id <some id>");
  }
  StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  env.getConfig().disableSysoutLogging();
  env.getConfig().setRestartStrategy(RestartStrategies.fixedDelayRestart(4, 10000));
  env.enableCheckpointing(5000); // create a checkpoint every 5 seconds
  env.getConfig().setGlobalJobParameters(parameterTool); // make parameters available in the web interface
  env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
  return env;
}

env1.getConfig().setRestartStrategy(RestartStrategies.noRestart());
env1.getConfig().disableSysoutLogging();

/**
 * Test that ensures that DeserializationSchema.isEndOfStream() is properly evaluated.
 *
 * @throws Exception
 */
public void runEndOfStreamTest() throws Exception {
  final int elementCount = 300;
  final String topic = writeSequence("testEndOfStream", elementCount, 1, 1);
  // read using custom schema
  final StreamExecutionEnvironment env1 = StreamExecutionEnvironment.getExecutionEnvironment();
  env1.setParallelism(1);
  env1.getConfig().setRestartStrategy(RestartStrategies.noRestart());
  env1.getConfig().disableSysoutLogging();
  Properties props = new Properties();
  props.putAll(standardProps);
  props.putAll(secureProps);
  DataStream<Tuple2<Integer, Integer>> fromKafka = env1.addSource(kafkaServer.getConsumer(topic, new FixedNumberDeserializationSchema(elementCount), props));
  fromKafka.flatMap(new FlatMapFunction<Tuple2<Integer, Integer>, Void>() {
    @Override
    public void flatMap(Tuple2<Integer, Integer> value, Collector<Void> out) throws Exception {
      // noop ;)
    }
  });
  tryExecute(env1, "Consume " + elementCount + " elements from Kafka");
  deleteTestTopic(topic);
}

writeEnv.getConfig().setRestartStrategy(RestartStrategies.noRestart());
writeEnv.getConfig().disableSysoutLogging();

env.getConfig().setRestartStrategy(RestartStrategies.noRestart());
env.getConfig().disableSysoutLogging();
env.getConfig().setRestartStrategy(RestartStrategies.noRestart());
env.getConfig().disableSysoutLogging();

@Nonnull
private JobGraph createJobGraph(long delay, int parallelism) throws IOException {
  SlotSharingGroup slotSharingGroup = new SlotSharingGroup();
  final JobVertex source = new JobVertex("source");
  source.setInvokableClass(OneTimeFailingInvokable.class);
  source.setParallelism(parallelism);
  source.setSlotSharingGroup(slotSharingGroup);
  final JobVertex sink = new JobVertex("sink");
  sink.setInvokableClass(NoOpInvokable.class);
  sink.setParallelism(parallelism);
  sink.setSlotSharingGroup(slotSharingGroup);
  sink.connectNewDataSetAsInput(source, DistributionPattern.POINTWISE, ResultPartitionType.PIPELINED);
  JobGraph jobGraph = new JobGraph(source, sink);
  jobGraph.setScheduleMode(ScheduleMode.EAGER);
  ExecutionConfig executionConfig = new ExecutionConfig();
  executionConfig.setRestartStrategy(RestartStrategies.fixedDelayRestart(1, delay));
  jobGraph.setExecutionConfig(executionConfig);
  return jobGraph;
}

writeEnv.getConfig().setRestartStrategy(RestartStrategies.noRestart());
writeEnv.getConfig().disableSysoutLogging();

env.setParallelism(parallelism);
env.enableCheckpointing(1000);
env.getConfig().setRestartStrategy(RestartStrategies.fixedDelayRestart(210, 0));

see.setParallelism(1);
see.getConfig().setRestartStrategy(RestartStrategies.noRestart());
see.setStateBackend(new FailingStateBackend());

@Override
public void testProgram(StreamExecutionEnvironment env) {
  // set the restart strategy.
  env.getConfig().setRestartStrategy(RestartStrategies.fixedDelayRestart(NO_OF_RETRIES, 0));
  env.enableCheckpointing(10);
  // create and start the file creating thread.
  fc = new FileCreator();
  fc.start();
  // create the monitoring source along with the necessary readers.
  TextInputFormat format = new TextInputFormat(new org.apache.flink.core.fs.Path(localFsURI));
  format.setFilesFilter(FilePathFilter.createDefaultFilter());
  DataStream<String> inputStream = env.readFile(format, localFsURI,
    FileProcessingMode.PROCESS_CONTINUOUSLY, INTERVAL);
  TestingSinkFunction sink = new TestingSinkFunction();
  inputStream.flatMap(new FlatMapFunction<String, String>() {
    @Override
    public void flatMap(String value, Collector<String> out) throws Exception {
      out.collect(value);
    }
  }).addSink(sink).setParallelism(1);
}

/**
 * Creates a streaming JobGraph from the StreamEnvironment.
 */
private JobGraph createJobGraph(
  int parallelism,
  int numberOfRetries,
  long restartDelay) {
  StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  env.setParallelism(parallelism);
  env.disableOperatorChaining();
  env.getConfig().setRestartStrategy(RestartStrategies.fixedDelayRestart(numberOfRetries, restartDelay));
  env.getConfig().disableSysoutLogging();
  DataStream<Integer> stream = env
    .addSource(new InfiniteTestSource())
    .shuffle()
    .map(new StatefulCounter());
  stream.addSink(new DiscardingSink<>());
  return env.getStreamGraph().getJobGraph();
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}

/**
 * Sets the restart strategy configuration. The configuration specifies which restart strategy
 * will be used for the execution graph in case of a restart.
 *
 * @param restartStrategyConfiguration Restart strategy configuration to be set
 */
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration) {
  config.setRestartStrategy(restartStrategyConfiguration);
}