Beispiel #1
0
    def on_start(self):
        if not self._custom_logging and self.redirect_stdouts:
            self.app.log.redirect_stdouts(self.redirect_stdouts_level)

        WorkController.on_start(self)

        # this signal can be used to e.g. change queues after
        # the -Q option has been applied.
        signals.celeryd_after_setup.send(sender=self.hostname, instance=self, conf=self.app.conf)

        if not self.app.conf.value_set_for("accept_content"):
            warnings.warn(CDeprecationWarning(W_PICKLE_DEPRECATED))

        if self.purge:
            self.purge_messages()

        # Dump configuration to screen so we have some basic information
        # for when users sends bug reports.
        print(
            safe_str(
                "".join(
                    [
                        string(self.colored.cyan(" \n", self.startup_info())),
                        string(self.colored.reset(self.extra_info() or "")),
                    ]
                )
            ),
            file=sys.__stdout__,
        )
        self.set_process_status("-active-")
        self.install_platform_tweaks(self)
Beispiel #2
0
    def on_start(self):
        app = self.app
        WorkController.on_start(self)

        # this signal can be used to e.g. change queues after
        # the -Q option has been applied.
        signals.celeryd_after_setup.send(
            sender=self.hostname, instance=self, conf=app.conf,
        )

        if self.purge:
            self.purge_messages()

        # Dump configuration to screen so we have some basic information
        # for when users sends bug reports.
        use_image = self._term_supports_images()
        if use_image:
            self.termimage(static.logo_as_base64())
        print(safe_str(''.join([
            string(self.colored.cyan(
                ' \n', self.startup_info(artlines=not use_image))),
            string(self.colored.reset(self.extra_info() or '')),
        ])), file=sys.__stdout__)
        self.set_process_status('-active-')
        self.install_platform_tweaks(self)
        if not self._custom_logging and self.redirect_stdouts:
            app.log.redirect_stdouts(self.redirect_stdouts_level)
Beispiel #3
0
    def on_start(self):
        if not self._custom_logging and self.redirect_stdouts:
            self.app.log.redirect_stdouts(self.redirect_stdouts_level)

        WorkController.on_start(self)

        # this signal can be used to e.g. change queues after
        # the -Q option has been applied.
        signals.celeryd_after_setup.send(
            sender=self.hostname, instance=self, conf=self.app.conf,
        )

        if getattr(os, 'getuid', None) and os.getuid() == 0:
            accept_encoding = self.app.conf.CELERY_ACCEPT_CONTENT
            if ('pickle' in accept_encoding or
                    'application/x-python-serialize' in accept_encoding):
                if not C_FORCE_ROOT:
                    raise RuntimeError(ROOT_DISALLOWED)
            warnings.warn(RuntimeWarning(ROOT_DISCOURAGED))

        if not self.app.conf.value_set_for('CELERY_ACCEPT_CONTENT'):
            warnings.warn(CDeprecationWarning(W_PICKLE_DEPRECATED))

        if self.purge:
            self.purge_messages()

        # Dump configuration to screen so we have some basic information
        # for when users sends bug reports.
        print(''.join([
            string(self.colored.cyan(' \n', self.startup_info())),
            string(self.colored.reset(self.extra_info() or '')),
        ]), file=sys.__stdout__)
        self.set_process_status('-active-')
        self.install_platform_tweaks(self)
Beispiel #4
0
 def emit_banner(self):
     # Dump configuration to screen so we have some basic information
     # for when users sends bug reports.
     use_image = term.supports_images()
     if use_image:
         print(term.imgcat(static.logo()))
     print(safe_str(''.join([
         string(self.colored.cyan(
             ' \n', self.startup_info(artlines=not use_image))),
         string(self.colored.reset(self.extra_info() or '')),
     ])), file=sys.__stdout__)
