def test_jobs_manager(self):
'Test the jobs manager'
from calibre.srv.jobs import JobsManager
O = namedtuple('O', 'max_jobs max_job_time')
class FakeLog(list):
def error(self, *args):
self.append(' '.join(args))
s = ('waiting', 'running')
jm = JobsManager(O(1, 5), FakeLog())
def job_status(jid):
return jm.job_status(jid)[0]
# Start jobs
job_id1 = jm.start_job('simple test', 'calibre.srv.jobs', 'sleep_test', args=(1.0,))
job_id2 = jm.start_job('t2', 'calibre.srv.jobs', 'sleep_test', args=(3,))
job_id3 = jm.start_job('err test', 'calibre.srv.jobs', 'error_test')
# Job 1
job_id = job_id1
status = jm.job_status(job_id)[0]
self.assertIn(status, s)
for jid in (job_id2, job_id3):
self.assertEqual(job_status(jid), 'waiting')
while job_status(job_id) in s:
time.sleep(0.01)
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual(status, 'finished')
self.assertFalse(was_aborted)
self.assertFalse(tb)
self.assertEqual(result, 1.0)
# Job 2
job_id = job_id2
while job_status(job_id) == 'waiting':
time.sleep(0.01)
self.assertEqual('running', job_status(job_id))
jm.abort_job(job_id)
self.assertIn(jm.wait_for_running_job(job_id), (True, None))
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual('finished', status)
self.assertTrue(was_aborted)
# Job 3
job_id = job_id3
while job_status(job_id) == 'waiting':
time.sleep(0.01)
self.assertIn(jm.wait_for_running_job(job_id), (True, None))
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual(status, 'finished')
self.assertFalse(was_aborted)
self.assertTrue(tb)
self.assertIn('a testing error', tb)
jm.start_job('simple test', 'calibre.srv.jobs', 'sleep_test', args=(1.0,))
jm.shutdown(), jm.wait_for_shutdown(monotonic() + 1)
def __init__(
self,
handler,
opts=None,
plugins=(),
# A calibre logging object. If None, a default log that logs to
# stdout is used
log=None,
# A calibre logging object for access logging, by default no access
# logging is performed
access_log=None):
self.ready = False
self.handler = handler
self.opts = opts or Options()
if self.opts.trusted_ips:
self.opts.trusted_ips = tuple(
parse_trusted_ips(self.opts.trusted_ips))
self.log = log or ThreadSafeLog(level=ThreadSafeLog.DEBUG)
self.jobs_manager = JobsManager(self.opts, self.log)
self.access_log = access_log
ba = (self.opts.listen_on, int(self.opts.port))
if not ba[0]:
# AI_PASSIVE does not work with host of '' or None
ba = ('0.0.0.0', ba[1])
self.bind_address = ba
self.bound_address = None
self.connection_map = {}
self.ssl_context = None
if self.opts.ssl_certfile is not None and self.opts.ssl_keyfile is not None:
self.ssl_context = ssl.create_default_context(
ssl.Purpose.CLIENT_AUTH)
self.ssl_context.load_cert_chain(certfile=self.opts.ssl_certfile,
keyfile=self.opts.ssl_keyfile)
self.ssl_context.set_servername_callback(self.on_ssl_servername)
self.pre_activated_socket = None
if self.opts.allow_socket_preallocation:
from calibre.srv.pre_activated import pre_activated_socket
self.pre_activated_socket = pre_activated_socket()
if self.pre_activated_socket is not None:
set_socket_inherit(self.pre_activated_socket, False)
self.bind_address = self.pre_activated_socket.getsockname()
self.create_control_connection()
self.pool = ThreadPool(self.log,
self.job_completed,
count=self.opts.worker_count)
self.plugin_pool = PluginPool(self, plugins)
def test_jobs_manager(self):
'Test the jobs manager'
from calibre.srv.jobs import JobsManager
O = namedtuple('O', 'max_jobs max_job_time')
class FakeLog(list):
def error(self, *args):
self.append(' '.join(args))
jm = JobsManager(O(1, 5), FakeLog())
job_id = jm.start_job('simple test',
'calibre.srv.jobs',
'sleep_test',
args=(1.0, ))
job_id2 = jm.start_job('t2',
'calibre.srv.jobs',
'sleep_test',
args=(3, ))
jid = jm.start_job('err test', 'calibre.srv.jobs', 'error_test')
status = jm.job_status(job_id)[0]
s = ('waiting', 'running')
self.assertIn(status, s)
status2 = jm.job_status(job_id2)[0]
self.assertEqual(status2, 'waiting')
while jm.job_status(job_id)[0] in s:
time.sleep(0.01)
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual(status, 'finished')
self.assertFalse(was_aborted)
self.assertFalse(tb)
self.assertEqual(result, 1.0)
status2 = jm.job_status(job_id2)[0]
time.sleep(0.01)
self.assertEqual(status2, 'running')
jm.abort_job(job_id2)
self.assertTrue(jm.wait_for_running_job(job_id2))
status, result, tb, was_aborted = jm.job_status(job_id2)
self.assertTrue(was_aborted)
self.assertTrue(jm.wait_for_running_job(jid))
status, result, tb, was_aborted = jm.job_status(jid)
self.assertTrue(tb), self.assertIn('a testing error', tb)
jm.start_job('simple test',
'calibre.srv.jobs',
'sleep_test',
args=(1.0, ))
jm.shutdown(), jm.wait_for_shutdown(monotonic() + 1)
