celery: celery 4.X support. Fixes #4169

- update tasks
- enabled celerybeat to function
- check and cleanup code for 4.X

rhodecode/lib/celerylib/loader.py

@@ -0,0 +1,256 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2017 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+"""
+Celery loader, run with::
+
+    celery worker --beat --app rhodecode.lib.celerylib.loader --loglevel DEBUG --ini=._dev/dev.ini
+"""
+import os
+import logging
+
+from celery import Celery
+from celery import signals
+from celery import Task
+from kombu.serialization import register
+from pyramid.threadlocal import get_current_request
+
+import rhodecode
+
+from rhodecode.lib.auth import AuthUser
+from rhodecode.lib.celerylib.utils import get_ini_config, parse_ini_vars
+from rhodecode.lib.ext_json import json
+from rhodecode.lib.pyramid_utils import bootstrap, setup_logging, prepare_request
+from rhodecode.lib.utils2 import str2bool
+from rhodecode.model import meta
+
+
+register('json_ext', json.dumps, json.loads,
+         content_type='application/x-json-ext',
+         content_encoding='utf-8')
+
+log = logging.getLogger('celery.rhodecode.loader')
+
+
+def add_preload_arguments(parser):
+    parser.add_argument(
+        '--ini', default=None,
+        help='Path to ini configuration file.'
+    )
+    parser.add_argument(
+        '--ini-var', default=None,
+        help='Comma separated list of key=value to pass to ini.'
+    )
+
+
+def get_logger(obj):
+    custom_log = logging.getLogger(
+        'rhodecode.task.{}'.format(obj.__class__.__name__))
+
+    if rhodecode.CELERY_ENABLED:
+        try:
+            custom_log = obj.get_logger()
+        except Exception:
+            pass
+
+    return custom_log
+
+
+base_celery_config = {
+    'result_backend': 'rpc://',
+    'result_expires': 60 * 60 * 24,
+    'result_persistent': True,
+    'imports': [],
+    'worker_max_tasks_per_child': 100,
+    'accept_content': ['json_ext'],
+    'task_serializer': 'json_ext',
+    'result_serializer': 'json_ext',
+    'worker_hijack_root_logger': False,
+}
+# init main celery app
+celery_app = Celery()
+celery_app.user_options['preload'].add(add_preload_arguments)
+ini_file_glob = None
+
+
[e-mail]_logging.connect
+def setup_logging_callback(**kwargs):
+    setup_logging(ini_file_glob)
+
+
[e-mail]_preload_options.connect
+def on_preload_parsed(options, **kwargs):
+    ini_location = options['ini']
+    ini_vars = options['ini_var']
+    celery_app.conf['INI_PYRAMID'] = options['ini']
+
+    if ini_location is None:
+        print('You must provide the paste --ini argument')
+        exit(-1)
+
+    options = None
+    if ini_vars is not None:
+        options = parse_ini_vars(ini_vars)
+
+    global ini_file_glob
+    ini_file_glob = ini_location
+
+    log.debug('Bootstrapping RhodeCode application...')
+    env = bootstrap(ini_location, options=options)
+
+    setup_celery_app(
+        app=env['app'], root=env['root'], request=env['request'],
+        registry=env['registry'], closer=env['closer'],
+        ini_location=ini_location)
+
+    # fix the global flag even if it's disabled via .ini file because this
+    # is a worker code that doesn't need this to be disabled.
+    rhodecode.CELERY_ENABLED = True
+
+
[e-mail]_success.connect
+def task_success_signal(result, **kwargs):
+    meta.Session.commit()
+    celery_app.conf['PYRAMID_CLOSER']()
+
+
[e-mail]_retry.connect
+def task_retry_signal(
+        request, reason, einfo, **kwargs):
+    meta.Session.remove()
+    celery_app.conf['PYRAMID_CLOSER']()
+
+
[e-mail]_failure.connect
+def task_failure_signal(
+        task_id, exception, args, kwargs, traceback, einfo, **kargs):
+    meta.Session.remove()
+    celery_app.conf['PYRAMID_CLOSER']()
+
+
[e-mail]_revoked.connect
+def task_revoked_signal(
+        request, terminated, signum, expired, **kwargs):
+    celery_app.conf['PYRAMID_CLOSER']()
+
+
+def setup_celery_app(app, root, request, registry, closer, ini_location):
+    ini_dir = os.path.dirname(os.path.abspath(ini_location))
+    celery_config = base_celery_config
+    celery_config.update({
+        # store celerybeat scheduler db where the .ini file is
+        'beat_schedule_filename': os.path.join(ini_dir, 'celerybeat-schedule'),
+    })
+    ini_settings = get_ini_config(ini_location)
+    log.debug('Got custom celery conf: %s', ini_settings)
+
+    celery_config.update(ini_settings)
+    celery_app.config_from_object(celery_config)
+
+    celery_app.conf.update({'PYRAMID_APP': app})
+    celery_app.conf.update({'PYRAMID_ROOT': root})
+    celery_app.conf.update({'PYRAMID_REQUEST': request})
+    celery_app.conf.update({'PYRAMID_REGISTRY': registry})
+    celery_app.conf.update({'PYRAMID_CLOSER': closer})
+
+
+def configure_celery(config, ini_location):
+    """
+    Helper that is called from our application creation logic. It gives
+    connection info into running webapp and allows execution of tasks from
+    RhodeCode itself
+    """
+    # store some globals into rhodecode
+    rhodecode.CELERY_ENABLED = str2bool(
+        config.registry.settings.get('use_celery'))
+    if rhodecode.CELERY_ENABLED:
+        log.info('Configuring celery based on `%s` file', ini_location)
+        setup_celery_app(
+            app=None, root=None, request=None, registry=config.registry,
+            closer=None, ini_location=ini_location)
+
+
+class RequestContextTask(Task):
+    """
+    This is a celery task which will create a rhodecode app instance context
+    for the task, patch pyramid with the original request
+    that created the task and also add the user to the context.
+    """
+
+    def apply_async(self, args=None, kwargs=None, task_id=None, producer=None,
+                    link=None, link_error=None, shadow=None, **options):
+        """ queue the job to run (we are in web request context here) """
+
+        req = get_current_request()
+
+        # web case
+        if hasattr(req, 'user'):
+            ip_addr = req.user.ip_addr
+            user_id = req.user.user_id
+
+        # api case
+        elif hasattr(req, 'rpc_user'):
+            ip_addr = req.rpc_user.ip_addr
+            user_id = req.rpc_user.user_id
+        else:
+            raise Exception(
+                'Unable to fetch required data from request: {}. \n'
+                'This task is required to be executed from context of '
+                'request in a webapp'.format(repr(req)))
+
+        if req:
+            # we hook into kwargs since it is the only way to pass our data to
+            # the celery worker
+            options['headers'] = options.get('headers', {})
+            options['headers'].update({
+                'rhodecode_proxy_data': {
+                    'environ': {
+                        'PATH_INFO': req.environ['PATH_INFO'],
+                        'SCRIPT_NAME': req.environ['SCRIPT_NAME'],
+                        'HTTP_HOST': req.environ.get('HTTP_HOST',
+                            req.environ['SERVER_NAME']),
+                        'SERVER_NAME': req.environ['SERVER_NAME'],
+                        'SERVER_PORT': req.environ['SERVER_PORT'],
+                        'wsgi.url_scheme': req.environ['wsgi.url_scheme'],
+                    },
+                    'auth_user': {
+                        'ip_addr': ip_addr,
+                        'user_id': user_id
+                    },
+                }
+            })
+
+        return super(RequestContextTask, self).apply_async(
+            args, kwargs, task_id, producer, link, link_error, shadow, **options)
+
+    def __call__(self, *args, **kwargs):
+        """ rebuild the context and then run task on celery worker """
+
+        proxy_data = getattr(self.request, 'rhodecode_proxy_data', None)
+        if not proxy_data:
+            return super(RequestContextTask, self).__call__(*args, **kwargs)
+
+        log.debug('using celery proxy data to run task: %r', proxy_data)
+        # re-inject and register threadlocals for proper routing support
+        request = prepare_request(proxy_data['environ'])
+        request.user = AuthUser(user_id=proxy_data['auth_user']['user_id'],
+                                ip_addr=proxy_data['auth_user']['ip_addr'])
+
+        return super(RequestContextTask, self).__call__(*args, **kwargs)
+