Beispiel #5
0
    def _fold_no_color(self, a, b):
        try:
            A = a.no_color()
        except AttributeError:
            A = string(a)
        try:
            B = b.no_color()
        except AttributeError:
            B = string(b)

        return ''.join((string(A), string(B)))
Beispiel #6
0
    def _fold_no_color(self, a, b):
        try:
            A = a.no_color()
        except AttributeError:
            A = string(a)
        try:
            B = b.no_color()
        except AttributeError:
            B = string(b)

        return safe_str(safe_str(A) + safe_str(B))
Beispiel #7
0
    def test_unicode(self):
        class X(object):
            def __unicode__(self):
                return "UNICODE"

            __str__ = __unicode__

            def __repr__(self):
                return "REPR"

        x = Proxy(lambda: X())
        self.assertEqual(string(x), "UNICODE")
        del (X.__unicode__)
        del (X.__str__)
        self.assertEqual(string(x), "REPR")
Beispiel #8
0
    def on_failure(self, exc_info):
        """Handler called if the task raised an exception."""
        task_ready(self)
        send_failed_event = True

        if not exc_info.internal:
            exc = exc_info.exception

            if isinstance(exc, Retry):
                return self.on_retry(exc_info)

            # These are special cases where the process would not have had
            # time to write the result.
            if self.store_errors:
                if isinstance(exc, WorkerLostError):
                    self.task.backend.mark_as_failure(
                        self.id, exc, request=self,
                    )
                elif isinstance(exc, Terminated):
                    self._announce_revoked(
                        'terminated', True, string(exc), False)
                    send_failed_event = False  # already sent revoked event
            # (acks_late) acknowledge after result stored.
            if self.task.acks_late:
                self.acknowledge()
        self._log_error(exc_info, send_failed_event=send_failed_event)
Beispiel #9
0
    def test_unicode(self):

        class X(object):

            def __unicode__(self):
                return 'UNICODE'
            __str__ = __unicode__

            def __repr__(self):
                return 'REPR'

        x = Proxy(lambda: X())
        self.assertEqual(string(x), 'UNICODE')
        del(X.__unicode__)
        del(X.__str__)
        self.assertEqual(string(x), 'REPR')
Beispiel #10
0
    def test_unicode(self):

        @python_2_unicode_compatible
        class X(object):

            def __unicode__(self):
                return 'UNICODE'
            __str__ = __unicode__

            def __repr__(self):
                return 'REPR'

        x = Proxy(lambda: X())
        assert string(x) == 'UNICODE'
        del(X.__unicode__)
        del(X.__str__)
        assert string(x) == 'REPR'
Beispiel #11
0
 def _index(self, id, body, **kwargs):
     return self.server.index(
         id=string(id),
         index=self.index,
         doc_type=self.doc_type,
         body=body,
         **kwargs
     )
Beispiel #12
0
 def test_pylibmc_unicode_key(self):
     with mock.reset_modules('celery.backends.cache'):
         with self.mock_pylibmc():
             from celery.backends import cache
             cache._imp = [None]
             task_id, result = string(uuid()), 42
             b = cache.CacheBackend(backend='memcache', app=self.app)
             b.store_result(task_id, result, state=states.SUCCESS)
             self.assertEqual(b.get_result(task_id), result)
Beispiel #13
0
 def test_pylibmc_unicode_key(self):
     with reset_modules('celery.backends.cache'):
         with self.mock_pylibmc():
             from celery.backends import cache
             cache._imp = [None]
             task_id, result = string(uuid()), 42
             b = cache.CacheBackend(backend='memcache', app=self.app)
             b.store_result(task_id, result, state=states.SUCCESS)
             self.assertEqual(b.get_result(task_id), result)
Beispiel #14
0
 def pretty(self, n):
     OK = str(self.colored.green('OK'))
     if isinstance(n, list):
         return OK, self.pretty_list(n)
     if isinstance(n, dict):
         if 'ok' in n or 'error' in n:
             return self.pretty_dict_ok_error(n)
     if isinstance(n, string_t):
         return OK, string(n)
     return OK, pformat(n)
