Git backend implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

import re

import time

import posixpath

import logging

import traceback

from dulwich.repo import Repo, NotGitRepository

#from dulwich.config import ConfigFile

from string import Template

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.backends.base import BaseRepository

from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import TagAlreadyExistError

from rhodecode.lib.vcs.exceptions import TagDoesNotExistError

from rhodecode.lib.vcs.utils import safe_unicode, makedate, date_fromtimestamp

            if os.path.isdir(self.path):

                opts['cwd'] = self.path

            p = subprocessio.SubprocessIOChunker(cmd, **opts)

        except (EnvironmentError, OSError), err:

            log.error(traceback.format_exc())

            raise RepositoryError("Couldn't run git command (%s).\n"

                                  "Original error was:%s" % (cmd, err))

        so = ''.join(p)

        se = None

        return so, se

        """

        Functon will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError

        """

    def _get_repo(self, create, src_url=None, update_after_clone=False,

            bare=False):

        if create and os.path.exists(self.path):

            raise RepositoryError("Location already exist")

        if src_url and not create:

            raise RepositoryError("Create should be set to True if src_url is "

                                  "given (clone operation creates repository)")

        try:

            if create and src_url:

                self.clone(src_url, update_after_clone, bare)

                return Repo(self.path)

            elif create:

                os.mkdir(self.path)

                if bare:

                    return Repo.init_bare(self.path)

                else:

                    return Repo.init(self.path)

            else:

                return Repo(self.path)

        except (NotGitRepository, OSError), err:

            raise RepositoryError(err)

        # Check if given revisions are present at repository (may raise

        # ChangesetDoesNotExistError)

        if rev1 != self.EMPTY_CHANGESET:

            self.get_changeset(rev1)

        self.get_changeset(rev2)

        file_filter = match(self.path, '', [path])

        return ''.join(patch.diff(self._repo, rev1, rev2, match=file_filter,

                          opts=diffopts(git=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

        """

        Function will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError, return code 200 if url

        is valid or True if it's a local path

        """

        from mercurial.util import url as Url

        # those authnadlers are patched for python 2.6.5 bug an

        # infinit looping when given invalid resources

        from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if('+' in url[:url.find('://')]):

        handlers = []

        test_uri, authinfo = Url(url).authinfo()

        if authinfo:

            #create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((httpbasicauthhandler(passmgr),

                             httpdigestauthhandler(passmgr)))

        that case repository would be created and returned.

        If ``src_url`` is given, would try to clone repository from the

        location at given clone_point. Additionally it'll make update to

        working copy accordingly to ``update_after_clone`` flag

        """

        try:

            if src_url:

                url = str(self._get_url(src_url))

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                try:

                    clone(self.baseui, url, self.path, **opts)

#                except urllib2.URLError:

#                    raise Abort("Got HTTP 404 error")

                except Exception:

                    raise

                # Don't try to create if we've already cloned repo

                create = False

            return localrepository(self.baseui, self.path, create=create)

        except (Abort, RepoError), err:

            if create:

                msg = "Cannot create repository at %s. Original error was %s"\

                    % (self.path, err)