rhodecode/lib/celerylib/utils.py

@@ -0,0 +1,156 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2017 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import os
+import json
+import logging
+import datetime
+
+from functools import partial
+
+from pyramid.compat import configparser
+from celery.result import AsyncResult
+import celery.loaders.base
+import celery.schedules
+
+
+log = logging.getLogger(__name__)
+
+
+def get_task_id(task):
+    task_id = None
+    if isinstance(task, AsyncResult):
+        task_id = task.task_id
+
+    return task_id
+
+
+def crontab(value):
+    return celery.schedules.crontab(**value)
+
+
+def timedelta(value):
+    return datetime.timedelta(**value)
+
+
+def safe_json(get, section, key):
+    value = ''
+    try:
+        value = get(key)
+        json_value = json.loads(value)
+    except ValueError:
+        msg = 'The %s=%s is not valid json in section %s' % (
+            key, value, section
+        )
+        raise ValueError(msg)
+
+    return json_value
+
+
+def get_beat_config(parser, section):
+    SCHEDULE_TYPE_MAP = {
+        'crontab': crontab,
+        'timedelta': timedelta,
+        'integer': int
+    }
+    get = partial(parser.get, section)
+    has_option = partial(parser.has_option, section)
+
+    schedule_type = get('type')
+    schedule_value = safe_json(get, section, 'schedule')
+
+    scheduler_cls = SCHEDULE_TYPE_MAP.get(schedule_type)
+
+    if scheduler_cls is None:
+        raise ValueError(
+            'schedule type %s in section %s is invalid' % (
+                schedule_type,
+                section
+            )
+        )
+
+    schedule = scheduler_cls(schedule_value)
+
+    config = {
+        'task': get('task'),
+        'schedule': schedule,
+    }
+
+    if has_option('args'):
+        config['args'] = safe_json(get, section, 'args')
+
+    if has_option('kwargs'):
+        config['kwargs'] = safe_json(get, section, 'kwargs')
+
+    return config
+
+
+def get_ini_config(ini_location):
+    """
+    Converts basic ini configuration into celery 4.X options
+    """
+    def key_converter(key_name):
+        pref = 'celery.'
+        if key_name.startswith(pref):
+            return key_name[len(pref):].replace('.', '_').lower()
+
+    def type_converter(parsed_key, value):
+        # cast to int
+        if value.isdigit():
+            return int(value)
+
+        # cast to bool
+        if value.lower() in ['true', 'false', 'True', 'False']:
+            return value.lower() == 'true'
+        return value
+
+    parser = configparser.SafeConfigParser(
+        defaults={'here': os.path.abspath(ini_location)})
+    parser.read(ini_location)
+
+    ini_config = {}
+    for k, v in parser.items('app:main'):
+        pref = 'celery.'
+        if k.startswith(pref):
+            ini_config[key_converter(k)] = type_converter(key_converter(k), v)
+
+    beat_config = {}
+    for section in parser.sections():
+        if section.startswith('celerybeat:'):
+            name = section.split(':', 1)[1]
+            beat_config[name] = get_beat_config(parser, section)
+
+    # final compose of settings
+    celery_settings = {}
+
+    if ini_config:
+        celery_settings.update(ini_config)
+    if beat_config:
+        celery_settings.update({'beat_schedule': beat_config})
+
+    return celery_settings
+
+
+def parse_ini_vars(ini_vars):
+    options = {}
+    for pairs in ini_vars.split(','):
+        key, value = pairs.split('=')
+        options[key] = value
+    return options

