if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(org_repo.path, gitrepo_remote)

                revs = []

                for x in gitrepo_remote.get_walker(include=[other_rev],

                                                   exclude=[org_rev]):

                    revs.append(x.commit.id)

                other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]

                if other_changesets:

                    ancestor = other_changesets[0].parents[0].raw_id

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestor = other_rev

            else:

                so, se = org_repo.run_git_command(

                )

                other_changesets = [org_repo.get_changeset(cs)

                              for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

                so, se = org_repo.run_git_command(

                )

                ancestor = re.findall(r'[0-9a-fA-F]{40}', so)[0]

            org_changesets = []

        else:

            raise Exception('Bad alias only git and hg is allowed')

        return other_changesets, org_changesets, ancestor

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name):

        c.compare_home = True

        org_repo = c.db_repo.repo_name

        other_repo = request.GET.get('other_repo', org_repo)

        c.a_repo = Repository.get_by_repo_name(org_repo)

        c.cs_repo = Repository.get_by_repo_name(other_repo)

        c.a_ref_name = c.cs_ref_name = _('Select changeset')

        return render('compare/compare_diff.html')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    # if push hook is enabled via web interface

    elif hook_type == 'post' and _hooks.get(Ui.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:

                    # update the symbolic ref if we push new repo

                    if repo.is_empty():

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

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

                    heads = repo.run_git_command(cmd)[0]

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

                    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:

                    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)

        """

        return path.split(self.repo_name, 1)[-1].strip('/')

    def inforefs(self, request, environ):

        """

        WSGI Response producer for HTTP GET Git Smart

        HTTP /info/refs request.

        """

        git_command = request.GET.get('service')

        if git_command not in self.commands:

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

            return exc.HTTPMethodNotAllowed()

        # note to self:

        # please, resist the urge to add '\n' to git capture and increment

        # line count by 1.

        # The code in Git client not only does NOT need '\n', but actually

        # blows up if you sprinkle "flush" (0000) as "0001\n".

        # It reads binary, per number of bytes specified.

        # if you do add '\n' as part of data, count it.

        server_advert = '# service=%s' % git_command

        packet_len = str(hex(len(server_advert) + 4)[2:].rjust(4, '0')).lower()

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        try:

            )

        except EnvironmentError, e:

            log.error(traceback.format_exc())

            raise exc.HTTPExpectationFailed()

        resp = Response()

        resp.content_type = 'application/x-%s-advertisement' % str(git_command)

        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_path = kallithea.CONFIG.get('git_path', 'git')

        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:

            out = subprocessio.SubprocessIOChunker(

                cmd,

                inputstream=inputstream,

            )

        except EnvironmentError, e:

            log.error(traceback.format_exc())

            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.

            from kallithea.lib.vcs import get_repo

            from dulwich.server import update_server_info

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

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

        request = Request(environ)

        _path = self._get_fixedpath(request.path_info)

        if _path.startswith('info/refs'):

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        from kallithea.model import init_model

        from kallithea.lib.utils2 import engine_from_config

        #get to remove repos !!

        add_cache(config)

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

        init_model(engine)

def check_git_version():

    """

    Checks what version of git is installed in system, and issues a warning

    if it's too old for Kallithea to work properly.

    """

    from kallithea import BACKENDS

    from kallithea.lib.vcs.backends.git.repository import GitRepository

    from kallithea.lib.vcs.conf import settings

    from distutils.version import StrictVersion

    if 'git' not in BACKENDS:

        return None

                                                    _safe=True)

    m = re.search("\d+.\d+.\d+", stdout)

    if m:

        ver = StrictVersion(m.group(0))

    else:

        ver = StrictVersion('0.0.0')

    req_ver = StrictVersion('1.7.4')

    log.debug('Git executable: "%s" version %s detected: %s'

              % (settings.GIT_EXECUTABLE_PATH, ver, stdout))

    if stderr:

        log.warning('Error detecting git version: %r' % stderr)

    elif ver < req_ver:

        log.warning('Kallithea detected git version %s, which is too old '

                    'for the system to function properly. '

                    'Please upgrade to version %s or later.' % (ver, req_ver))

    return ver

@decorator.decorator

def jsonify(func, *args, **kwargs):

    """Action decorator that formats output for JSON

        path = self._fix_path(path)

        if self._get_kind(path) != NodeKind.FILE:

            raise ChangesetError("File does not exist for revision %s at "

                " '%s'" % (self.raw_id, path))

        return path

    def _get_file_nodes(self):

        return chain(*(t[2] for t in self.walk()))

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent)

                for parent in self._commit.parents]

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        rev_filter = settings.GIT_REV_FILTER

        so, se = self.repository.run_git_command(

        )

        children = []

        pat = re.compile(r'^%s' % self.raw_id)

        for l in so.splitlines():

            if pat.match(l):

                childs = l.split(' ')[1:]

                children.extend(childs)

        return [self.repository.get_changeset(cs) for cs in children]

    def next(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        cs = self

        while True:

            try:

                next_ = cs.revision + 1

                next_rev = cs.repository.revisions[next_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = cs.repository.get_changeset(next_rev)

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.raw_length()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

        return self.get_file_history(path, limit=1)[0]

    def get_file_history(self, path, limit=None):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        TODO: This function now uses os underlying 'git' and 'grep' commands

        which is generally not good. Should be replaced with algorithm

        iterating commits.

        """

        self._get_filectx(path)

        cs_id = safe_str(self.id)

        f_path = safe_str(path)

        if limit:

        else:

        so, se = self.repository.run_git_command(cmd)

        ids = re.findall(r'[0-9a-fA-F]{40}', so)

        return [self.repository.get_changeset(sha) for sha in ids]

    def get_file_history_2(self, path):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        self._get_filectx(path)

        from dulwich.walk import Walker

        include = [self.id]

        walker = Walker(self.repository._repo.object_store, include,

                        paths=[path], max_entries=1)

        return [self.repository.get_changeset(sha)

                for sha in (x.commit.id for x in walker)]

    def get_file_annotate(self, path):

        """

        Returns a generator of four element tuples with

            lineno, sha, changeset lazy loader and line

        TODO: This function now uses os underlying 'git' command which is

        generally not good. Should be replaced with algorithm iterating

        commits.

        """

        # -l     ==> outputs long shas (and we need all 40 characters)

        # --root ==> doesn't put '^' character for boundaries

        # -r sha ==> blames for the given revision

        so, se = self.repository.run_git_command(cmd)

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            ln_no = i + 1

            sha, line = re.split(r' ', blame_line, 1)

            yield (ln_no, sha, lambda: self.repository.get_changeset(sha), line)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

                    node._tree = obj

                elif isinstance(obj, objects.Blob):

                    node = FileNode(path, changeset=self)

                    node._blob = obj

                else:

                    raise NodeDoesNotExistError("There is no file nor directory "

                        "at the given path '%s' at revision %s"

                        % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        Gets a fast accessible file changes for given changeset

        """

        added, modified, deleted = self._changes_cache

        return list(added.union(modified).union(deleted))

    @LazyProperty

    def _diff_name_status(self):

        output = []

        for parent in self.parents:

            so, se = self.repository.run_git_command(cmd)

            output.append(so.strip())

        return '\n'.join(output)

    @LazyProperty

    def _changes_cache(self):

        added = set()

        modified = set()

        deleted = set()

        _r = self.repository._repo

        parents = self.parents

        if not self.parents:

            parents = [EmptyChangeset()]

        for parent in parents:

            if isinstance(parent, EmptyChangeset):

                oid = None

            else:

                oid = _r[parent.raw_id].tree

            changes = _r.object_store.tree_changes(oid, _r[self.raw_id].tree)

            for (oldpath, newpath), (_, _), (_, _) in changes:

                if newpath and oldpath:

                    modified.add(newpath)

                elif newpath and not oldpath:

# -*- coding: utf-8 -*-

"""

    vcs.backends.git.repository

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Git repository implementation.

    :created_on: Apr 8, 2010

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

"""

import os

import re

import time

import errno

import urllib

import urllib2

import logging

import posixpath

import string

from dulwich.objects import Tag

from dulwich.repo import Repo, NotGitRepository

from dulwich.config import ConfigFile

from kallithea.lib.vcs import subprocessio

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError,

    RepositoryError, TagAlreadyExistError, TagDoesNotExistError

)

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

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.ordered_dict import OrderedDict

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

from kallithea.lib.vcs.utils.hgcompat import (

    hg_url, httpbasicauthhandler, httpdigestauthhandler

)

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

        """

        return self._get_all_revisions()

    @classmethod

    def _run_git_command(cls, cmd, **opts):

        """

        Runs given ``cmd`` as git command and returns tuple

        (stdout, stderr).

        :param cmd: git command to be executed

        :param opts: env options to pass into Subprocess command

        """

        if '_bare' in opts:

            _copts = []

            del opts['_bare']

        else:

            _copts = ['-c', 'core.quotepath=false', ]

        safe_call = False

        if '_safe' in opts:

            #no exc on failure

            del opts['_safe']

            safe_call = True

        gitenv = os.environ

        # need to clean fix GIT_DIR !

        if 'GIT_DIR' in gitenv:

            del gitenv['GIT_DIR']

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        _git_path = settings.GIT_EXECUTABLE_PATH

        cmd = [_git_path] + _copts + cmd

        try:

            _opts = dict(

                env=gitenv,

            )

            _opts.update(opts)

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

        except (EnvironmentError, OSError), err:

            tb_err = ("Couldn't run git command (%s).\n"

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

            log.error(tb_err)

            if safe_call:

                return '', err

            else:

                raise RepositoryError(tb_err)

        return ''.join(p.output), ''.join(p.error)

    def run_git_command(self, cmd):

        opts = {}

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

            opts['cwd'] = self.path

        return self._run_git_command(cmd, **opts)

    @classmethod

    def _check_url(cls, url):

        """

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

                GitRepository._check_url(src_url)

                self.clone(src_url, update_after_clone, bare)

                return Repo(self.path)

            elif create:

                os.makedirs(self.path)

                if bare:

                    return Repo.init_bare(self.path)

                else:

                    return Repo.init(self.path)

            else:

                return self._repo

        except (NotGitRepository, OSError), err:

            raise RepositoryError(err)

    def _get_all_revisions(self):

        # we must check if this repo is not empty, since later command

        # fails if it is. And it's cheaper to ask than throw the subprocess

        # errors

        try:

            self._repo.head()

        except KeyError:

            return []

        rev_filter = settings.GIT_REV_FILTER

        try:

            so, se = self.run_git_command(cmd)

        except RepositoryError:

            # Can be raised for empty repositories

            return []

        return so.splitlines()

    def _get_all_revisions2(self):

        #alternate implementation using dulwich

        includes = [x[1][0] for x in self._parsed_refs.iteritems()

                    if x[1][1] != 'T']

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        For git backend we always return integer here. This way we ensure

        that changeset's revision attribute would become integer.

        """

        is_null = lambda o: len(o) == revision.count('0')

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

          ``start_date`` would be filtered out from returned set

        :param end_date: if specified, changesets with commit date greater than

          ``end_date`` would be filtered out from returned set

        :param branch_name: if specified, changesets not reachable from given

          branch would be filtered out from returned set

        :param reverse: if ``True``, returned generator would be reversed

          (meaning that returned changesets would have descending date order)

        :raise BranchDoesNotExistError: If given ``branch_name`` does not

            exist.

        :raise ChangesetDoesNotExistError: If changeset for given ``start`` or

          ``end`` could not be found.

        """

        if branch_name and branch_name not in self.branches:

            raise BranchDoesNotExistError("Branch '%s' not found" \

                                          % branch_name)

        # actually we should check now if it's not an empty repo to not spaw

        # subprocess commands

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        # %H at format means (full) commit hash, initial hashes are retrieved

        # in ascending date order

        if start_date:

        if end_date:

        if branch_name:

        else:

        revs = self.run_git_command(cmd)[0].splitlines()

        start_pos = 0

        end_pos = len(revs)

        if start:

            _start = self._get_revision(start)

            try:

                start_pos = revs.index(_start)

            except ValueError:

                pass

        if end is not None:

            _end = self._get_revision(end)

            try:

                end_pos = revs.index(_end)

            except ValueError:

                pass

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError('start cannot be after end')

        if end_pos is not None:

            end_pos += 1

        revs = revs[start_pos:end_pos]

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

          shown. Defaults to ``3``.

        """

        flags = ['-U%s' % context, '--full-index', '--binary', '-p', '-M', '--abbrev=40']

        if ignore_whitespace:

            flags.append('-w')

        if hasattr(rev1, 'raw_id'):

            rev1 = getattr(rev1, 'raw_id')

        if hasattr(rev2, 'raw_id'):

            rev2 = getattr(rev2, 'raw_id')

        if rev1 == self.EMPTY_CHANGESET:

            rev2 = self.get_changeset(rev2).raw_id

        else:

            rev1 = self.get_changeset(rev1).raw_id

            rev2 = self.get_changeset(rev2).raw_id

        if path:

        stdout, stderr = self.run_git_command(cmd)

        # TODO: don't ignore stderr

        # If we used 'show' command, strip first few lines (until actual diff

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            parts = stdout.split('\ndiff ', 1)

            if len(parts) > 1:

                stdout = 'diff ' + parts[1]

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

        return GitInMemoryChangeset(self)

    def clone(self, url, update_after_clone=True, bare=False):

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

          working directory

        :param bare: If set to ``True``, repository would be cloned into

          *bare* git repository (no working directory at all).

        """

        url = self._get_url(url)

        cmd = ['clone', '-q']

        if bare:

            cmd.append('--bare')

        elif not update_after_clone:

            cmd.append('--no-checkout')

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def fetch(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        for line in (x for x in so.splitlines()):

            sha, ref = line.split('\t')

        self.run_git_command(cmd)

    def _update_server_info(self):

        """

        runs gits update-server-info command in this repo instance

        """

        from dulwich.server import update_server_info

        try:

            update_server_info(self._repo)

        except OSError, e:

            if e.errno != errno.ENOENT:

                raise

            # Workaround for dulwich crashing on for example its own dulwich/tests/data/repos/simple_merge.git/info/refs.lock

            log.error('Ignoring error running update-server-info: %s', e)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return GitWorkdir(self)

    def get_config_value(self, section, name, config_file=None):

        """

    #        raise e

    #

    #    return answer

    """

    def __init__(self, cmd, inputstream=None, buffer_size=65536,