def test_play_all(self):
"""Test pausing all processes on a communicator"""
procs = []
for _ in range(10):
proc = test_utils.WaitForSignalProcess(communicator=self.communicator)
procs.append(proc)
proc.pause('hold tight')
self.assertTrue(all([proc.paused for proc in procs]))
self.process_controller.play_all()
# Wait until they are all paused
yield utils.wait_util(lambda: all([not proc.paused for proc in procs]))
def test_play(self):
proc = test_utils.WaitForSignalProcess(communicator=self.communicator)
self.assertTrue(proc.pause())
# Send a play message
play_future = self.process_controller.pause_process(proc.pid)
# Allow the process to respond to the request
result = yield play_future
# Check that all is as we expect
self.assertTrue(result)
self.assertEqual(proc.state, plumpy.ProcessState.CREATED)
def test_kill_all(self):
"""Test pausing all processes on a communicator"""
procs = []
for _ in range(10):
procs.append(
test_utils.WaitForSignalProcess(
communicator=self.communicator))
self.process_controller.kill_all('bang bang, I shot you down')
yield utils.wait_util(lambda: all([proc.killed() for proc in procs]))
self.assertTrue(
all([proc.state == plumpy.ProcessState.KILLED for proc in procs]))
def test_play(self):
proc = test_utils.WaitForSignalProcess(communicator=self.communicator)
# Run the process in the background
proc.loop().add_callback(proc.step_until_terminated)
self.assertTrue(proc.pause())
# Send a play message
result = yield self.process_controller.play_process(proc.pid)
# Check that all is as we expect
self.assertTrue(result)
self.assertEqual(proc.state, plumpy.ProcessState.WAITING)
def test_kill(self):
proc = test_utils.WaitForSignalProcess(communicator=self.communicator)
# Send a kill message
kill_future = yield self.process_controller.kill_process(proc.pid)
# Allow the process to respond to the request
result = yield kill_future
# Check the outcome
self.assertTrue(result)
# Occasionally fail
self.assertEqual(proc.state, plumpy.ProcessState.KILLED)
def test_wait_continue(self):
proc = test_utils.WaitForSignalProcess()
# Wait - Execute the process and wait until it is waiting
listener = plumpy.ProcessListener()
listener.on_process_waiting = lambda proc: proc.resume()
proc.add_process_listener(listener)
self.loop.run_sync(proc.step_until_terminated)
# Check it's done
self.assertTrue(proc.done())
self.assertEqual(proc.state, ProcessState.FINISHED)
def test_wait_save_continue(self):
""" Test that process saved while in WAITING state restarts correctly when loaded """
proc = test_utils.WaitForSignalProcess()
self.loop.add_callback(proc.step_until_terminated)
yield test_utils.run_until_waiting(proc)
saved_state = plumpy.Bundle(proc)
# Run the process to the end
proc.resume()
result1 = yield proc.future()
# Load from saved state and run again
proc2 = saved_state.unbundle(plumpy.LoadSaveContext(loop=self.loop))
self.loop.add_callback(proc2.step_until_terminated)
proc2.resume()
result2 = yield proc2.future()
# Check results match
self.assertEqual(result1, result2)
def test_pause_play_status_messaging(self):
"""
Test the setting of a processes' status through pause and play works correctly.
Any process can have its status set to a given message. When pausing, a pause message can be set for the
status, which should store the current status, which should be restored, once the process is played again.
"""
PLAY_STATUS = 'process was played by Hans Klok'
PAUSE_STATUS = 'process was paused by Evel Knievel'
proc = test_utils.WaitForSignalProcess()
proc.set_status(PLAY_STATUS)
loop = self.loop
loop.add_callback(proc.step_until_terminated)
@gen.coroutine
def async_test():
yield test_utils.run_until_waiting(proc)
self.assertEqual(proc.state, ProcessState.WAITING)
result = yield proc.pause(PAUSE_STATUS)
self.assertTrue(result)
self.assertTrue(proc.paused)
self.assertEqual(proc.status, PAUSE_STATUS)
result = proc.play()
self.assertEqual(proc.status, PLAY_STATUS)
self.assertIsNone(proc._pre_paused_status)
proc.resume()
# Wait until the process is terminated
yield proc.future()
# Check it's done
self.assertTrue(proc.done())
self.assertEqual(proc.state, ProcessState.FINISHED)
loop.run_sync(async_test)
def test_kill_when_paused(self):
proc = test_utils.WaitForSignalProcess()
@gen.coroutine
def run_async(proc):
yield test_utils.run_until_waiting(proc)
saved_state = plumpy.Bundle(proc)
result = yield proc.pause()
self.assertTrue(result)
self.assertTrue(proc.paused)
# Kill the process
proc.kill()
with self.assertRaises(plumpy.KilledError):
result = yield proc.future()
self.assertEqual(proc.state, ProcessState.KILLED)
self.loop.add_callback(proc.step_until_terminated)
self.loop.run_sync(lambda: run_async(proc))
