Python process_initializerの例

コード例 #1

ファイル: test_worker.py プロジェクト: AdrianRibao/celery

    def test_process_initializer(self, set_mp_process_title, _signals):
        from celery import Celery
        from celery import signals
        from celery.state import _tls
        from celery.concurrency.processes import process_initializer
        from celery.concurrency.processes import (WORKER_SIGRESET,
                                                  WORKER_SIGIGNORE)

        def on_worker_process_init(**kwargs):
            on_worker_process_init.called = True
        on_worker_process_init.called = False
        signals.worker_process_init.connect(on_worker_process_init)

        loader = Mock()
        loader.override_backends = {}
        app = Celery(loader=loader, set_as_current=False)
        app.loader = loader
        app.conf = AttributeDict(DEFAULTS)
        process_initializer(app, "awesome.worker.com")
        _signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
        _signals.reset.assert_any_call(*WORKER_SIGRESET)
        self.assertTrue(app.loader.init_worker.call_count)
        self.assertTrue(on_worker_process_init.called)
        self.assertIs(_tls.current_app, app)
        set_mp_process_title.assert_called_with("celeryd",
                        hostname="awesome.worker.com")

コード例 #2

ファイル: test_worker.py プロジェクト: fxiang21/company_bt

    def test_process_initializer(self, set_mp_process_title, _signals):
        from celery import Celery
        from celery import signals
        from celery._state import _tls
        from celery.concurrency.processes import process_initializer
        from celery.concurrency.processes import (WORKER_SIGRESET,
                                                  WORKER_SIGIGNORE)

        def on_worker_process_init(**kwargs):
            on_worker_process_init.called = True

        on_worker_process_init.called = False
        signals.worker_process_init.connect(on_worker_process_init)

        loader = Mock()
        loader.override_backends = {}
        app = Celery(loader=loader, set_as_current=False)
        app.loader = loader
        app.conf = AttributeDict(DEFAULTS)
        process_initializer(app, 'awesome.worker.com')
        _signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
        _signals.reset.assert_any_call(*WORKER_SIGRESET)
        self.assertTrue(app.loader.init_worker.call_count)
        self.assertTrue(on_worker_process_init.called)
        self.assertIs(_tls.current_app, app)
        set_mp_process_title.assert_called_with(
            'celeryd',
            hostname='awesome.worker.com',
        )

コード例 #3

ファイル: __init__.py プロジェクト: crankycoder/zamboni-lib

    def test_process_initializer(self, set_mp_process_title, _signals):
        from celery import Celery
        from celery import signals
        from celery.app import _tls
        from celery.concurrency.processes import process_initializer
        from celery.concurrency.processes import (WORKER_SIGRESET,
                                                  WORKER_SIGIGNORE)

        def on_worker_process_init(**kwargs):
            on_worker_process_init.called = True

        on_worker_process_init.called = False
        signals.worker_process_init.connect(on_worker_process_init)

        loader = Mock()
        app = Celery(loader=loader, set_as_current=False)
        app.conf = AttributeDict(DEFAULTS)
        process_initializer(app, "awesome.worker.com")
        self.assertIn((tuple(WORKER_SIGIGNORE), {}),
                      _signals.ignore.call_args_list)
        self.assertIn((tuple(WORKER_SIGRESET), {}),
                      _signals.reset.call_args_list)
        self.assertTrue(app.loader.init_worker.call_count)
        self.assertTrue(on_worker_process_init.called)
        self.assertIs(_tls.current_app, app)
        set_mp_process_title.assert_called_with("celeryd",
                                                hostname="awesome.worker.com")

コード例 #4

ファイル: test_worker.py プロジェクト: charettes/celery

    def test_process_initializer(self, set_mp_process_title, _signals):
        from celery import Celery
        from celery import signals
        from celery._state import _tls
        from celery.concurrency.processes import process_initializer
        from celery.concurrency.processes import (WORKER_SIGRESET,
                                                  WORKER_SIGIGNORE)

        def on_worker_process_init(**kwargs):
            on_worker_process_init.called = True
        on_worker_process_init.called = False
        signals.worker_process_init.connect(on_worker_process_init)

        loader = Mock()
        loader.override_backends = {}
        app = Celery(loader=loader, set_as_current=False)
        app.loader = loader
        app.conf = AttributeDict(DEFAULTS)
        process_initializer(app, 'awesome.worker.com')
        _signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
        _signals.reset.assert_any_call(*WORKER_SIGRESET)
        self.assertTrue(app.loader.init_worker.call_count)
        self.assertTrue(on_worker_process_init.called)
        self.assertIs(_tls.current_app, app)
        set_mp_process_title.assert_called_with(
            'celeryd', hostname='awesome.worker.com',
        )

        with patch('celery.task.trace.setup_worker_optimizations') as swo:
            os.environ['FORKED_BY_MULTIPROCESSING'] = "1"
            try:
                process_initializer(app, 'luke.worker.com')
                swo.assert_called_with(app)
            finally:
                os.environ.pop('FORKED_BY_MULTIPROCESSING', None)

