def process_initializer(app, hostname):
"""Pool child process initializer.
This will initialize a child pool process to ensure the correct
app instance is used and things like
logging works.
"""
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title('celeryd', hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.loader.init_worker()
app.loader.init_worker_process()
app.log.setup(int(os.environ.get('CELERY_LOG_LEVEL', 0) or 0),
os.environ.get('CELERY_LOG_FILE') or None,
bool(os.environ.get('CELERY_LOG_REDIRECT', False)),
str(os.environ.get('CELERY_LOG_REDIRECT_LEVEL')))
if os.environ.get('FORKED_BY_MULTIPROCESSING'):
# pool did execv after fork
trace.setup_worker_optimizations(app)
else:
app.set_current()
set_default_app(app)
app.finalize()
trace._tasks = app._tasks # enables fast_trace_task optimization.
# rebuild execution handler for all tasks.
from celery.app.trace import build_tracer
for name, task in items(app.tasks):
task.__trace__ = build_tracer(name, task, app.loader, hostname,
app=app)
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks."""
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.maybe_patch_process_group()
platforms.set_mp_process_title('celeryd', hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.log.setup(int(os.environ.get('CELERY_LOG_LEVEL', 0)),
os.environ.get('CELERY_LOG_FILE') or None,
bool(os.environ.get('CELERY_LOG_REDIRECT', False)),
str(os.environ.get('CELERY_LOG_REDIRECT_LEVEL')))
app.loader.init_worker()
app.loader.init_worker_process()
if os.environ.get('FORKED_BY_MULTIPROCESSING'):
# pool did execv after fork
trace.setup_worker_optimizations(app)
else:
app.set_current()
set_default_app(app)
app.finalize()
trace._tasks = app._tasks # enables fast_trace_task optimization.
from celery.task.trace import build_tracer
for name, task in items(app.tasks):
task.__trace__ = build_tracer(name, task, app.loader, hostname)
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Pool child process initializer."""
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.loader.init_worker()
app.loader.init_worker_process()
app.log.setup(
int(os.environ.get("CELERY_LOG_LEVEL", 0)),
os.environ.get("CELERY_LOG_FILE") or None,
bool(os.environ.get("CELERY_LOG_REDIRECT", False)),
str(os.environ.get("CELERY_LOG_REDIRECT_LEVEL")),
)
if os.environ.get("FORKED_BY_MULTIPROCESSING"):
# pool did execv after fork
trace.setup_worker_optimizations(app)
else:
app.set_current()
set_default_app(app)
app.finalize()
trace._tasks = app._tasks # enables fast_trace_task optimization.
from celery.task.trace import build_tracer
for name, task in items(app.tasks):
task.__trace__ = build_tracer(name, task, app.loader, hostname)
signals.worker_process_init.send(sender=None)
def execute_and_trace(task_name, *args, **kwargs):
"""This is a pickleable method used as a target when applying to pools.
It's the same as::
>>> WorkerTaskTrace(task_name, *args, **kwargs).execute_safe()
"""
platforms.set_mp_process_title("celeryd", info=task_name)
try:
return WorkerTaskTrace(task_name, *args, **kwargs).execute_safe()
finally:
platforms.set_mp_process_title("celeryd")
def execute_and_trace(task_name, *args, **kwargs):
"""This is a pickleable method used as a target when applying to pools.
It's the same as::
>>> WorkerTaskTrace(task_name, *args, **kwargs).execute_safe()
"""
hostname = kwargs.get("hostname")
platforms.set_mp_process_title("celeryd", task_name, hostname=hostname)
try:
return WorkerTaskTrace(task_name, *args, **kwargs).execute_safe()
finally:
platforms.set_mp_process_title("celeryd", "-idle-", hostname)
def process_initializer(app, hostname):
"""Pool child process initializer.
Initialize the child pool process to ensure the correct
app instance is used and things like logging works.
"""
_set_task_join_will_block(True)
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.loader.init_worker()
app.loader.init_worker_process()
logfile = os.environ.get("CELERY_LOG_FILE") or None
if logfile and "%i" in logfile.lower():
# logfile path will differ so need to set up logging again.
app.log.already_setup = False
app.log.setup(
int(os.environ.get("CELERY_LOG_LEVEL", 0) or 0),
logfile,
bool(os.environ.get("CELERY_LOG_REDIRECT", False)),
str(os.environ.get("CELERY_LOG_REDIRECT_LEVEL")),
hostname=hostname,
)
if os.environ.get("FORKED_BY_MULTIPROCESSING"):
# pool did execv after fork
trace.setup_worker_optimizations(app, hostname)
else:
app.set_current()
set_default_app(app)
app.finalize()
trace._tasks = app._tasks # enables fast_trace_task optimization.
# rebuild execution handler for all tasks.
from celery.app.trace import build_tracer
for name, task in items(app.tasks):
task.__trace__ = build_tracer(name,
task,
app.loader,
hostname,
app=app)
from celery.worker import state as worker_state
worker_state.reset_state()
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks.
Used for multiprocessing environments.
"""
app = app_or_default(app)
[platforms.reset_signal(signal) for signal in WORKER_SIGRESET]
[platforms.ignore_signal(signal) for signal in WORKER_SIGIGNORE]
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.loader.init_worker()
signals.worker_process_init.send(sender=None)
def process_initializer():
"""Initializes the process so it can be used to process tasks.
Used for multiprocessing environments.
"""
map(platforms.reset_signal, WORKER_SIGRESET)
map(platforms.ignore_signal, WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd")
# This is for windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
from celery.loaders import current_loader
current_loader().init_worker()
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks."""
app = app_or_default(app)
app.set_current()
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.log.setup(int(os.environ.get("CELERY_LOG_LEVEL", 0)),
os.environ.get("CELERY_LOG_FILE") or None,
bool(os.environ.get("CELERY_LOG_REDIRECT", False)),
str(os.environ.get("CELERY_LOG_REDIRECT_LEVEL")))
app.loader.init_worker()
app.loader.init_worker_process()
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks."""
app = app_or_default(app)
app.set_current()
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.log.setup(int(os.environ.get("CELERY_LOG_LEVEL", 0)),
os.environ.get("CELERY_LOG_FILE") or None,
bool(os.environ.get("CELERY_LOG_REDIRECT", False)),
str(os.environ.get("CELERY_LOG_REDIRECT_LEVEL")))
app.loader.init_worker()
app.loader.init_worker_process()
signals.worker_process_init.send(sender=None)
def process_initializer(hostname):
"""Initializes the process so it can be used to process tasks.
Used for multiprocessing environments.
"""
map(platforms.reset_signal, WORKER_SIGRESET)
map(platforms.ignore_signal, WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
from celery.loaders import current_loader
current_loader().init_worker()
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks.
Used for multiprocessing environments.
"""
app = app_or_default(app)
app.set_current()
[platforms.reset_signal(signal) for signal in WORKER_SIGRESET]
[platforms.ignore_signal(signal) for signal in WORKER_SIGIGNORE]
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.loader.init_worker()
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks."""
app.set_current()
set_default_app(app)
trace._tasks = app._tasks # make sure this optimization is set.
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title('celeryd', hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.log.setup(int(os.environ.get('CELERY_LOG_LEVEL', 0)),
os.environ.get('CELERY_LOG_FILE') or None,
bool(os.environ.get('CELERY_LOG_REDIRECT', False)),
str(os.environ.get('CELERY_LOG_REDIRECT_LEVEL')))
app.loader.init_worker()
app.loader.init_worker_process()
app.finalize()
from celery.task.trace import build_tracer
for name, task in app.tasks.iteritems():
task.__trace__ = build_tracer(name, task, app.loader, hostname)
signals.worker_process_init.send(sender=None)
def process_initializer(app, hostname):
"""Initializes the process so it can be used to process tasks."""
app.set_current()
set_default_app(app)
trace._tasks = app._tasks # make sure this optimization is set.
platforms.signals.reset(*WORKER_SIGRESET)
platforms.signals.ignore(*WORKER_SIGIGNORE)
platforms.set_mp_process_title("celeryd", hostname=hostname)
# This is for Windows and other platforms not supporting
# fork(). Note that init_worker makes sure it's only
# run once per process.
app.log.setup(int(os.environ.get("CELERY_LOG_LEVEL", 0)),
os.environ.get("CELERY_LOG_FILE") or None,
bool(os.environ.get("CELERY_LOG_REDIRECT", False)),
str(os.environ.get("CELERY_LOG_REDIRECT_LEVEL")))
app.loader.init_worker()
app.loader.init_worker_process()
app.finalize()
from celery.task.trace import build_tracer
for name, task in app.tasks.iteritems():
task.__trace__ = build_tracer(name, task, app.loader, hostname)
signals.worker_process_init.send(sender=None)
def set_process_status(info):
arg_start = "manage" in sys.argv[0] and 2 or 1
if sys.argv[arg_start:]:
info = "%s (%s)" % (info, " ".join(sys.argv[arg_start:]))
return platforms.set_mp_process_title("celeryd", info=info)
def set_process_status(self, info):
return platforms.set_mp_process_title('celeryd',
info='%s (%s)' % (info, platforms.strargv(sys.argv)),
hostname=self.hostname)
def test_mp_hostname(self, current_process, set_process_title):
current_process().name = 'Foo'
set_mp_process_title('foo', hostname='*****@*****.**', info='hello')
set_process_title.assert_called_with('foo: [email protected]:Foo', info='hello')
def set_process_status(self, info):
return platforms.set_mp_process_title(
'celeryd',
info='%s (%s)' % (info, platforms.strargv(sys.argv)),
hostname=self.hostname)
def set_process_status(self, info):
return platforms.set_mp_process_title(
'celeryd',
info=f'{info} ({platforms.strargv(sys.argv)})',
hostname=self.hostname,
)
def set_process_status(self, info):
info = "%s (%s)" % (info, platforms.strargv(sys.argv))
return platforms.set_mp_process_title("celeryd",
info=info,
hostname=self.hostname)
def set_process_status(self, info):
info = "%s (%s)" % (info, platforms.strargv(sys.argv))
return platforms.set_mp_process_title("celeryd",
info=info,
hostname=self.hostname)
def test_mp_hostname(self, current_process, set_process_title):
current_process().name = 'Foo'
set_mp_process_title('foo', hostname='*****@*****.**', info='hello')
set_process_title.assert_called_with('foo: [email protected]:Foo', info='hello')
def set_process_status(self, info):
return platforms.set_mp_process_title(
'celeryd',
info='{0} ({1})'.format(info, platforms.strargv(sys.argv)),
hostname=self.hostname,
)
def test_mp_hostname(self, current_process, set_process_title):
current_process().name = "Foo"
set_mp_process_title("foo", hostname="*****@*****.**", info="hello")
set_process_title.assert_called_with("foo: [email protected]:Foo", info="hello")
