def run(self, loglevel="ERROR", logfile=None, http_port=8989,
http_address='', app=None, **kwargs):
print("celerymon %s is starting." % celery.__version__)
app = self.app
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
"http_port": http_port,
"http_address": http_address or "localhost",
"conninfo": app.broker_connection().as_uri(),
})
print("celerymon has started.")
arg_start = "manage" in sys.argv[0] and 2 or 1
platforms.set_process_title("celerymon",
info=" ".join(sys.argv[arg_start:]))
def _run_monitor():
app.log.setup_logging_subsystem(loglevel=loglevel,
logfile=logfile)
logger = app.log.get_default_logger(name="celery.mon")
monitor = MonitorService(logger=logger,
http_port=http_port,
http_address=http_address)
try:
monitor.start()
except Exception, exc:
logger.error("celerymon raised exception %r\n%s" % (
exc, traceback.format_exc()))
def run(self,
loglevel='ERROR',
logfile=None,
http_port=8989,
http_address='',
app=None,
detach=False,
pidfile=None,
uid=None,
gid=None,
umask=None,
working_directory=None,
**kwargs):
print('celerymon %s is starting.' % self.version)
app = self.app
workdir = working_directory
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(
STARTUP_INFO_FMT % {
'http_port': http_port,
'http_address': http_address or 'localhost',
'conninfo': app.broker_connection().as_uri(),
})
print('celerymon has started.')
set_process_title('celerymon', info=strargv(sys.argv))
def _run_monitor():
create_pidlock(pidfile)
app.log.setup_logging_subsystem(loglevel=loglevel, logfile=logfile)
logger = app.log.get_default_logger(name='celery.mon')
monitor = MonitorService(logger=logger,
http_port=http_port,
http_address=http_address)
try:
monitor.start()
except Exception, exc:
logger.error('celerymon raised exception %r',
exc,
exc_info=True)
except KeyboardInterrupt:
pass
def run(
self,
loglevel="ERROR",
logfile=None,
http_port=8989,
http_address="",
app=None,
detach=False,
pidfile=None,
uid=None,
gid=None,
umask=None,
working_directory=None,
**kwargs
):
print("celerymon %s is starting." % (self.version,))
app = self.app
workdir = working_directory
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(
STARTUP_INFO_FMT
% {
"http_port": http_port,
"http_address": http_address or "localhost",
"conninfo": app.broker_connection().as_uri(),
}
)
print("celerymon has started.")
set_process_title("celerymon", info=strargv(sys.argv))
def _run_monitor():
app.log.setup_logging_subsystem(loglevel=loglevel, logfile=logfile)
logger = app.log.get_default_logger(name="celery.mon")
monitor = MonitorService(logger=logger, http_port=http_port, http_address=http_address)
try:
monitor.start()
except Exception, exc:
logger.error("celerymon raised exception %r\n%s" % (exc, traceback.format_exc()))
except KeyboardInterrupt:
pass
def start(self, embedded_process=False):
self.logger.info("Celerybeat: Starting...")
self.logger.debug(
"Celerybeat: " "Ticking with max interval->%s" % (humanize_seconds(self.scheduler.max_interval))
)
if embedded_process:
platforms.set_process_title("celerybeat")
try:
try:
while not self._shutdown.isSet():
interval = self.scheduler.tick()
self.debug("Celerybeat: Waking up %s." % (humanize_seconds(interval, prefix="in ")))
time.sleep(interval)
except (KeyboardInterrupt, SystemExit):
self._shutdown.set()
finally:
self.sync()
def start(self, embedded_process=False):
self.logger.info("Celerybeat: Starting...")
self.logger.debug("Celerybeat: "
"Ticking with max interval->%s" % (
humanize_seconds(self.scheduler.max_interval)))
if embedded_process:
platforms.set_process_title("celerybeat")
try:
try:
while not self._shutdown.isSet():
interval = self.scheduler.tick()
self.debug("Celerybeat: Waking up %s." % (
humanize_seconds(interval, prefix="in ")))
time.sleep(interval)
except (KeyboardInterrupt, SystemExit):
self._shutdown.set()
finally:
self.sync()
def run(self, app=None, detach=False, pidfile=None,
uid=None, gid=None, umask=None, working_directory=None, **kwargs):
print('celery_stalker is starting.')
app = self.app
workdir = working_directory
print(STARTUP_INFO_FMT % {
'conninfo': app.broker_connection().as_uri(),
})
print('celery_stalker has started.')
set_process_title('celery_stalker', info=strargv(sys.argv))
logfile = 'celery_stalker.log'
def _run_monitor():
create_pidlock(pidfile)
logger = logging.getLogger('celery_stalker')
log_handler = logging.FileHandler(logfile)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
logger.setLevel(logging.INFO)
monitor = MonitorService(logger=logger)
try:
monitor.start()
except Exception, exc:
logger.error('celery_stalker raised exception %r',
exc, exc_info=True)
except KeyboardInterrupt:
pass
def run(self, loglevel='ERROR', logfile=None, http_port=8989,
http_address='', app=None, detach=False, pidfile=None,
uid=None, gid=None, umask=None, working_directory=None, **kwargs):
print('celerymon %s is starting.' % self.version)
app = self.app
workdir = working_directory
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
'http_port': http_port,
'http_address': http_address or 'localhost',
'conninfo': app.broker_connection().as_uri(),
})
print('celerymon has started.')
set_process_title('celerymon', info=strargv(sys.argv))
def _run_monitor():
create_pidlock(pidfile)
app.log.setup_logging_subsystem(loglevel=loglevel,
logfile=logfile)
logger = app.log.get_default_logger(name='celery.mon')
monitor = MonitorService(logger=logger,
http_port=http_port,
http_address=http_address)
try:
monitor.start()
except Exception, exc:
logger.error('celerymon raised exception %r',
exc, exc_info=True)
except KeyboardInterrupt:
pass
def start(self, embedded_process=False):
info('beat: Starting...')
debug('beat: Ticking with max interval->%s',
humanize_seconds(self.scheduler.max_interval))
signals.beat_init.send(sender=self)
if embedded_process:
signals.beat_embedded_init.send(sender=self)
platforms.set_process_title('celery beat')
try:
while not self._is_shutdown.is_set():
interval = self.scheduler.tick()
if interval and interval > 0.0:
debug('beat: Waking up %s.',
humanize_seconds(interval, prefix='in '))
time.sleep(interval)
if self.scheduler.should_sync():
self.scheduler._do_sync()
except (KeyboardInterrupt, SystemExit):
self._is_shutdown.set()
finally:
self.sync()
def run_monitor(loglevel=conf.CELERYMON_LOG_LEVEL,
logfile=conf.CELERYMON_LOG_FILE, http_port=8989,
http_address='', **kwargs):
"""Starts the celery monitor."""
print("celerymon %s is starting." % celery.__version__)
# Setup logging
if not isinstance(loglevel, int):
loglevel = conf.LOG_LEVELS[loglevel.upper()]
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
"http_port": http_port,
"http_address": http_address or "localhost",
"conninfo": info.format_broker_info(),
})
from celery.log import setup_logger, redirect_stdouts_to_logger
print("celerymon has started.")
arg_start = "manage" in sys.argv[0] and 2 or 1
platforms.set_process_title("celerymon",
info=" ".join(sys.argv[arg_start:]))
def _run_monitor():
logger = setup_logger(loglevel, logfile)
monitor = MonitorService(logger=logger,
http_port=http_port,
http_address=http_address)
try:
monitor.start()
except Exception, e:
emergency_error(logfile,
"celerymon raised exception %s: %s\n%s" % (
e.__class__, e, traceback.format_exc()))
def run(self, loglevel="ERROR", logfile=None, http_port=8989,
http_address='', app=None, detach=False, pidfile=None,
uid=None, gid=None, umask=None, working_directory=None, **kwargs):
print("celerymon %s is starting." % (self.version, ))
app = self.app
workdir = working_directory
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
# Dump configuration to screen so we have some basic information
# when users sends e-mails.
print(STARTUP_INFO_FMT % {
"http_port": http_port,
"http_address": http_address or "localhost",
"conninfo": app.broker_connection().as_uri(),
})
print("celerymon has started.")
set_process_title("celerymon", info=strargv(sys.argv))
def _run_monitor():
app.log.setup_logging_subsystem(loglevel=loglevel,
logfile=logfile)
logger = app.log.get_default_logger(name="celery.mon")
monitor = MonitorService(logger=logger,
http_port=http_port,
http_address=http_address)
try:
monitor.start()
except Exception, exc:
logger.error("celerymon raised exception %r\n%s" % (
exc, traceback.format_exc()))
except KeyboardInterrupt:
pass
def run(self, loglevel="ERROR", logfile=None, http_port=12201,
http_address='', app=None, detach=False, pidfile=None,
uid=None, gid=None, umask=None, working_directory=None,
plugins=None, storage=None, debug=False, **kwargs):
print("{0} {1} is starting.".format(self.namespace, self.version, ))
app = self.app
workdir = working_directory
# Setup logging
if not isinstance(loglevel, int):
loglevel = LOG_LEVELS[loglevel.upper()]
print("")
print("Using below's plugins.")
pprint(plugins)
# debug server
# print(STARTUP_INFO_FMT % {
# "http_port": http_port,
# "http_address": http_address or "localhost",
# "conninfo": app.broker_connection().as_uri(),
# })
print("")
print("{0} has started.".format(self.namespace))
set_process_title("{0}".format(self.namespace), info=strargv(sys.argv))
if detach:
with detached(logfile, pidfile, uid, gid, umask, workdir):
self._run_tracker(
loglevel, logfile, http_port,
http_address, plugins=plugins, storage=storage)
else:
self._run_tracker(
loglevel, logfile, http_port,
http_address, plugins=plugins, storage=storage)
def set_process_status(self, prog, info=''):
prog = '{0}:{1}'.format(self.prog_name, prog)
info = '{0} {1}'.format(info, strargv(sys.argv))
return set_process_title(prog, info=info)
def set_process_status(self, prog, info=''):
prog = '%s:%s' % (self.prog_name, prog)
info = '%s %s' % (info, strargv(sys.argv))
return set_process_title(prog, info=info)
def set_process_title(self):
arg_start = 'manage' in sys.argv[0] and 2 or 1
platforms.set_process_title(
'celery beat',
info=' '.join(sys.argv[arg_start:]),
)
def set_process_title(self):
arg_start = "manage" in sys.argv[0] and 2 or 1
platforms.set_process_title("celerybeat",
info=" ".join(sys.argv[arg_start:]))
def when_no_setps(self):
prev = platforms._setproctitle = platforms._setproctitle, None
try:
set_process_title("foo")
finally:
platforms._setproctitle = prev
def set_process_status(prog, info=""):
info = "%s %s" % (info, platforms.strargv(sys.argv))
return platforms.set_process_title(prog, info=info)
def set_process_status(prog, info=""):
info = "%s %s" % (info, platforms.strargv(sys.argv))
return platforms.set_process_title(prog,
info=info)
def _set_process_status(prog, info=''):
prog = '{}:{}'.format('celery events', prog)
info = f'{info} {strargv(sys.argv)}'
return set_process_title(prog, info=info)
def set_process_status(self, prog, info=''):
prog = f'{self.prog_name}:{prog}'
info = '{} {}'.format(info, strargv(sys.argv))
return set_process_title(prog, info=info)
def set_process_status(self, prog, info=""):
prog = "%s:%s" % (self.prog_name, prog)
info = "%s %s" % (info, platforms.strargv(sys.argv))
return platforms.set_process_title(prog, info=info)
def test_no_setps(self):
prev, platforms._setproctitle = platforms._setproctitle, None
try:
set_process_title('foo')
finally:
platforms._setproctitle = prev
def set_process_status(self, prog, info=''):
prog = '%s:%s' % (self.prog_name, prog)
info = '%s %s' % (info, strargv(sys.argv))
return set_process_title(prog, info=info)
def _set_process_status(prog, info=''):
prog = '{0}:{1}'.format('celery events', prog)
info = '{0} {1}'.format(info, strargv(sys.argv))
return set_process_title(prog, info=info)
def set_process_title(self, info):
set_process_title('%s#%s' % (self.name, shortuuid(self.branch.id)),
'%s (-D %s)' % (info, self.instance_dir))
def set_process_title(self):
arg_start = "manage" in sys.argv[0] and 2 or 1
platforms.set_process_title("celerybeat",
info=" ".join(sys.argv[arg_start:]))
def test_no_setps(self):
prev, platforms._setproctitle = platforms._setproctitle, None
try:
set_process_title('foo')
finally:
platforms._setproctitle = prev
def when_no_setps(self):
prev = platforms._setproctitle = platforms._setproctitle, None
try:
set_process_title("foo")
finally:
platforms._setproctitle = prev
def set_process_title(self):
arg_start = 'manage' in sys.argv[0] and 2 or 1
platforms.set_process_title('celerybeat',
info=' '.join(sys.argv[arg_start:]))
def set_process_title(self, info):
set_process_title("%s#%s" % (self.name, shortuuid(self.branch.id)),
"%s (-D %s)" % (info, self.instance_dir))
