def update_zabbix_templates(device, templates=None, remote=False):
hostname = device.name
role = device.venture_role
try:
ip = device.ipaddress_set.get(hostname=hostname)
except IPAddress.DoesNotExist:
return
if templates is None:
templates = _calculate_zabbix_templates(role)
if remote:
task = zabbix_update_task.delay
else:
task = zabbix_update_task
task(hostname, str(ip.address), templates)
def update_mangopay_pay_out(id):
payout = MangoPayPayOut.objects.get(id=id, mangopay_id__isnull=False)
try:
payout = payout.get()
except ResponseException as exc:
raise update_mangopay_pay_out.retry((), {"id": id}, exc=exc)
if not payout.status or payout.status == "CREATED":
eta = next_weekday()
update_mangopay_pay_out.apply_async((), {"id": id}, eta=eta)
elif payout.status == "SUCCEEDED":
task = getattr(settings, 'MANGOPAY_PAYOUT_SUCCEEDED_TASK', None)
if task:
task().run(payout_id=payout.id)
else:
logger.error("Payout %i could not be process successfully" % payout.id)
def update_mangopay_pay_out(id):
payout = MangoPayPayOut.objects.get(id=id, mangopay_id__isnull=False)
try:
payout = payout.get()
except ResponseException as exc:
raise update_mangopay_pay_out.retry((), {"id": id}, exc=exc)
if not payout.status or payout.status == "CREATED":
eta = next_weekday()
update_mangopay_pay_out.apply_async((), {"id": id}, eta=eta)
elif payout.status == "SUCCEEDED":
task = getattr(settings, 'MANGOPAY_PAYOUT_SUCCEEDED_TASK', None)
if task:
task().run(payout_id=payout.id)
else:
logger.error("Payout %i could not be process successfully" % payout.id)
def __init__(self):
try:
from celery.task import task
except:
raise InvalidImageCacheBackendError("Celery image cache backend requires the 'celery' library")
if not getattr(CeleryImageCacheBackend, '_task', None):
CeleryImageCacheBackend._task = task(generate)
def litetask_celery(task_func):
"""
Wrapper around celery.task
"""
tsk = task(litetask_futures(task_func), queue='celery')
tsk.__func__ = tsk
tsk.task_func = task_func
return tsk
def __init__(self):
try:
from celery.task import task
except:
raise InvalidImageCacheBackendError(
"Celery image cache backend requires the 'celery' library")
if not getattr(CeleryImageCacheBackend, '_task', None):
CeleryImageCacheBackend._task = task(generate)
def oqtask(task_func):
"""
Wrapper around celery.task and parallel.litetask
"""
tsk = task(litetask(task_func), queue=celery_queue)
tsk.__func__ = tsk
tsk.task_func = task_func
return tsk
def litetask_celery(task_func):
"""
Wrapper around celery.task
"""
tsk = task(litetask_futures(task_func), queue='celery')
tsk.__func__ = tsk
tsk.task_func = task_func
return tsk
def oqtask(task_func):
"""
Wrapper around celery.task and parallel.litetask
"""
tsk = task(litetask(task_func), queue=celery_queue)
tsk.__func__ = tsk
tsk.task_func = task_func
return tsk
def decorator(taskfunc):
def db_constructor(job_id, *args, **kwargs):
session = db_constructor.backend.ResultSession()
zoomdb = ZoomDatabase(session.bind, job_id)
return taskfunc(job_id, zoomdb, *args, **kwargs)
db_constructor = task(**celery_kwargs)(db_constructor)
return db_constructor
def test_task(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs), None
except:
exctype, exc, _tb = sys.exc_info()
return str(exc), exctype
return task(wrapper)
def oqtask(task_func):
"""
Task function decorator which sets up logging and catches (and logs) any
errors which occur inside the task. Also checks to make sure the job is
actually still running. If it is not running, the task doesn't get
executed, so we don't do useless computation.
"""
@wraps(task_func)
def wrapped(*args):
"""
Initialize logs, make sure the job is still running, and run the task
code surrounded by a try-except. If any error occurs, log it as a
critical failure.
"""
# job_id is always assumed to be the first argument
job_id = args[0]
job = models.OqJob.objects.get(id=job_id)
if job.is_running is False:
# the job was killed, it is useless to run the task
return
# it is important to save the task id soon, so that
# the revoke functionality can work
EnginePerformanceMonitor.store_task_id(job_id, tsk)
with EnginePerformanceMonitor(
'total ' + task_func.__name__, job_id, tsk, flush=True):
with EnginePerformanceMonitor(
'loading calculation object', job_id, tsk, flush=True):
calculation = job.calculation
# tasks write on the celery log file
logs.init_logs(
level=job.log_level,
calc_domain='hazard' if isinstance(
calculation, models.HazardCalculation) else'risk',
calc_id=calculation.id)
try:
return task_func(*args), None
except:
etype, exc, tb = sys.exc_info()
tb_str = ''.join(traceback.format_tb(tb))
return '%s\n%s' % (exc, tb_str), etype
finally:
CacheInserter.flushall()
# the task finished, we can remove from the performance
# table the associated row 'storing task id'
models.Performance.objects.filter(
oq_job=job,
operation='storing task id',
task_id=tsk.request.id).delete()
celery_queue = config.get('amqp', 'celery_queue')
tsk = task(wrapped, queue=celery_queue)
tsk.task_func = task_func
return tsk
def wrapped(func):
@wraps(func)
def _wrapped(*args, **kwargs):
statsd_key = 'jobs.duration.{name}'.format(name=name)
if stat_suffix:
statsd_key += '.{key}'.format(key=stat_suffix(*args, **kwargs))
with statsd.timer(statsd_key):
result = func(*args, **kwargs)
return result
return task(name=name, **kwargs)(_wrapped)
def block_structure_task(**kwargs):
"""
Decorator for block structure tasks.
"""
return task(
default_retry_delay=settings.
BLOCK_STRUCTURES_SETTINGS['TASK_DEFAULT_RETRY_DELAY'],
max_retries=settings.BLOCK_STRUCTURES_SETTINGS['TASK_MAX_RETRIES'],
bind=True,
**kwargs)
def block_structure_task(**kwargs):
"""
Decorator for block structure tasks.
"""
return task(
default_retry_delay=settings.BLOCK_STRUCTURES_SETTINGS['TASK_DEFAULT_RETRY_DELAY'],
max_retries=settings.BLOCK_STRUCTURES_SETTINGS['TASK_MAX_RETRIES'],
bind=True,
**kwargs
)
def wrapped(func):
@wraps(func)
def _wrapped(*args, **kwargs):
key = 'jobs.duration.{name}'.format(name=name)
if stat_suffix:
key += '.{key}'.format(key=stat_suffix(*args, **kwargs))
with metrics.timer(key):
result = func(*args, **kwargs)
return result
return task(name=name, **kwargs)(_wrapped)
def oqtask(task_func):
"""
Task function decorator which sets up logging and catches (and logs) any
errors which occur inside the task. Also checks to make sure the job is
actually still running. If it is not running, the task doesn't get
executed, so we don't do useless computation.
:param task_func: the function to decorate
"""
def wrapped(*args):
"""
Initialize logs, make sure the job is still running, and run the task
code surrounded by a try-except. If any error occurs, log it as a
critical failure.
"""
# the last argument is assumed to be a monitor
monitor = args[-1]
job = models.OqJob.objects.get(id=monitor.job_id)
if job.is_running is False:
# the job was killed, it is useless to run the task
raise JobNotRunning(monitor.job_id)
# it is important to save the task id soon, so that
# the revoke functionality can work
with monitor("storing task id", task=tsk, autoflush=True):
pass
with logs.handle(job):
check_mem_usage() # warn if too much memory is used
# run the task
try:
total = "total " + task_func.__name__
with monitor(total, task=tsk):
with GroundShakingIntensityModel.forbid_instantiation():
return task_func(*args)
finally:
# save on the db
CacheInserter.flushall()
# the task finished, we can remove from the performance
# table the associated row 'storing task id'
models.Performance.objects.filter(
oq_job=job, operation="storing task id", task_id=tsk.request.id
).delete()
celery_queue = config.get("amqp", "celery_queue")
f = lambda *args: safely_call(wrapped, args, pickle=True)
f.__name__ = task_func.__name__
f.__module__ = task_func.__module__
tsk = task(f, queue=celery_queue)
tsk.__func__ = tsk
tsk.task_func = task_func
return tsk
def task_with_callbacks(func, **options):
""" decorator "task with callbacks"
Callback or list of callbacks which go to function in "callbacks" kwarg,
will be executed after the function, regardless of the subtask's return
status.
If subtask (function) result is an object, then a property named
"async_result" will be added to that object so that it will be possible to
join() for that result.
"""
return task(run_with_callbacks(func), **options)
def test_task(func):
@functools.wraps(func)
def wrapper(*args):
try:
res = func(*[a.unpickle() for a in args])
return Pickled((res, None))
except:
exctype, exc, tb = sys.exc_info()
tb_str = ''.join(traceback.format_tb(tb))
err_msg = '\n%s%s: %s' % (tb_str, exctype.__name__, exc)
return Pickled((err_msg, exctype))
return task(wrapper)
def task_with_callbacks(func, **options):
""" decorator "task with callbacks"
Callback or list of callbacks which go to function in "callbacks" kwarg,
will be executed after the function, regardless of the subtask's return
status.
If subtask (function) result is an object, then a property named
"async_result" will be added to that object so that it will be possible to
join() for that result.
"""
return task(run_with_callbacks(func), **options)
def oqtask(task_func):
"""
Task function decorator which sets up logging and catches (and logs) any
errors which occur inside the task. Also checks to make sure the job is
actually still running. If it is not running, the task doesn't get
executed, so we don't do useless computation.
:param task_func: the function to decorate
"""
def wrapped(*args):
"""
Initialize logs, make sure the job is still running, and run the task
code surrounded by a try-except. If any error occurs, log it as a
critical failure.
"""
# the last argument is assumed to be a monitor
monitor = args[-1]
job = models.OqJob.objects.get(id=monitor.job_id)
if job.is_running is False:
# the job was killed, it is useless to run the task
raise JobNotRunning(monitor.job_id)
# it is important to save the task id soon, so that
# the revoke functionality can work
with monitor('storing task id', task=tsk, autoflush=True):
pass
with logs.handle(job):
check_mem_usage() # warn if too much memory is used
# run the task
try:
total = 'total ' + task_func.__name__
with monitor(total, task=tsk, autoflush=True):
return task_func(*args)
finally:
# save on the db
CacheInserter.flushall()
# the task finished, we can remove from the performance
# table the associated row 'storing task id'
models.Performance.objects.filter(
oq_job=job,
operation='storing task id',
task_id=tsk.request.id).delete()
celery_queue = config.get('amqp', 'celery_queue')
f = lambda *args: safely_call(wrapped, args, pickle=True)
f.__name__ = task_func.__name__
f.__module__ = task_func.__module__
tsk = task(f, queue=celery_queue)
tsk.__func__ = tsk
tsk.task_func = task_func
return tsk
def oqtask(task_func):
"""
Task function decorator which sets up logging and catches (and logs) any
errors which occur inside the task. Also checks to make sure the job is
actually still running. If it is not running, the task doesn't get
executed, so we don't do useless computation.
:param task_func: the function to decorate
"""
def wrapped(*args):
"""
Initialize logs, make sure the job is still running, and run the task
code surrounded by a try-except. If any error occurs, log it as a
critical failure.
"""
# job_id is always assumed to be the first argument
job_id = args[0]
job = models.OqJob.objects.get(id=job_id)
if job.is_running is False:
# the job was killed, it is useless to run the task
raise JobNotRunning(job_id)
# it is important to save the task id soon, so that
# the revoke functionality can work
EnginePerformanceMonitor.store_task_id(job_id, tsk)
with EnginePerformanceMonitor(
'total ' + task_func.__name__, job_id, tsk, flush=True):
# tasks write on the celery log file
logs.set_level(job.log_level)
try:
# log a warning if too much memory is used
check_mem_usage(SOFT_MEM_LIMIT, HARD_MEM_LIMIT)
# run the task
return task_func(*args)
finally:
# save on the db
CacheInserter.flushall()
# the task finished, we can remove from the performance
# table the associated row 'storing task id'
models.Performance.objects.filter(
oq_job=job,
operation='storing task id',
task_id=tsk.request.id).delete()
celery_queue = config.get('amqp', 'celery_queue')
f = lambda *args: safely_call(wrapped, args, pickle=True)
f.__name__ = task_func.__name__
tsk = task(f, queue=celery_queue)
tsk.task_func = task_func
return tsk
def test_task(func):
@functools.wraps(func)
def wrapper(*args):
try:
res = func(*[a.unpickle() for a in args])
return Pickled((res, None))
except:
exctype, exc, tb = sys.exc_info()
tb_str = ''.join(traceback.format_tb(tb))
err_msg = '\n%s%s: %s' % (tb_str, exctype.__name__, exc)
return Pickled((err_msg, exctype))
tsk = task(wrapper)
tsk.task_func = func
return tsk
def createTask(self, name):
return task.task(__module__=self.__module__, name=name)(return_True)
from celery.utils import uuid
from celery.utils.timeutils import parse_iso8601, timedelta_seconds
from celery.tests.utils import Case, with_eager_tasks, WhateverIO
def now():
return current_app.now()
def return_True(*args, **kwargs):
# Task run functions can't be closures/lambdas, as they're pickled.
return True
return_True_task = task()(return_True)
def raise_exception(self, **kwargs):
raise Exception('%s error' % self.__class__)
class MockApplyTask(Task):
applied = 0
def run(self, x, y):
return x * y
@classmethod
def apply_async(self, *args, **kwargs):
self.applied += 1
logs.init_logs_amqp_send(level=job.log_level,
calc_domain='hazard',
calc_id=calculation.id)
else:
logs.init_logs_amqp_send(level=job.log_level,
calc_domain='risk',
calc_id=calculation.id)
try:
# Tasks can be used in the `execute` or `post-process` phase
if job.is_running is False:
raise JobCompletedError('Job %d was killed' % job_id)
elif job.status not in ('executing', 'post_processing'):
raise JobCompletedError(
'The status of job %d is %s, should be executing or '
'post_processing' % (job_id, job.status))
# else continue with task execution
res = task_func(*args, **kwargs)
# TODO: should we do something different with JobCompletedError?
except Exception, err:
logs.LOG.critical('Error occurred in task: %s', err)
logs.LOG.exception(err)
raise
else:
return res
finally:
CacheInserter.flushall()
celery_queue = config.get('amqp', 'celery_queue')
tsk = task(wrapped, ignore_result=True, queue=celery_queue)
return tsk
def run(self, obj, field_name):
"""Just run `build` on FieldFile, can't pass it directly to Celery."""
return self.build(getattr(obj, field_name))
def build(self, fieldfile):
book = fieldfile.instance
out = self.transform(book.wldocument(), fieldfile)
fieldfile.save(None, File(open(out.get_filename())), save=False)
if book.pk is not None:
type(book).objects.filter(pk=book.pk).update(**{
fieldfile.field.attname: fieldfile
})
if fieldfile.field.format_name in app_settings.FORMAT_ZIPS:
remove_zip(app_settings.FORMAT_ZIPS[fieldfile.field.format_name])
# Don't decorate BuildEbook, because we want to subclass it.
BuildEbookTask = task(BuildEbook, ignore_result=True)
@BuildEbook.register('txt')
@task(ignore_result=True)
class BuildTxt(BuildEbook):
@staticmethod
def transform(wldoc, fieldfile):
return wldoc.as_text()
@BuildEbook.register('pdf')
@task(ignore_result=True)
class BuildPdf(BuildEbook):
@staticmethod
def transform(wldoc, fieldfile):
def task(*args, **kwargs): # ✞
kwargs.setdefault("accept_magic_kwargs", True)
return _task.task(*args, **kwargs)
def test_task(func, *args, **kwargs):
kwargs['queue'] = config.get('amqp', 'celery_queue')
return task(func, *args, **kwargs)
from celery.execute import send_task
from celery.five import items, range, string_t
from celery.result import EagerResult
from celery.schedules import crontab, crontab_parser, ParseException
from celery.utils import uuid
from celery.utils.timeutils import parse_iso8601, timedelta_seconds
from celery.tests.case import AppCase, eager_tasks, WhateverIO
def return_True(*args, **kwargs):
# Task run functions can't be closures/lambdas, as they're pickled.
return True
return_True_task = task()(return_True)
def raise_exception(self, **kwargs):
raise Exception('%s error' % self.__class__)
class MockApplyTask(Task):
applied = 0
def run(self, x, y):
return x * y
@classmethod
def apply_async(self, *args, **kwargs):
self.applied += 1
#@task
def _send_notification(type='email', **kwargs):
""" sends notification to user """
kwargs.update({'fail_silently': True})
if type == 'email':
send_mail(**kwargs)
return 0
else:
return 0
def send_void_mail(*args, **kwargs):
if settings.DEBUG_MESSAGES:
logger.info('no email sent, because SEND_EMAIL is disabled')
if 'message' in kwargs:
if settings.DEBUG_MESSAGES:
logger.info("message: %s" % kwargs['message'])
return
#SET SETTINGS, DISABLING SENDING NOTIFICATIONS OR ENABLING THEM
if settings.SMS_ENABLE:
send_sms = task(_send_sms)
else:
send_sms = lambda x,y: x
send_sms.delay = send_void_sms
if settings.SEND_EMAIL:
send_notification = task(_send_notification)
else:
send_notification = lambda x: x
send_notification.delay = send_void_mail
def task(*args, **kwargs): # ✞
kwargs.setdefault("accept_magic_kwargs", True)
return _task.task(*args, **kwargs)
def decorator(func):
return task(**kwargs)(func)
def decorator(func):
return task(**kwargs)(func)
@wraps(task_func)
def wrapped(*args, **kwargs):
"""
Initialize logs, make sure the job is still running, and run the task
code surrounded by a try-except. If any error occurs, log it as a
critical failure.
"""
# job_id is always assumed to be the first arugment passed to a task
# this is the only required argument
job_id = args[0]
# Set up logging via amqp.
try:
# check if the job is still running
job = models.OqJob.objects.get(id=job_id)
if not job.status == 'executing' and not job.is_running:
# the job is not running
raise JobCompletedError(job_id)
# The job is running.
# Setup task logging, via AMQP ...
logs.init_logs_amqp_send(level=job.log_level, job_id=job_id)
# ... and continue with task execution.
task_func(*args, **kwargs)
# TODO: should we do something different with the JobCompletedError?
except Exception, err:
logs.LOG.critical('Error occurred in task: %s' % str(err))
logs.LOG.exception(err)
raise
return task(wrapped, ignore_result=True)
"""Just run `build` on FieldFile, can't pass it directly to Celery."""
return self.build(getattr(obj, field_name))
def build(self, fieldfile):
book = fieldfile.instance
out = self.transform(book.wldocument(), fieldfile)
fieldfile.save(None, File(open(out.get_filename())), save=False)
if book.pk is not None:
type(book).objects.filter(pk=book.pk).update(
**{fieldfile.field.attname: fieldfile})
if fieldfile.field.format_name in app_settings.FORMAT_ZIPS:
remove_zip(app_settings.FORMAT_ZIPS[fieldfile.field.format_name])
# Don't decorate BuildEbook, because we want to subclass it.
BuildEbookTask = task(BuildEbook, ignore_result=True)
@BuildEbook.register('txt')
@task(ignore_result=True)
class BuildTxt(BuildEbook):
@staticmethod
def transform(wldoc, fieldfile):
return wldoc.as_text()
@BuildEbook.register('pdf')
@task(ignore_result=True)
class BuildPdf(BuildEbook):
@staticmethod
def transform(wldoc, fieldfile):
def wrapper(fcn):
return task(*args, **kwargs)(fcn)
def _get_task(self):
return task(lambda: None).delay()
def createTask(self, name):
return task(__module__=self.__module__, name=name)(return_True)
def wrapper(fcn):
return task(*args, **kwargs)(fcn)
stats.put("ol.celery.task_run_time", run_time * 1000)
stats.put("ol.celery.%s_run_time"%fn.__name__, run_time * 1000)
except:
pass
raise ExceptionWrapper(e, d)
log = s.getvalue()
d = dict(largs = json.dumps(largs),
kargs = json.dumps(kargs),
command = fn.__name__,
enqueued_at = enqueue_time,
started_at = started_at,
log = log,
result = ret,
context = task_context,
parent_task = parent_task)
logging.root.removeHandler(h)
task_context = {}
try:
end_time = calendar.timegm(datetime.datetime.utcnow().timetuple())
run_time = end_time - started_at
stats.put("ol.celery.task_run_time", run_time * 1000)
stats.put("ol.celery.%s_run_time"%fn.__name__, run_time * 1000)
except:
pass
return d
retval = task(wrapped)
patched_delay = create_patched_delay(retval)
retval.original_delay = retval.delay
retval.delay = patched_delay
return retval
'Update failure for {0}'.format(shop.domain))
send_html_email.delay('mail/customers/update_report.html', result_dict,
start_char + _('Update report for %s') % shop.domain,
email=[user.email])
except SoftTimeLimitExceeded:
# send email
send_email.delay('mail/feedback', {'message': unicode(shop.domain), 'email': user.email},
'Time limit exceeded')
send_email.delay('mail/customers/time_limit_exceeded.html', {'language': language},
_('Time limit exceeded'), email=[user.email])
status.update_status = 'success'
status.save()
def checked_update_presta_data_task(shop, *args, **kwargs):
if shop.user.is_paid():
checked_update_presta_data.delay(shop, *args, **kwargs)
else:
checked_update_presta_data_free.delay(shop, *args, **kwargs)
checked_update_presta_data_free = task(ignore_result=True,
name="presta.tasks.checked_update_presta_data_free",
soft_time_limit=300,
time_limit=305)(_checked_update_presta_data)
checked_update_presta_data = task(ignore_result=True,
name="presta.tasks.checked_update_presta_data",
time_limit=3600)(_checked_update_presta_data)
def cleanBlanksFromList(datalist):
return [x for x in datalist if x]
@task()
def _get_task(self):
return task(lambda : None).delay()
# Set up logging via amqp.
if isinstance(calculation, models.HazardCalculation):
logs.init_logs_amqp_send(level=job.log_level,
calc_domain='hazard',
calc_id=calculation.id)
else:
logs.init_logs_amqp_send(level=job.log_level,
calc_domain='risk',
calc_id=calculation.id)
try:
res = task_func(*args, **kwargs)
except Exception, err:
logs.LOG.critical('Error occurred in task: %s', err)
logs.LOG.exception(err)
raise
else:
return res
finally:
CacheInserter.flushall()
# the task finished, we can remove from the performance
# table the associated row 'storing task id', then the
# supervisor will not try revoke it without need
models.Performance.objects.filter(
oq_job=job,
operation='storing task id',
task_id=tsk.request.id).delete()
celery_queue = config.get('amqp', 'celery_queue')
tsk = task(wrapped, ignore_result=True, queue=celery_queue)
return tsk
def mltshp_task(*args, **options):
# This is how celery's periodic_task decorator customizes the class, so try it here too.
return task(**dict({"base": MltshpTask}, **options))
raise RuntimeError('Monitor(%r).flush() must not be called '
'by %s!' % (self.monitor.operation, self.taskname))
def rec_delattr(mon, name):
"""
Delete attribute from a monitor recursively
"""
for child in mon.children:
rec_delattr(child, name)
if name in vars(mon):
delattr(mon, name)
if OQ_DISTRIBUTE == 'celery':
safe_task = task(safely_call, queue='celery')
def _wakeup(sec):
"""Waiting functions, used to wake up the process pool"""
try:
import prctl
except ImportError:
pass
else:
# if the parent dies, the children die
prctl.set_pdeathsig(signal.SIGKILL)
time.sleep(sec)
return os.getpid()
run_time * 1000)
except:
pass
raise ExceptionWrapper(e, d)
log = s.getvalue()
d = dict(largs=json.dumps(largs),
kargs=json.dumps(kargs),
command=fn.__name__,
enqueued_at=enqueue_time,
started_at=started_at,
log=log,
result=ret,
context=task_context,
parent_task=parent_task)
logging.root.removeHandler(h)
task_context = {}
try:
end_time = calendar.timegm(datetime.datetime.utcnow().timetuple())
run_time = end_time - started_at
stats.put("ol.celery.task_run_time", run_time * 1000)
stats.put("ol.celery.%s_run_time" % fn.__name__, run_time * 1000)
except:
pass
return d
retval = task(wrapped)
patched_delay = create_patched_delay(retval)
retval.original_delay = retval.delay
retval.delay = patched_delay
return retval
})
mail = EmailMultiAlternatives(subject=subject,
body=text,
from_email=from_email,
to=to)
# html
html = render_to_string(
"lfs/mail/review_added_mail.html", {
"site": "http://%s" % Site.objects.get(id=settings.SITE_ID),
"review": review,
"product": product,
})
mail.attach_alternative(html, "text/html")
mail.send(fail_silently=True)
# celery
try:
from celery.task import task
except ImportError:
pass
else:
_send_customer_added = task(_send_customer_added)
_send_order_paid_mail = task(_send_order_paid_mail)
_send_order_received_mail = task(_send_order_received_mail)
_send_order_sent_mail = task(_send_order_sent_mail)
_send_review_added = task(_send_review_added)
import pynliner
body = pynliner.fromString(body)
msg.attach_alternative(body, "text/html")
except TemplateDoesNotExist:
logging.info("Email sent without HTML, since %s not found" %
html_path)
msg.send(fail_silently=fail_silently)
# reset environment to original language
if isinstance(recipient, User):
activate(current_language)
if use_celery:
_send_task = task(_send)
def get_users_language(user):
"""
Returns site-specific language for this user. Raises
LanguageStoreNotAvailable if this site does not use translated
notifications.
"""
if getattr(settings, 'NOTIFICATION_LANGUAGE_MODULE', False):
try:
app_label, model_name = settings.NOTIFICATION_LANGUAGE_MODULE.split(
'.')
model = models.get_model(app_label, model_name)
language_model = model._default_manager.get(
user__id__exact=user.id)
args[-1].weight = getattr(args[0], 'weight', 1.)
def do_not_aggregate(acc, value):
"""
Do nothing aggregation function.
:param acc: the accumulator
:param value: the value to accumulate
:returns: the accumulator unchanged
"""
return acc
if OQ_DISTRIBUTE == 'celery':
safe_task = task(safely_call, queue='celery')
def _wakeup(sec):
"""Waiting functions, used to wake up the process pool"""
try:
import prctl
except ImportError:
pass
else:
# if the parent dies, the children die
prctl.set_pdeathsig(signal.SIGKILL)
time.sleep(sec)
return os.getpid()
text = render_to_string("lfs/mail/review_added_mail.txt", {
"review": review,
"product": product,
})
mail = EmailMultiAlternatives(
subject=subject, body=text, from_email=from_email, to=to)
# html
html = render_to_string("lfs/mail/review_added_mail.html", {
"site": "http://%s" % Site.objects.get(id=settings.SITE_ID),
"review": review,
"product": product,
})
mail.attach_alternative(html, "text/html")
mail.send(fail_silently=True)
# celery
try:
from celery.task import task
except ImportError:
pass
else:
_send_customer_added = task(_send_customer_added)
_send_order_paid_mail = task(_send_order_paid_mail)
_send_order_received_mail = task(_send_order_received_mail)
_send_order_sent_mail = task(_send_order_sent_mail)
_send_review_added = task(_send_review_added)
# try to attach the html variant
try:
body = render_to_string(html_path, context)
if pynliner:
body = pynliner.fromString(body)
msg.attach_alternative(body, "text/html")
except TemplateDoesNotExist:
logging.info("Email sent without HTML, since %s not found" % html_path)
msg.send(fail_silently=fail_silently)
# reset environment to original language
if isinstance(recipient, User):
activate(current_language)
if use_celery:
_send_task = task(_send)
def get_users_language(user):
"""
Returns site-specific language for this user. Raises
LanguageStoreNotAvailable if this site does not use translated
notifications.
"""
if getattr(settings, 'NOTIFICATION_LANGUAGE_MODULE', False):
try:
app_label, model_name = settings.NOTIFICATION_LANGUAGE_MODULE.split('.')
model = models.get_model(app_label, model_name)
language_model = model._default_manager.get(user__id__exact=user.id)
if hasattr(language_model, 'language'):
return language_model.language
backurl = getattr(mon, 'backurl', None)
zsocket = (
Socket(backurl, zmq.PUSH, 'connect') if backurl else mock.MagicMock()
) # do nothing
with zsocket:
zsocket.send(res)
return zsocket.num_sent if backurl else res
if OQ_DISTRIBUTE.startswith('celery'):
from celery.result import ResultSet
from celery import Celery
from celery.task import task
app = Celery('openquake')
app.config_from_object('openquake.engine.celeryconfig')
safetask = task(safely_call, queue='celery') # has to be global
class IterResult(object):
"""
:param iresults:
an iterator over Result objects
:param taskname:
the name of the task
:param num_tasks:
the total number of expected tasks
:param progress:
a logging function for the progress report
:param sent:
the number of bytes sent (0 if OQ_DISTRIBUTE=no)
"""