コード例 #5

    def test_process_initializer(self, set_mp_process_title, _signals):
        from celery import Celery
        from celery import signals
        from celery._state import _tls
        from celery.concurrency.processes import process_initializer
        from celery.concurrency.processes import (WORKER_SIGRESET,
                                                  WORKER_SIGIGNORE)

        def on_worker_process_init(**kwargs):
            on_worker_process_init.called = True
        on_worker_process_init.called = False
        signals.worker_process_init.connect(on_worker_process_init)

        loader = Mock()
        loader.override_backends = {}
        app = Celery(loader=loader, set_as_current=False)
        app.loader = loader
        app.conf = AttributeDict(DEFAULTS)
        process_initializer(app, 'awesome.worker.com')
        _signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
        _signals.reset.assert_any_call(*WORKER_SIGRESET)
        self.assertTrue(app.loader.init_worker.call_count)
        self.assertTrue(on_worker_process_init.called)
        self.assertIs(_tls.current_app, app)
        set_mp_process_title.assert_called_with(
            'celeryd', hostname='awesome.worker.com',
        )

        with patch('celery.app.trace.setup_worker_optimizations') as swo:
            os.environ['FORKED_BY_MULTIPROCESSING'] = "1"
            try:
                process_initializer(app, 'luke.worker.com')
                swo.assert_called_with(app)
            finally:
                os.environ.pop('FORKED_BY_MULTIPROCESSING', None)

コード例 #6

ファイル: test_worker.py プロジェクト: nonoDevil/celery

    def test_process_initializer(self, set_mp_process_title, _signals):
        with restore_logging():
            from celery import signals
            from celery._state import _tls
            from celery.concurrency.processes import process_initializer, WORKER_SIGRESET, WORKER_SIGIGNORE

            def on_worker_process_init(**kwargs):
                on_worker_process_init.called = True

            on_worker_process_init.called = False
            signals.worker_process_init.connect(on_worker_process_init)

            def Loader(*args, **kwargs):
                loader = Mock(*args, **kwargs)
                loader.conf = {}
                loader.override_backends = {}
                return loader

            with self.Celery(loader=Loader) as app:
                app.conf = AttributeDict(DEFAULTS)
                process_initializer(app, "awesome.worker.com")
                _signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
                _signals.reset.assert_any_call(*WORKER_SIGRESET)
                self.assertTrue(app.loader.init_worker.call_count)
                self.assertTrue(on_worker_process_init.called)
                self.assertIs(_tls.current_app, app)
                set_mp_process_title.assert_called_with("celeryd", hostname="awesome.worker.com")

                with patch("celery.app.trace.setup_worker_optimizations") as S:
                    os.environ["FORKED_BY_MULTIPROCESSING"] = "1"
                    try:
                        process_initializer(app, "luke.worker.com")
                        S.assert_called_with(app)
                    finally:
                        os.environ.pop("FORKED_BY_MULTIPROCESSING", None)

コード例 #7

ファイル: __init__.py プロジェクト: jterrace/celery

    def test_process_initializer(self, set_mp_process_title, _signals):
        from celery import Celery
        from celery import signals
        from celery.app import _tls
        from celery.concurrency.processes import process_initializer
        from celery.concurrency.processes import WORKER_SIGRESET, WORKER_SIGIGNORE

        def on_worker_process_init(**kwargs):
            on_worker_process_init.called = True

        on_worker_process_init.called = False
        signals.worker_process_init.connect(on_worker_process_init)

        app = Celery(loader=Mock(), set_as_current=False)
        process_initializer(app, "awesome.worker.com")
        self.assertIn((tuple(WORKER_SIGIGNORE), {}), _signals.ignore.call_args_list)
        self.assertIn((tuple(WORKER_SIGRESET), {}), _signals.reset.call_args_list)
        self.assertTrue(app.loader.init_worker.call_count)
        self.assertTrue(on_worker_process_init.called)
        self.assertIs(_tls.current_app, app)
        set_mp_process_title.assert_called_with("celeryd", hostname="awesome.worker.com")