def run(self):
a = self.submit(increment, 3)
b = self.submit(increment, 3, __priority=5)
c = self.submit(increment, 3, __priority=None)
d = self.submit(increment_high_priority, 3)
e = self.submit(increment_high_priority, 3, __priority=30)
futures.wait(a, b, c, d, e)
def run(self):
x = 1
y = 2
z = 3
future = self.submit(
Chain(
Group(
(increment_slowly, x),
(increment_slowly, y),
(increment_slowly, z),
),
multiply,
send_result=True
)
)
futures.wait(future)
res = future.result[-1]
print('({}+1)*({}+1)*({}+1) = {}'.format(x, y, z, res))
# Canvas's and Group's can also be "optional"
future = self.submit(
Chain(
(fail_incrementing, x),
(increment_slowly, 1), # never executed
raises_on_failure=False,
)
)
futures.wait(future)
print('SUCCESS!')
def run(self):
a = self.submit(increment, 3)
b = self.submit(increment, 3, __priority=5)
c = self.submit(increment, 3, __priority=None)
d = self.submit(increment_high_priority, 3)
e = self.submit(increment_high_priority, 3, __priority=30)
futures.wait(a, b, c, d, e)
def run(self):
results = [self.submit(get_uuid) for _ in range(10)]
results.append(
self.submit(get_uuid, results[0].result) # Changed arguments, must submit
)
futures.wait(*results)
assert all(r.result == results[0].result for r in results[1:-1])
assert results[0].result != results[-1].result
def run(self):
all = [
self.submit(self.wait_signal("signal1")),
self.submit(func_a_1_2),
self.submit(self.signal("signal1")),
# self.submit(Signal('signal1')), # The other way; FIXME remove?
]
futures.wait(*all)
def run(self):
f = self.submit(ChildSignalsParentWorkflow)
futures.wait(f)
child_signal = self.submit(self.wait_signal("ChildReady"))
futures.wait(child_signal)
print("Parent: ended wait on ChildReady")
print(child_signal.result)
print("Parent: end")
def run(self):
all = [
self.submit(self.wait_signal('signal1')),
self.submit(func_a_1_2),
self.submit(self.signal('signal1')),
# self.submit(Signal('signal1')), # The other way; FIXME remove?
]
futures.wait(*all)
def run(self, *args, **kwargs):
print(colorize(GREEN, "NotFailingWorkflow args: {}".format(args)))
print(colorize(GREEN, "NotFailingWorkflow kwargs: {}".format(kwargs)))
g = Group(raises_on_failure=False)
g.append(FailingWorkflow)
g.append(timeout_no_raise)
f = self.submit(g)
futures.wait(f)
def run(self, x, t=30):
y = self.submit(increment, x)
yy = self.submit(Delay, t, y)
z = self.submit(double, y)
print('({x} + 1) * 2 = {result}'.format(x=x, result=z.result))
futures.wait(yy, z)
return z.result
def run(self, fail=True):
x = self.submit(fail_but_dont_raise)
if fail:
y = self.submit(fail_and_raise)
futures.wait(x, y)
raise ValueError("YOU SHOULD NEVER SEE THIS")
else:
futures.wait(x)
def run(self):
f = self.submit(ChildSignalsParentWorkflow)
futures.wait(f)
child_signal = self.submit(self.wait_signal('ChildReady'))
futures.wait(child_signal)
print('Parent: ended wait on ChildReady')
print(child_signal.result)
print('Parent: end')
def run(self):
results = [self.submit(get_uuid) for _ in range(10)]
results.append(
self.submit(get_uuid, results[0].result) # Changed arguments, must submit
)
futures.wait(*results)
assert all(r.result == results[0].result for r in results[1:-1])
assert results[0].result != results[-1].result
def run(self, fail=True):
x = self.submit(fail_but_dont_raise)
if fail:
y = self.submit(fail_and_raise)
futures.wait(x, y)
raise ValueError("YOU SHOULD NEVER SEE THIS")
else:
futures.wait(x)
def run(self, num, force_steps=[]):
self.add_forced_steps(force_steps, "workflow_init")
taskf = self.submit(
Step('my_step',
task.ActivityTask(MyTask, num),
force_steps_if_executed=['my_step_2']))
futures.wait(taskf)
def run(self, *args, **kwargs):
print(colorize(GREEN, "NotFailingWorkflow args: {}".format(args)))
print(colorize(GREEN, "NotFailingWorkflow kwargs: {}".format(kwargs)))
g = Group(raises_on_failure=False)
g.append(FailingWorkflow)
g.append(timeout_no_raise)
f = self.submit(g)
futures.wait(f)
def run(self):
results = []
results.append(self.submit(increment, 0))
results.append(self.submit(increment, 0))
results.append(self.submit(triple, 1))
results.append(self.submit(triple, 2))
results.append(self.submit(triple, 2))
results.append(self.submit(Tetra, 1))
futures.wait(*results)
def run(self, num, force_steps=None, skip_steps=None):
self.add_forced_steps(force_steps or [], "workflow_init")
self.add_skipped_steps(skip_steps or [], "workflow_init")
taskf = self.submit(
Step('my_step',
task.ActivityTask(MyTask, num),
force_steps_if_executed=['my_step_2']))
futures.wait(taskf)
def run(self):
results = []
results.append(self.submit(increment, 0))
results.append(self.submit(increment, 0))
results.append(self.submit(triple, 1))
results.append(self.submit(triple, 2))
results.append(self.submit(triple, 2))
results.append(self.submit(Tetra, 1))
futures.wait(*results)
def run(self, x, t=30):
y = self.submit(increment, x)
yy = self.submit(delay, t, y)
z = self.submit(double, y)
print '({x} + 1) * 2 = {result}'.format(
x=x,
result=z.result)
futures.wait(yy, z)
return z.result
def run(self):
all = [
self.submit(ChildWorkUntilSignalWorkflow),
self.submit(
Chain(
ActivityTask(func_a_1_2),
self.signal('signal1'),
)),
]
futures.wait(*all)
def run(self, x, t=30):
execution = self.get_execution_context()
print('DEBUG: execution context: {}'.format(execution))
y = self.submit(increment, x)
yy = self.submit(Delay, t, y)
z = self.submit(double, y)
print('({x} + 1) * 2 = {result}'.format(x=x, result=z.result))
futures.wait(yy, z)
return z.result
def run(self, x=5):
future = self.submit(
Chain(ActivityTask(increment, x),
ActivityTask(double),
send_result=True))
print("Future: {}".format(future))
futures.wait(future)
print("Result: {}".format(future.result)) # future.result == [6, 12]
return future.result
def run(self, x, t=30):
execution = self.get_run_context()
logger.warning("execution context from decider: {}".format(execution))
y = self.submit(increment, x)
yy = self.submit(Delay, t, y)
z = self.submit(double, y)
logger.warning("result of ({x} + 1) * 2 = {result}".format(
x=x, result=z.result))
futures.wait(yy, z)
return z.result
def run(self):
m = self.submit(self.record_marker('marker 1'))
m = self.submit(self.record_marker('marker 1', 'some details'))
self.submit(self.record_marker('marker 2', "2nd marker's details"))
futures.wait(m)
markers = self.list_markers()
assert 2 == len(markers)
print('Markers: {}'.format(markers))
markers = self.list_markers(all=True)
assert 3 == len(markers)
print('Markers, all: {}'.format(markers))
def run(self):
m = self.submit(self.record_marker("marker 1"))
m = self.submit(self.record_marker("marker 1", "some details"))
self.submit(self.record_marker("marker 2", "2nd marker's details"))
futures.wait(m)
markers = self.list_markers()
assert 2 == len(markers)
print("Markers: {}".format(markers))
markers = self.list_markers(all=True)
assert 3 == len(markers)
print("Markers, all: {}".format(markers))
def run(self):
all = [
self.submit(ChildWorkUntilSignalWorkflow),
self.submit(
Chain(
ActivityTask(func_a_1_2),
self.signal('signal1'),
)
),
]
futures.wait(*all)
def run(self, num, force_steps=None, skip_steps=None):
self.add_forced_steps(force_steps or [], "workflow_init")
self.add_skipped_steps(skip_steps or [], "workflow_init")
taskf = self.submit(
Step(
"my_step",
task.ActivityTask(MyTask, num),
force_steps_if_executed=["my_step_2"],
))
futures.wait(taskf)
def run(self, *args, **kwargs):
future = self.submit(
Chain(
Group(
(self.wait_signal("signal 2"), ),
(self.wait_signal("signal"), ),
(wait_and_signal, ),
(wait_and_signal, "signal 2"),
),
(increment, 1),
))
futures.wait(future)
def run(self, x, t=30):
execution = self.get_run_context()
logger.warning("execution context from decider: {}".format(execution))
y = self.submit(increment, x)
yy = self.submit(Delay, t, y)
z = self.submit(double, y)
logger.warning("result of ({x} + 1) * 2 = {result}".format(
x=x,
result=z.result))
futures.wait(yy, z)
return z.result
def run(self, *args, **kwargs):
future = self.submit(
Chain(
Group(
(self.wait_signal('signal 2'),),
(self.wait_signal('signal'),),
(wait_and_signal,),
(wait_and_signal, 'signal 2'),
),
(increment, 1),
)
)
futures.wait(future)
def run(self, x=5):
future = self.submit(
Chain(
ActivityTask(increment, x),
ActivityTask(double),
send_result=True
)
)
print('Future: {}'.format(future))
futures.wait(future)
print('Result: {}'.format(future.result)) # future.result == [6, 12]
return future.result
def run(self):
run_context = self.get_run_context()
print(run_context)
f1 = self.submit(
self.signal(
'IAmReady',
# workflow_id=execution_context.get('workflow_id'),
# run_id=execution_context.get('run_id'),
propagate=False,
))
f2 = self.submit(self.wait_signal('IAmReady'))
futures.wait(f1, f2)
print('C1: end')
def run(self, use_chain):
m1 = self.record_marker("marker 1")
m2 = self.record_marker("marker 1", "some details")
m3 = self.record_marker("marker 2", "2nd marker's details")
if use_chain:
# Markers will be submitted in 3 replays
future = self.submit(Chain(m1, m2, m3))
else:
# Markers will be submitted as one decision
future = self.submit(m1)
self.submit(m2)
self.submit(m3)
futures.wait(future)
def run(self, t1=30, t2=120):
"""
Cancel timer 2 after timer 1 is fired.
"""
future = self.submit(
Group(
self.start_timer("timer 2", t2),
Chain(self.start_timer("timer 1", t1), self.cancel_timer("timer 2"),),
)
)
if future.pending:
print("Starting timers")
futures.wait(future)
print("Timer fired, exiting")
def run(self):
future = self.submit(
Step('my_step', Group(
(multiply, 1),
(multiply, 2),
(multiply, 3),
)))
futures.wait(future)
# You can force the step even if already executed
group = Group((multiply, 1), (multiply, 2), (multiply, 3))
step = Step('my_step_force', group, force=True)
futures.wait(self.submit(step))
# You can play another activity group in the step was already computed
group_done = Group(self.signal('DONE'))
step = Step('my_step_with_callback_done',
group,
activities_if_step_already_done=group_done)
futures.wait(self.submit(step))
# You can emit a signal with the identifier step.{step_name}
# after the step is executed (cached or not)
step = Step('my_step_with_signal', group, emit_signal=True)
futures.wait(self.submit(step))
def run(self):
chain1 = Chain(
Group(ActivityTask(func_a_1_1), ActivityTask(func_a_1_2)),
self.signal("signal1"),
Group(ActivityTask(func_a_2_1), ActivityTask(func_a_2_2)),
)
chain2 = Chain(
Group(ActivityTask(func_b_1_1), ActivityTask(func_b_1_2)),
self.wait_signal("signal1"),
Group(ActivityTask(func_b_2_1), ActivityTask(func_b_2_2)),
)
my_group = Group(chain1, chain2)
fut = self.submit(my_group)
futures.wait(fut)
def run(self):
run_context = self.get_run_context()
print(run_context)
f1 = self.submit(
self.signal(
'IAmReady',
# workflow_id=execution_context.get('workflow_id'),
# run_id=execution_context.get('run_id'),
propagate=False,
)
)
f2 = self.submit(self.wait_signal('IAmReady'))
futures.wait(f1, f2)
print('C1: end')
def run(self):
chain1 = Chain(
Group(ActivityTask(func_a_1_1), ActivityTask(func_a_1_2)),
self.signal("signal1"),
Group(ActivityTask(func_a_2_1), ActivityTask(func_a_2_2)),
)
chain2 = Chain(
Group(ActivityTask(func_b_1_1), ActivityTask(func_b_1_2)),
self.wait_signal("signal1"),
Group(ActivityTask(func_b_2_1), ActivityTask(func_b_2_2)),
)
my_group = Group(chain1, chain2)
fut = self.submit(my_group)
futures.wait(fut)
def run(self):
run_context = self.get_run_context()
parent_workflow_id = run_context.get('parent_workflow_id')
parent_run_id = run_context.get('parent_run_id')
print(run_context)
f = self.submit(
self.signal('ChildReady',
workflow_id=parent_workflow_id,
run_id=parent_run_id,
me={
'workflow_id': run_context.get('workflow_id'),
'run_id': run_context.get('run_id'),
}))
futures.wait(f)
print('C1: end')
def run(self, use_chain):
m1 = (self.record_marker('marker 1'))
m2 = (self.record_marker('marker 1', 'some details'))
m3 = self.record_marker('marker 2', "2nd marker's details")
if use_chain:
# Markers will be submitted in 3 replays
future = self.submit(Chain(
m1, m2, m3
))
else:
# Markers will be submitted as one decision
future = self.submit(m1)
self.submit(m2)
self.submit(m3)
futures.wait(future)
def run(self, t1=2, t2=120):
"""
Cancel timer 2 after timer 1 is fired.
"""
future = self.submit(
Group(
self.start_timer("timer 2", t2),
Chain(
self.start_timer("timer 1", t1),
self.cancel_timer("timer 2"),
),
)
)
if future.pending:
print('Starting timers')
futures.wait(future)
print('Timer fired, exiting')
def run(self):
run_context = self.get_run_context()
parent_workflow_id = run_context.get('parent_workflow_id')
parent_run_id = run_context.get('parent_run_id')
print(run_context)
f = self.submit(
self.signal(
'ChildReady',
workflow_id=parent_workflow_id, run_id=parent_run_id,
me={
'workflow_id': run_context.get('workflow_id'),
'run_id': run_context.get('run_id'),
}
)
)
futures.wait(f)
print('C1: end')
def run(self):
x = 1
y = 2
z = 3
future = self.submit(
Chain(Group(
ActivityTask(increment_slowly, x),
ActivityTask(increment_slowly, y),
ActivityTask(increment_slowly, z),
),
ActivityTask(multiply),
send_result=True))
futures.wait(future)
res = future.result[-1]
print('({}+1)*({}+1)*({}+1) = {}'.format(x, y, z, res))
def run(self):
run_context = self.get_run_context()
parent_workflow_id = run_context.get("parent_workflow_id")
parent_run_id = run_context.get("parent_run_id")
print(run_context)
f = self.submit(
self.signal(
"ChildReady",
workflow_id=parent_workflow_id,
run_id=parent_run_id,
me={
"workflow_id": run_context.get("workflow_id"),
"run_id": run_context.get("run_id"),
},
)
)
futures.wait(f)
print("C1: end")
def run(self):
x = 1
y = 2
z = 3
future = self.submit(
Chain(
Group(
ActivityTask(increment_slowly, x),
ActivityTask(increment_slowly, y),
ActivityTask(increment_slowly, z),
),
ActivityTask(multiply),
send_result=True
)
)
futures.wait(future)
res = future.result[-1]
print '({}+1)*({}+1)*({}+1) = {}'.format(x, y, z, res)
def run(self):
future = self.submit(
Step(
'my_step',
Group(
(multiply, 1),
(multiply, 2),
(multiply, 3),
)
)
)
futures.wait(future)
# You can force the step even if already executed
group = Group((multiply, 1), (multiply, 2), (multiply, 3))
step = Step(
'my_step_force',
group,
force=True)
futures.wait(self.submit(step))
# You can play another activity group in the step was already computed
group_done = Group(self.signal('DONE'))
step = Step(
'my_step_with_callback_done',
group,
activities_if_step_already_done=group_done)
futures.wait(self.submit(step))
# You can emit a signal with the identifier step.{step_name}
# after the step is executed (cached or not)
step = Step(
'my_step_with_signal',
group,
emit_signal=True)
futures.wait(self.submit(step))
def run(self, *args, **kwargs):
xs = self.map(increment, xrange(self.nb_parts))
values = futures.wait(*xs)
return values
def run(self):
f = self.submit(ChildSignalsSelfWorkflow)
futures.wait(f)
child_signal = self.submit(self.wait_signal('IAmReady'))
assert child_signal.finished is False
print('Parent: end')
def run(self):
x = self.submit(fail_but_dont_raise)
y = self.submit(fail_and_raise)
futures.wait(x, y)
raise ValueError("YOU SHOULD NEVER SEE THIS")
def run(self, seconds):
x = self.submit(sleep, seconds)
futures.wait(x)
def run(self):
results = self.map(increment, range(constants.MAX_DECISIONS + 5))
futures.wait(*results)
def run(self):
signal_waiter = self.submit(self.wait_signal('signal1'))
while not signal_waiter.finished:
fut = self.submit(func_a_1_1)
futures.wait(fut)
def run(self, *args, **kwargs):
xs = self.map(increment, range(self.nb_parts))
values = futures.wait(*xs)
return values
def run(self):
all = [
self.submit(self.signal('signal1')),
]
futures.wait(*all)
def run(self):
results = self.map(increment,
range(constants.MAX_OPEN_ACTIVITY_COUNT + 5))
futures.wait(*results)
def run(self):
all = [
self.submit(ChildWaitSignalsWorkflow),
self.submit(ChildSendSignalsWorkflow),
]
futures.wait(*all)
def run(self):
results = self.map(increment, xrange(constants.MAX_DECISIONS + 20))
futures.wait(*results)
def run(self):
all = [
self.submit(ChildSendSignalsWorkflow),
self.submit(self.wait_signal('signal1')),
]
futures.wait(*all)
def run(self):
all = [
self.submit(self.wait_signal('signal1')),
self.submit(func_a_1_1),
]
futures.wait(*all)
