def apply_target(target,
args=(),
kwargs={},
callback=None,
accept_callback=None,
pid=None,
getpid=os.getpid,
propagate=(),
monotonic=monotonic,
**_):
if accept_callback:
accept_callback(pid or getpid(), monotonic())
try:
ret = target(*args, **kwargs)
except propagate:
raise
except Exception:
raise
except (WorkerShutdown, WorkerTerminate):
raise
except BaseException as exc:
try:
reraise(WorkerLostError, WorkerLostError(repr(exc)),
sys.exc_info()[2])
except WorkerLostError:
callback(ExceptionInfo())
else:
callback(ret)
def apply_async(self, entry, producer=None, advance=True, **kwargs):
# Update time-stamps and run counts before we actually execute,
# so we have that done if an exception is raised (doesn't schedule
# forever.)
entry = self.reserve(entry) if advance else entry
task = self.app.tasks.get(entry.task)
try:
if task:
return task.apply_async(entry.args,
entry.kwargs,
producer=producer,
**entry.options)
else:
return self.send_task(entry.task,
entry.args,
entry.kwargs,
producer=producer,
**entry.options)
except Exception as exc: # pylint: disable=broad-except
reraise(
SchedulingError,
SchedulingError(
"Couldn't apply scheduled task {0.name}: {exc}".format(
entry, exc=exc)),
sys.exc_info()[2])
finally:
self._tasks_since_sync += 1
if self.should_sync():
self._do_sync()
def acquire(self):
"""Acquire lock."""
try:
self.write_pid()
except OSError as exc:
reraise(LockFailed, LockFailed(str(exc)), sys.exc_info()[2])
return self
def reraise_errors(msg="{0!r}", errors=None):
"""Context reraising crypto errors as :exc:`SecurityError`."""
errors = (cryptography.exceptions, ) if errors is None else errors
try:
yield
except errors as exc:
reraise(SecurityError, SecurityError(msg.format(exc)),
sys.exc_info()[2])
def reraise_errors(msg='{0!r}', errors=None):
assert crypto is not None
errors = (crypto.Error, ) if errors is None else errors
try:
yield
except errors as exc:
reraise(SecurityError, SecurityError(msg.format(exc)),
sys.exc_info()[2])
def get_backend_cls(backend=None, loader=None):
"""Get backend class by name/alias"""
backend = backend or "disabled"
loader = loader or current_app.loader
aliases = dict(BACKEND_ALIASES, **loader.override_backends)
try:
return symbol_by_name(backend, aliases)
except ValueError as exc:
reraise(ValueError, ValueError(UNKNOWN_BACKEND.format(backend, exc)), sys.exc_info()[2])
def raise_with_context(exc):
exc_info = sys.exc_info()
if not exc_info:
raise exc
if exc_info[1] is exc:
raise
elif exc_info[2]:
reraise(type(exc), exc, exc_info[2])
raise exc
def raise_with_context(exc):
exc_info = sys.exc_info()
if not exc_info:
raise exc
if exc_info[1] is exc:
raise
elif exc_info[2]:
reraise(type(exc), exc, exc_info[2])
raise exc
def reraise_errors(msg='{0!r}', errors=None):
assert crypto is not None
errors = (crypto.Error, ) if errors is None else errors
try:
yield
except errors as exc:
reraise(SecurityError,
SecurityError(msg.format(exc)),
sys.exc_info()[2])
def reraise_errors(msg='{0!r}', errors=None):
"""Context reraising crypto errors as :exc:`SecurityError`."""
errors = (cryptography.exceptions,) if errors is None else errors
try:
yield
except errors as exc:
reraise(SecurityError,
SecurityError(msg.format(exc)),
sys.exc_info()[2])
def maybe_reraise():
"""Re-raise if an exception is currently being handled, or return
otherwise."""
exc_info = sys.exc_info()
try:
if exc_info[2]:
reraise(exc_info[0], exc_info[1], exc_info[2])
finally:
# see http://docs.python.org/library/sys.html#sys.exc_info
del(exc_info)
def get_backend_cls(backend=None, loader=None):
"""Get backend class by name/alias"""
backend = backend or 'disabled'
loader = loader or current_app.loader
aliases = dict(BACKEND_ALIASES, **loader.override_backends)
try:
return symbol_by_name(backend, aliases)
except ValueError as exc:
reraise(ValueError, ValueError(UNKNOWN_BACKEND.format(backend, exc)),
sys.exc_info()[2])
def maybe_reraise():
"""Re-raise if an exception is currently being handled, or return
otherwise."""
exc_info = sys.exc_info()
try:
if exc_info[2]:
reraise(exc_info[0], exc_info[1], exc_info[2])
finally:
# see http://docs.python.org/library/sys.html#sys.exc_info
del (exc_info)
def _import_config_module(self, name):
try:
self.find_module(name)
except NotAPackage:
if name.endswith('.py'):
reraise(NotAPackage, NotAPackage(CONFIG_WITH_SUFFIX.format(
module=name, suggest=name[:-3])), sys.exc_info()[2])
reraise(NotAPackage, NotAPackage(CONFIG_INVALID_NAME.format(
module=name)), sys.exc_info()[2])
else:
return self.import_from_cwd(name)
def _import_config_module(self, name):
try:
self.find_module(name)
except NotAPackage:
if name.endswith('.py'):
reraise(NotAPackage, NotAPackage(CONFIG_WITH_SUFFIX.format(
module=name, suggest=name[:-3])), sys.exc_info()[2])
reraise(NotAPackage, NotAPackage(CONFIG_INVALID_NAME.format(
module=name)), sys.exc_info()[2])
else:
return self.import_from_cwd(name)
def get_backend_cls(backend=None, loader=None):
"""Get backend class by name/alias"""
backend = backend or "disabled"
loader = loader or current_app.loader
aliases = dict(BACKEND_ALIASES, **loader.override_backends)
try:
cls = symbol_by_name(backend, aliases)
except ValueError as exc:
reraise(ImproperlyConfigured, ImproperlyConfigured(UNKNOWN_BACKEND.format(backend, exc)), sys.exc_info()[2])
if isinstance(cls, types.ModuleType):
raise ImproperlyConfigured(UNKNOWN_BACKEND.format(backend, "is a Python module, not a backend class."))
return cls
def get_backend_cls(backend=None, loader=None):
"""Get backend class by name/alias"""
backend = backend or 'disabled'
loader = loader or current_app.loader
aliases = dict(BACKEND_ALIASES, **loader.override_backends)
try:
cls = symbol_by_name(backend, aliases)
except ValueError as exc:
reraise(ImproperlyConfigured, ImproperlyConfigured(
UNKNOWN_BACKEND.format(backend, exc)), sys.exc_info()[2])
if isinstance(cls, types.ModuleType):
raise ImproperlyConfigured(UNKNOWN_BACKEND.format(
backend, 'is a Python module, not a backend class.'))
return cls
def extract_response(raw_response, loads=json.loads):
"""Extract the response text from a raw JSON response."""
if not raw_response:
raise InvalidResponseError("Empty response")
try:
payload = loads(raw_response)
except ValueError as exc:
reraise(InvalidResponseError, InvalidResponseError(str(exc)), sys.exc_info()[2])
status = payload["status"]
if status == "success":
return payload["retval"]
elif status == "failure":
raise RemoteExecuteError(payload.get("reason"))
else:
raise UnknownStatusError(str(status))
def by_name(backend=None, loader=None,
extension_namespace='celery.result_backends'):
"""Get backend class by name/alias."""
backend = backend or 'disabled'
loader = loader or current_app.loader
aliases = dict(BACKEND_ALIASES, **loader.override_backends)
aliases.update(
load_extension_class_names(extension_namespace) or {})
try:
cls = symbol_by_name(backend, aliases)
except ValueError as exc:
reraise(ImproperlyConfigured, ImproperlyConfigured(
UNKNOWN_BACKEND.strip().format(backend, exc)), sys.exc_info()[2])
if isinstance(cls, types.ModuleType):
raise ImproperlyConfigured(UNKNOWN_BACKEND.strip().format(
backend, 'is a Python module, not a backend class.'))
return cls
def apply_target(target, args=(), kwargs={}, callback=None,
accept_callback=None, pid=None, getpid=os.getpid,
monotonic=monotonic, **_):
if accept_callback:
accept_callback(pid or getpid(), monotonic())
try:
ret = target(*args, **kwargs)
except Exception:
raise
except BaseException as exc:
try:
reraise(WorkerLostError, WorkerLostError(repr(exc)),
sys.exc_info()[2])
except WorkerLostError:
callback(ExceptionInfo())
else:
callback(ret)
def by_name(backend=None, loader=None,
extension_namespace='celery.result_backends'):
"""Get backend class by name/alias."""
backend = backend or 'disabled'
loader = loader or current_app.loader
aliases = dict(BACKEND_ALIASES, **loader.override_backends)
aliases.update(
load_extension_class_names(extension_namespace) or {})
try:
cls = symbol_by_name(backend, aliases)
except ValueError as exc:
reraise(ImproperlyConfigured, ImproperlyConfigured(
UNKNOWN_BACKEND.strip().format(backend, exc)), sys.exc_info()[2])
if isinstance(cls, types.ModuleType):
raise ImproperlyConfigured(UNKNOWN_BACKEND.strip().format(
backend, 'is a Python module, not a backend class.'))
return cls
def extract_response(raw_response, loads=json.loads):
"""Extract the response text from a raw JSON response."""
if not raw_response:
raise InvalidResponseError('Empty response')
try:
payload = loads(raw_response)
except ValueError as exc:
reraise(InvalidResponseError, InvalidResponseError(str(exc)),
sys.exc_info()[2])
status = payload['status']
if status == 'success':
return payload['retval']
elif status == 'failure':
raise RemoteExecuteError(payload.get('reason'))
else:
raise UnknownStatusError(str(status))
def extract_response(raw_response, loads=json.loads):
"""Extract the response text from a raw JSON response."""
if not raw_response:
raise InvalidResponseError('Empty response')
try:
payload = loads(raw_response)
except ValueError as exc:
reraise(InvalidResponseError, InvalidResponseError(
str(exc)), sys.exc_info()[2])
status = payload['status']
if status == 'success':
return payload['retval']
elif status == 'failure':
raise RemoteExecuteError(payload.get('reason'))
else:
raise UnknownStatusError(str(status))
def apply_target(target, args=(), kwargs={}, callback=None,
accept_callback=None, pid=None, getpid=os.getpid,
propagate=(), monotonic=monotonic, **_):
"""Apply function within pool context."""
if accept_callback:
accept_callback(pid or getpid(), monotonic())
try:
ret = target(*args, **kwargs)
except propagate:
raise
except Exception:
raise
except (WorkerShutdown, WorkerTerminate):
raise
except BaseException as exc:
try:
reraise(WorkerLostError, WorkerLostError(repr(exc)),
sys.exc_info()[2])
except WorkerLostError:
callback(ExceptionInfo())
else:
callback(ret)
def apply_async(self, entry, producer=None, advance=True, **kwargs):
if advance:
# attempt to reserve a schedule entry for this leek instance;
# if reserve returns None, do nothing
entry = self.reserve(entry) if advance else entry
if entry:
task = self.app.tasks.get(entry.task)
try:
if task:
return task.apply_async(entry.args, entry.kwargs,
producer=producer,
**entry.options)
else:
return self.send_task(entry.task, entry.args, entry.kwargs,
producer=producer,
**entry.options)
except Exception as exc:
reraise(SchedulingError, SchedulingError(
"Couldn't apply scheduled task {0.name}: {exc}".format(
entry, exc=exc)), sys.exc_info()[2])
def on_exit(*x):
if x[0]:
reraise(x[0], x[1], x[2])
def on_exit(*x):
if x[0]:
reraise(x[0], x[1], x[2])