Beispiel #15
0
 def prettify(self, n):
     OK = str(self.colored.green('OK'))
     if isinstance(n, list):
         return OK, self.prettify_list(n)
     if isinstance(n, dict):
         if 'ok' in n or 'error' in n:
             return self.prettify_dict_ok_error(n)
     if isinstance(n, string_t):
         return OK, string(n)
     return OK, pformat(n)
Beispiel #16
0
    def on_failure(self, exc_info, send_failed_event=True, return_ok=False):
        """Handler called if the task raised an exception."""
        task_ready(self)
        if isinstance(exc_info.exception, MemoryError):
            raise MemoryError('Process got: %s' % (exc_info.exception, ))
        elif isinstance(exc_info.exception, Reject):
            return self.reject(requeue=exc_info.exception.requeue)
        elif isinstance(exc_info.exception, Ignore):
            return self.acknowledge()

        exc = exc_info.exception

        if isinstance(exc, Retry):
            return self.on_retry(exc_info)

        # (acks_late) acknowledge after result stored.
        requeue = False
        if self.task.acks_late:
            reject = (self.task.reject_on_worker_lost
                      and isinstance(exc, WorkerLostError))
            ack = self.task.acks_on_failure_or_timeout
            if reject:
                requeue = not self.delivery_info.get('redelivered')
                self.reject(requeue=requeue)
                send_failed_event = False
            elif ack:
                self.acknowledge()

        # These are special cases where the process would not have had time
        # to write the result.
        if isinstance(exc, Terminated):
            self._announce_revoked('terminated', True, string(exc), False)
            send_failed_event = False  # already sent revoked event
        elif not requeue and (isinstance(exc, WorkerLostError)
                              or not return_ok):
            # only mark as failure if task has not been requeued
            self.task.backend.mark_as_failure(
                self.id,
                exc,
                request=self._context,
                store_result=self.store_errors,
            )

        if send_failed_event:
            self.send_event(
                'task-failed',
                exception=safe_repr(get_pickled_exception(exc_info.exception)),
                traceback=exc_info.traceback,
            )

        if not return_ok:
            error('Task handler raised error: %r',
                  exc,
                  exc_info=exc_info.exc_info)
Beispiel #17
0
    def test_memcache_unicode_key(self):
        with self.mock_memcache():
            with reset_modules("celery.backends.cache"):
                with mask_modules("pylibmc"):
                    from celery.backends import cache

                    cache._imp = [None]
                    task_id, result = string(uuid()), 42
                    b = cache.CacheBackend(backend="memcache")
                    b.store_result(task_id, result, status=states.SUCCESS)
                    self.assertEqual(b.get_result(task_id), result)
Beispiel #18
0
 def emit_banner(self):
     # Dump configuration to screen so we have some basic information
     # for when users sends bug reports.
     use_image = term.supports_images()
     if use_image:
         print(term.imgcat(static.logo()))
     print(
         safe_str(
             "".join(
                 [
                     string(
                         self.colored.cyan(
                             " \n", self.startup_info(artlines=not use_image)
                         )
                     ),
                     string(self.colored.reset(self.extra_info() or "")),
                 ]
             )
         ),
         file=sys.__stdout__,
     )
Beispiel #19
0
 def pretty(self, n):
     OK = str(self.colored.green('OK'))
     if isinstance(n, list):
         return OK, self.pretty_list(n)
     if isinstance(n, dict):
         if 'ok' in n or 'error' in n:
             return self.pretty_dict_ok_error(n)
         else:
             return OK, json.dumps(n, sort_keys=True, indent=4)
     if isinstance(n, string_t):
         return OK, string(n)
     return OK, pformat(n)
