log.info(errors)

            return htmlfill.render(

                base.render('admin/repos/repo_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                force_defaults=False,

                encoding="UTF-8")

        try:

            # create is done sometimes async on celery, db transaction

            # management is handled there.

        except Exception:

            log.error(traceback.format_exc())

            msg = (_('Error creating repository %s')

                   % form_result.get('repo_name'))

            webutils.flash(msg, category='error')

            raise HTTPFound(location=url('home'))

        raise HTTPFound(location=webutils.url('repo_creating_home',

                              repo_name=form_result['repo_name_full'],

                              ))

    @NotAnonymous()

                repo_name_full=repo_name,

                repo_type=repo_type,

                repo_description=description,

                repo_private=private,

                clone_uri=clone_uri,

                repo_group=repo_group,

                repo_landing_rev=landing_rev,

                enable_statistics=enable_statistics,

                enable_downloads=enable_downloads,

                repo_copy_permissions=copy_permissions,

            )

            # no commit, it's done in RepoModel, or async via celery

            return dict(

                msg="Created new repository `%s`" % (repo_name,),

                success=True,  # cannot return the repo data here since fork

                               # can be done async

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to create repository `%s`' % (repo_name,))

    # permission check inside

            form_data = dict(

                repo_name=fork_name_parts[-1],

                repo_name_full=fork_name,

                repo_group=repo_group,

                repo_type=repo.repo_type,

                description=description,

                private=private,

                copy_permissions=copy_permissions,

                landing_rev=landing_rev,

                update_after_clone=False,

                fork_parent_id=repo.repo_id,

            )

            # no commit, it's done in RepoModel, or async via celery

            return dict(

                msg='Created fork of `%s` as `%s`' % (repo.repo_name,

                                                      fork_name),

                success=True,  # cannot return the repo data here since fork

                               # can be done async

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to fork repository `%s` as `%s`' % (repo_name,

                                                            fork_name)

                             repo_groups=c.repo_groups,

                             landing_revs=c.landing_revs_choices)()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            # an approximation that is better than nothing

            if not db.Ui.get_by_key('hooks', db.Ui.HOOK_UPDATE).ui_active:

                form_result['update_after_clone'] = False

            # create fork is done sometimes async on celery, db transaction

            # management is handled there.

        except formencode.Invalid as errors:

            return htmlfill.render(

                base.render('forks/fork.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('An error occurred during repository forking %s') %

                    repo_name, category='error')

from decorator import decorator

from tg import config

import kallithea

from kallithea.lib.pidlock import DaemonLock, LockHeld

from kallithea.lib.utils2 import safe_bytes

from kallithea.model import meta

log = logging.getLogger(__name__)

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:

                meta.Session.remove()  # prevent reuse of auto created db sessions

                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)

    else:

        def f_wrapped(*args, **kwargs):

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

            try:

                f_org(*args, **kwargs)

            except Exception as e:

                log.error('exception executing sync task %s in sync: %r', f_org.__name__, e)

    return f_wrapped

def __get_lockkey(func, *fargs, **fkwargs):

    params = list(fargs)

    params.extend(['%s-%s' % ar for ar in fkwargs.items()])

    func_name = str(func.__name__) if hasattr(func, '__name__') else str(func)

    lockkey = 'task_%s.lock' % \

        sha1(safe_bytes(func_name + '-' + '-'.join(str(x) for x in params))).hexdigest()