def create_celery(app):
global __celery
if __celery:
return __celery
celery = Celery(
app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['BROKER_URL'],
)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
db.session = db.create_scoped_session()
try:
response = TaskBase.__call__(self, *args, **kwargs)
finally:
db.session.remove()
return response
celery.Task = ContextTask
__celery = celery
return __celery
def make_celery(flask_app): """ While you can use Celery without any reconfiguration with Flask, it becomes a bit nicer by subclassing tasks and adding support for Flask's application contexts and hooking it up with the Flask configuration. - http://flask.pocoo.org/docs/patterns/celery/ """ celery = Celery() celery.config_from_object(settings.config) TaskBase = celery.Task class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with flask_app.app_context(): return TaskBase.__call__(self, *args, **kwargs) celery.Task = ContextTask return celery
def setup_celery(self):
celery = Celery()
import radar.ukrdc_importer.tasks # noqa
import radar.ukrdc_exporter.tasks # noqa
broker_url = self.config.get('CELERY_BROKER_URL')
if broker_url is not None:
celery.conf.BROKER_URL = broker_url
celery.conf.update(self.config)
TaskBase = celery.Task
app = self
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery():
app, conf = create_app()
if app.config['REDIS_PASSWORD']:
redis_broker='redis://:{}@{}:{}/0'.format(
app.config['REDIS_PASSWORD'],
app.config['REDIS_HOST'],
app.config['REDIS_PORT'],
)
else:
redis_broker='redis://{}:{}/0'.format(
app.config['REDIS_HOST'],
app.config['REDIS_PORT'],
)
app.logger.info('MIGRATE_MODE: {}, MIGRATE_ES: {}, Broker at {}'
.format(MIGRATE_MODE, MIGRATE_ES,app.config['REDIS_HOST']))
celery = Celery(app.import_name, broker=redis_broker)
celery.conf.update(app.config)
celery.data_db = app.data_db
# boiler plate to get our tasks running in the app context
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app=None):
"""Create a new Celery object and tie together the Celery config to the
app's config. Wrap all tasks in the context of the application.
Args:
app (Flask)
Returns:
celery (Celery)
"""
app = app or create_app()
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'],
include=CELERY_TASK_LIST)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app=None, settings_override=None):
"""Creates a celery app to perform asynchronous jobs.
Params:
app: A Flask app.
settings_override: Override settings from config file.
"""
app = app or create_app('silently_celery', os.path.dirname(__file__),
settings_override)
celery = Celery(__name__, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
if app.debug == True:
#Disable while image data is written to the log.
celery.conf.CELERYD_LOG_LEVEL = LOG_LEVELS['DEBUG']
class ContextTask(celery.Task):
"""Add Flask app context awareness."""
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return celery.Task.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
"""
Recommended from Flask's documentation to set up the Celery object.
:param app:
:return:
"""
celery = Celery(app.import_name)
# Determine which Celery configuration to load:
# The order is:
# 1. `SM_CELERY_CONFIG` Environment Variable
# 2. The default "celeryconfig.py"
celery.config_from_object(get_celery_config_file())
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
cel = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
# celery.conf.update(
# CELERY_IMPORTS=(
# 'buyapi.tasks', # we're not including our tasks here as
# 'app.module_b.tasks', # our tasks are in other files listed here
# )
# )
cel.conf.update(CELERYBEAT_SCHEDULE={
# Executes every Monday morning at 7:30 A.M
'every_minute': {
'task': 'tasks.regular.run_every_minute',
'schedule': timedelta(minutes=1),
},
}, CELERY_TIMEZONE='Europe/Moscow')
cel.conf.update(app.config)
# cel.conf.update(CELERY_TASK_RESULT_EXPIRES=10)
TaskBase = cel.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
cel.Task = ContextTask
return cel
def make_celery():
"""
Configures Celery task queue
"""
celery = Celery("tasks", broker=SETTINGS['MESSAGE_BROKER_URL'],
backend=SETTINGS['REDIS_URL'])
# Settings to adjust to the AMQP message quota
celery.conf.update(
CELERY_TASK_SERIALIZER='pickle',
CELERY_ACCEPT_CONTENT=['pickle'],
CELERY_RESULT_SERIALIZER='json',
BROKER_POOL_LIMIT=1,
CELERYD_CONCURRENCY=2,
CELERYD_PROCESSES=1
)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def prepare_celery(app):
"""Set up celery for this application."""
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
class ContextTask(celery.Task):
"""A task which maintains an SQLAlchemy database session."""
abstract = True
_session = None
@property
def session(self):
"""Database session"""
if self._session is None:
self._session = scoped_session(sessionmaker(bind=app.engine))
return self._session
@property
def redis(self):
"""Get a redis client which is appropriate."""
return app.redis
def after_return(self, *args, **kwargs):
if self._session is not None:
self._session.remove()
super(ContextTask, self).after_return(*args, **kwargs)
def __call__(self, *args, **kwargs):
with app.app_context():
return super(ContextTask, self).__call__(*args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(flask_app=None):
logger.debug("Creating celery app")
if not flask_app:
if has_app_context():
logger.debug("Using current flask app")
app = current_app
else:
logger.debug("No current flask app")
app = create_app()
else:
app = flask_app
celery = Celery(app.import_name,
broker=app.config['CELERY_BROKER_URL'],
backend=app.config['CELERY_RESULT_BACKEND'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
celery.logger = get_task_logger(__name__)
app.celery = celery
return app
def make_celery(app):
# default to using JSON, rather than Pickle (Celery's default, but Celery
# warns about it)
for var, dfl in [
('CELERY_ACCEPT_CONTENT', ['json']),
('CELERY_TASK_SERIALIZER', 'json'),
('CELERY_RESULT_SERIALIZER', 'json')]:
app.config[var] = app.config.get(var, dfl)
broker = app.config.get('CELERY_BROKER_URL', 'memory://')
celery = Celery(app.import_name, broker=broker)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
try:
return TaskBase.__call__(self, *args, **kwargs)
finally:
# flush any open DB sessions used by this task
current_app.db.flush_sessions()
celery.Task = ContextTask
app.celery_tasks = dict((fn, celery.task(**kwargs)(fn))
for (fn, kwargs) in _defined_tasks.iteritems())
return celery
def bootstrap_celery(app):
"""
Registers celery with the app
:param app: the flask app
:return: the Celery context
"""
# importing here because some tasks refer to app, lol
from AuthorityReporter.tasks.etl import links_for_page, get_contributing_authors, edit_distance, get_all_revisions
from AuthorityReporter.tasks.etl import get_title_top_authors, set_page_key
from AuthorityReporter.tasks.solr import add_with_metadata, build_wiki_user_doc, get_wiki_topic_doc
from AuthorityReporter.tasks.solr import analyze_pages_globally, analyze_users_globally, analyze_wikis_globally
from AuthorityReporter.tasks.solr import aggregate_global_topic, analyze_topics_globally
from AuthorityReporter.tasks.solr import analyze_all_user_pages_globally
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
"""
构造 celery
:param app:
:return:
"""
broker_url = app.config["REDIS_URL"]
backend_url = app.config["REDIS_URL"]
celery = Celery("ovftool_celery", broker=broker_url, backend=backend_url)
celery.conf.update(CELERYBEAT_SCHEDULE={
}, CELERY_ENABLE_UTC=True)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(flask_app):
"""Create a Celery application."""
celery = Celery(flask_app.import_name)
celery.conf.update(flask_app.config)
celery.Task = AppContextTask
# Set Flask application object on the Celery application.
celery.flask_app = flask_app
return celery
def make_celery(app):
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(broker='amqp://guest@localhost//', backend='rpc')
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(app.import_name, backend='redis://localhost:6379/0', broker='redis://localhost:6379/0')
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(backend='redis://localhost:6379/1')
celery.config_from_object('cl.celeryConfig')
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(app.import_name)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def celery_config(app): # Configures async library for updating movie images
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(main='MONKEY_TASKS', backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(flask_app):
region = getenv('AWS_SQS_REGION')
celery_options = {
'broker_transport_options': {
'region': region
},
'task_default_queue': QUEUE_NAME
}
broker_url = getenv('AWS_SQS_BROKER_URL')
if not broker_url:
broker_url = 'sqs://'
if getenv('AWS_SQS_ACCESS_KEY_ID') and getenv('AWS_SQS_SECRET_ACCESS_KEY'):
broker_url += '{}:{}@'.format(
quote_plus(getenv('AWS_SQS_ACCESS_KEY_ID')),
quote_plus(getenv('AWS_SQS_SECRET_ACCESS_KEY'))
)
celery = Celery(
flask_app.import_name,
broker=broker_url,
include=[
'app.api.services',
'app.emails',
'app.emails.util',
'app.tasks.email',
'app.tasks.mailchimp',
'app.tasks.brief_tasks',
'app.tasks.s3',
'app.tasks.brief_response_tasks',
'app.tasks.supplier_tasks',
'app.tasks.jira',
'app.tasks.dreamail',
'app.tasks.publish_tasks'
]
)
celery.conf.update(flask_app.config)
celery.config_from_object(celery_options)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def after_return(self, *args, **kwargs):
db.session.remove()
def __call__(self, *args, **kwargs):
if current_app:
return TaskBase.__call__(self, *args, **kwargs)
else:
with flask_app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app):
celery = Celery(__name__, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
taskbase = celery.Task
class ContextTask(taskbase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return taskbase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
'''pass flask to celery when background tasks are run'''
celery = Celery(app.name)
celery.config_from_object("celeryconfig")
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(application):
celery = Celery(application.name,
broker=application.config['CELERY_BROKER_URL'])
celery.conf.update(application.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with application.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(app.__class__)
platforms.C_FORCE_ROOT = True
celery.config_from_object('setting')
#celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return (app,celery)
def make_celery(server):
celery = Celery(app.import_name,
backend=server.config['CELERY_RESULT_BACKEND'],
broker=server.config['CELERY_BROKER_URL'])
celery.conf.update(server.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with server.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app=None):
if not app:
app = make_app()
celery = Celery('tasks', broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery_ = Celery('celery_app')
celery_.config_from_object('config')
TaskBase = celery_.Task
celery_.app = app
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery_.Task = ContextTask
return celery_
def make_celery(app=None):
app = app or create_app()
celery = Celery(
app.import_name,
backend=app.config['CELERY_BACKEND'],
broker=app.config['CELERY_BROKER_URL'],
)
celery.conf.update(app.config)
celery.callback_url = app.config['API_CALLBACK_URL']
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app=None):
"""Return a celery app in app context"""
app = app or create_app(os.environ.get("ENV", "prod"),
register_blueprints=False)
celery = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app: Scaffold) -> Celery:
"""
Creating a celery application for flask applications.
Source: https://flask.palletsprojects.com/en/1.1.x/patterns/celery/#configure
"""
celery = Celery(
app.import_name,
backend=app.config["CELERY_RESULT_BACKEND"],
broker=app.config["CELERY_BROKER_URL"],
)
celery.conf.update(app.config)
class ContextTask(celery.Task):
def __call__(self, *args, **kwargs):
with app.app_context():
return self.run(*args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
"""
Integrate app context to celery.Task
"""
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
# Make other extensions could be called normally
celery.Task = ContextTask
return celery
def make_celery(app):
# create the celery instance and configure it
celery = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
# setup the base class for celery tasks
TaskBase = celery.Task
class ContextTask(TaskBase):
"""Task class which creates an app_context before calling the task."""
abstract = True
def __call(self, *args, **kwargs):
with app.app_context():
return super(ContextTask, self).__call__(*args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
if app.config['CELERY_RESULT_BACKEND'] and app.config['CELERY_BROKER_URL']:
celery = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
else:
logger.error("Celery disable, redis backend is required.")
return None
def create_celery(application):
"""
Configures celery instance from application, using it's config
:param application: Flask application instance
:return: Celery instance
"""
celery = Celery(application.import_name,
broker=application.config['CELERY_BROKER_URL'])
celery.conf.update(application.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with application.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app=None):
"""
:param app:
:return:
"""
app = app or create_app(app_name='worker')
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
# set redis url vars
app.config['CELERY_BROKER_URL'] = 'redis://localhost:6379/0'
# 'REDIS_URL', 'redis://localhost:6379/0')
app.config['CELERY_RESULT_BACKEND'] = app.config['CELERY_BROKER_URL']
# create context tasks in celery
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
# print app.config
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery(app=None):
"""
The function creates a new Celery object, configures it with the broker
from the application config, updates the rest of the Celery config from the
Flask config and then creates a subclass of the task that wraps the task
execution in an application context.
http://flask.pocoo.org/docs/0.10/patterns/celery/
:param app: flask.Flask application instance or None
:return: configured celery.Celery instance
"""
if app is None:
app = create_app()
celery = Celery(
app.import_name,
broker=app.config.get('CELERY_BROKER_URL'),
backend=app.config.get('CELERY_BROKER_URL'),
)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
# If we're already in an app_context, use that. Otherwise, use
# the default app.app_context. This is necessary for providing
# custom applications for tests
def get_ctx(): # pragma: no cover
try:
ctx = current_app.app_context()
except RuntimeError:
ctx = app.app_context()
return ctx
with get_ctx():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(
app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL']
)
celery.conf.update(app.config)
class ContextTask(celery.Task):
def __call__(self, *args, **kwargs):
with app.app_context():
return self.run(*args, **kwargs)
class ContextQueueOnce(QueueOnce):
def __call__(self, *args, **kwargs):
with app.app_context():
return super(ContextQueueOnce, self).__call__(*args, **kwargs)
celery.Task = ContextTask
celery.QueueOnce = ContextQueueOnce
return celery
def make_celery(flask_app=None, config_name='prod'):
from . import create_app
flask_app = flask_app or create_app(config_name)
c = Celery(flask_app.import_name)
c.app = flask_app
logger.info('celery {} flask app {}'.format(c, c.app))
c.config_from_object('celeryconf')
TaskBase = c.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
logger.error('ContextTask {}'.format(flask_app))
with flask_app.app_context():
logger.error('ContextTask app context {}'.format(flask_app))
return TaskBase.__call__(self, *args, **kwargs)
c.Task = ContextTask
return c
def make_celery(app):
#Celery configuration
app.config['CELERY_BROKER_URL'] = 'redis://localhost:13800/0'
app.config['CELERY_RESULT_BACKEND'] = 'redis://localhost:13800/0'
app.config['CELERYBEAT_SCHEDULE'] = {
'periodic_task-every-minute': {
'task': 'periodic_task',
'schedule': crontab(minute="*")
}
}
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery(app):
celery = Celery(
app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['BROKER_URL']
)
celery.conf.update(app.config)
celery.config_from_object(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
celery = Celery(
app.import_name,
result_backend=app.config["CELERY_RESULT_BACKEND"],
broker=app.config["CELERY_BROKER_URL"],
timezone="Europe/London",
)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery(flask_application):
"""
Creating the Celery application instance.
:param obj flask_application: The Flask application instance.
:return:
"""
celery_app = Celery(flask_application.import_name,
backend=flask_application.config['CELERY_RESULT_BACKEND'],
broker=flask_application.config['BROKER_URL'])
celery_app.conf.update(flask_application.config)
celery_task = celery_app.Task
class ContextTask(celery_task):
abstract = True
def __call__(self, *args, **kwargs):
with flask_application.app_context():
return celery_task.__call__(self, *args, **kwargs)
celery_app.Task = ContextTask
return celery_app
def make_celery(app):
app.config['CELERYBEAT_SCHEDULE'] = {
# Executes every minute
'periodic_task-every-minute': {
'task': 'periodic_task',
'schedule': crontab(minute="*")
}
}
celery = Celery(app.import_name, broker='amqp://rabbitmq')
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def get_celery_app(config):
global _celery_app
if _celery_app:
return _celery_app
_celery_app = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
_celery_app.conf.update(app.config)
class ContextTask(_celery_app.Task):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return _celery_app.Task.__call__(self, *args, **kwargs)
_celery_app.Task = ContextTask
return _celery_app
def make_celery(app):
# Create and configure the celery app
celery = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(**S.CELERY_CONFIG)
# Subclass the base Task so that tasks run in a Flask app context
TaskBase = celery.Task
class ContextTask(TaskBase): # noqa
def __call__(self, *args, **kwargs): # noqa
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
# Add the tasks
Tasks.bind(celery)
return celery
def make_celery(app=None):
"""
Create the celery instance from an existing app, or from a new app
:param app: Flask app if created
:return:
"""
app = app or create_app('dev')
celery = Celery(__name__, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task # pylint: disable=C0103
class ContextTask(TaskBase): # pylint: disable=R0903
""" Inject flask context into the celery object """
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app=None):
"""
Factory method that to place a Celery instance in the context
of a Flask application
:param app: :class:`Flask` application instance
"""
app = app or create_app('longboxed', os.path.dirname(__file__))
celery = Celery(__name__, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app=None):
app = app or create_app('staging')
celery = Celery(__name__)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
from .tasks import register_tasks
register_tasks(celery)
return celery
def make_celery():
tasks_app = Celery(
'telemock',
broker=BROKER_URI,
# backend=REDIS_URI,
include=['tasks']
)
flask_app = setup_app()
TaskBase = tasks_app.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
""" add flask context to base celery task class """
with flask_app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
tasks_app.Task = ContextTask
return tasks_app
def create_celery_app(app=None):
app = app or create_app('apollo', '', register_all_blueprints=False)
celery = Celery(__name__, broker=app.config['CELERY_BROKER_URL'])
# configure exception logging
client = Client(app.config.get('SENTRY_DSN', ''))
register_logger_signal(client)
register_signal(client)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app: Flask = None) -> 'Celery':
from alerta.utils.format import register_custom_serializer
register_custom_serializer()
app = app or create_app()
celery = Celery(app.name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase): # type: ignore
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app, settings):
celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
celery.config_from_object(celery_config)
task_base = celery.Task
class ContextTask(task_base):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return task_base.__call__(self, *args, **kwargs)
celery.Task = ContextTask
from src.tasks import init_tasks
init_tasks(app, celery, settings)
return celery
def make_celery(app):
"""
初始化celery
http://flask.pocoo.org/docs/1.0/patterns/celery/
:param app:
:return:
"""
from celery import Celery
celery = Celery(app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
class ContextTask(celery.Task):
def __call__(self, *args, **kwargs):
with app.app_context():
return self.run(*args, **kwargs)
celery.Task = ContextTask
return celery
def make_celery(app):
"""Generate celery instance from flask config"""
celery = Celery(
app.import_name, # APP name as str; used only for RabbitMQ to identify your tasks
broker=app.config['CELERY_BROKER_URL'], # We'll read them from flask config
backend=app.config['CELERY_RESULT_BACKEND'], # We'll read them from flask config
include=['tasks'] # Here add your tasks file
)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_celery_app(app): # pragma: no cover
app = app or create_app()
celery = Celery(__name__,
backend='amqp',
broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
import serendip_api.tasks
return celery
def make_celery(app):
celery = Celery(
app.import_name,
backend=app.config['CELERY_RESULT_BACKEND'],
broker=app.config['CELERY_BROKER_URL']
)
class ContextTask(celery.Task):
abstract = True
def __call__(self, *args, **kwarg):
with app.app_context():
return self.run(*args, **kwarg)
celery.Task = ContextTask
celery.conf.update(
CELERYBEAT_SCHEDULE={
'destroy-performlogs': {
'task': 'flaskr.workers.performlogs.destroy_performlogs',
'schedule': crontab(hour=1, minute=0)
}
}
)
return celery
