return callback(deleted_by=deleted_by, **user_dict)

    return 0

def _hook_environment(repo_path):

    """

    Create a light-weight environment for stand-alone scripts and return an UI and the

    db repository.

    Git hooks are executed as subprocess of Git while Kallithea is waiting, and

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    from paste.deploy import appconfig

    from sqlalchemy import engine_from_config

    from kallithea.config.environment import load_environment

    from kallithea.model.base import init_model

    extras = _extract_extras()

    path, ini_name = os.path.split(extras['config'])

    conf = appconfig('config:%s' % ini_name, relative_to=path)

    conf = load_environment(conf.global_conf, conf.local_conf)

    setup_cache_regions(conf)

    engine = engine_from_config(conf, 'sqlalchemy.')

    init_model(engine)

    repo_path = safe_unicode(repo_path)

    # fix if it's not a bare repo

    if repo_path.endswith(os.sep + '.git'):

        repo_path = repo_path[:-5]

    repo = Repository.get_by_full_path(repo_path)

    if not repo:

        raise OSError('Repository %s not found in database'

                      % (safe_str(repo_path)))

    baseui = make_ui('db')

    return baseui, repo

def handle_git_pre_receive(repo_path, git_stdin_lines):

    """Called from Git pre-receive hook"""

    baseui, repo = _hook_environment(repo_path)

    scm_repo = repo.scm_instance

    push_lock_handling(baseui, scm_repo)

def handle_git_post_receive(repo_path, git_stdin_lines):

    """Called from Git post-receive hook"""

    baseui, repo = _hook_environment(repo_path)

    # the post push hook should never use the cached instance

    scm_repo = repo.scm_instance_no_cache()

    _hooks = dict(baseui.configitems('hooks')) or {}

    # if push hook is enabled via web interface

    if _hooks.get(Ui.HOOK_PUSH_LOG):

        rev_data = []

        for l in git_stdin_lines:

            old_rev, new_rev, ref = l.strip().split(' ')

            _ref_data = ref.split('/')

            if _ref_data[1] in ['tags', 'heads']:

                rev_data.append({'old_rev': old_rev,

                                 'new_rev': new_rev,

                                 'ref': ref,

                                 'type': _ref_data[1],

                                 'name': '/'.join(_ref_data[2:])})

        git_revs = []

        for push_ref in rev_data:

            _type = push_ref['type']

            if _type == 'heads':

                if push_ref['old_rev'] == EmptyChangeset().raw_id:

                    # update the symbolic ref if we push new repo

                    if scm_repo.is_empty():

                        scm_repo._repo.refs.set_symbolic_ref('HEAD',

                                            'refs/heads/%s' % push_ref['name'])

                    cmd = ['for-each-ref', '--format=%(refname)', 'refs/heads/*']

                    heads = scm_repo.run_git_command(cmd)[0]

                    cmd = ['log', push_ref['new_rev'],

                           '--reverse', '--pretty=format:%H', '--not']

                    heads = heads.replace(push_ref['ref'], '')

                    for l in heads.splitlines():

                        cmd.append(l.strip())

                    git_revs += scm_repo.run_git_command(cmd)[0].splitlines()

                elif push_ref['new_rev'] == EmptyChangeset().raw_id:

                    # delete branch case

                    git_revs += ['delete_branch=>%s' % push_ref['name']]

                else:

                    cmd = ['log', '%(old_rev)s..%(new_rev)s' % push_ref,

                           '--reverse', '--pretty=format:%H']

                    git_revs += scm_repo.run_git_command(cmd)[0].splitlines()

            elif _type == 'tags':

                git_revs += ['tag=>%s' % push_ref['name']]

        log_push_action(baseui, scm_repo, _git_revs=git_revs)