configs/development.ini

@@ -296,28 +296,15 b' labs_settings_active = true'
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
-broker.host = localhost
-broker.vhost = rabbitmqhost
-broker.port = 5672
-broker.user = rabbitmq
-broker.password = qweqwe
-
-celery.imports = rhodecode.lib.celerylib.tasks
 
-celery.result.backend = amqp
-celery.result.dburi = amqp://
-celery.result.serialier = json
+# connection url to the message broker (default rabbitmq)
+celery.broker_url = amqp://rabbitmq:qweqwe@localhost:5672/rabbitmqhost
 
-#celery.send.task.error.emails = true
-#celery.amqp.task.result.expires = 18000
-
-celeryd.concurrency = 2
-#celeryd.log.file = celeryd.log
-celeryd.log.level = debug
-celeryd.max.tasks.per.child = 1
+# maximum tasks to execute before worker restart
+celery.max_tasks_per_child = 100
 
 ## tasks will never be sent to the queue, but executed locally instead.
-celery.always.eager = false
+celery.task_always_eager = false
 
 ####################################
 ###         BEAKER CACHE        ####
@@ -649,7 +636,7 b' custom.conf = 1'
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
-keys = root, sqlalchemy, beaker, rhodecode, ssh_wrapper
+keys = root, sqlalchemy, beaker, rhodecode, ssh_wrapper, celery
 
 [handlers]
 keys = console, console_sql