Beispiel #20
0
 def pretty(self, n):
     OK = str(self.colored.green('OK'))
     if isinstance(n, list):
         return OK, self.pretty_list(n)
     if isinstance(n, dict):
         if 'ok' in n or 'error' in n:
             return self.pretty_dict_ok_error(n)
         else:
             return OK, json.dumps(n, sort_keys=True, indent=4)
     if isinstance(n, string_t):
         return OK, string(n)
     return OK, pformat(n)
Beispiel #21
0
    def on_failure(self, exc_info, send_failed_event=True, return_ok=False):
        """Handler called if the task raised an exception."""
        task_ready(self)
        if isinstance(exc_info.exception, MemoryError):
            raise MemoryError('Process got: %s' % (exc_info.exception,))
        elif isinstance(exc_info.exception, Reject):
            return self.reject(requeue=exc_info.exception.requeue)
        elif isinstance(exc_info.exception, Ignore):
            return self.acknowledge()

        exc = exc_info.exception

        if isinstance(exc, Retry):
            return self.on_retry(exc_info)

        # These are special cases where the process wouldn't've had
        # time to write the result.
        if isinstance(exc, Terminated):
            self._announce_revoked(
                'terminated', True, string(exc), False)
            send_failed_event = False  # already sent revoked event
        elif isinstance(exc, WorkerLostError) or not return_ok:
            self.task.backend.mark_as_failure(
                self.id, exc, request=self._context,
                store_result=self.store_errors,
            )
        # (acks_late) acknowledge after result stored.
        if self.task.acks_late:
            reject = (
                self.task.reject_on_worker_lost and
                isinstance(exc, WorkerLostError)
            )
            ack = self.task.acks_on_failure_or_timeout
            if reject:
                requeue = not self.delivery_info.get('redelivered')
                self.reject(requeue=requeue)
                send_failed_event = False
            elif ack:
                self.acknowledge()

        if send_failed_event:
            self.send_event(
                'task-failed',
                exception=safe_repr(get_pickled_exception(exc_info.exception)),
                traceback=exc_info.traceback,
            )

        if not return_ok:
            error('Task handler raised error: %r', exc,
                  exc_info=exc_info.exc_info)
Beispiel #22
0
    def on_start(self):
        if not self._custom_logging and self.redirect_stdouts:
            self.app.log.redirect_stdouts(self.redirect_stdouts_level)

        WorkController.on_start(self)

        # this signal can be used to e.g. change queues after
        # the -Q option has been applied.
        signals.celeryd_after_setup.send(
            sender=self.hostname,
            instance=self,
            conf=self.app.conf,
        )

        if getattr(os, 'getuid', None) and os.getuid() == 0:
            accept_encoding = self.app.conf.CELERY_ACCEPT_CONTENT
            if ('pickle' in accept_encoding
                    or 'application/x-python-serialize' in accept_encoding):
                if not C_FORCE_ROOT:
                    raise RuntimeError(ROOT_DISALLOWED)
            warnings.warn(RuntimeWarning(ROOT_DISCOURAGED))

        if not self.app.conf.value_set_for('CELERY_ACCEPT_CONTENT'):
            warnings.warn(CDeprecationWarning(W_PICKLE_DEPRECATED))

        if self.purge:
            self.purge_messages()

        # Dump configuration to screen so we have some basic information
        # for when users sends bug reports.
        print(''.join([
            string(self.colored.cyan(' \n', self.startup_info())),
            string(self.colored.reset(self.extra_info() or '')),
        ]),
              file=sys.__stdout__)
        self.set_process_status('-active-')
        self.install_platform_tweaks(self)
Beispiel #23
0
    def on_start(self):
        app = self.app
        if not self._custom_logging and self.redirect_stdouts:
            app.log.redirect_stdouts(self.redirect_stdouts_level)

        WorkController.on_start(self)

        # this signal can be used to e.g. change queues after
        # the -Q option has been applied.
        signals.celeryd_after_setup.send(
            sender=self.hostname, instance=self, conf=app.conf,
        )

        if self.purge:
            self.purge_messages()

        # Dump configuration to screen so we have some basic information
        # for when users sends bug reports.
        print(safe_str(''.join([
            string(self.colored.cyan(' \n', self.startup_info())),
            string(self.colored.reset(self.extra_info() or '')),
        ])), file=sys.__stdout__)
        self.set_process_status('-active-')
        self.install_platform_tweaks(self)
