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]

            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: