org.springframework.batch.core.job.flow.Flow Java Examples

private Flow processSplitNode(Deque<LabelledTaskNode> visitorDeque, SplitNode splitNode) {
	Deque<Flow> flows = new LinkedList<>();
	//For each node in the split process it as a DSL flow.
	for (LabelledTaskNode taskNode : splitNode.getSeries()) {
		Deque<Flow> resultFlowDeque = new LinkedList<>();
		flows.addAll(processSplitFlow(taskNode, resultFlowDeque));
	}
	removeProcessedNodes(visitorDeque, splitNode);
	Flow nestedSplitFlow = new FlowBuilder.SplitBuilder<>(
			new FlowBuilder<Flow>("Split" + UUID.randomUUID().toString()),
			taskExecutor)
			.add(flows.toArray(new Flow[flows.size()]))
			.build();
	FlowBuilder<Flow> taskAppFlowBuilder =
			new FlowBuilder<>("Flow" + UUID.randomUUID().toString());
	if (this.hasNestedSplit) {
		this.splitFlows = flows.size();
		int threadCorePoolSize = this.composedTaskProperties.getSplitThreadCorePoolSize();
		Assert.isTrue(threadCorePoolSize >= this.splitFlows,
				"Split thread core pool size " + threadCorePoolSize + " should be equal or greater "
						+ "than the depth of split flows " + (this.splitFlows +1) + "."
						+ " Try setting the composed task property `splitThreadCorePoolSize`");
	}
	return taskAppFlowBuilder.start(nestedSplitFlow).end();
}
 

private Flow processSplitNode(Deque<LabelledTaskNode> visitorDeque, SplitNode splitNode) {
	Deque<Flow> flows = new LinkedList<>();
	//For each node in the split process it as a DSL flow.
	for (LabelledTaskNode taskNode : splitNode.getSeries()) {
		Deque<Flow> resultFlowDeque = new LinkedList<>();
		flows.addAll(processSplitFlow(taskNode, resultFlowDeque));
	}
	removeProcessedNodes(visitorDeque, splitNode);
	Flow nestedSplitFlow = new FlowBuilder.SplitBuilder<>(
			new FlowBuilder<Flow>("Split" + UUID.randomUUID().toString()),
			taskExecutor)
			.add(flows.toArray(new Flow[flows.size()]))
			.build();
	FlowBuilder<Flow> taskAppFlowBuilder =
			new FlowBuilder<>("Flow" + UUID.randomUUID().toString());
	if (this.hasNestedSplit) {
		this.splitFlows = flows.size();
		int threadCorePoolSize = this.composedTaskProperties.getSplitThreadCorePoolSize();
		Assert.isTrue(threadCorePoolSize >= this.splitFlows,
				"Split thread core pool size " + threadCorePoolSize + " should be equal or greater "
						+ "than the depth of split flows " + (this.splitFlows +1) + "."
						+ " Try setting the composed task property `splitThreadCorePoolSize`");
	}
	return taskAppFlowBuilder.start(nestedSplitFlow).end();
}
 

private Flow postReleaseFlow(TasksToRun tasksToRun, ReleaserProperties properties,
		ProjectsToRun projectsToRun) {
	Iterator<? extends ReleaserTask> iterator = tasksToRun.iterator();
	if (!iterator.hasNext()) {
		return null;
	}
	ReleaserTask task = iterator.next();
	Flow flow = flow(properties, projectsToRun, task);
	FlowBuilder<Flow> flowBuilder = new FlowBuilder<Flow>(
			"parallelPostRelease_" + System.currentTimeMillis()).start(flow);
	if (!iterator.hasNext()) {
		return flowBuilder.build();
	}
	FlowBuilder.SplitBuilder<Flow> builder = flowBuilder.split(taskExecutor());
	List<Flow> flows = new LinkedList<>();
	while (iterator.hasNext()) {
		flows.add(flow(properties, projectsToRun, iterator.next()));
	}
	Flow[] objects = flows.toArray(new Flow[0]);
	return builder.add(objects).build();
}
 

