你正在阅读 Celery 3.1 的文档。开发版本文档见: 此处.
# -*- coding: utf-8 -*-
"""
celery.worker.control
~~~~~~~~~~~~~~~~~~~~~
Remote control commands.
"""
from __future__ import absolute_import
import os
from datetime import datetime
from kombu.utils.encoding import safe_repr
from celery.platforms import signals as _signals
from celery.utils import timeutils
from celery.utils.compat import UserDict
from celery.utils.log import get_logger
from celery.utils import jsonify
from . import state
from .state import revoked
DEFAULT_TASK_INFO_ITEMS = ('exchange', 'routing_key', 'rate_limit')
logger = get_logger(__name__)
@Panel.register
[文档]def revoke(panel, task_id, terminate=False, signal=None, **kwargs):
"""Revoke task by task id."""
revoked.add(task_id)
if terminate:
signum = _signals.signum(signal or 'TERM')
for request in state.reserved_requests:
if request.id == task_id:
logger.info('Terminating %s (%s)', task_id, signum)
request.terminate(panel.consumer.pool, signal=signum)
break
else:
return {'ok': 'terminate: task %s not found' % (task_id, )}
return {'ok': 'terminating %s (%s)' % (task_id, signal)}
logger.info('Revoking task %s', task_id)
return {'ok': 'revoking task %s' % (task_id, )}
@Panel.register
@Panel.register
[文档]def enable_events(panel):
dispatcher = panel.consumer.event_dispatcher
if not dispatcher.enabled:
dispatcher.enable()
dispatcher.send('worker-online')
logger.info('Events enabled by remote.')
return {'ok': 'events enabled'}
return {'ok': 'events already enabled'}
@Panel.register
[文档]def disable_events(panel):
dispatcher = panel.consumer.event_dispatcher
if dispatcher.enabled:
dispatcher.send('worker-offline')
dispatcher.disable()
logger.info('Events disabled by remote.')
return {'ok': 'events disabled'}
return {'ok': 'events already disabled'}
@Panel.register
[文档]def heartbeat(panel):
logger.debug('Heartbeat requested by remote.')
dispatcher = panel.consumer.event_dispatcher
dispatcher.send('worker-heartbeat', freq=5, **state.SOFTWARE_INFO)
@Panel.register
[文档]def rate_limit(panel, task_name, rate_limit, **kwargs):
"""Set new rate limit for a task type.
See :attr:`celery.task.base.Task.rate_limit`.
:param task_name: Type of task.
:param rate_limit: New rate limit.
"""
try:
timeutils.rate(rate_limit)
except ValueError, exc:
return {'error': 'Invalid rate limit string: %s' % exc}
try:
panel.app.tasks[task_name].rate_limit = rate_limit
except KeyError:
logger.error('Rate limit attempt for unknown task %s',
task_name, exc_info=True)
return {'error': 'unknown task'}
if not hasattr(panel.consumer.ready_queue, 'refresh'):
logger.error('Rate limit attempt, but rate limits disabled.')
return {'error': 'rate limits disabled'}
panel.consumer.ready_queue.refresh()
if not rate_limit:
logger.info('Rate limits disabled for tasks of type %s', task_name)
return {'ok': 'rate limit disabled successfully'}
logger.info('New rate limit for tasks of type %s: %s.',
task_name, rate_limit)
return {'ok': 'new rate limit set successfully'}
@Panel.register
[文档]def time_limit(panel, task_name=None, hard=None, soft=None, **kwargs):
try:
task = panel.app.tasks[task_name]
except KeyError:
logger.error('Change time limit attempt for unknown task %s',
task_name, exc_info=True)
return {'error': 'unknown task'}
task.soft_time_limit = soft
task.time_limit = hard
logger.info('New time limits for tasks of type %s: soft=%s hard=%s',
task_name, soft, hard)
return {'ok': 'time limits set successfully'}
@Panel.register
[文档]def dump_schedule(panel, safe=False, **kwargs):
from celery.worker.job import Request
schedule = panel.consumer.timer.schedule
if not schedule.queue:
logger.debug('--Empty schedule--')
return []
formatitem = lambda (i, item): '%s. %s pri%s %r' % (
i, datetime.utcfromtimestamp(item['eta']),
item['priority'], item['item'],
)
info = map(formatitem, enumerate(schedule.info()))
logger.debug('* Dump of current schedule:\n%s', '\n'.join(info))
scheduled_tasks = []
for info in schedule.info():
item = info['item']
if item.args and isinstance(item.args[0], Request):
scheduled_tasks.append({
'eta': info['eta'],
'priority': info['priority'],
'request': item.args[0].info(safe=safe),
})
return scheduled_tasks
@Panel.register
[文档]def dump_reserved(panel, safe=False, **kwargs):
reserved = state.reserved_requests
if not reserved:
logger.debug('--Empty queue--')
return []
logger.debug('* Dump of currently reserved tasks:\n%s',
'\n'.join(map(safe_repr, reserved)))
return [request.info(safe=safe)
for request in reserved]
@Panel.register
[文档]def dump_active(panel, safe=False, **kwargs):
return [request.info(safe=safe) for request in state.active_requests]
@Panel.register
[文档]def stats(panel, **kwargs):
asinfo = {}
if panel.consumer.controller.autoscaler:
asinfo = panel.consumer.controller.autoscaler.info()
return {'total': state.total_count,
'consumer': panel.consumer.info,
'pool': panel.consumer.pool.info,
'autoscaler': asinfo,
'pid': os.getpid()}
@Panel.register
@Panel.register
[文档]def dump_tasks(panel, taskinfoitems=None, **kwargs):
tasks = panel.app.tasks
taskinfoitems = taskinfoitems or DEFAULT_TASK_INFO_ITEMS
def _extract_info(task):
fields = dict(
(field, str(getattr(task, field, None)))
for field in taskinfoitems
if getattr(task, field, None) is not None)
info = map('='.join, fields.items())
if not info:
return task.name
return '%s [%s]' % (task.name, ' '.join(info))
info = map(
_extract_info,
(tasks[task] for task in sorted(tasks)),
)
logger.debug('* Dump of currently registered tasks:\n%s', '\n'.join(info))
return info
@Panel.register
@Panel.register
[文档]def pool_grow(panel, n=1, **kwargs):
if panel.consumer.controller.autoscaler:
panel.consumer.controller.autoscaler.force_scale_up(n)
else:
panel.consumer.pool.grow(n)
return {'ok': 'spawned worker processes'}
@Panel.register
[文档]def pool_shrink(panel, n=1, **kwargs):
if panel.consumer.controller.autoscaler:
panel.consumer.controller.autoscaler.force_scale_down(n)
else:
panel.consumer.pool.shrink(n)
return {'ok': 'terminated worker processes'}
@Panel.register
[文档]def pool_restart(panel, modules=None, reload=False, reloader=None, **kwargs):
panel.consumer.controller.reload(modules, reload, reloader=reloader)
return {'ok': 'reload started'}
@Panel.register
[文档]def autoscale(panel, max=None, min=None):
autoscaler = panel.consumer.controller.autoscaler
if autoscaler:
max_, min_ = autoscaler.update(max, min)
return {'ok': 'autoscale now min=%r max=%r' % (max_, min_)}
raise ValueError('Autoscale not enabled')
@Panel.register
[文档]def shutdown(panel, msg='Got shutdown from remote', **kwargs):
logger.warning(msg)
raise SystemExit(msg)
@Panel.register
[文档]def add_consumer(panel, queue, exchange=None, exchange_type=None,
routing_key=None, **options):
panel.consumer.add_task_queue(queue, exchange, exchange_type,
routing_key, **options)
return {'ok': 'add consumer %r' % (queue, )}
@Panel.register
[文档]def cancel_consumer(panel, queue=None, **_):
panel.consumer.cancel_task_queue(queue)
return {'ok': 'no longer consuming from %s' % (queue, )}
@Panel.register
[文档]def active_queues(panel):
"""Returns the queues associated with each worker."""
return [dict(queue.as_dict(recurse=True))
for queue in panel.consumer.task_consumer.queues]
@Panel.register