use of com.cloudbees.groovy.cps.Continuable in project workflow-cps-plugin by jenkinsci.
the class CpsFlowExecution method start.
@Override
public void start() throws IOException {
final CpsScript s = parseScript();
scriptClass = s.getClass();
s.$initialize();
final FlowHead h = new FlowHead(this);
synchronized (this) {
heads.put(h.getId(), h);
}
h.newStartNode(new FlowStartNode(this, iotaStr()));
final CpsThreadGroup g = new CpsThreadGroup(this);
g.register(s);
final SettableFuture<CpsThreadGroup> f = SettableFuture.create();
programPromise = f;
// Ensures we've saves the WorkFlowRun at least once with initial state
saveOwner();
g.runner.submit(new Runnable() {
@Override
public void run() {
CpsThread t = g.addThread(new Continuable(s, createInitialEnv()), h, null);
t.resume(new Outcome(null, null));
f.set(g);
}
/**
* Environment to start executing the script in.
* During sandbox execution, we need to call sandbox interceptor while executing asynchronous code.
*/
private Env createInitialEnv() {
return Envs.empty(isSandbox() ? new SandboxInvoker() : new DefaultInvoker());
}
});
}
use of com.cloudbees.groovy.cps.Continuable in project workflow-cps-plugin by jenkinsci.
the class CpsBodyExecution method createContinuable.
/**
* Creates {@link Continuable} that executes the given invocation and pass its result to {@link FutureCallback}.
*
* The {@link Continuable} itself will just yield null. {@link CpsThreadGroup} considers the whole
* execution a failure if any of the threads fail, so this behaviour ensures that a problem in the closure
* body won't terminate the workflow.
*/
private Continuable createContinuable(CpsThread currentThread, CpsCallableInvocation inv) {
// we need FunctionCallEnv that acts as the back drop of try/catch block.
// TODO: we need to capture the surrounding calling context to capture variables, and switch to ClosureCallEnv
FunctionCallEnv caller = new FunctionCallEnv(null, onSuccess, null, null);
if (currentThread.getExecution().isSandbox())
caller.setInvoker(new SandboxInvoker());
// catch an exception thrown from body and treat that as a failure
TryBlockEnv env = new TryBlockEnv(caller, null);
env.addHandler(Throwable.class, onFailure);
return new Continuable(// perhaps at some point in the future we'll let the Step implementation control this.
inv.invoke(env, null, onSuccess));
}
use of com.cloudbees.groovy.cps.Continuable in project workflow-cps-plugin by jenkinsci.
the class CpsFlowExecution method loadProgramFailed.
/**
* Used by {@link #loadProgramAsync(File)} to propagate a failure to load the persisted execution state.
* <p>
* Let the workflow interrupt by throwing an exception that indicates how it failed.
* @param promise same as {@link #programPromise} but more strongly typed
*/
private void loadProgramFailed(final Throwable problem, SettableFuture<CpsThreadGroup> promise) {
FlowHead head;
synchronized (this) {
if (heads == null || heads.isEmpty()) {
head = null;
} else {
head = getFirstHead();
}
}
if (head == null) {
// something went catastrophically wrong and there's no live head. fake one
head = new FlowHead(this);
try {
head.newStartNode(new FlowStartNode(this, iotaStr()));
} catch (IOException e) {
LOGGER.log(Level.FINE, "Failed to persist", e);
}
}
CpsThreadGroup g = new CpsThreadGroup(this);
final FlowHead head_ = head;
promise.set(g);
runInCpsVmThread(new FutureCallback<CpsThreadGroup>() {
@Override
public void onSuccess(CpsThreadGroup g) {
CpsThread t = g.addThread(new Continuable(new ThrowBlock(new ConstantBlock(problem instanceof AbortException ? problem : new IOException("Failed to load build state", problem)))), head_, null);
t.resume(new Outcome(null, null));
}
@Override
public void onFailure(Throwable t) {
LOGGER.log(Level.WARNING, "Failed to set program failure on " + owner, t);
croak(t);
}
});
}
Aggregations