private Flow createFlow() {

		while (!this.visitorDeque.isEmpty()) {

			if (this.visitorDeque.peek() instanceof TaskAppNode) {
				TaskAppNode taskAppNode = (TaskAppNode) this.visitorDeque.pop();

				if (taskAppNode.hasTransitions()) {
					handleTransition(this.executionDeque, taskAppNode);
				}
				else {
					this.executionDeque.push(getTaskAppFlow(taskAppNode));
				}
			}
			//When end marker of a split is found, process the split
			else if (this.visitorDeque.peek() instanceof SplitNode) {
				Deque<LabelledTaskNode> splitNodeDeque = new LinkedList<>();
				SplitNode splitNode = (SplitNode) this.visitorDeque.pop();
				splitNodeDeque.push(splitNode);
				while (!this.visitorDeque.isEmpty() && !this.visitorDeque.peek().equals(splitNode)) {
					splitNodeDeque.push(this.visitorDeque.pop());
				}
				splitNodeDeque.push(this.visitorDeque.pop());
				handleSplit(splitNodeDeque, splitNode);
			}
			//When start marker of a DSL flow is found, process it.
			else if (this.visitorDeque.peek() instanceof FlowNode) {
				handleFlow(this.executionDeque);
			}
		}

		return this.jobDeque.pop();
	}
 

private void handleTransition(Deque<Flow> resultFlowDeque,
		TaskAppNode taskAppNode) {
	String beanName = getBeanName(taskAppNode);
	Step currentStep = this.context.getBean(beanName, Step.class);
	FlowBuilder<Flow> builder = new FlowBuilder<Flow>(beanName)
			.from(currentStep);

	boolean wildCardPresent = false;

	for (TransitionNode transitionNode : taskAppNode.getTransitions()) {
		String transitionBeanName = getBeanName(transitionNode);

		wildCardPresent = transitionNode.getStatusToCheck().equals(WILD_CARD);

		Step transitionStep = this.context.getBean(transitionBeanName,
				Step.class);
		builder.on(transitionNode.getStatusToCheck()).to(transitionStep)
				.from(currentStep);
	}

	if (wildCardPresent && !resultFlowDeque.isEmpty()) {
		throw new IllegalStateException(
				"Invalid flow following '*' specifier.");
	}
	else {
		//if there are nodes are in the execution Deque.  Make sure that
		//they are processed as a target of the wildcard instead of the
		//whole transition.
		if (!resultFlowDeque.isEmpty()) {
			builder.on(WILD_CARD).to(handleFlowForSegment(resultFlowDeque)).from(currentStep);
		}
	}

	resultFlowDeque.push(builder.end());
}
 

private Flow createFlow() {

		while (!this.visitorDeque.isEmpty()) {

			if (this.visitorDeque.peek() instanceof TaskAppNode) {
				TaskAppNode taskAppNode = (TaskAppNode) this.visitorDeque.pop();

				if (taskAppNode.hasTransitions()) {
					handleTransition(this.executionDeque, taskAppNode);
				}
				else {
					this.executionDeque.push(getTaskAppFlow(taskAppNode));
				}
			}
			//When end marker of a split is found, process the split
			else if (this.visitorDeque.peek() instanceof SplitNode) {
				Deque<LabelledTaskNode> splitNodeDeque = new LinkedList<>();
				SplitNode splitNode = (SplitNode) this.visitorDeque.pop();
				splitNodeDeque.push(splitNode);
				while (!this.visitorDeque.isEmpty() && !this.visitorDeque.peek().equals(splitNode)) {
					splitNodeDeque.push(this.visitorDeque.pop());
				}
				splitNodeDeque.push(this.visitorDeque.pop());
				handleSplit(splitNodeDeque, splitNode);
			}
			//When start marker of a DSL flow is found, process it.
			else if (this.visitorDeque.peek() instanceof FlowNode) {
				handleFlow(this.executionDeque);
			}
		}

		return this.jobDeque.pop();
	}
 

private void handleFlow(Deque<Flow> executionDeque) {
	if(!executionDeque.isEmpty()) {
		this.flowBuilder.start(executionDeque.pop());
	}

	while (!executionDeque.isEmpty()) {
			this.flowBuilder.next(executionDeque.pop());
	}

	this.visitorDeque.pop();
	this.jobDeque.push(this.flowBuilder.end());
}
 

private Flow handleFlowForSegment(Deque<Flow> resultFlowDeque) {
	FlowBuilder<Flow> localTaskAppFlowBuilder =
			new FlowBuilder<>("Flow" + UUID.randomUUID().toString());

	if(!resultFlowDeque.isEmpty()) {
		localTaskAppFlowBuilder.start(resultFlowDeque.pop());

	}

	while (!resultFlowDeque.isEmpty()) {
		localTaskAppFlowBuilder.next(resultFlowDeque.pop());
	}

	return localTaskAppFlowBuilder.end();
}
 

private Flow handleFlowForSegment(Deque<Flow> resultFlowDeque) {
	FlowBuilder<Flow> localTaskAppFlowBuilder =
			new FlowBuilder<>("Flow" + UUID.randomUUID().toString());

	if(!resultFlowDeque.isEmpty()) {
		localTaskAppFlowBuilder.start(resultFlowDeque.pop());

	}

	while (!resultFlowDeque.isEmpty()) {
		localTaskAppFlowBuilder.next(resultFlowDeque.pop());
	}

	return localTaskAppFlowBuilder.end();
}
 