@@ -688,6 +675,11 b' handlers ='
 qualname = ssh_wrapper
 propagate = 1
 
+[logger_celery]
+level = DEBUG
+handlers =
+qualname = celery
+
 
 ##############
 ## HANDLERS ##

configs/production.ini

@@ -271,28 +271,15 b' labs_settings_active = true'
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
-broker.host = localhost
-broker.vhost = rabbitmqhost
-broker.port = 5672
-broker.user = rabbitmq
-broker.password = qweqwe
-
-celery.imports = rhodecode.lib.celerylib.tasks
 
-celery.result.backend = amqp
-celery.result.dburi = amqp://
-celery.result.serialier = json
+# connection url to the message broker (default rabbitmq)
+celery.broker_url = amqp://rabbitmq:qweqwe@localhost:5672/rabbitmqhost
 
-#celery.send.task.error.emails = true
-#celery.amqp.task.result.expires = 18000
-
-celeryd.concurrency = 2
-#celeryd.log.file = celeryd.log
-celeryd.log.level = debug
-celeryd.max.tasks.per.child = 1
+# maximum tasks to execute before worker restart
+celery.max_tasks_per_child = 100
 
 ## tasks will never be sent to the queue, but executed locally instead.
-celery.always.eager = false
+celery.task_always_eager = false
 
 ####################################
 ###         BEAKER CACHE        ####
@@ -619,7 +606,7 b' custom.conf = 1'
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
-keys = root, sqlalchemy, beaker, rhodecode, ssh_wrapper
+keys = root, sqlalchemy, beaker, rhodecode, ssh_wrapper, celery
 
 [handlers]
 keys = console, console_sql
@@ -658,6 +645,11 b' handlers ='
 qualname = ssh_wrapper
 propagate = 1
 
+[logger_celery]
+level = DEBUG
+handlers =
+qualname = celery
+
 
 ##############
 ## HANDLERS ##

rhodecode/api/views/repo_api.py

@@ -32,6 +32,7 b' from rhodecode.api.utils import ('
 from rhodecode.lib import audit_logger
 from rhodecode.lib import repo_maintenance
 from rhodecode.lib.auth import HasPermissionAnyApi, HasUserGroupPermissionAnyApi