Beispiel #24
0
    def test_index(self):
        x = ElasticsearchBackend(app=self.app)
        x.doc_type = 'test-doc-type'
        x._server = Mock()
        x._server.index = Mock()
        expected_result = dict(_id=sentinel.task_id,
                               _source={'result': sentinel.result})
        x._server.index.return_value = expected_result

        body = {"field1": "value1"}
        x._index(id=sentinel.task_id, body=body, kwarg1='test1')
        x._server.index.assert_called_once_with(id=string(sentinel.task_id),
                                                doc_type=x.doc_type,
                                                index=x.index,
                                                body=body,
                                                kwarg1='test1')
Beispiel #25
0
    def startup_info(self):
        app = self.app
        concurrency = string(self.concurrency)
        appr = '{0}:{1:#x}'.format(app.main or '__main__', id(app))
        if not isinstance(app.loader, AppLoader):
            loader = qualname(app.loader)
            if loader.startswith('celery.loaders'):  # pragma: no cover
                loader = loader[14:]
            appr += ' ({0})'.format(loader)
        if self.autoscale:
            max, min = self.autoscale
            concurrency = '{{min={0}, max={1}}}'.format(min, max)
        pool = self.pool_cls
        if not isinstance(pool, string_t):
            pool = pool.__module__
        concurrency += ' ({0})'.format(pool.split('.')[-1])
        events = 'ON'
        if not self.send_events:
            events = 'OFF (enable -E to monitor this worker)'

        banner = BANNER.format(
            app=appr,
            hostname=safe_str(self.hostname),
            timestamp=datetime.now().replace(microsecond=0),
            version=VERSION_BANNER,
            conninfo=self.app.connection().as_uri(),
            results=maybe_sanitize_url(
                self.app.conf.result_backend or 'disabled',
            ),
            concurrency=concurrency,
            platform=safe_str(_platform.platform()),
            events=events,
            queues=app.amqp.queues.format(indent=0, indent_first=False),
        ).splitlines()

        # integrate the ASCII art.
        for i, x in enumerate(banner):
            try:
                banner[i] = ' '.join([ARTLINES[i], banner[i]])
            except IndexError:
                banner[i] = ' ' * 16 + banner[i]
        return '\n'.join(banner) + '\n'
    def test_index(self):
        x = ElasticsearchBackend(app=self.app)
        x.doc_type = 'test-doc-type'
        x._server = Mock()
        x._server.index = Mock()
        expected_result = dict(
            _id=sentinel.task_id,
            _source={'result': sentinel.result}
        )
        x._server.index.return_value = expected_result

        body = {"field1": "value1"}
        x._index(id=sentinel.task_id, body=body, kwarg1='test1')
        x._server.index.assert_called_once_with(
            id=string(sentinel.task_id),
            doc_type=x.doc_type,
            index=x.index,
            body=body,
            kwarg1='test1'
        )
