def task(f_org):

    """Wrapper of celery.task.task, running async if CELERY_APP

    """

    if kallithea.CELERY_APP:

        def f_async(*args, **kwargs):

            log.info('executing %s task', f_org.__name__)

            try:

                f_org(*args, **kwargs)

            finally:

                log.info('executed %s task', f_org.__name__)

        runner = kallithea.CELERY_APP.task(name=f_org.__name__, ignore_result=True)(f_async)

        def f_wrapped(*args, **kwargs):

            t = runner.apply_async(args=args, kwargs=kwargs)

            log.info('executing task %s in async mode - id %s', f_org, t.task_id)

            return t

    else:

        def f_wrapped(*args, **kwargs):

            log.info('executing task %s in sync', f_org.__name__)

            try:

                result = f_org(*args, **kwargs)

        lockkey = __get_lockkey(func, *fargs, **fkwargs)

        log.info('running task with lockkey %s', lockkey)

        try:

            l = DaemonLock(os.path.join(config['cache_dir'], lockkey))

            ret = func(*fargs, **fkwargs)

            l.release()

            return ret

        except LockHeld:

            log.info('LockHeld')

            return 'Task with key %s already running' % lockkey

    return decorator(__wrapper, func)

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.model import db, meta, repo, userlog

__all__ = ['whoosh_index', 'get_commits_stats', 'send_email']

log = celery.utils.log.get_task_logger(__name__)

@celerylib.task

@celerylib.locked_task

def whoosh_index(repo_location, full_index):

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location) \

                         .run(full_index=full_index)

def _author_username(author):

    """Return the username of the user identified by the email part of the 'author' string,

    default to the name or email.

    Kind of similar to h.person() ."""

    email = author_email(author)

    if email:

        user = db.User.get_by_email(email)

        if user is not None:

            return user.username

    # Still nothing?  Just pass back the author name if any, else the email

    return author_name(author) or email

@celerylib.task

def get_commits_stats(repo_name, ts_min_y, ts_max_y, recurse_limit=100):

    lockkey = celerylib.__get_lockkey('get_commits_stats', repo_name, ts_min_y,

                            ts_max_y)

    log.info('running task with lockkey %s', lockkey)

    try:

        lock = celerylib.DaemonLock(os.path.join(config['cache_dir'], lockkey))

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

        db_repo = db.Repository.get_by_repo_name(repo_name)

        if db_repo is None:

            return True

        if len(scm_repo.revisions) > 1 and kallithea.CELERY_APP and recurse_limit > 0:

            get_commits_stats(repo_name, ts_min_y, ts_max_y, recurse_limit - 1)

        elif recurse_limit <= 0:

            log.debug('Not recursing - limit has been reached')

        else:

            log.debug('Not recursing')

    except celerylib.LockHeld:

        log.info('Task with key %s already running', lockkey)

        return 'Task with key %s already running' % lockkey

@celerylib.task

def send_email(recipients, subject, body='', html_body='', headers=None, from_name=None):

    """

    Sends an email with defined parameters from the .ini files.

    :param recipients: list of recipients, if this is None, the defined email

        address from field 'email_to' and all admins is used instead

    :param subject: subject of the mail

    :param body: plain text body of the mail

    :param html_body: html version of body

    :param headers: dictionary of prepopulated e-mail headers

    :param from_name: full name to be used as sender of this mail - often a

    .full_name_or_username value

        smtp_serv.sendmail(app_email_from, recipients, msg.as_string())

        smtp_serv.quit()

        log.info('Mail was sent to: %s' % recipients)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@celerylib.task

def create_repo(form_data, cur_user):

    cur_user = db.User.guess_instance(cur_user)

    owner = cur_user

    repo_name = form_data['repo_name']

    repo_name_full = form_data['repo_name_full']

    repo_type = form_data['repo_type']

    description = form_data['repo_description']

    private = form_data['repo_private']

    clone_uri = form_data.get('clone_uri')

    repo_group = form_data['repo_group']

    landing_rev = form_data['repo_landing_rev']

        # rollback things manually !

        db_repo = db.Repository.get_by_repo_name(repo_name_full)

        if db_repo:

            db.Repository.delete(db_repo.repo_id)

            meta.Session().commit()

            repo.RepoModel()._delete_filesystem_repo(db_repo)

        raise

    return True

@celerylib.task

def create_repo_fork(form_data, cur_user):

    """

    Creates a fork of repository using interval VCS methods

    :param form_data:

    :param cur_user:

    """

    base_path = kallithea.CONFIG['base_path']

    cur_user = db.User.guess_instance(cur_user)

    repo_name = form_data['repo_name']  # fork in this case

    repo_name_full = form_data['repo_name_full']