+from rhodecode.lib.celerylib.utils import get_task_id
 from rhodecode.lib.utils2 import str2bool, time_to_datetime
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
@@ -712,10 +713,7 b' def create_repo('
         }
 
         task = RepoModel().create(form_data=data, cur_user=owner)
-        from celery.result import BaseAsyncResult
-        task_id = None
-        if isinstance(task, BaseAsyncResult):
-            task_id = task.task_id
+        task_id = get_task_id(task)
         # no commit, it's done in RepoModel, or async via celery
         return {
             'msg': "Created new repository `%s`" % (schema_data['repo_name'],),
@@ -1105,10 +1103,8 b' def fork_repo(request, apiuser, repoid, '
 
         task = RepoModel().create_fork(data, cur_user=owner)
         # no commit, it's done in RepoModel, or async via celery
-        from celery.result import BaseAsyncResult
-        task_id = None
-        if isinstance(task, BaseAsyncResult):
-            task_id = task.task_id
+        task_id = get_task_id(task)
+
         return {
             'msg': 'Created fork of `%s` as `%s`' % (
                 repo.repo_name, schema_data['repo_name']),

rhodecode/apps/admin/views/repositories.py

@@ -28,6 +28,7 b' from pyramid.renderers import render'
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView, DataGridAppView
+from rhodecode.lib.celerylib.utils import get_task_id
 
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.auth import (
@@ -143,22 +144,19 b' class AdminReposView(BaseAppView, DataGr'
         c = self.load_default_context()
 
         form_result = {}
+        self._load_form_data(c)
         task_id = None
-        self._load_form_data(c)
-
         try:
             # CanWriteToGroup validators checks permissions of this POST
             form = RepoForm(
                 self.request.translate, repo_groups=c.repo_groups_choices,
                 landing_revs=c.landing_revs_choices)()
-            form_results = form.to_python(dict(self.request.POST))
+            form_result = form.to_python(dict(self.request.POST))
 
             # create is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create(form_result, self._rhodecode_user.user_id)
-            from celery.result import BaseAsyncResult
-            if isinstance(task, BaseAsyncResult):
-                task_id = task.task_id
+            task_id = get_task_id(task)
         except formencode.Invalid as errors:
             data = render('rhodecode:templates/admin/repos/repo_add.mako',
                           self._get_template_context(c), self.request)

rhodecode/apps/repository/views/repo_checks.py

@@ -46,11 +46,9 b' class RepoChecksView(BaseAppView):'
 
         repo_name = self.request.matchdict['repo_name']
         db_repo = Repository.get_by_repo_name(repo_name)
-        if not db_repo:
-            raise HTTPNotFound()
 
         # check if maybe repo is already created
-        if db_repo.repo_state in [Repository.STATE_CREATED]:
+        if db_repo and db_repo.repo_state in [Repository.STATE_CREATED]:
             # re-check permissions before redirecting to prevent resource
             # discovery by checking the 302 code
             perm_set = ['repository.read', 'repository.write', 'repository.admin']
@@ -80,9 +78,10 b' class RepoChecksView(BaseAppView):'
 
         if task_id and task_id not in ['None']:
             import rhodecode
-            from celery.result import AsyncResult
+            from rhodecode.lib.celerylib.loader import celery_app
             if rhodecode.CELERY_ENABLED:
-                task = AsyncResult(task_id)
+                task = celery_app.AsyncResult(task_id)
+                task.get()
                 if task.failed():
                     msg = self._log_creation_exception(task.result, repo_name)
                     h.flash(msg, category='error')

rhodecode/apps/repository/views/repo_forks.py

@@ -33,6 +33,7 b' from rhodecode.lib.auth import ('
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasRepoPermissionAny, HasPermissionAnyDecorator, CSRFRequired)
 import rhodecode.lib.helpers as h
+from rhodecode.lib.celerylib.utils import get_task_id
 from rhodecode.model.db import coalesce, or_, Repository, RepoGroup
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.forms import RepoForkForm
@@ -226,9 +227,8 b' class RepoForksView(RepoAppView, DataGri'
             # management is handled there.
             task = RepoModel().create_fork(
                 form_result, c.rhodecode_user.user_id)
-            from celery.result import BaseAsyncResult
-            if isinstance(task, BaseAsyncResult):
-                task_id = task.task_id
+
+            task_id = get_task_id(task)
         except formencode.Invalid as errors:
             c.rhodecode_db_repo = self.db_repo
 

rhodecode/config/environment.py

@@ -23,14 +23,6 b' import os'
 import logging
 import rhodecode
 
-# ------------------------------------------------------------------------------
-# CELERY magic until refactor - issue #4163 - import order matters here:
-#from rhodecode.lib import celerypylons  # this must be first, celerypylons
-                                        # sets config settings upon import
-
-import rhodecode.integrations           # any modules using celery task
-                                        # decorators should be added afterwards:
-# ------------------------------------------------------------------------------
 
 from rhodecode.config import utils
 
@@ -54,14 +46,6 b' def load_pyramid_environment(global_conf'
         'secret': settings_merged.get('channelstream.secret')
     }
 
-
-    # TODO(marcink): celery
-    # # store some globals into rhodecode
-    # rhodecode.CELERY_ENABLED = str2bool(config['app_conf'].get('use_celery'))
-    # rhodecode.CELERY_EAGER = str2bool(
-    #     config['app_conf'].get('celery.always.eager'))
-
-
     # If this is a test run we prepare the test environment like
     # creating a test database, test search index and test repositories.
     # This has to be done before the database connection is initialized.

rhodecode/config/licenses.json

@@ -189,7 +189,7 b''
   "python2.7-jupyter-core-4.3.0": {
     "BSD 4-clause \"Original\" or \"Old\" License": "http://spdx.org/licenses/BSD-4-Clause"
   }, 
-  "python2.7-kombu-1.5.1": {
+  "python2.7-kombu-4.1.0": {
     "BSD 4-clause \"Original\" or \"Old\" License": "http://spdx.org/licenses/BSD-4-Clause"
   }, 
   "python2.7-mistune-0.7.4": {

rhodecode/config/middleware.py

@@ -42,6 +42,7 b' from rhodecode.lib.vcs import VCSCommuni'
 from rhodecode.lib.exceptions import VCSServerUnavailable
 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
+from rhodecode.lib.celerylib.loader import configure_celery
 from rhodecode.lib.plugins.utils import register_rhodecode_plugin
 from rhodecode.lib.utils2 import aslist as rhodecode_aslist, AttributeDict
 from rhodecode.subscribers import (
@@ -87,9 +88,11 b' def make_pyramid_app(global_config, **se'
     pyramid_app = wrap_app_in_wsgi_middlewares(pyramid_app, config)
     pyramid_app.config = config
 
+    config.configure_celery(global_config['__file__'])
     # creating the app uses a connection - return it after we are done
     meta.Session.remove()
 
+    log.info('Pyramid app %s created and configured.', pyramid_app)
     return pyramid_app
 
 
@@ -196,6 +199,8 b' def includeme(config):'
     config.add_directive(
         'register_rhodecode_plugin', register_rhodecode_plugin)
 
+    config.add_directive('configure_celery', configure_celery)
+
     if asbool(settings.get('appenlight', 'false')):
         config.include('appenlight_client.ext.pyramid_tween')
 

rhodecode/integrations/types/hipchat.py

@@ -20,18 +20,16 b''
 
 from __future__ import unicode_literals
 import deform
-import re
 import logging
 import requests
 import colander
 import textwrap
-from celery.task import task
 from mako.template import Template
 
 from rhodecode import events
 from rhodecode.translation import _
 from rhodecode.lib import helpers as h