def test_regular_task(self):
T1 = self.createTaskCls("T1", "c.unittest.t.t1")
self.assertTrue(isinstance(T1(), T1))
self.assertTrue(T1().run())
self.assertTrue(callable(T1()),
"Task class is callable()")
self.assertTrue(T1()(),
"Task class runs run() when called")
# task name generated out of class module + name.
T2 = self.createTaskCls("T2")
self.assertEquals(T2().name, "celery.tests.test_task.T2")
registry.tasks.register(T1)
t1 = T1()
consumer = t1.get_consumer()
self.assertRaises(NotImplementedError, consumer.receive, "foo", "foo")
consumer.discard_all()
self.assertTrue(consumer.fetch() is None)
# Without arguments.
presult = t1.delay()
self.assertNextTaskDataEquals(consumer, presult, t1.name)
# With arguments.
presult2 = task.delay_task(t1.name, name="George Constanza")
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza")
# With eta.
presult2 = task.apply_async(t1, kwargs=dict(name="George Constanza"),
eta=datetime.now() + timedelta(days=1))
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza", test_eta=True)
# With countdown.
presult2 = task.apply_async(t1, kwargs=dict(name="George Constanza"),
countdown=10)
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza", test_eta=True)
self.assertRaises(registry.tasks.NotRegistered, task.delay_task,
"some.task.that.should.never.exist.X.X.X.X.X")
# Discarding all tasks.
task.discard_all()
tid3 = task.delay_task(t1.name)
self.assertEquals(task.discard_all(), 1)
self.assertTrue(consumer.fetch() is None)
self.assertFalse(task.is_done(presult.task_id))
self.assertFalse(presult.is_done())
default_backend.mark_as_done(presult.task_id, result=None)
self.assertTrue(task.is_done(presult.task_id))
self.assertTrue(presult.is_done())
publisher = t1.get_publisher()
self.assertTrue(isinstance(publisher, messaging.TaskPublisher))
def test_regular_task(self):
T1 = self.createTaskCls("T1", "c.unittest.t.t1")
self.assertTrue(isinstance(T1(), T1))
self.assertTrue(T1().run())
self.assertTrue(callable(T1()),
"Task class is callable()")
self.assertTrue(T1()(),
"Task class runs run() when called")
# task without name raises NotImplementedError
T2 = self.createTaskCls("T2")
self.assertRaises(NotImplementedError, T2)
registry.tasks.register(T1)
t1 = T1()
consumer = t1.get_consumer()
self.assertRaises(NotImplementedError, consumer.receive, "foo", "foo")
consumer.discard_all()
self.assertTrue(consumer.fetch() is None)
# Without arguments.
presult = t1.delay()
self.assertNextTaskDataEquals(consumer, presult, t1.name)
# With arguments.
presult2 = task.delay_task(t1.name, name="George Constanza")
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza")
self.assertRaises(registry.tasks.NotRegistered, task.delay_task,
"some.task.that.should.never.exist.X.X.X.X.X")
# Discarding all tasks.
task.discard_all()
tid3 = task.delay_task(t1.name)
self.assertEquals(task.discard_all(), 1)
self.assertTrue(consumer.fetch() is None)
self.assertFalse(task.is_done(presult.task_id))
self.assertFalse(presult.is_done())
default_backend.mark_as_done(presult.task_id, result=None)
self.assertTrue(task.is_done(presult.task_id))
self.assertTrue(presult.is_done())
publisher = t1.get_publisher()
self.assertTrue(isinstance(publisher, messaging.TaskPublisher))
def main(concurrency=DAEMON_CONCURRENCY, daemon=False,
loglevel=DAEMON_LOG_LEVEL, logfile=DAEMON_LOG_FILE, discard=False,
pidfile=DAEMON_PID_FILE, queue_wakeup_after=QUEUE_WAKEUP_AFTER):
"""Run the celery daemon."""
if settings.DATABASE_ENGINE == "sqlite3" and concurrency > 1:
import warnings
warnings.warn("The sqlite3 database engine doesn't support "
"concurrency. We'll be using a single process only.",
UserWarning)
concurrency = 1
if discard:
discarded_count = discard_all()
what = "message"
if discarded_count > 1:
what = "messages"
sys.stderr.write("Discard: Erased %d %s from the queue.\n" % (
discarded_count, what))
if daemon:
sys.stderr.write("Launching celeryd in the background...\n")
pidfile_handler = PIDFile(pidfile)
pidfile_handler.check()
daemonize(pidfile=pidfile_handler)
atexit.register(remove_pidfile, pidfile)
else:
logfile = None # log to stderr when not running as daemon.
discovery.autodiscover()
celeryd = WorkController(concurrency=concurrency,
loglevel=loglevel,
logfile=logfile,
queue_wakeup_after=queue_wakeup_after,
is_detached=daemon)
try:
celeryd.run()
except Exception, e:
emergency_error(logfile, "celeryd raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def purge_messages(self):
discarded_count = discard_all()
what = discarded_count > 1 and "messages" or "message"
print("discard: Erased %d %s from the queue.\n" % (
discarded_count, what))
def run_worker(concurrency=conf.CELERYD_CONCURRENCY,
loglevel=conf.CELERYD_LOG_LEVEL, logfile=conf.CELERYD_LOG_FILE,
hostname=None,
discard=False, run_clockservice=False, events=False, **kwargs):
"""Starts the celery worker server."""
hostname = hostname or socket.gethostname()
print("celery@%s v%s is starting." % (hostname, celery.__version__))
from celery.loaders import current_loader, load_settings
loader = current_loader()
settings = load_settings()
if not concurrency:
concurrency = multiprocessing.cpu_count()
if conf.CELERY_BACKEND == "database" \
and settings.DATABASE_ENGINE == "sqlite3" and \
concurrency > 1:
import warnings
warnings.warn("The sqlite3 database engine doesn't support "
"concurrency. We'll be using a single process only.",
UserWarning)
concurrency = 1
# Setup logging
if not isinstance(loglevel, int):
loglevel = conf.LOG_LEVELS[loglevel.upper()]
if discard:
discarded_count = discard_all()
what = discarded_count > 1 and "messages" or "message"
print("discard: Erased %d %s from the queue.\n" % (
discarded_count, what))
# Run the worker init handler.
# (Usually imports task modules and such.)
loader.on_worker_init()
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
tasklist = ""
if loglevel <= logging.INFO:
from celery.registry import tasks
tasklist = tasks.keys()
if not loglevel <= logging.DEBUG:
tasklist = filter(lambda s: not s.startswith("celery."), tasklist)
tasklist = TASK_LIST_FMT % "\n".join(" . %s" % task
for task in sorted(tasklist))
print(STARTUP_INFO_FMT % {
"conninfo": info.format_broker_info(),
"queues": info.format_routing_table(indent=8),
"concurrency": concurrency,
"loglevel": conf.LOG_LEVELS[loglevel],
"logfile": logfile or "[stderr]",
"celerybeat": run_clockservice and "ON" or "OFF",
"events": events and "ON" or "OFF",
"tasks": tasklist,
"loader": loader.__class__.__module__,
})
print("Celery has started.")
set_process_status("Running...")
def run_worker():
worker = WorkController(concurrency=concurrency,
loglevel=loglevel,
logfile=logfile,
hostname=hostname,
embed_clockservice=run_clockservice,
send_events=events)
# Install signal handler so SIGHUP restarts the worker.
install_worker_restart_handler(worker)
from celery import signals
signals.worker_init.send(sender=worker)
try:
worker.start()
except Exception, e:
emergency_error(logfile, "celeryd raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def run_worker(concurrency=DAEMON_CONCURRENCY, detach=False,
loglevel=DAEMON_LOG_LEVEL, logfile=DAEMON_LOG_FILE, discard=False,
pidfile=DAEMON_PID_FILE, umask=0, uid=None, gid=None,
supervised=False, working_directory=None, chroot=None,
statistics=None, **kwargs):
"""Starts the celery worker server."""
# set SIGCLD back to the default SIG_DFL (before python-daemon overrode
# it) lets the parent wait() for the terminated child process and stops
# the 'OSError: [Errno 10] No child processes' problem.
if hasattr(signal, "SIGCLD"): # Make sure the platform supports signals.
signal.signal(signal.SIGCLD, signal.SIG_DFL)
print("Celery %s is starting." % __version__)
if statistics is not None:
settings.CELERY_STATISTICS = statistics
if not concurrency:
concurrency = multiprocessing.cpu_count()
if conf.CELERY_BACKEND == "database" \
and settings.DATABASE_ENGINE == "sqlite3" and \
concurrency > 1:
import warnings
warnings.warn("The sqlite3 database engine doesn't support "
"concurrency. We'll be using a single process only.",
UserWarning)
concurrency = 1
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
if not detach:
logfile = None # log to stderr when not running in the background.
if discard:
discarded_count = discard_all()
what = discarded_count > 1 and "messages" or "message"
print("discard: Erased %d %s from the queue.\n" % (
discarded_count, what))
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
"vhost": getattr(settings, "AMQP_VHOST", "(default)"),
"host": getattr(settings, "AMQP_SERVER", "(default)"),
"port": getattr(settings, "AMQP_PORT", "(default)"),
"exchange": conf.AMQP_EXCHANGE,
"exchange_type": conf.AMQP_EXCHANGE_TYPE,
"consumer_queue": conf.AMQP_CONSUMER_QUEUE,
"consumer_rkey": conf.AMQP_CONSUMER_ROUTING_KEY,
"publisher_rkey": conf.AMQP_PUBLISHER_ROUTING_KEY,
"concurrency": concurrency,
"loglevel": loglevel,
"pidfile": pidfile,
"statistics": settings.CELERY_STATISTICS and "ON" or "OFF",
})
print("Celery has started.")
if detach:
if not CAN_DETACH:
raise RuntimeError(
"This operating system doesn't support detach. ")
from daemon import DaemonContext
from celery.log import setup_logger, redirect_stdouts_to_logger
# Since without stderr any errors will be silently suppressed,
# we need to know that we have access to the logfile
if logfile:
open(logfile, "a").close()
pidlock = acquire_pidlock(pidfile)
if umask is None:
umask = 0
if uid is None:
uid = os.geteuid()
if gid is None:
gid = os.getegid()
working_directory = working_directory or os.getcwd()
context = DaemonContext(chroot_directory=chroot,
working_directory=working_directory,
umask=umask,
pidfile=pidlock,
uid=uid,
gid=gid)
context.open()
logger = setup_logger(loglevel, logfile)
redirect_stdouts_to_logger(logger, loglevel)
# Run the worker init handler.
# (Usually imports task modules and such.)
current_loader.on_worker_init()
def run_worker():
worker = WorkController(concurrency=concurrency,
loglevel=loglevel,
logfile=logfile,
is_detached=detach)
# Install signal handler that restarts celeryd on SIGHUP,
# (only on POSIX systems)
install_restart_signal_handler(worker)
try:
worker.start()
except Exception, e:
emergency_error(logfile, "celeryd raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def run_worker(concurrency=DAEMON_CONCURRENCY, detach=False,
loglevel=DAEMON_LOG_LEVEL, logfile=DAEMON_LOG_FILE, discard=False,
pidfile=DAEMON_PID_FILE, umask=0, uid=None, gid=None,
supervised=False, working_directory=None, chroot=None,
statistics=None, **kwargs):
"""Starts the celery worker server."""
print("Celery %s is starting." % __version__)
if statistics:
settings.CELERY_STATISTICS = statistics
if not concurrency:
concurrency = multiprocessing.cpu_count()
if settings.DATABASE_ENGINE == "sqlite3" and concurrency > 1:
import warnings
warnings.warn("The sqlite3 database engine doesn't support "
"concurrency. We'll be using a single process only.",
UserWarning)
concurrency = 1
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
if not detach:
logfile = None # log to stderr when not running in the background.
if discard:
discarded_count = discard_all()
what = discarded_count > 1 and "messages" or "message"
print("discard: Erased %d %s from the queue.\n" % (
discarded_count, what))
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
"vhost": settings.AMQP_VHOST,
"host": settings.AMQP_SERVER,
"port": settings.AMQP_PORT,
"exchange": conf.AMQP_EXCHANGE,
"exchange_type": conf.AMQP_EXCHANGE_TYPE,
"consumer_queue": conf.AMQP_CONSUMER_QUEUE,
"consumer_rkey": conf.AMQP_CONSUMER_ROUTING_KEY,
"publisher_rkey": conf.AMQP_PUBLISHER_ROUTING_KEY,
"concurrency": concurrency,
"loglevel": loglevel,
"pidfile": pidfile,
"statistics": settings.CELERY_STATISTICS and "ON" or "OFF",
})
print("Celery has started.")
if detach:
if not CAN_DETACH:
raise RuntimeError(
"This operating system doesn't support detach. ")
from daemon import DaemonContext
# Since without stderr any errors will be silently suppressed,
# we need to know that we have access to the logfile
if logfile:
open(logfile, "a").close()
pidlock = acquire_pidlock(pidfile)
if not umask:
umask = 0
uid = uid and int(uid) or os.geteuid()
gid = gid and int(gid) or os.getegid()
working_directory = working_directory or os.getcwd()
context = DaemonContext(chroot_directory=chroot,
working_directory=working_directory,
umask=umask,
pidfile=pidlock,
uid=uid,
gid=gid)
context.open()
discovery.autodiscover()
def run_worker():
worker = WorkController(concurrency=concurrency,
loglevel=loglevel,
logfile=logfile,
is_detached=detach)
try:
worker.start()
except Exception, e:
emergency_error(logfile, "celeryd raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def purge_messages(self):
discarded_count = discard_all()
what = discarded_count > 1 and "messages" or "message"
print("discard: Erased %d %s from the queue.\n" %
(discarded_count, what))
#!/usr/bin/env python import parametros from guars.nucleo.models import * Aldeaporusuario.objects.all().update(depositohuerto=0,depositobarrizal=0,depositobosque=0,depositomina=0) Materiaporaldea.objects.all().update(enconstruccion=False,nivelactual=0) from celery import task task.discard_all()
def run_worker(concurrency=conf.DAEMON_CONCURRENCY, detach=False,
loglevel=conf.DAEMON_LOG_LEVEL, logfile=conf.DAEMON_LOG_FILE,
discard=False, pidfile=conf.DAEMON_PID_FILE, umask=0,
uid=None, gid=None, working_directory=None,
chroot=None, statistics=None, run_clockservice=False, **kwargs):
"""Starts the celery worker server."""
print("Celery %s is starting." % __version__)
if statistics is not None:
settings.CELERY_STATISTICS = statistics
if not concurrency:
concurrency = multiprocessing.cpu_count()
if conf.CELERY_BACKEND == "database" \
and settings.DATABASE_ENGINE == "sqlite3" and \
concurrency > 1:
import warnings
warnings.warn("The sqlite3 database engine doesn't support "
"concurrency. We'll be using a single process only.",
UserWarning)
concurrency = 1
# Setup logging
if not isinstance(loglevel, int):
loglevel = conf.LOG_LEVELS[loglevel.upper()]
if not detach:
logfile = None # log to stderr when not running in the background.
if discard:
discarded_count = discard_all()
what = discarded_count > 1 and "messages" or "message"
print("discard: Erased %d %s from the queue.\n" % (
discarded_count, what))
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
"conninfo": get_connection_info(),
"exchange": conf.AMQP_EXCHANGE,
"exchange_type": conf.AMQP_EXCHANGE_TYPE,
"consumer_queue": conf.AMQP_CONSUMER_QUEUE,
"consumer_rkey": conf.AMQP_CONSUMER_ROUTING_KEY,
"publisher_rkey": conf.AMQP_PUBLISHER_ROUTING_KEY,
"concurrency": concurrency,
"loglevel": loglevel,
"pidfile": pidfile,
"statistics": settings.CELERY_STATISTICS and "ON" or "OFF",
"celerybeat": run_clockservice and "ON" or "OFF",
})
print("Celery has started.")
if detach:
from celery.log import setup_logger, redirect_stdouts_to_logger
context = platform.create_daemon_context(logfile, pidfile,
chroot_directory=chroot,
working_directory=working_directory,
umask=umask,
uid=uid,
gid=gid)
context.open()
logger = setup_logger(loglevel, logfile)
redirect_stdouts_to_logger(logger, loglevel)
# Run the worker init handler.
# (Usually imports task modules and such.)
current_loader.on_worker_init()
def run_worker():
worker = WorkController(concurrency=concurrency,
loglevel=loglevel,
logfile=logfile,
embed_clockservice=run_clockservice,
is_detached=detach)
# Install signal handler that restarts celeryd on SIGHUP,
# (only on POSIX systems)
install_worker_restart_handler(worker)
try:
worker.start()
except Exception, e:
emergency_error(logfile, "celeryd raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
