"""

    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

    extras = json.loads(env['RHODECODE_EXTRAS'])

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

    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(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)))

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

    for k, v in extras.items():

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

    if hook_type == 'pre':

        repo = repo.scm_instance

    else:

        #post push shouldn't use the cached instance never

        repo = repo.scm_instance_no_cache()

    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:

            _type = push_ref['type']

            if _type == 'heads':

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

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

                    heads = repo.run_git_command(cmd)[0]

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

                    heads = ' '.join(map(lambda c: c.strip('\n').strip(),

                                         heads.splitlines()))

                    cmd = (('log %(new_rev)s' % push_ref) +

                           ' --reverse --pretty=format:"%H" --not ' + heads)

                    git_revs += 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 += repo.run_git_command(cmd)[0].splitlines()

            elif _type == 'tags':

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

        log_push_action(baseui, repo, _git_revs=git_revs)

    def mark_as_fork(self, repo, fork, user):

        repo = self.__get_repo(repo)

        fork = self.__get_repo(fork)

        if fork and repo.repo_id == fork.repo_id:

            raise Exception("Cannot set repository as fork of itself")

        repo.fork = fork

        self.sa.add(repo)

        return repo

    def _handle_push(self, repo, username, action, repo_name, revisions):

        """

        Triggers push action hooks

        :param repo: SCM repo

        :param username: username who pushes

        :param action: push/push_loca/push_remote

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        from rhodecode import CONFIG

        from rhodecode.lib.base import _get_ip_addr

        try:

            from pylons import request

            environ = request.environ

        except TypeError:

            # we might use this outside of request context, let's fake the

            # environ data

            from webob import Request

            environ = Request.blank('').environ

        #trigger push hook

        extras = {

            'ip': _get_ip_addr(environ),

            'username': username,

            'action': 'push_local',

            'repository': repo_name,

            'scm': repo.alias,

            'config': CONFIG['__file__'],

            'server_url': get_server_url(environ),

            'make_lock': None,

            'locked_by': [None, None]

        }

        _scm_repo = repo._repo

        _set_extras(extras)

        if repo.alias == 'hg':

            log_push_action(_scm_repo.ui, _scm_repo, node=revisions[0])

        elif repo.alias == 'git':

    def _get_IMC_module(self, scm_type):

        """

        Returns InMemoryCommit class based on scm_type

        :param scm_type:

        """

        if scm_type == 'hg':

            from rhodecode.lib.vcs.backends.hg import \

                MercurialInMemoryChangeset as IMC

        elif scm_type == 'git':

            from rhodecode.lib.vcs.backends.git import \

                GitInMemoryChangeset as IMC

        return IMC

    def pull_changes(self, repo, username):

        dbrepo = self.__get_repo(repo)

        clone_uri = dbrepo.clone_uri

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        repo_name = dbrepo.repo_name

        try:

            if repo.alias == 'git':

                repo.fetch(clone_uri)

            else:

                repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

        except:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        """

        Commits changes

        :param repo: SCM instance

        """

        user = self._get_user(user)

        IMC = self._get_IMC_module(repo.alias)

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)