def test_emergency_error_file(self):
tempfile = mktemp(suffix="unittest", prefix="celery")
emergency_error(tempfile, "Vandelay Industries")
tempfilefh = open(tempfile, "r")
try:
self.assertIn("Vandelay Industries", "".join(tempfilefh))
finally:
tempfilefh.close()
os.unlink(tempfile)
def _run_monitor():
logger = setup_logger(loglevel, logfile)
monitor = MonitorService(logger=logger, http_port=http_port)
try:
monitor.start()
except Exception, e:
emergency_error(logfile,
"celerymon raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def _run_clock():
logger = setup_logger(loglevel, logfile)
clockservice = ClockService(logger=logger, is_detached=detach)
try:
clockservice.start()
except Exception, e:
emergency_error(
logfile, "celerybeat raised exception %s: %s\n%s" % (e.__class__, e, traceback.format_exc())
)
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 _run_clock():
from celery.log import setup_logger
logger = setup_logger(loglevel, logfile)
clockservice = ClockService(logger=logger, schedule_filename=schedule)
try:
clockservice.start()
except Exception, e:
emergency_error(logfile,
"celerybeat raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def start_scheduler(self):
from celery.log import setup_logger
logger = setup_logger(self.loglevel, self.logfile)
beat = self.ClockService(logger, schedule_filename=self.schedule)
try:
self.install_sync_handler(beat)
beat.start()
except Exception, exc:
emergency_error(
self.logfile, "celerybeat raised exception %s: %s\n%s" %
(exc.__class__, exc, traceback.format_exc()))
def start_scheduler(self, logger=None):
beat = self.Service(logger=logger,
max_interval=self.max_interval,
scheduler_cls=self.scheduler_cls,
schedule_filename=self.schedule)
try:
self.install_sync_handler(beat)
beat.start()
except Exception, exc:
emergency_error(self.logfile,
"celerybeat raised exception %s: %s\n%s" % (
exc.__class__, exc, traceback.format_exc()))
def start_scheduler(self):
from celery.log import setup_logger
logger = setup_logger(self.loglevel, self.logfile)
beat = ClockService(logger,
schedule_filename=self.schedule)
try:
self.install_sync_handler(beat)
beat.start()
except Exception, exc:
emergency_error(self.logfile,
"celerybeat raised exception %s: %s\n%s" % (
exc.__class__, exc, traceback.format_exc()))
def run_worker():
worker = WorkController(concurrency=concurrency,
loglevel=loglevel,
logfile=logfile,
is_detached=detach)
# Install signal handler that restarts celeryd on SIGHUP
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():
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(self):
worker = WorkController(concurrency=self.concurrency,
loglevel=self.loglevel,
logfile=self.logfile,
hostname=self.hostname,
ready_callback=self.on_listener_ready,
embed_clockservice=self.run_clockservice,
send_events=self.events)
# Install signal handler so SIGHUP restarts the worker.
install_worker_restart_handler(worker)
install_worker_term_handler(worker)
install_worker_int_handler(worker)
signals.worker_init.send(sender=worker)
try:
worker.start()
except Exception, exc:
emergency_error(self.logfile,
"celeryd raised exception %s: %s\n%s" % (
exc.__class__, exc, traceback.format_exc()))
def start_scheduler(self, logger=None):
c = self.colored
beat = self.Service(logger=logger,
max_interval=self.max_interval,
scheduler_cls=self.scheduler_cls,
schedule_filename=self.schedule)
print(str(c.blue("__ ", c.magenta("-"),
c.blue(" ... __ "), c.magenta("-"),
c.blue(" _\n"),
c.reset(self.startup_info(beat)))))
if self.socket_timeout:
logger.debug("Setting default socket timeout to %r" % (
self.socket_timeout))
socket.setdefaulttimeout(self.socket_timeout)
try:
self.install_sync_handler(beat)
beat.start()
except Exception, exc:
emergency_error(self.logfile,
"celerybeat raised exception %s: %s\n%s" % (
exc.__class__, exc, traceback.format_exc()))
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 test_emergency_error_file(self):
tempfile = mktemp(suffix="unittest", prefix="celery")
emergency_error(tempfile, "Vandelay Industries")
with open(tempfile, "r") as tempfilefh:
self.assertTrue("Vandelay Industries" in "".join(tempfilefh))
os.unlink(tempfile)
def test_emergency_error(self):
sio = StringIO()
emergency_error(sio, "Testing emergency error facility")
self.assertEqual(rpartition(sio.getvalue(), ":")[2].strip(),
"Testing emergency error facility")
def test_emergency_error_stderr(self):
with override_stdouts() as outs:
stdout, stderr = outs
emergency_error(None, "The lazy dog crawls under the fast fox")
self.assertTrue("The lazy dog crawls under the fast fox" in \
stderr.getvalue())
def with_override_stdouts(outs):
stdout, stderr = outs
emergency_error(None, "The lazy dog crawls under the fast fox")
self.assertIn("The lazy dog crawls under the fast fox",
stderr.getvalue())