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())