private void handleTransition(Deque<Flow> resultFlowDeque,
		TaskAppNode taskAppNode) {
	String beanName = getBeanName(taskAppNode);
	Step currentStep = this.context.getBean(beanName, Step.class);
	FlowBuilder<Flow> builder = new FlowBuilder<Flow>(beanName)
			.from(currentStep);

	boolean wildCardPresent = false;

	for (TransitionNode transitionNode : taskAppNode.getTransitions()) {
		String transitionBeanName = getBeanName(transitionNode);

		wildCardPresent = transitionNode.getStatusToCheck().equals(WILD_CARD);

		Step transitionStep = this.context.getBean(transitionBeanName,
				Step.class);
		builder.on(transitionNode.getStatusToCheck()).to(transitionStep)
				.from(currentStep);
	}

	if (wildCardPresent && !resultFlowDeque.isEmpty()) {
		throw new IllegalStateException(
				"Invalid flow following '*' specifier.");
	}
	else {
		//if there are nodes are in the execution Deque.  Make sure that
		//they are processed as a target of the wildcard instead of the
		//whole transition.
		if (!resultFlowDeque.isEmpty()) {
			builder.on(WILD_CARD).to(handleFlowForSegment(resultFlowDeque)).from(currentStep);
		}
	}

	resultFlowDeque.push(builder.end());
}
 

private void handleFlow(Deque<Flow> executionDeque) {
	if(!executionDeque.isEmpty()) {
		this.flowBuilder.start(executionDeque.pop());
	}

	while (!executionDeque.isEmpty()) {
			this.flowBuilder.next(executionDeque.pop());
	}

	this.visitorDeque.pop();
	this.jobDeque.push(this.flowBuilder.end());
}
 

private Flow splitFlow(){
    Flow flow04 = new FlowBuilder<SimpleFlow>("flow04").start(step0004).build();
    Flow flow05 = new FlowBuilder<SimpleFlow>("flow05").start(step0005).build();
    Flow flow06 = new FlowBuilder<SimpleFlow>("flow06").start(step0006).build();
    return new FlowBuilder<SimpleFlow>("splitFlow")
            .split(new SimpleAsyncTaskExecutor("springbatch_seedboot"))
            .add(flow04, flow05, flow06)
            .build();
}
 

@Override
public ExecutionResult runPostReleaseTrainTasks(Options options,
		ReleaserProperties properties, String taskName, TasksToRun tasksToRun) {
	ProjectsToRun projectsToRun = postReleaseTrainProjects(
			new OptionsAndProperties(properties, options));
	Flow flow = postReleaseFlow(tasksToRun, properties, projectsToRun);
	String name = taskName + "_" + System.currentTimeMillis();
	if (flow == null) {
		log.info("No release train post release tasks to run, will do nothing");
		return ExecutionResult.success();
	}
	Job job = this.jobBuilderFactory.get(name).start(flow).build().build();
	return runJob(job);
}
 

private Flow toFlowOfTasks(TasksToRun tasksToRun, NamedArgumentsSupplier args,
		FlowBuilder<Flow> flowBuilder) {
	Iterator<? extends ReleaserTask> iterator = tasksToRun.iterator();
	ReleaserTask task = iterator.next();
	flowBuilder.start(createStep(task, args));
	while (iterator.hasNext()) {
		flowBuilder.next(createStep(iterator.next(), args));
	}
	return flowBuilder.build();
}
 

private Flow flow(ReleaserProperties properties, ProjectsToRun projectsToRun,
		ReleaserTask task) {
	return new FlowBuilder<Flow>(task.name() + "Flow")
			.start(createStep(task, new NamedArgumentsSupplier("postRelease",
					() -> Arguments.forPostRelease(properties, projectsToRun))))
			.build();
}
 

/**
 * Processes each node in split as a  DSL Flow.
 * @param node represents a single node in the split.
 * @return Deque of Job Flows that was obtained from the Node.
 */
