def test_play_all(self): procs = [] # Launch a bunch of processes for i in range(0, 9): procs.append(WaitForSignalProcess.new()) self.manager.start(procs[-1]) wait_until(procs, ProcessState.WAITING, timeout=1) # Check they are all in state we expect for p in procs: self.assertTrue(p.is_playing(), "state '{}'".format(p.state)) # Now try and pause them all self.manager.pause_all() # Check they are all in state we expect for p in procs: self.assertEqual(p.state, ProcessState.WAITING) self.assertFalse(p.is_playing()) self.manager.play_all() for p in procs: p.continue_() wait_until_stopped(procs) for p in procs: self.assertEqual(p.state, ProcessState.STOPPED) self.manager.shutdown() self.assertFalse(p.is_playing())
def test_push_over_limit(self): with SchedulingExecutor(max_threads=2) as executor: procs = (WaitForSignalProcess(), WaitForSignalProcess(), WaitForSignalProcess()) # Play first two executor.play(procs[0]) executor.play(procs[1]) # Get first two to the waiting state self.assertTrue( wait_until((procs[0], procs[1]), ProcessState.WAITING, timeout=2.)) self.assertTrue(procs[0].is_playing()) self.assertTrue(procs[1].is_playing()) self.assertFalse(procs[2].is_playing()) # Now play third executor.play(procs[2]) # Get third to the waiting state self.assertTrue( wait_until(procs[2], ProcessState.WAITING, timeout=2.)) # Now that it's waiting p2 should be pulled and the other two should be playing self.assertTrue(procs[2].wait(timeout=2.)) # Check the final expected state # WARNING: The others could not be playing *yet* because it is too early time.sleep(0.1) self.assertTrue(procs[1].is_playing()) self.assertFalse(procs[2].is_playing()) self.assertTrue(procs[0].is_playing())
def test_pause(self): # Create the process and wait until it is waiting p = WaitForSignalProcess.new() self.controller.insert_and_play(p) wait_until(p, ProcessState.WAITING) self.assertTrue(p.is_playing()) # Send a message asking the process to pause self.assertIsNotNone(self.publisher.pause(p.pid, timeout=5.)) self.assertFalse(p.is_playing())
def test_abort_future(self): """ Test aborting a process through the future """ self.assertEqual(self.executor.get_num_processes(), 0) proc = WaitForSignalProcess.new() future = self.executor.play(proc) wait_until(proc, ProcessState.WAITING) self.assertTrue(future.abort(timeout=2.)) self.assertEqual(self.executor.get_num_processes(), 0)
def test_abort_interrupt(self): """ Test aborting a process through the process manager """ self.assertEqual(self.executor.get_num_processes(), 0) proc = WaitForSignalProcess.new() # Start a process and make sure it is waiting future = self.executor.play(proc) wait_until(proc, ProcessState.WAITING) # Then interrupt by aborting self.assertTrue(future.abort(timeout=2.)) self.assertEqual(self.executor.get_num_processes(), 0)
def test_wait_pause_play(self): p = WaitForSignalProcess.new() self.executor.play(p) # Wait self.assertTrue(wait_until(p, ProcessState.WAITING, timeout=2.)) # Pause self.assertTrue(p.pause(timeout=1.)) # Play self.executor.play(p) self.assertTrue(wait_until(p, ProcessState.WAITING, timeout=2.))
def test_wait_continue(self): p = WaitForSignalProcess.new() t = threading.Thread(target=p.play) t.start() self.assertTrue(wait_until(p, ProcessState.WAITING, 5)) self.assertEqual(p.state, ProcessState.WAITING) self.assertTrue(p.is_playing()) p.continue_() self.assertTrue(wait_until(p, ProcessState.STOPPED, 5)) self.assertEqual(p.state, ProcessState.STOPPED)
def test_pause(self): # Create the process and wait until it is waiting p = WaitForSignalProcess.new() self.manager.start(p) wait_until(p, ProcessState.WAITING) self.assertTrue(p.is_playing()) # Send a message asking the process to pause self.channel.basic_publish( exchange=self.exchange, routing_key='', body=action_encode({'pid': p.pid, 'intent': 'pause'})) self.controller.poll(time_limit=1) self.assertFalse(p.is_playing()) self.assertTrue(self.manager.abort(p.pid, timeout=10))
def test_wait_continue(self): p = WaitForSignalProcess.new() self.executor.play(p) self.assertTrue(wait_until(p, ProcessState.WAITING, timeout=1.)) p.continue_() self.assertTrue(p.wait(timeout=2.)) self.assertTrue(p.has_finished())
def test_abort(self): # Create the process and wait until it is waiting p = WaitForSignalProcess.new() self.manager.start(p) wait_until(p, ProcessState.WAITING) self.assertTrue(p.is_playing()) # Send a message asking the process to abort self.channel.basic_publish( exchange=self.exchange, routing_key='', body=action_encode({'pid': p.pid, 'intent': 'abort'})) self.controller.poll(time_limit=1) self.assertTrue(wait_until(p, ProcessState.STOPPED, 10), "Process did not stop before timeout") self.assertTrue(p.has_aborted()) self.manager.shutdown()
def test_play_pause_abort(self): procs = [] for i in range(0, 10): procs.append(WaitForSignalProcess.new()) self.manager.start(procs[-1]) self.assertTrue(wait_until(procs, ProcessState.WAITING)) self.assertTrue(self.manager.pause_all(timeout=2)) self.assertTrue(self.manager.abort_all(timeout=2))
def test_simple_queue(self): with SchedulingExecutor(max_threads=2) as executor: procs = [] for i in range(10): proc = DummyProcess() procs.append(proc) executor.play(proc) self.assertTrue(wait_until(procs, ProcessState.STOPPED, timeout=2.))
def test_abort(self): p = WaitForSignalProcess.new() t = threading.Thread(target=p.play) # Start the process t.start() # Wait until it is waiting wait_until(p, ProcessState.WAITING) self.assertEqual(p.state, ProcessState.WAITING) # Abort it p.abort() # Wait until it's completely finished wait_until_stopped(p) self.assertEqual(p.state, ProcessState.STOPPED) self.assertTrue(p.has_aborted()) self.safe_join(t)
def test_wait_pause_play_continue(self): p = WaitForSignalProcess.new() fut = self.executor.play(p) # Wait self.assertTrue(wait_until(p, ProcessState.WAITING, 1.)) self.assertTrue(p.is_playing()) # Pause self.assertTrue(p.pause(timeout=1.)) self.assertFalse(p.is_playing()) # Play fut.play() self.assertEqual(p.state, ProcessState.WAITING) # Continue p.continue_() self.assertTrue(wait_until(p, ProcessState.STOPPED), 1.)
def test_wait_pause_play_continue(self): p = WaitForSignalProcess.new() t = threading.Thread(target=p.play) t.start() self.assertTrue(wait_until(p, ProcessState.WAITING, 5)) self.assertTrue(p.is_playing()) p.pause() self.safe_join(t) self.assertFalse(p.is_playing()) t = threading.Thread(target=p.play) t.start() self.assertEqual(p.state, ProcessState.WAITING) p.continue_() self.assertTrue(wait_until(p, ProcessState.STOPPED), 5) self.safe_join(t, 5) self.assertFalse(t.is_alive())
def test_future_abort(self): p = WaitForSignalProcess.new() future = self.executor.play(p) # Wait self.assertTrue(wait_until(p, ProcessState.WAITING)) self.assertTrue(p.is_playing()) # Abort self.assertTrue(future.abort(timeout=3.)) self.assertTrue(p.has_aborted())
def test_play_pause_abort(self): num_procs = 10 procs = [] for i in range(0, num_procs): procs.append(WaitForSignalProcess.new()) self.executor.play(procs[-1]) # Wait self.assertTrue(wait_until(procs, ProcessState.WAITING)) self.assertEqual(self.executor.pause_all(timeout=3.), num_procs)
def test_status(self): procs = [] for i in range(0, 20): procs.append(WaitForSignalProcess.new()) for p in procs: self.manager.start(p) wait_until(procs, ProcessState.WAITING) response = self._send_and_get() d = json.loads(response) self.assertEqual(len(d), len(procs)) self.assertSetEqual(set([str(p.pid) for p in procs]), set(d.keys())) playing = set([entry['playing'] for entry in d.itervalues()]) self.assertSetEqual(playing, {True}) self.assertTrue(self.manager.abort_all(timeout=10), "Couldn't abort all processes in timeout") response = self._send_and_get() self.assertIsNone(response)
def test_simple_push_over_limit(self): with SchedulingExecutor(max_threads=1) as executor: p1 = WaitForSignalProcess() p2 = WaitForSignalProcess() f1 = executor.play(p1) self.assertTrue(wait_until(p1, ProcessState.WAITING, timeout=2.)) # This should push of P1 f2 = executor.play(p2) self.assertTrue(p1.wait(timeout=1.)) self.assertTrue(wait_until(p2, ProcessState.WAITING, timeout=2.)) # Now P2 should be paused and P1 running again self.assertTrue(p2.wait(timeout=1.)) # Finish p1 p1.continue_() self.assertTrue(f1.wait(timeout=1.)) # Now P2 should be running again p2.continue_() self.assertTrue(f2.wait(timeout=1.))
def test_abort(self): # Create the process and wait until it is waiting p = WaitForSignalProcess.new() self.controller.insert_and_play(p) self.assertTrue(wait_until(p, ProcessState.WAITING, timeout=2.)) self.assertTrue(p.is_playing()) # Send a message asking the process to abort self.assertIsNotNone( self.publisher.abort(p.pid, msg='Farewell', timeout=5.)) self.assertTrue(p.wait(timeout=2.), "Process failed to stop running") self.assertFalse(p.is_playing()) self.assertTrue(p.has_aborted()) self.assertEqual(p.get_abort_msg(), 'Farewell')
def test_future_pause_play(self): p = WaitForSignalProcess.new() future = self.executor.play(p) # Wait self.assertTrue(wait_until(p, ProcessState.WAITING)) self.assertTrue(p.is_playing()) # Pause self.assertTrue(future.pause(timeout=3.)) self.assertFalse(p.is_playing()) # Play future.play() p.continue_() self.assertTrue(future.wait(timeout=1.))
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_wait_pause_continue_play(self): p = WaitForSignalProcess.new() # Play the process and wait until it is waiting self.executor.play(p) # Wait self.assertTrue(wait_until(p, ProcessState.WAITING, 1.)) # Pause self.assertTrue(p.pause(timeout=1.)) # Continue p.continue_() # Play p.play() self.assertTrue(p.wait(timeout=1.)) self.assertEqual(p.state, ProcessState.STOPPED)
def test_pause_all(self): procs = [] # Launch a bunch of processes for i in range(0, 9): procs.append(WaitForSignalProcess.new()) self.manager.start(procs[-1]) self.assertTrue(wait_until(procs, ProcessState.WAITING, timeout=5)) # Check they are all in state we expect for p in procs: self.assertTrue(p.is_playing()) # Now try and pause them all self.manager.pause_all() # Check they are all in state we expect for p in procs: self.assertEqual(p.state, ProcessState.WAITING) self.assertFalse(p.is_playing())
def test_status(self): procs = [] for i in range(0, 20): p = WaitForSignalProcess.new() procs.append(p) self.controller.insert_and_play(p) self.assertTrue(wait_until(procs, ProcessState.WAITING, timeout=2.)) procs_dict = status_decode(self._send_and_get())[status.PROCS_KEY] self.assertEqual(len(procs_dict), len(procs)) self.assertSetEqual(set([p.pid for p in procs]), set(procs_dict.keys())) playing = set([entry['playing'] for entry in procs_dict.itervalues()]) self.assertSetEqual(playing, {True}) self.assertTrue(self.controller.abort_all(timeout=5.), "Couldn't abort all processes in timeout") self.controller.remove_all() response = status_decode(self._send_and_get()) self.assertEqual(len(response[status.PROCS_KEY]), 0)
def test_wait_until(self): p = WaitForSignalProcess.new() self.executor.play(p) self.assertTrue(wait_until(p, ProcessState.WAITING, timeout=1.))