Beispiel #27
0
    def startup_info(self, artlines=True):
        app = self.app
        concurrency = string(self.concurrency)
        appr = "{0}:{1:#x}".format(app.main or "__main__", id(app))
        if not isinstance(app.loader, AppLoader):
            loader = qualname(app.loader)
            if loader.startswith("celery.loaders"):  # pragma: no cover
                loader = loader[14:]
            appr += " ({0})".format(loader)
        if self.autoscale:
            max, min = self.autoscale
            concurrency = "{{min={0}, max={1}}}".format(min, max)
        pool = self.pool_cls
        if not isinstance(pool, string_t):
            pool = pool.__module__
        concurrency += " ({0})".format(pool.split(".")[-1])
        events = "ON"
        if not self.task_events:
            events = "OFF (enable -E to monitor tasks in this worker)"

        banner = BANNER.format(
            app=appr,
            hostname=safe_str(self.hostname),
            timestamp=datetime.now().replace(microsecond=0),
            version=VERSION_BANNER,
            conninfo=self.app.connection().as_uri(),
            results=self.app.backend.as_uri(),
            concurrency=concurrency,
            platform=safe_str(_platform.platform()),
            events=events,
            queues=app.amqp.queues.format(indent=0, indent_first=False),
        ).splitlines()

        # integrate the ASCII art.
        if artlines:
            for i, _ in enumerate(banner):
                try:
                    banner[i] = " ".join([ARTLINES[i], banner[i]])
                except IndexError:
                    banner[i] = " " * 16 + banner[i]
        return "\n".join(banner) + "\n"
Beispiel #28
0
    def startup_info(self):
        app = self.app
        concurrency = string(self.concurrency)
        appr = '{0}:{1:#x}'.format(app.main or '__main__', id(app))
        if not isinstance(app.loader, AppLoader):
            loader = qualname(app.loader)
            if loader.startswith('celery.loaders'):  # pragma: no cover
                loader = loader[14:]
            appr += ' ({0})'.format(loader)
        if self.autoscale:
            max, min = self.autoscale
            concurrency = '{{min={0}, max={1}}}'.format(min, max)
        pool = self.pool_cls
        if not isinstance(pool, string_t):
            pool = pool.__module__
        concurrency += ' ({0})'.format(pool.split('.')[-1])
        events = 'ON'
        if not self.send_events:
            events = 'OFF (enable -E to monitor this worker)'

        banner = BANNER.format(
            app=appr,
            hostname=safe_str(self.hostname),
            version=VERSION_BANNER,
            conninfo=self.app.connection().as_uri(),
            results=maybe_sanitize_url(
                self.app.conf.result_backend or 'disabled',
            ),
            concurrency=concurrency,
            platform=safe_str(_platform.platform()),
            events=events,
            queues=app.amqp.queues.format(indent=0, indent_first=False),
        ).splitlines()

        # integrate the ASCII art.
        for i, x in enumerate(banner):
            try:
                banner[i] = ' '.join([ARTLINES[i], banner[i]])
            except IndexError:
                banner[i] = ' ' * 16 + banner[i]
        return '\n'.join(banner) + '\n'
Beispiel #29
0
    def test_set(self):

        self.backend._client = MagicMock()
        self.backend._client.put_item = MagicMock()

        # should return None
        with patch('celery.backends.dynamodb.time', self._mock_time):
            assert self.backend.set(sentinel.key, sentinel.value) is None

        assert self.backend._client.put_item.call_count == 1
        _, call_kwargs = self.backend._client.put_item.call_args
        expected_kwargs = {
            'Item': {
                u'timestamp': {u'N': str(self._static_timestamp)},
                u'id': {u'S': string(sentinel.key)},
                u'result': {u'B': sentinel.value}
            },
            'TableName': 'celery'
        }
        assert call_kwargs['Item'] == expected_kwargs['Item']
        assert call_kwargs['TableName'] == 'celery'
Beispiel #30
0
    def test_set(self):

        self.backend._client = MagicMock()
        self.backend._client.put_item = MagicMock()

        # should return None
        with patch('celery.backends.dynamodb.time', self._mock_time):
            assert self.backend.set(sentinel.key, sentinel.value) is None

        assert self.backend._client.put_item.call_count == 1
        _, call_kwargs = self.backend._client.put_item.call_args
        expected_kwargs = {
            'Item': {
                u'timestamp': {u'N': str(self._static_timestamp)},
                u'id': {u'S': string(sentinel.key)},
                u'result': {u'B': sentinel.value}
            },
            'TableName': 'celery'
        }
        assert call_kwargs['Item'] == expected_kwargs['Item']
        assert call_kwargs['TableName'] == 'celery'
