def test_sched_clear(self):
ready_queue = Queue()
sched = Scheduler(ready_queue)
sched.enter(MockItem("foo"), eta=datetime.now(), callback=None)
self.assertFalse(sched.empty())
sched.clear()
self.assertTrue(sched.empty())
def __init__(self):
self.ready_queue = FastQueue()
self.ready_queue.put(
TaskRequest(task_name=mytask.name,
task_id=gen_unique_id(),
args=(2, 2),
kwargs={}))
self.eta_schedule = Scheduler(self.ready_queue)
self.event_dispatcher = Dispatcher()
def test_sched_info(self):
ready_queue = Queue()
sched = Scheduler(ready_queue)
item = MockItem("foo")
sched.enter(item, eta=10, callback=None)
self.assertDictEqual({
"eta": 10,
"priority": 0,
"item": item
},
sched.info().next())
def test_sched_revoked(self):
ready_queue = Queue()
sched = Scheduler(ready_queue)
now = datetime.now()
callback_called = [False]
def callback():
callback_called[0] = True
sched.enter(MockItem("foo", revoked=True), eta=now, callback=callback)
iter(sched).next()
self.assertFalse(callback_called[0])
self.assertRaises(Empty, ready_queue.get_nowait)
self.assertFalse(sched.queue)
sched.clear()
def test_sched_and_run_now(self):
ready_queue = Queue()
sched = Scheduler(ready_queue)
now = datetime.now()
callback_called = [False]
def callback():
callback_called[0] = True
sched.enter(MockItem("foo"), eta=now, callback=callback)
remaining = iter(sched).next()
self.assertIsNone(remaining)
self.assertTrue(callback_called[0])
self.assertEqual(ready_queue.get_nowait().task_id, "foo")
def test_sched_run_later(self):
ready_queue = Queue()
sched = Scheduler(ready_queue)
now = datetime.now()
callback_called = [False]
def callback():
callback_called[0] = True
eta = now + timedelta(seconds=10)
sched.enter(MockItem("foo"), eta=eta, callback=callback)
remaining = iter(sched).next()
self.assertTrue(remaining > 7 or remaining == sched.max_interval)
self.assertFalse(callback_called[0])
self.assertRaises(Empty, ready_queue.get_nowait)
def __init__(self,
concurrency=None,
logfile=None,
loglevel=None,
send_events=conf.SEND_EVENTS,
hostname=None,
ready_callback=noop,
embed_clockservice=False,
pool_cls=conf.CELERYD_POOL,
listener_cls=conf.CELERYD_LISTENER,
mediator_cls=conf.CELERYD_MEDIATOR,
eta_scheduler_cls=conf.CELERYD_ETA_SCHEDULER,
schedule_filename=conf.CELERYBEAT_SCHEDULE_FILENAME,
task_time_limit=conf.CELERYD_TASK_TIME_LIMIT,
task_soft_time_limit=conf.CELERYD_TASK_SOFT_TIME_LIMIT,
max_tasks_per_child=conf.CELERYD_MAX_TASKS_PER_CHILD,
pool_putlocks=conf.CELERYD_POOL_PUTLOCKS,
db=conf.CELERYD_STATE_DB):
# Options
self.loglevel = loglevel or self.loglevel
self.concurrency = concurrency or self.concurrency
self.logfile = logfile or self.logfile
self.logger = setup_logger(loglevel, logfile)
self.hostname = hostname or socket.gethostname()
self.embed_clockservice = embed_clockservice
self.ready_callback = ready_callback
self.send_events = send_events
self.task_time_limit = task_time_limit
self.task_soft_time_limit = task_soft_time_limit
self.max_tasks_per_child = max_tasks_per_child
self.pool_putlocks = pool_putlocks
self.db = db
self._finalize = Finalize(self, self.stop, exitpriority=1)
if self.db:
persistence = state.Persistent(self.db)
Finalize(persistence, persistence.save, exitpriority=5)
# Queues
if conf.DISABLE_RATE_LIMITS:
self.ready_queue = FastQueue()
else:
self.ready_queue = TaskBucket(task_registry=registry.tasks)
self.eta_schedule = Scheduler(self.ready_queue, logger=self.logger)
self.logger.debug("Instantiating thread components...")
# Threads + Pool + Consumer
self.pool = instantiate(pool_cls,
self.concurrency,
logger=self.logger,
initializer=process_initializer,
maxtasksperchild=self.max_tasks_per_child,
timeout=self.task_time_limit,
soft_timeout=self.task_soft_time_limit,
putlocks=self.pool_putlocks)
self.mediator = instantiate(mediator_cls,
self.ready_queue,
callback=self.process_task,
logger=self.logger)
self.scheduler = instantiate(eta_scheduler_cls,
self.eta_schedule,
logger=self.logger)
self.clockservice = None
if self.embed_clockservice:
self.clockservice = EmbeddedClockService(
logger=self.logger, schedule_filename=schedule_filename)
prefetch_count = self.concurrency * conf.CELERYD_PREFETCH_MULTIPLIER
self.listener = instantiate(listener_cls,
self.ready_queue,
self.eta_schedule,
logger=self.logger,
hostname=self.hostname,
send_events=self.send_events,
init_callback=self.ready_callback,
initial_prefetch_count=prefetch_count,
pool=self.pool)
# The order is important here;
# the first in the list is the first to start,
# and they must be stopped in reverse order.
self.components = filter(None,
(self.pool, self.mediator, self.scheduler,
self.clockservice, self.listener))
def setUp(self):
self.ready_queue = FastQueue()
self.eta_schedule = Scheduler(self.ready_queue)
self.logger = get_logger()
self.logger.setLevel(0)
def test_empty_queue_yields_None(self):
ready_queue = Queue()
sched = Scheduler(ready_queue)
self.assertIsNone(iter(sched).next())
