]

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

                if other_changesets:

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

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestors = [other_rev]

                gitrepo.close()

                gitrepo_remote.close()

            else:

                    ['log', '--reverse', '--pretty=format:%H',

                     '-s', '%s..%s' % (org_rev, other_rev)]

                )

                other_changesets = [org_repo.get_changeset(cs)

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

                    ['merge-base', org_rev, other_rev]

                )

                ancestors = [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, ancestors

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    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 scm_repo.is_empty():

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

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

                # build exclude list without the ref

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

                ref = push_ref['ref']

                heads = [head for head in stdout.splitlines() if head != ref]

                # now list the git revs while excluding from the list

                cmd = ['log', push_ref['new_rev'], '--reverse', '--pretty=format:%H']

                cmd.append('--not')

                cmd.extend(heads) # empty list is ok

                git_revs += stdout.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 += stdout.splitlines()

        elif _type == 'tags':

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

    process_pushed_raw_ids(git_revs)

    return 0

# Almost exactly like Mercurial contrib/hg-ssh:

def rejectpush(ui, **kwargs):

        """

        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

            ['rev-list', rev_filter, '--children']

        )

        return [

            self.repository.get_changeset(cs)

            for parts in (l.split(' ') for l in so.splitlines())

            if parts[0] == self.raw_id

            for cs in parts[1:]

        ]

    def next(self, branch=None):

        if branch and self.branch != branch:

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

        """

        self._get_filectx(path)

        cs_id = safe_str(self.id)

        f_path = safe_str(path)

        if limit is not None:

            cmd = ['log', '-n', str(safe_int(limit, 0)),

                   '--pretty=format:%H', '-s', cs_id, '--', f_path]

        else:

            cmd = ['log',

                   '--pretty=format:%H', '-s', cs_id, '--', f_path]

        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]

        """

        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.

        """

        cmd = ['blame', '-l', '--root', '-r', self.id, '--', path]

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

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

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

        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.

        finally:

            p.close()

        # TODO: introduce option to make commands fail if they have any stderr output?

        if stderr:

            log.debug('stderr from %s:\n%s', cmd, stderr)

        else:

            log.debug('stderr from %s: None', cmd)

        return stdout, stderr

    def run_git_command(self, cmd):

        """

        Runs given ``cmd`` as git command with cwd set to current repo.

        """

        cwd = None

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

            cwd = self.path

    @classmethod

    def _check_url(cls, url):

        """

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

        link. Sometimes it may happened that git 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, exception is also thrown

        when the return code is non 200

        """

    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

        cmd = ['rev-list', rev_filter, '--reverse', '--date-order']

        try:

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

        cmd = ['log', '--date-order', '--reverse', '--pretty=format:%H']

        if max_revisions:

            cmd += ['--max-count=%s' % max_revisions]

        if start_date:

            cmd += ['--since', start_date.strftime('%m/%d/%y %H:%M:%S')]

        if end_date:

            cmd += ['--until', end_date.strftime('%m/%d/%y %H:%M:%S')]

        if branch_name:

            cmd.append(branch_name)

        else:

            cmd.append(settings.GIT_REV_FILTER)

        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:

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        cmd = ['pull', '--ff-only', 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)

        cmd = ['fetch', url, '--']

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

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

            cmd.append('+%s:%s' % (ref, ref))

        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: