def save_instance_state(self, out_state):
super(WorkChain, self).save_instance_state(out_state)
# Ask the context to save itself
bundle = Bundle()
self.ctx.save_instance_state(bundle)
out_state[self._CONTEXT] = bundle
# Save intersteps
for interstep in self._intersteps:
bundle = Bundle()
interstep.save_instance_state(bundle)
out_state.setdefault(self._INTERSTEPS, []).append(bundle)
# Save barriers
for barrier in self._barriers:
bundle = Bundle()
barrier.save_instance_state(bundle)
out_state.setdefault(self._BARRIERS, []).append(bundle)
# Ask the stepper to save itself
if self._stepper is not None:
bundle = Bundle()
self._stepper.save_position(bundle)
out_state[self._STEPPER_STATE] = bundle
out_state[self._ABORTED] = self._aborted
def save_instance_state(self, bundle):
"""
Ask the process to save its current instance state.
:param bundle: A bundle to save the state to
:type bundle: :class:`plum.persistence.Bundle`
"""
# TODO: Add a timeout to this method, the user may not want to wait
# indefinitely for the lock
with self.__save_lock:
# Immutables first
bundle[self.BundleKeys.CREATION_TIME.value] = self.creation_time
bundle[self.BundleKeys.CLASS_NAME.value] = util.fullname(self)
bundle[self.BundleKeys.PID.value] = self.pid
# Now state stuff
state_bundle = Bundle()
self._state.save_instance_state(state_bundle)
bundle[self.BundleKeys.STATE.value] = state_bundle
bundle[self.BundleKeys.FINISHED.value] = self._finished
bundle[self.BundleKeys.TERMINATED.value] = self._terminated
# Inputs/outputs
bundle.set_if_not_none(self.BundleKeys.INPUTS.value,
self.raw_inputs)
bundle[self.BundleKeys.OUTPUTS.value] = Bundle(self._outputs)
def test_created_bundle(self):
"""
Check that the bundle after just creating a process is as we expect
:return:
"""
proc = DummyProcessWithOutput.new()
b = Bundle()
proc.save_instance_state(b)
self.assertIsNone(b.get('inputs', None))
self.assertEqual(len(b['outputs']), 0)
def save_instance_state(self, out_state):
super(WorkChain, self).save_instance_state(out_state)
# Ask the context to save itself
context_state = Bundle()
self.ctx.save_instance_state(context_state)
out_state[self._CONTEXT] = context_state
# Ask the stepper to save itself
if self._stepper is not None:
stepper_state = Bundle()
self._stepper.save_position(stepper_state)
out_state[self._STEPPER_STATE] = stepper_state
def save_position(self, out_position):
if self._stepper is not None:
stepper_pos = Bundle()
self._stepper.save_position(stepper_pos)
out_position[self._STEPPER_POS] = stepper_pos
out_position[self._CHECK_CONDITION] = self._check_condition
out_position[self._FINISHED] = self._finished
def save_instance_state(self, bundle):
"""
As the process to save its current instance state.
:param bundle: A bundle to save the state to
:type bundle: :class:`plum.persistence.Bundle`
"""
bundle[self.BundleKeys.CLASS_NAME.value] = util.fullname(self)
bundle[self.BundleKeys.STATE.value] = self.state
bundle[self.BundleKeys.PID.value] = self.pid
bundle[self.BundleKeys.FINISHED.value] = self._finished
bundle[self.BundleKeys.ABORTED.value] = self._aborted
bundle.set_if_not_none(self.BundleKeys.EXCEPTION.value, self._exception)
if self._next_transition is not None:
bundle[self.BundleKeys.NEXT_TRANSITION.value] = \
self._next_transition.__name__
bundle.set_if_not_none(self.BundleKeys.ABORT_MSG.value, self._abort_msg)
# Save inputs and outputs
bundle.set_if_not_none(self.BundleKeys.INPUTS.value, self.raw_inputs)
bundle[self.BundleKeys.OUTPUTS.value] = Bundle(self._outputs)
if self._wait is not None:
bundle[self.BundleKeys.WAITING_ON.value] = self.save_wait_on_state()
bundle[self.BundleKeys.WAIT_ON_CALLBACK.value] = \
self._wait.callback.__name__
def create_bundle(self, process):
bundle = Bundle()
process.save_instance_state(bundle)
inputs = bundle[Process.BundleKeys.INPUTS.value]
if inputs:
bundle[Process.BundleKeys.INPUTS.value] = self._convert_to_ids(inputs)
return bundle
def save_position(self, out_position):
out_position[self._POSITION] = self._pos
# Save the position of the current step we're working (if it's not a
# direct function)
if self._current_stepper is not None:
stepper_pos = Bundle()
self._current_stepper.save_position(stepper_pos)
out_position[self._STEPPER_POS] = stepper_pos
def save_instance_state(self, out_state):
super(self.__class__, self).save_instance_state(out_state)
# Save all the waits lists
waits = []
for w in self._wait_list:
b = Bundle()
w.save_instance_state(b)
waits.append(b)
out_state[self.WAIT_LIST] = waits
def save_wait_on_state(self):
"""
Create a saved instance state for the WaitOn the process is currently
waiting for. If the wait on is :class:`plum.wait.Unsavable` then
the process should override this and save some information that allows
it to recreate it.
:return: The saved instance state of the wait on
:rtype: :class:`plum.persistence.bundle.Bundle`
"""
b = Bundle()
self.get_waiting_on().save_instance_state(b)
return b
def _check_process_against_snapshot(self, snapshot, proc):
self.assertEqual(snapshot.state, proc.state)
new_bundle = Bundle()
proc.save_instance_state(new_bundle)
self.assertEqual(
snapshot.bundle, new_bundle,
"Bundle mismatch with process class {}\n"
"Snapshot:\n{}\n"
"Loaded:\n{}".format(proc.__class__, snapshot.bundle, new_bundle))
self.assertEqual(
snapshot.outputs, proc.outputs,
"Outputs mismatch with process class {}\n"
"Snapshot:\n{}\n"
"Loaded:\n{}".format(proc.__class__, snapshot.outputs,
proc.outputs))
def test_restart(self):
p = _RestartProcess.new()
future = self.executor.play(p)
self.assertTrue(wait_until(p, ProcessState.WAITING, timeout=2.))
# Save the state of the process
bundle = Bundle()
p.save_instance_state(bundle)
self.assertTrue(future.abort(timeout=2.))
# Load a process from the saved state
p = _RestartProcess.create_from(bundle)
self.assertEqual(p.state, ProcessState.WAITING)
# Now play it
future = self.executor.play(p)
p.continue_()
self.assertEqual(future.result(timeout=1.0), {'finished': True})
def test_if_block_persistence(self):
""" This test was created to capture issue #902 """
wc = IfTest.new_instance()
while not wc.ctx.s1 and not wc.has_finished():
wc.tick()
self.assertTrue(wc.ctx.s1)
self.assertFalse(wc.ctx.s2)
# Now bundle the thing
b = Bundle()
wc.save_instance_state(b)
# Abort the current one
wc.stop()
wc.destroy(execute=True)
# Load from saved tate
wc = IfTest.create_from(b)
self.assertTrue(wc.ctx.s1)
self.assertFalse(wc.ctx.s2)
wc.run_until_complete()
def save_position(self, out_position):
out_position[self._POSITION] = self._pos
if self._current_stepper is not None:
stepper_pos = Bundle()
self._current_stepper.save_position(stepper_pos)
out_position[self._STEPPER_POS] = stepper_pos
def create_bundle(self, process):
checkpoint = Bundle()
process.save_instance_state(checkpoint)
return checkpoint
def create_snapshot(proc):
b = Bundle()
proc.save_instance_state(b)
return Snapshot(proc.state, b, proc.outputs.copy())
def save_instance_state(self, bundle):
super(WaitForSignalProcess, self).save_instance_state(bundle)
bundle[self.BARRIER] = Bundle()
self._barrier.save_instance_state(bundle[self.BARRIER])
def _save(self, p):
b = Bundle()
p.save_instance_state(b)
self.snapshots.append((p.state, b))
self.outputs.append(p.outputs.copy())