Beispiel #1
0
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)
Beispiel #2
0
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)
Beispiel #3
0
 def update_strategies(self):
     S = self.strategies
     app = self.app
     loader = app.loader
     hostname = self.hostname
     for name, task in self.app.tasks.iteritems():
         S[name] = task.start_strategy(app, self)
         task.__trace__ = build_tracer(name, task, loader, hostname)
Beispiel #4
0
 def update_strategies(self):
     S = self.strategies
     app = self.app
     loader = app.loader
     hostname = self.hostname
     for name, task in self.app.tasks.iteritems():
         S[name] = task.start_strategy(app, self)
         task.__trace__ = build_tracer(name, task, loader, hostname)
Beispiel #5
0
 def test_fast_trace_task(self):
     from celery.task import trace
     setup_worker_optimizations(self.app)
     self.assertIs(trace.trace_task_ret, trace._fast_trace_task)
     try:
         mytask.__trace__ = build_tracer(mytask.name, mytask,
                                         self.app.loader, 'test')
         res = trace.trace_task_ret(mytask.name, uuid(), [4], {})
         self.assertEqual(res, 4 ** 4)
     finally:
         reset_worker_optimizations()
         self.assertIs(trace.trace_task_ret, trace._trace_task_ret)
     delattr(mytask, '__trace__')
     res = trace.trace_task_ret(mytask.name, uuid(), [4], {})
     self.assertEqual(res, 4 ** 4)
Beispiel #6
0
 def test_fast_trace_task(self):
     from celery.task import trace
     setup_worker_optimizations(self.app)
     self.assertIs(trace.trace_task_ret, trace._fast_trace_task)
     try:
         mytask.__trace__ = build_tracer(mytask.name, mytask,
                                         self.app.loader, 'test')
         res = trace.trace_task_ret(mytask.name, uuid(), [4], {})
         self.assertEqual(res, 4 ** 4)
     finally:
         reset_worker_optimizations()
         self.assertIs(trace.trace_task_ret, trace._trace_task_ret)
     delattr(mytask, '__trace__')
     res = trace.trace_task_ret(mytask.name, uuid(), [4], {})
     self.assertEqual(res, 4 ** 4)
Beispiel #7
0
def execute_and_trace(name, uuid, args, kwargs, request=None, **opts):
    """This is a pickleable method used as a target when applying to pools.

    It's the same as::

        >>> trace_task(name, *args, **kwargs)[0]

    """
    task = _tls.current_app._tasks[name]
    try:
        hostname = opts.get("hostname")
        setps("celeryd", name, hostname, rate_limit=True)
        try:
            if task.__tracer__ is None:
                task.__tracer__ = build_tracer(name, task, **opts)
            return task.__tracer__(uuid, args, kwargs, request)[0]
        finally:
            setps("celeryd", "-idle-", hostname, rate_limit=True)
    except Exception, exc:
        return report_internal_error(task, exc)
Beispiel #8
0
def execute_and_trace(name, uuid, args, kwargs, request=None, **opts):
    """This is a pickleable method used as a target when applying to pools.

    It's the same as::

        >>> trace_task(name, *args, **kwargs)[0]

    """
    task = current_app.tasks[name]
    try:
        hostname = opts.get("hostname")
        setps("celeryd", name, hostname, rate_limit=True)
        try:
            if task.__tracer__ is None:
                task.__tracer__ = build_tracer(name, task, **opts)
            return task.__tracer__(uuid, args, kwargs, request)[0]
        finally:
            setps("celeryd", "-idle-", hostname, rate_limit=True)
    except Exception, exc:
        return report_internal_error(task, exc)
Beispiel #9
0
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()
    app.finalize()

    from celery.task.trace import build_tracer
    for name, task in app.tasks.iteritems():
        task.__tracer__ = 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)
Beispiel #11
0
 def update_strategies(self):
     loader = self.app.loader
     for name, task in items(self.app.tasks):
         self.strategies[name] = task.start_strategy(self.app, self)
         task.__trace__ = build_tracer(name, task, loader, self.hostname)
Beispiel #12
0
 def update_strategies(self):
     loader = self.app.loader
     for name, task in items(self.app.tasks):
         self.strategies[name] = task.start_strategy(self.app, self)
         task.__trace__ = build_tracer(name, task, loader, self.hostname)
Beispiel #13
0
 def test_trace_task_ret(self):
     mytask.__trace__ = build_tracer(mytask.name, mytask,
                                     self.app.loader, 'test')
     res = _trace_task_ret(mytask.name, uuid(), [4], {})
     self.assertEqual(res, 4 ** 4)
Beispiel #14
0
 def test_trace_task_ret(self):
     mytask.__trace__ = build_tracer(mytask.name, mytask,
                                     current_app.loader, "test")
     res = trace_task_ret(mytask.name, uuid(), [4], {})
     self.assertEqual(res, 4**4)
Beispiel #15
0
 def test_trace_task_ret(self):
     mytask.__trace__ = build_tracer(mytask.name, mytask,
                                     self.app.loader, 'test')
     res = _trace_task_ret(mytask.name, uuid(), [4], {})
     self.assertEqual(res, 4 ** 4)
Beispiel #16
0
 def test_trace_task_ret(self):
     mytask.__trace__ = build_tracer(mytask.name, mytask,
                                     current_app.loader, "test")
     res = trace_task_ret(mytask.name, uuid(), [4], {})
     self.assertEqual(res, 4 ** 4)