Beispiel #31
0
    def startup_info(self):
        app = self.app
        concurrency = string(self.concurrency)
        appr = "{0}:{1:#x}".format(app.main or "__main__", id(app))
        if not isinstance(app.loader, AppLoader):
            loader = qualname(app.loader)
            if loader.startswith("celery.loaders"):
                loader = loader[14:]
            appr += " ({0})".format(loader)
        if self.autoscale:
            max, min = self.autoscale
            concurrency = "{{min={0}, max={1}}}".format(min, max)
        pool = self.pool_cls
        if not isinstance(pool, string_t):
            pool = pool.__module__
        concurrency += " ({0})".format(pool.split(".")[-1])
        events = "ON"
        if not self.send_events:
            events = "OFF (enable -E to monitor this worker)"

        banner = BANNER.format(
            app=appr,
            hostname=safe_str(self.hostname),
            version=VERSION_BANNER,
            conninfo=self.app.connection().as_uri(),
            results=maybe_sanitize_url(self.app.conf.result_backend or "disabled"),
            concurrency=concurrency,
            platform=safe_str(_platform.platform()),
            events=events,
            queues=app.amqp.queues.format(indent=0, indent_first=False),
        ).splitlines()

        # integrate the ASCII art.
        for i, x in enumerate(banner):
            try:
                banner[i] = " ".join([ARTLINES[i], banner[i]])
            except IndexError:
                banner[i] = " " * 16 + banner[i]
        return "\n".join(banner) + "\n"
Beispiel #32
0
    def startup_info(self, artlines=True):
        app = self.app
        concurrency = string(self.concurrency)
        appr = '{0}:{1:#x}'.format(app.main or '__main__', id(app))
        if not isinstance(app.loader, AppLoader):
            loader = qualname(app.loader)
            if loader.startswith('celery.loaders'):  # pragma: no cover
                loader = loader[14:]
            appr += ' ({0})'.format(loader)
        pool = self.pool_cls
        if not isinstance(pool, string_t):
            pool = pool.__module__
        concurrency += ' ({0})'.format(pool.split('.')[-1])
        events = 'ON'
        if not self.task_events:
            events = 'OFF (enable -E to monitor tasks in this worker)'

        banner = BANNER.format(
            app=appr,
            hostname=safe_str(self.hostname),
            timestamp=datetime.now().replace(microsecond=0),
            version=VERSION_BANNER,
            conninfo=self.app.connection().as_uri(),
            results=self.app.backend.as_uri(),
            concurrency=concurrency,
            platform=safe_str(_platform.platform()),
            events=events,
            queues=app.amqp.queues.format(indent=0, indent_first=False),
        ).splitlines()

        # integrate the ASCII art.
        if artlines:
            for i, x in enumerate(banner):
                try:
                    banner[i] = ' '.join([ARTLINES[i], banner[i]])
                except IndexError:
                    banner[i] = ' ' * 16 + banner[i]
        return '\n'.join(banner) + '\n'
Beispiel #33
0
    def on_failure(self, exc_info, send_failed_event=True, return_ok=False):
        """Handler called if the task raised an exception."""
        task_ready(self)

        if isinstance(exc_info.exception, MemoryError):
            raise MemoryError("Process got: %s" % (exc_info.exception,))
        elif isinstance(exc_info.exception, Reject):
            return self.reject(requeue=exc_info.exception.requeue)
        elif isinstance(exc_info.exception, Ignore):
            return self.acknowledge()

        exc = exc_info.exception

        if isinstance(exc, Retry):
            return self.on_retry(exc_info)

        # These are special cases where the process would not have had
        # time to write the result.
        if self.store_errors:
            if isinstance(exc, Terminated):
                self._announce_revoked("terminated", True, string(exc), False)
                send_failed_event = False  # already sent revoked event
            elif isinstance(exc, WorkerLostError) or not return_ok:
                self.task.backend.mark_as_failure(self.id, exc, request=self)
        # (acks_late) acknowledge after result stored.
        if self.task.acks_late:
            self.acknowledge()

        if send_failed_event:
            self.send_event(
                "task-failed",
                exception=safe_repr(get_pickled_exception(exc_info.exception)),
                traceback=exc_info.traceback,
            )

        if not return_ok:
            error("Task handler raised error: %r", exc, exc_info=exc_info.exc_info)
