Best Java code snippets using org.apache.flink.runtime.jobgraph.JobVertex.<init> (Showing top 20 results out of 315)

private static JobGraph getWorkingJobGraph() {
  final JobVertex jobVertex = new JobVertex("Working job vertex.");
  jobVertex.setInvokableClass(NoOpInvokable.class);
  return new JobGraph("Working testing job", jobVertex);
}

  taskConfig.setStubWrapper(new UserCodeObjectWrapper<Object>(streamNode.getInputFormat()));
} else {
  jobVertex = new JobVertex(
      chainedNames.get(streamNodeId),
      jobVertexId,
jobVertex.setInvokableClass(streamNode.getJobVertexClass());

final JobID jobID = new JobID();
final JobVertex imalock = new JobVertex("imalock");
imalock.setInvokableClass(SemaphoreInvokable.class);

@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;
}

headVertex.setInvokableClass(IterationHeadTask.class);
headConfig = new TaskConfig(headVertex.getConfiguration());
toReturn = null;
headVertex = new JobVertex("PartialSolution ("+iteration.getNodeName()+")");
headVertex.setResources(iteration.getMinResources(), iteration.getPreferredResources());
headVertex.setInvokableClass(IterationHeadTask.class);
headConfig = new TaskConfig(headVertex.getConfiguration());
headConfig.setDriver(NoOpDriver.class);

headVertex.setInvokableClass(IterationHeadTask.class);
headConfig = new TaskConfig(headVertex.getConfiguration());
toReturn = null;
headVertex = new JobVertex("IterationHead("+iteration.getNodeName()+")");
headVertex.setResources(iteration.getMinResources(), iteration.getPreferredResources());
headVertex.setInvokableClass(IterationHeadTask.class);
headConfig = new TaskConfig(headVertex.getConfiguration());
headConfig.setDriver(NoOpDriver.class);

SlotSharingGroup sharingGroup = new SlotSharingGroup();
JobVertex producer = new JobVertex("Speed Test Producer");
jobGraph.addVertex(producer);
producer.setSlotSharingGroup(sharingGroup);
producer.setInvokableClass(SpeedTestProducer.class);
producer.setParallelism(numSubtasks);
producer.getConfiguration().setInteger(DATA_VOLUME_GB_CONFIG_KEY, dataVolumeGb);
  forwarder = new JobVertex("Speed Test Forwarder");
  jobGraph.addVertex(forwarder);
  forwarder.setSlotSharingGroup(sharingGroup);
  forwarder.setInvokableClass(SpeedTestForwarder.class);
  forwarder.setParallelism(numSubtasks);
JobVertex consumer = new JobVertex("Speed Test Consumer");
jobGraph.addVertex(consumer);
consumer.setSlotSharingGroup(sharingGroup);
consumer.setInvokableClass(SpeedTestConsumer.class);
consumer.setParallelism(numSubtasks);
consumer.getConfiguration().setBoolean(IS_SLOW_RECEIVER_CONFIG_KEY, isSlowReceiver);

} else {
  vertex = new JobVertex(taskName);
  vertex.setResources(node.getMinResources(), node.getPreferredResources());
  vertex.setInvokableClass((this.currentIteration != null && node.isOnDynamicPath()) ? IterationIntermediateTask.class : BatchTask.class);

final JobVertex sender = new JobVertex("Sender");
sender.setParallelism(2);
sender.setInvokableClass(BlockingInvokable.class);

final JobVertex sync = new JobVertex("Sync (" + bulkNode.getNodeName() + ")");
sync.setResources(bulkNode.getMinResources(), bulkNode.getPreferredResources());
sync.setInvokableClass(IterationSynchronizationSinkTask.class);
sync.setParallelism(1);
sync.setMaxParallelism(1);
  rootOfStepFunctionVertex.setInvokableClass(IterationTailTask.class);
  rootOfTerminationCriterionVertex.setInvokableClass(IterationTailTask.class);

final ClusterClient<?> client = cluster.getClusterClient();
final JobVertex vertex = new JobVertex("Blocking vertex");
vertex.setInvokableClass(BlockingNoOpInvokable.class);
vertex.setParallelism(1);

private JobVertex createDualInputVertex(DualInputPlanNode node) throws CompilerException {
  final String taskName = node.getNodeName();
  final DriverStrategy ds = node.getDriverStrategy();
  final JobVertex vertex = new JobVertex(taskName);
  final TaskConfig config = new TaskConfig(vertex.getConfiguration());
  vertex.setResources(node.getMinResources(), node.getPreferredResources());
  vertex.setInvokableClass( (this.currentIteration != null && node.isOnDynamicPath()) ? IterationIntermediateTask.class : BatchTask.class);
  
  // set user code
  config.setStubWrapper(node.getProgramOperator().getUserCodeWrapper());
  config.setStubParameters(node.getProgramOperator().getParameters());
  
  // set the driver strategy
  config.setDriver(ds.getDriverClass());
  config.setDriverStrategy(ds);
  if (node.getComparator1() != null) {
    config.setDriverComparator(node.getComparator1(), 0);
  }
  if (node.getComparator2() != null) {
    config.setDriverComparator(node.getComparator2(), 1);
  }
  if (node.getPairComparator() != null) {
    config.setDriverPairComparator(node.getPairComparator());
  }
  
  // assign memory, file-handles, etc.
  assignDriverResources(node, config);
  return vertex;
}

JobVertex sender = new JobVertex("sender");
JobVertex receiver = new JobVertex("receiver");
sender.setInvokableClass(Tasks.Sender.class);
receiver.setInvokableClass(Tasks.BlockingOnceReceiver.class);

final JobVertex sender = new JobVertex("Sender");
sender.setParallelism(2);
sender.setInvokableClass(BlockingInvokable.class);

final JobVertex sync = new JobVertex("Sync (" + iterNode.getNodeName() + ")");
sync.setResources(iterNode.getMinResources(), iterNode.getPreferredResources());
sync.setInvokableClass(IterationSynchronizationSinkTask.class);
sync.setParallelism(1);
sync.setMaxParallelism(1);
    nextWorksetVertex.setInvokableClass(IterationTailTask.class);
    solutionDeltaVertex.setInvokableClass(IterationTailTask.class);

JobVertex blockingVertex = new JobVertex("Blocking vertex");
blockingVertex.setInvokableClass(BlockingNoOpInvokable.class);
JobGraph jobGraph = new JobGraph(blockingVertex);

 static JobGraph trivialJobGraph() {
  JobGraph g = new JobGraph();
  JobVertex v = new JobVertex("1");
  v.setInvokableClass(DummyInvokable.class);
  g.addVertex(v);
  return g;
 }
}

  taskConfig.setStubWrapper(new UserCodeObjectWrapper<Object>(streamNode.getInputFormat()));
} else {
  jobVertex = new JobVertex(
      chainedNames.get(streamNodeId),
      jobVertexId,
jobVertex.setInvokableClass(streamNode.getJobVertexClass());

  taskConfig.setStubWrapper(new UserCodeObjectWrapper<Object>(streamNode.getInputFormat()));
} else {
  jobVertex = new JobVertex(
      chainedNames.get(streamNodeId),
      jobVertexId,
jobVertex.setInvokableClass(streamNode.getJobVertexClass());

  taskConfig.setStubWrapper(new UserCodeObjectWrapper<Object>(streamNode.getInputFormat()));
} else {
  jobVertex = new JobVertex(
      chainedNames.get(streamNodeId),
      jobVertexId,
jobVertex.setInvokableClass(streamNode.getJobVertexClass());