def test_scheduler_should_not_overload_worker(self, m_total_cores,
m_free_cores):
# Given
n_core = jobs.total_cores()
config = [dict(host='localhost')]
s = jobs.Scheduler(worker_config=config, wait=0.5)
j1 = self._make_dummy_job(n_core, sleep=0.5)
j2 = self._make_dummy_job(n_core, sleep=0.5)
j3 = self._make_dummy_job(n_core, sleep=0.5)
j4 = self._make_dummy_job(0, sleep=0.5)
# When
proxy1 = s.submit(j1)
proxy2 = s.submit(j2)
proxy3 = s.submit(j3)
proxy4 = s.submit(j4)
# Then
self.assertEqual(len(s.workers), 1)
# Basically, submit will wait for the existing jobs to complete.
# Therefore when s.submit(j3) is called it should wait until a
# free worker is available.
self.assertEqual(proxy1.status(), 'done')
self.assertEqual(proxy2.status(), 'done')
self.assertEqual(proxy3.status(), 'running')
# Proxy4 will be running since it needs no cores.
self.assertEqual(proxy4.status(), 'running')
self._wait_while_not_done(proxy3, 20)
self.assertEqual(proxy3.status(), 'done')
self._wait_while_not_done(proxy4, 15)
self.assertEqual(proxy4.status(), 'done')
def test_scheduler_does_not_start_worker_when_created(self, mock_lw):
# Given
config = [dict(host='localhost')]
# When
s = jobs.Scheduler(worker_config=config)
# Then
self.assertEqual(mock_lw.call_count, 0)
self.assertEqual(len(s.workers), 0)
def test_scheduler_only_creates_required_workers(self, mock_remote_worker):
# Given
config = [
dict(host='host1', python=sys.executable, testing=True),
dict(host='host2', python=sys.executable, testing=True),
]
s = jobs.Scheduler(worker_config=config)
j = self._make_dummy_job()
# When
proxy = s.submit(j)
# Then
self.assertEqual(len(s.workers), 1)
self.assertEqual(proxy.worker.host, 'host1')
# Wait for this job to end and then see what happens
# When a new job is submitted.
self._wait_while_not_done(proxy, 25)
# When
j = self._make_dummy_job()
s.submit(j)
# Then
self.assertEqual(len(s.workers), 1)
self.assertEqual(proxy.worker.host, 'host1')
# Running two jobs in a row should produce two workers.
# When
j = self._make_dummy_job()
proxy = s.submit(j)
# Then
self.assertEqual(len(s.workers), 2)
self.assertEqual(proxy.worker.host, 'host2')
# Adding more should work.
# When
j = self._make_dummy_job()
proxy = s.submit(j)
j = self._make_dummy_job()
proxy1 = s.submit(j)
# Then
self.assertEqual(len(s.workers), 2)
self._wait_while_not_done(proxy, 15)
self._wait_while_not_done(proxy1, 15)
self.assertEqual(proxy.status(), 'done')
self.assertEqual(proxy.worker.host, 'host1')
self.assertEqual(proxy1.worker.host, 'host2')
def test_scheduler_starts_worker_on_submit(self, mock_lw):
attrs = {'host': 'localhost', 'free_cores.return_value': 2}
mock_lw.return_value = mock.MagicMock(**attrs)
# Given
config = [dict(host='localhost')]
s = jobs.Scheduler(worker_config=config)
j = jobs.Job([sys.executable, '-c', 'print(1)'], output_dir=self.root)
# When
s.submit(j)
# Then
self.assertEqual(mock_lw.call_count, 1)
self.assertEqual(len(s.workers), 1)
def test_scheduler_works_with_local_worker(self, mock_free_cores):
# Given
s = jobs.Scheduler(worker_config=[dict(host='localhost')])
# When
j = jobs.Job(
[sys.executable, '-c', 'import time; time.sleep(0.05); print(1)'],
output_dir=self.root)
proxy = s.submit(j)
# Then
wait_until(lambda: proxy.status() != 'done', timeout=2)
self.assertEqual(proxy.status(), 'done')
self.assertEqual(proxy.get_stderr(), '')
self.assertEqual(proxy.get_stdout().strip(), '1')
info = proxy.get_info()
self.assertEqual(info['status'], 'done')
self.assertEqual(info['exitcode'], 0)