Beispiel #34
0
 def no_color(self):
     if self.s:
         return string(reduce(self._fold_no_color, self.s))
     return ''
Beispiel #35
0
 def embed(self):
     prefix = ''
     if self.enabled:
         prefix = self.op
     return ''.join((string(prefix), string(reduce(self._add, self.s))))
Beispiel #36
0
 def __add__(self, other):
     return string(self) + string(other)
Beispiel #37
0
 def _add(self, a, b):
     return string(a) + string(b)
Beispiel #38
0
 def _add(self, a, b):
     return string(a) + string(b)
Beispiel #39
0
 def strtotal(self):
     if not self.total_apx:
         return '?'
     return string(self.total_apx)
Beispiel #40
0
 def set(self, key, value):
     key = string(key)
     request_parameters = self._prepare_put_request(key, value)
     self.client.put_item(**request_parameters)
Beispiel #41
0
 def __unicode__(self):
     try:
         return string(self._get_current_object())
     except RuntimeError:  # pragma: no cover
         return repr(self)
Beispiel #42
0
 def __unicode__(self):
     suffix = ''
     if self.enabled:
         suffix = RESET_SEQ
     return string(''.join((self.embed(), string(suffix))))
Beispiel #43
0
 def get(self, key):
     key = string(key)
     request_parameters = self._prepare_get_request(key)
     item_response = self.client.get_item(**request_parameters)
     item = self._item_to_dict(item_response)
     return item.get(self._value_field.name)
Beispiel #44
0
 def embed(self):
     prefix = ''
     if self.enabled:
         prefix = self.op
     return ''.join((string(prefix), string(reduce(self._add, self.s))))
Beispiel #45
0
 def set(self, key, value):
     key = string(key)
     request_parameters = self._prepare_put_request(key, value)
     self.client.put_item(**request_parameters)
Beispiel #46
0
 def delete(self, key):
     key = string(key)
     request_parameters = self._prepare_get_request(key)
     self.client.delete_item(**request_parameters)
Beispiel #47
0
 def __str__(self):
     suffix = ''
     if self.enabled:
         suffix = RESET_SEQ
     return string(''.join((self.embed(), string(suffix))))
Beispiel #48
0
 def delete(self, key):
     key = string(key)
     request_parameters = self._prepare_get_request(key)
     self.client.delete_item(**request_parameters)
Beispiel #49
0
 def _index(self, id, body, **kwargs):
     return self.server.index(id=string(id),
                              index=self.index,
                              doc_type=self.doc_type,
                              body=body,
                              **kwargs)
Beispiel #50
0
 def get(self, key):
     key = string(key)
     request_parameters = self._prepare_get_request(key)
     item_response = self.client.get_item(**request_parameters)
     item = self._item_to_dict(item_response)
     return item.get(self._value_field.name)
Beispiel #51
0
 def strtotal(self):
     if not self.total_apx:
         return '?'
     return string(self.total_apx)
Beispiel #52
0
 def __add__(self, other):
     return string(self) + string(other)
Beispiel #53
0
 def no_color(self):
     if self.s:
         return string(reduce(self._fold_no_color, self.s))
     return ''
Beispiel #54
0
 def prepare_exception(self, exc, serializer=None):
     """Prepare exception for serialization."""
     serializer = self.serializer if serializer is None else serializer
     if serializer in EXCEPTION_ABLE_CODECS:
         return get_pickleable_exception(exc)
     return {'exc_type': type(exc).__name__, 'exc_message': string(exc)}