private Deque<Flow> processSplitFlow(LabelledTaskNode node, Deque<Flow> resultFlowDeque) {
	TaskParser taskParser = new TaskParser("split_flow" + UUID.randomUUID().toString(), node.stringify(),
			false, true);
	ComposedRunnerVisitor splitElementVisitor = new ComposedRunnerVisitor();
	taskParser.parse().accept(splitElementVisitor);

	Deque splitElementDeque = splitElementVisitor.getFlow();
	Deque<Flow> elementFlowDeque = new LinkedList<>();

	while (!splitElementDeque.isEmpty()) {

		if (splitElementDeque.peek() instanceof TaskAppNode) {

			TaskAppNode taskAppNode = (TaskAppNode) splitElementDeque.pop();

			if (taskAppNode.hasTransitions()) {
				handleTransition(elementFlowDeque, taskAppNode);
			}
			else {
				elementFlowDeque.push(
						getTaskAppFlow(taskAppNode));
			}
		}
		else if (splitElementDeque.peek() instanceof FlowNode) {
			resultFlowDeque.push(handleFlowForSegment(elementFlowDeque));
			splitElementDeque.pop();
		}
		else if (splitElementDeque.peek() instanceof SplitNode) {
			this.hasNestedSplit = true;
			Deque splitNodeDeque = new LinkedList<>();
			SplitNode splitNode = (SplitNode) splitElementDeque.pop();
			splitNodeDeque.push(splitNode);
			while (!splitElementDeque.isEmpty() && !splitElementDeque.peek().equals(splitNode)) {
				splitNodeDeque.push(splitElementDeque.pop());
			}
			splitNodeDeque.push(splitElementDeque.pop());
			elementFlowDeque.push(processSplitNode(splitNodeDeque, splitNode));
		}
	}
	return resultFlowDeque;
}
 

private Flow getTaskAppFlow(TaskAppNode taskApp) {
	String beanName = getBeanName(taskApp);
	Step currentStep = this.context.getBean(beanName, Step.class);

	return new FlowBuilder<Flow>(beanName).from(currentStep).end();
}
 

private Flow flow() {
    return new FlowBuilder<Flow>("flow")
            .start(step1())
            .next(step2())
            .build();
}
 

StuffToRun(ReleaseGroup releaseGroup, Flow flow) {
	this.releaseGroup = releaseGroup;
	this.flow = flow;
	this.task = null;
}
 

private FlowBuilder<Flow> flowBuilder(String projectName) {
	return new FlowBuilder<>(projectName + "_Flow_" + System.currentTimeMillis());
}
 

private Flow getTaskAppFlow(TaskAppNode taskApp) {
	String beanName = getBeanName(taskApp);
	Step currentStep = this.context.getBean(beanName, Step.class);

	return new FlowBuilder<Flow>(beanName).from(currentStep).end();
}
 

/**
 * Processes each node in split as a  DSL Flow.
 * @param node represents a single node in the split.
 * @return Deque of Job Flows that was obtained from the Node.
 */
private Deque<Flow> processSplitFlow(LabelledTaskNode node, Deque<Flow> resultFlowDeque) {
	TaskParser taskParser = new TaskParser("split_flow" + UUID.randomUUID().toString(), node.stringify(),
			false, true);
	ComposedRunnerVisitor splitElementVisitor = new ComposedRunnerVisitor();
	taskParser.parse().accept(splitElementVisitor);

	Deque splitElementDeque = splitElementVisitor.getFlow();
	Deque<Flow> elementFlowDeque = new LinkedList<>();

	while (!splitElementDeque.isEmpty()) {

		if (splitElementDeque.peek() instanceof TaskAppNode) {

			TaskAppNode taskAppNode = (TaskAppNode) splitElementDeque.pop();

			if (taskAppNode.hasTransitions()) {
				handleTransition(elementFlowDeque, taskAppNode);
			}
			else {
				elementFlowDeque.push(
						getTaskAppFlow(taskAppNode));
			}
		}
		else if (splitElementDeque.peek() instanceof FlowNode) {
			resultFlowDeque.push(handleFlowForSegment(elementFlowDeque));
			splitElementDeque.pop();
		}
		else if (splitElementDeque.peek() instanceof SplitNode) {
			this.hasNestedSplit = true;
			Deque splitNodeDeque = new LinkedList<>();
			SplitNode splitNode = (SplitNode) splitElementDeque.pop();
			splitNodeDeque.push(splitNode);
			while (!splitElementDeque.isEmpty() && !splitElementDeque.peek().equals(splitNode)) {
				splitNodeDeque.push(splitElementDeque.pop());
			}
			splitNodeDeque.push(splitElementDeque.pop());
			elementFlowDeque.push(processSplitNode(splitNodeDeque, splitNode));
		}
	}
	return resultFlowDeque;
}
 

private Flow flow2() {
    return new FlowBuilder<Flow>("flow2")
            .start(step3())
            .build();
}
 

private Flow flow1() {
    return new FlowBuilder<Flow>("flow1")
            .start(step1())
            .next(step2())
            .build();
}