handle_git_post_receive = (lambda repo_path, revs, env:

    handle_git_receive(repo_path, revs, env, hook_type='post'))

def handle_git_receive(repo_path, revs, env, hook_type='post'):

    """

    A really hacky method that is runned by git post-receive hook and logs

    an push action together with pushed revisions. It's executed by subprocess

    thus needs all info to be able to create a on the fly pylons enviroment,

    connect to database and run the logging code. Hacky as sh*t but works.

    :param repo_path:

    :type repo_path:

    :param revs:

    :type revs:

    :param env:

    :type env:

    """

    from paste.deploy import appconfig

    from sqlalchemy import engine_from_config

    from rhodecode.config.environment import load_environment

    from rhodecode.model import init_model

    from rhodecode.model.db import RhodeCodeUi

    from rhodecode.lib.utils import make_ui

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

    load_environment(conf.global_conf, conf.local_conf)

    engine = engine_from_config(conf, 'sqlalchemy.db1.')

    init_model(engine)

    baseui = make_ui('db')

    # fix if it's not a bare repo

    if repo_path.endswith('.git'):

        repo_path = repo_path[:-4]

    repo = Repository.get_by_full_path(repo_path)

    if not repo:

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

                      % (safe_str(repo_path)))

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

    for k, v in extras.items():

        baseui.setconfig('rhodecode_extras', k, v)

    repo = repo.scm_instance

    repo.ui = baseui

    if hook_type == 'pre':

        pre_push(baseui, repo)

    # if push hook is enabled via web interface

    elif hook_type == 'post' and _hooks.get(RhodeCodeUi.HOOK_PUSH):

        rev_data = []

        for l in revs:

            old_rev, new_rev, ref = l.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': _ref_data[2].strip()})

        git_revs = []

        for push_ref  in rev_data:

        resp.charset = None

        resp.app_iter = out

        return resp

    def backend(self, request, environ):

        """

        WSGI Response producer for HTTP POST Git Smart HTTP requests.

        Reads commands and data from HTTP POST's body.

        returns an iterator obj with contents of git command's

        response to stdout

        """

        git_command = self._get_fixedpath(request.path_info)

        if git_command not in self.commands:

            log.debug('command %s not allowed' % git_command)

            return exc.HTTPMethodNotAllowed()

        if 'CONTENT_LENGTH' in environ:

            inputstream = FileWrapper(environ['wsgi.input'],

                                      request.content_length)

        else:

            inputstream = environ['wsgi.input']

        try:

            gitenv = os.environ

            from rhodecode.lib.compat import json

            gitenv['RHODECODE_EXTRAS'] = json.dumps(self.extras)

            # forget all configs

            gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

            opts = dict(

                env=gitenv,

                cwd=os.getcwd()

            )

            out = subprocessio.SubprocessIOChunker(

                r'git %s --stateless-rpc "%s"' % (git_command[4:],

                                                  self.content_path),

                inputstream=inputstream,

                **opts

            )

        except EnvironmentError, e:

            log.exception(e)

            raise exc.HTTPExpectationFailed()

        if git_command in [u'git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            subprocess.call(u'git --git-dir "%s" '

                            'update-server-info' % self.content_path,

                            shell=True)

        resp = Response()

        resp.content_type = 'application/x-%s-result' % git_command.encode('utf8')

        resp.charset = None

        resp.app_iter = out

        return resp

    def __call__(self, environ, start_response):