Merge lp:~jelmer/brz/bundle-git into lp:brz

[Jelmer Vernooij]

Bundle the git plugin with Breezy.

Bundle the git plugin with Breezy.

All tests now pass, and the plugin is fully functional - I've been using it on my git repositories without issues over the last couple of months.

See https://bugs.launchpad.net/brz-git/+bugs for a list of remaining bugs. Most of these are around support for shelves, shallow branches and rename tracking.

The code is well tested (not in the least thanks to the various per_X testsuites in core), but could be less ugly in some places.

[Martin Packman (gz)]

Not reviewing all of bzr-git here obviously, but merging in to core is a great step forward, thank you!

review: Approve

[Jelmer Vernooij (jelmer)]

review: Approve

=== added file '.mailmap'
--- .mailmap	1970-01-01 00:00:00 +0000
+++ .mailmap	2018-05-10 00:44:29 +0000
@@ -0,0 +1,5 @@
+Jelmer Vernooij <[e-mail]> <[e-mail]>
+Jelmer Vernooij <[e-mail]> <[e-mail]>
+Jelmer Vernooij <[e-mail]> <[e-mail]>
+INADA Naoki  <[e-mail]> <[e-mail]>
+Martin Packman <[e-mail]> <[e-mail]>

=== modified file '.travis.yml'
--- .travis.yml	2018-05-10 00:38:40 +0000
+++ .travis.yml	2018-05-10 00:44:29 +0000
@@ -4,6 +4,9 @@
     update: true
 sudo: false
 cache: pip
+git:
+  depth: false
+
 python:
   - 3.5
   - 3.6
@@ -26,7 +29,7 @@
 install:
   - sudo apt install python-all-dev python3-all-dev subunit
   - travis_retry pip install -U setuptools
-  - travis_retry pip install -U pip coverage codecov flake8 testtools paramiko fastimport configobj cython testscenarios six docutils python-subunit $TEST_REQUIRE
+  - travis_retry pip install -U pip coverage codecov flake8 testtools paramiko fastimport configobj cython testscenarios six docutils python-subunit dulwich $TEST_REQUIRE
 
 after_success:
   - codecov

=== added directory 'breezy/plugins/git'
=== added file 'breezy/plugins/git/.testr.conf'
--- breezy/plugins/git/.testr.conf	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/.testr.conf	2018-05-10 00:44:29 +0000
@@ -0,0 +1,4 @@
+[DEFAULT]
+test_command=BRZ_PLUGINS_AT=git@`pwd` BRZ_PLUGIN_PATH=-site:-user ${BRZ:-../../../brz} selftest ^breezy.plugins.git. Git --subunit2 $IDOPTION $LISTOPT
+test_id_option=--load-list $IDFILE
+test_list_option=--list

=== added file 'breezy/plugins/git/Makefile'
--- breezy/plugins/git/Makefile	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/Makefile	2018-05-10 00:44:29 +0000
@@ -0,0 +1,80 @@
+DEBUGGER ?= 
+BRZ_OPTIONS ?= 
+BRZ ?= $(shell which brz)
+PYTHON ?= $(shell which python)
+SETUP ?= ./setup.py
+PYDOCTOR ?= pydoctor
+CTAGS ?= ctags
+PYLINT ?= pylint
+RST2HTML ?= rst2html
+TESTS ?= ^breezy.plugins.git. Git breezy.tests.test_info.TestInfo.test_describe_tree_format breezy.tests.test_errors.TestErrors.test_no_arg_named_message breezy.tests.test_info.TestInfo.test_describe_checkout_format
+SUBUNIT_FILTER ?= subunit-filter --fixup-expected-failures=xfail --success --xfail
+SUBUNIT_FORMATTER = subunit2pyunit
+
+all:: build 
+
+build::
+	$(SETUP) build
+
+build-inplace::
+
+install::
+	$(SETUP) install
+
+clean::
+	$(SETUP) clean
+	rm -f *.so
+
+check:: build-inplace 
+	BRZ_PLUGINS_AT=git@$(shell pwd) BRZ_PLUGIN_PATH=-site:-user $(DEBUGGER) $(PYTHON) $(PYTHON_OPTIONS) $(BRZ) $(BRZ_OPTIONS) selftest --subunit2 $(TEST_OPTIONS) $(TESTS) | $(SUBUNIT_FILTER) | $(SUBUNIT_FORMATTER)
+
+list-failing-tests:
+	$(MAKE) check SUBUNIT_FILTER="subunit-filter -F" SUBUNIT_FORMATTER=subunit-ls | grep -e "^breezy\\." | sort
+
+xfail:
+	$(MAKE) -s list-failing-tests > xfail
+
+check-all::
+	$(MAKE) check TESTS="^breezy.plugins.git. Git" SUBUNIT_FILTER=cat
+
+check-verbose::
+	$(MAKE) check TEST_OPTIONS=-v
+
+check-one::
+	$(MAKE) check TEST_OPTIONS=--one
+
+check-random::
+	$(MAKE) check TEST_OPTIONS="--random=now --verbose --one"
+
+show-plugins::
+	BRZ_PLUGINS_AT=git@$(shell pwd) $(BRZ) plugins -v
+
+lint::
+	$(PYLINT) -f parseable *.py */*.py
+
+tags::
+	$(CTAGS) -R .
+
+ctags:: tags
+
+coverage::
+	$(MAKE) check BRZ_OPTIONS="--coverage coverage"
+
+.PHONY: update-pot po/brz-git.pot
+update-pot: po/brz-git.pot
+
+TRANSLATABLE_PYFILES:=$(shell find . -name '*.py' \
+		| grep -v 'tests/' \
+		)
+
+po/brz-git.pot: $(PYFILES) $(DOCFILES)
+	BRZ_PLUGINS_AT=git@$(shell pwd) brz export-pot \
+          --plugin=git > po/brz-git.pot
+	echo $(TRANSLATABLE_PYFILES) | xargs \
+	xgettext --package-name "brz-git" \
+	  --msgid-bugs-address "<[e-mail]>" \
+	  --copyright-holder "Canonical Ltd <[e-mail]>" \
+	  --from-code ISO-8859-1 --sort-by-file --join --add-comments=i18n: \
+	  -d brz-git -p po -o brz-git.pot
+
+.PHONY: xfail

=== added file 'breezy/plugins/git/TODO'
--- breezy/plugins/git/TODO	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/TODO	2018-05-10 00:44:29 +0000
@@ -0,0 +1,2 @@
++ Rename detection - pad.lv/1760740
++ Shallow branches - pad.lv/1764215

=== added file 'breezy/plugins/git/__init__.py'
--- breezy/plugins/git/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/__init__.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,440 @@
+# Copyright (C) 2009-2018 Jelmer Vernooij <[e-mail]>
+# Copyright (C) 2006-2009 Canonical Ltd
+
+# Authors: Robert Collins <[e-mail]>
+#          Jelmer Vernooij <[e-mail]>
+#          John Carr <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+"""A GIT branch and repository format implementation for bzr."""
+
+from __future__ import absolute_import
+
+import os
+import sys
+
+dulwich_minimum_version = (0, 19, 0)
+
+from breezy.i18n import gettext
+
+from ... import (
+    __version__ as breezy_version,
+    errors as bzr_errors,
+    trace,
+    version_info,
+    )
+
+from ...controldir import (
+    ControlDirFormat,
+    Prober,
+    format_registry,
+    network_format_registry as controldir_network_format_registry,
+    )
+
+from ...transport import (
+    register_lazy_transport,
+    register_transport_proto,
+    transport_server_registry,
+    )
+from ...commands import (
+    plugin_cmds,
+    )
+
+
+if getattr(sys, "frozen", None):
+    # allow import additional libs from ./_lib for bzr.exe only
+    sys.path.append(os.path.normpath(
+        os.path.join(os.path.dirname(__file__), '_lib')))
+
+
+def import_dulwich():
+    try:
+        from dulwich import __version__ as dulwich_version
+    except ImportError:
+        raise bzr_errors.DependencyNotPresent("dulwich",
+            "bzr-git: Please install dulwich, https://www.dulwich.io/")
+    else:
+        if dulwich_version < dulwich_minimum_version:
+            raise bzr_errors.DependencyNotPresent("dulwich",
+                "bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
+                    dulwich_minimum_version)
+
+
+_versions_checked = False
+def lazy_check_versions():
+    global _versions_checked
+    if _versions_checked:
+        return
+    import_dulwich()
+    _versions_checked = True
+
+format_registry.register_lazy('git',
+    __name__ + ".dir", "LocalGitControlDirFormat",
+    help='GIT repository.', native=False, experimental=False,
+    )
+
+format_registry.register_lazy('git-bare',
+    __name__ + ".dir", "BareLocalGitControlDirFormat",
+    help='Bare GIT repository (no working tree).', native=False,
+    experimental=False,
+    )
+
+from ...revisionspec import (RevisionSpec_dwim, revspec_registry)
+revspec_registry.register_lazy("git:", __name__ + ".revspec",
+    "RevisionSpec_git")
+RevisionSpec_dwim.append_possible_lazy_revspec(
+    __name__ + ".revspec", "RevisionSpec_git")
+
+
+class LocalGitProber(Prober):
+
+    def probe_transport(self, transport):
+        try:
+            external_url = transport.external_url()
+        except bzr_errors.InProcessTransport:
+            raise bzr_errors.NotBranchError(path=transport.base)
+        if (external_url.startswith("http:") or
+            external_url.startswith("https:")):
+            # Already handled by RemoteGitProber
+            raise bzr_errors.NotBranchError(path=transport.base)
+        from ... import urlutils
+        if urlutils.split(transport.base)[1] == ".git":
+            raise bzr_errors.NotBranchError(path=transport.base)
+        if not transport.has_any(['objects', '.git/objects', '.git']):
+            raise bzr_errors.NotBranchError(path=transport.base)
+        lazy_check_versions()
+        from .dir import (
+            BareLocalGitControlDirFormat,
+            LocalGitControlDirFormat,
+            )
+        if transport.has_any(['.git/objects', '.git']):
+            return LocalGitControlDirFormat()
+        if transport.has('info') and transport.has('objects'):
+            return BareLocalGitControlDirFormat()
+        raise bzr_errors.NotBranchError(path=transport.base)
+
+    @classmethod
+    def known_formats(cls):
+        from .dir import (
+            BareLocalGitControlDirFormat,
+            LocalGitControlDirFormat,
+            )
+        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
+
+
+def user_agent_for_github():
+    # GitHub requires we lie. https://github.com/dulwich/dulwich/issues/562
+    return "git/Breezy/%s" % breezy_version
+
+
+class RemoteGitProber(Prober):
+
+    def probe_http_transport(self, transport):
+        from ... import urlutils
+        base_url, _ = urlutils.split_segment_parameters(transport.external_url())
+        url = urlutils.join(base_url, "info/refs") + "?service=git-upload-pack"
+        from ...transport.http import Request
+        headers = {"Content-Type": "application/x-git-upload-pack-request"}
+        req = Request('GET', url, accepted_errors=[200, 403, 404, 405],
+                      headers=headers)
+        if req.get_host() == "github.com":
+            # GitHub requires we lie. https://github.com/dulwich/dulwich/issues/562
+            req.add_header("User-Agent", user_agent_for_github())
+        elif req.get_host() == "bazaar.launchpad.net":
+            # Don't attempt Git probes against bazaar.launchpad.net; pad.lv/1744830
+            raise bzr_errors.NotBranchError(transport.base)
+        req.follow_redirections = True
+        resp = transport._perform(req)
+        if resp.code in (404, 405):
+            raise bzr_errors.NotBranchError(transport.base)
+        headers = resp.headers
+        ct = headers.getheader("Content-Type")
+        if ct is None:
+            raise bzr_errors.NotBranchError(transport.base)
+        if ct.startswith("application/x-git"):
+            from .remote import RemoteGitControlDirFormat
+            return RemoteGitControlDirFormat()
+        else:
+            from .dir import (
+                BareLocalGitControlDirFormat,
+                )
+            ret = BareLocalGitControlDirFormat()
+            ret._refs_text = resp.read()
+            return ret
+
+    def probe_transport(self, transport):
+        try:
+            external_url = transport.external_url()
+        except bzr_errors.InProcessTransport:
+            raise bzr_errors.NotBranchError(path=transport.base)
+
+        if (external_url.startswith("http:") or
+            external_url.startswith("https:")):
+            return self.probe_http_transport(transport)
+
+        if (not external_url.startswith("git://") and
+            not external_url.startswith("git+")):
+            raise bzr_errors.NotBranchError(transport.base)
+
+        # little ugly, but works
+        from .remote import (
+            GitSmartTransport,
+            RemoteGitControlDirFormat,
+            )
+        if isinstance(transport, GitSmartTransport):
+            return RemoteGitControlDirFormat()
+        raise bzr_errors.NotBranchError(path=transport.base)
+
+    @classmethod
+    def known_formats(cls):
+        from .remote import RemoteGitControlDirFormat
+        return set([RemoteGitControlDirFormat()])
+
+
+ControlDirFormat.register_prober(LocalGitProber)
+ControlDirFormat._server_probers.append(RemoteGitProber)
+
+register_transport_proto('git://',
+        help="Access using the Git smart server protocol.")
+register_transport_proto('git+ssh://',
+        help="Access using the Git smart server protocol over SSH.")
+
+register_lazy_transport("git://", __name__ + '.remote',
+                        'TCPGitSmartTransport')
+register_lazy_transport("git+ssh://", __name__ + '.remote',
+                        'SSHGitSmartTransport')
+
+
+plugin_cmds.register_lazy("cmd_git_import", [], __name__ + ".commands")
+plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
+    __name__ + ".commands")
+plugin_cmds.register_lazy("cmd_git_refs", [], __name__ + ".commands")
+plugin_cmds.register_lazy("cmd_git_apply", [], __name__ + ".commands")
+plugin_cmds.register_lazy("cmd_git_push_pristine_tar_deltas",
+        ['git-push-pristine-tar', 'git-push-pristine'],
+    __name__ + ".commands")
+
+def extract_git_foreign_revid(rev):
+    try:
+        foreign_revid = rev.foreign_revid
+    except AttributeError:
+        from .mapping import mapping_registry
+        foreign_revid, mapping = \
+            mapping_registry.parse_revision_id(rev.revision_id)
+        return foreign_revid
+    else:
+        from .mapping import foreign_vcs_git
+        if rev.mapping.vcs == foreign_vcs_git:
+            return foreign_revid
+        else:
+            raise bzr_errors.InvalidRevisionId(rev.revision_id, None)
+
+
+def update_stanza(rev, stanza):
+    mapping = getattr(rev, "mapping", None)
+    try:
+        git_commit = extract_git_foreign_revid(rev)
+    except bzr_errors.InvalidRevisionId:
+        pass
+    else:
+        stanza.add("git-commit", git_commit)
+
+from ...hooks import install_lazy_named_hook
+install_lazy_named_hook("breezy.version_info_formats.format_rio",
+    "RioVersionInfoBuilder.hooks", "revision", update_stanza,
+    "git commits")
+
+
+transport_server_registry.register_lazy('git',
+    __name__ + '.server',
+    'serve_git',
+    'Git Smart server protocol over TCP. (default port: 9418)')
+
+transport_server_registry.register_lazy('git-receive-pack',
+    __name__ + '.server',
+    'serve_git_receive_pack',
+    help='Git Smart server receive pack command. (inetd mode only)')
+transport_server_registry.register_lazy('git-upload-pack',
+    __name__ + 'git.server',
+    'serve_git_upload_pack',
+    help='Git Smart server upload pack command. (inetd mode only)')
+
+from ...repository import (
+    format_registry as repository_format_registry,
+    network_format_registry as repository_network_format_registry,
+    )
+repository_network_format_registry.register_lazy('git',
+    __name__ + '.repository', 'GitRepositoryFormat')
+
+register_extra_lazy_repository_format = getattr(repository_format_registry,
+    "register_extra_lazy")
+register_extra_lazy_repository_format(__name__ + '.repository',
+    'GitRepositoryFormat')
+
+from ...branch import (
+    network_format_registry as branch_network_format_registry,
+    )
+branch_network_format_registry.register_lazy('git',
+    __name__ + '.branch', 'LocalGitBranchFormat')
+
+
+from ...branch import (
+    format_registry as branch_format_registry,
+    )
+branch_format_registry.register_extra_lazy(
+    __name__ + '.branch',
+    'LocalGitBranchFormat',
+    )
+branch_format_registry.register_extra_lazy(
+    __name__ + '.remote',
+    'RemoteGitBranchFormat',
+    )
+
+
+from ...workingtree import (
+    format_registry as workingtree_format_registry,
+    )
+workingtree_format_registry.register_extra_lazy(
+    __name__ + '.workingtree',
+    'GitWorkingTreeFormat',
+    )
+
+controldir_network_format_registry.register_lazy('git',
+    __name__ + ".dir", "GitControlDirFormat")
+
+
+try:
+    from ...registry import register_lazy
+except ImportError:
+    from ...diff import format_registry as diff_format_registry
+    diff_format_registry.register_lazy('git', __name__ + '.send',
+        'GitDiffTree', 'Git am-style diff format')
+
+    from ...send import (
+        format_registry as send_format_registry,
+        )
+    send_format_registry.register_lazy('git', __name__ + '.send',
+                                       'send_git', 'Git am-style diff format')
+
+    from ...directory_service import directories
+    directories.register_lazy('github:', __name__ + '.directory',
+                              'GitHubDirectory',
+                              'GitHub directory.')
+    directories.register_lazy('[e-mail]:', __name__ + '.directory',
+                              'GitHubDirectory',
+                              'GitHub directory.')
+
+    from ...help_topics import (
+        topic_registry,
+        )
+    topic_registry.register_lazy('git', __name__ + '.help', 'help_git',
+        'Using Bazaar with Git')
+
+    from ...foreign import (
+        foreign_vcs_registry,
+        )
+    foreign_vcs_registry.register_lazy("git",
+        __name__ + ".mapping", "foreign_vcs_git", "Stupid content tracker")
+else:
+    register_lazy("breezy.diff", "format_registry",
+        'git', __name__ + '.send', 'GitDiffTree',
+        'Git am-style diff format')
+    register_lazy("breezy.send", "format_registry",
+        'git', __name__ + '.send', 'send_git',
+        'Git am-style diff format')
+    register_lazy('breezy.directory_service', 'directories', 'github:',
+            __name__ + '.directory', 'GitHubDirectory',
+            'GitHub directory.')
+    register_lazy('breezy.directory_service', 'directories',
+            '[e-mail]:', __name__ + '.directory',
+            'GitHubDirectory', 'GitHub directory.')
+    register_lazy('breezy.help_topics', 'topic_registry',
+            'git', __name__ + '.help', 'help_git',
+            'Using Bazaar with Git')
+    register_lazy('breezy.foreign', 'foreign_vcs_registry', "git",
+        __name__ + ".mapping", "foreign_vcs_git", "Stupid content tracker")
+
+def update_git_cache(repository, revid):
+    """Update the git cache after a local commit."""
+    if getattr(repository, "_git", None) is not None:
+        return # No need to update cache for git repositories
+
+    if not repository.control_transport.has("git"):
+        return # No existing cache, don't bother updating
+    try:
+        lazy_check_versions()
+    except bzr_errors.DependencyNotPresent, e:
+        # dulwich is probably missing. silently ignore
+        trace.mutter("not updating git map for %r: %s",
+            repository, e)
+
+    from .object_store import BazaarObjectStore
+    store = BazaarObjectStore(repository)
+    with store.lock_write():
+        try:
+            parent_revisions = set(repository.get_parent_map([revid])[revid])
+        except KeyError:
+            # Isn't this a bit odd - how can a revision that was just committed be missing?
+            return
+        missing_revisions = store._missing_revisions(parent_revisions)
+        if not missing_revisions:
+            # Only update if the cache was up to date previously
+            store._update_sha_map_revision(revid)
+
+
+def post_commit_update_cache(local_branch, master_branch, old_revno, old_revid,
+        new_revno, new_revid):
+    if local_branch is not None:
+        update_git_cache(local_branch.repository, new_revid)
+    update_git_cache(master_branch.repository, new_revid)
+
+
+def loggerhead_git_hook(branch_app, environ):
+    branch = branch_app.branch
+    config_stack = branch.get_config_stack()
+    if config_stack.get('http_git'):
+        return None
+    from .server import git_http_hook
+    return git_http_hook(branch, environ['REQUEST_METHOD'],
+        environ['PATH_INFO'])
+
+install_lazy_named_hook("breezy.branch",
+    "Branch.hooks", "post_commit", post_commit_update_cache,
+    "git cache")
+install_lazy_named_hook("breezy.plugins.loggerhead.apps.branch",
+    "BranchWSGIApp.hooks", "controller",
+    loggerhead_git_hook, "git support")
+
+
+from ...config import (
+    option_registry,
+    Option,
+    bool_from_store,
+    )
+
+option_registry.register(
+    Option('git.http',
+           default=None, from_unicode=bool_from_store, invalid='warning',
+           help='''\
+Allow fetching of Git packs over HTTP.
+
+This enables support for fetching Git packs over HTTP in Loggerhead.
+'''))
+
+def test_suite():
+    from . import tests
+    return tests.test_suite()

=== added file 'breezy/plugins/git/annotate.py'
--- breezy/plugins/git/annotate.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/annotate.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,151 @@
+# Copyright (C) 2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Annotate."""
+
+from __future__ import absolute_import
+
+from dulwich.errors import (
+    NotTreeError,
+    )
+from dulwich.object_store import (
+    tree_lookup_path,
+    )
+
+from ...errors import UnavailableRepresentation
+from ...graph import Graph
+from ...revision import (
+    NULL_REVISION,
+    )
+
+from .filegraph import GitFileLastChangeScanner
+
+
+class GitFulltextContentFactory(object):
+    """Static data content factory.
+
+    This takes a fulltext when created and just returns that during
+    get_bytes_as('fulltext').
+
+    :ivar sha1: None, or the sha1 of the content fulltext.
+    :ivar storage_kind: The native storage kind of this factory. Always
+        'fulltext'.
+    :ivar key: The key of this content. Each key is a tuple with a single
+        string in it.
+    :ivar parents: A tuple of parent keys for self.key. If the object has
+        no parent information, None (as opposed to () for an empty list of
+        parents).
+     """
+
+    def __init__(self, store, path, revision, blob_id):
+        """Create a ContentFactory."""
+        self.store = store
+        self.key = (path, revision)
+        self.storage_kind = 'fulltext'
+        self.parents = None
+        self.blob_id = blob_id
+
+    def get_bytes_as(self, storage_kind):
+        if storage_kind == 'fulltext':
+            return self.store[self.blob_id].as_raw_string()
+        elif storage_kind == 'chunked':
+            return self.store[self.blob_id].as_raw_chunks()
+        raise UnavailableRepresentation(self.key, storage_kind,
+                'fulltext')
+
+
+class GitAbsentContentFactory(object):
+    """Absent data content factory.
+
+    :ivar sha1: None, or the sha1 of the content fulltext.
+    :ivar storage_kind: The native storage kind of this factory. Always
+        'fulltext'.
+    :ivar key: The key of this content. Each key is a tuple with a single
+        string in it.
+    :ivar parents: A tuple of parent keys for self.key. If the object has
+        no parent information, None (as opposed to () for an empty list of
+        parents).
+     """
+
+    def __init__(self, store, path, revision):
+        """Create a ContentFactory."""
+        self.store = store
+        self.key = (path, revision)
+        self.storage_kind = 'absent'
+        self.parents = None
+
+    def get_bytes_as(self, storage_kind):
+        raise ValueError
+
+
+class AnnotateProvider(object):
+
+    def __init__(self, change_scanner):
+        self.change_scanner = change_scanner
+        self.store = self.change_scanner.repository._git.object_store
+
+    def _get_parents(self, path, text_revision):
+        commit_id, mapping = self.change_scanner.repository.lookup_bzr_revision_id(
+            text_revision)
+        text_parents = []
+        for commit_parent in self.store[commit_id].parents:
+            try:
+                (path, text_parent) = self.change_scanner.find_last_change_revision(path, commit_parent)
+            except KeyError:
+                continue
+            if text_parent not in text_parents:
+                text_parents.append(text_parent)
+        return tuple([(path,
+            self.change_scanner.repository.lookup_foreign_revision_id(p)) for p
+            in text_parents])
+
+    def get_parent_map(self, keys):
+        ret = {}
+        for key in keys:
+            (path, text_revision) = key
+            if text_revision == NULL_REVISION:
+                ret[key] = ()
+                continue
+            try:
+                ret[key] = self._get_parents(path, text_revision)
+            except KeyError:
+                pass
+        return ret
+
+    def get_record_stream(self, keys, ordering, include_delta_closure):
+        if ordering == 'topological':
+            graph = Graph(self)
+            keys = graph.iter_topo_order(keys)
+        store = self.change_scanner.repository._git.object_store
+        for (path, text_revision) in keys:
+            try:
+                commit_id, mapping = self.change_scanner.repository.lookup_bzr_revision_id(
+                    text_revision)
+            except errors.NoSuchRevision:
+                yield GitAbsentContentFactory(store, path, text_revision)
+                continue
+
+            try:
+                tree_id = store[commit_id].tree
+            except KeyError:
+                yield GitAbsentContentFactory(store, path, text_revision)
+                continue
+            try:
+                (mode, blob_sha) = tree_lookup_path(store.__getitem__, tree_id, path)
+            except KeyError:
+                yield GitAbsentContentFactory(store, path, text_revision)
+            else:
+                yield GitFulltextContentFactory(store, path, text_revision, blob_sha)

=== added file 'breezy/plugins/git/branch.py'
--- breezy/plugins/git/branch.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/branch.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,1291 @@
+# Copyright (C) 2007,2012 Canonical Ltd
+# Copyright (C) 2009-2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""An adapter between a Git Branch and a Bazaar Branch"""
+
+from __future__ import absolute_import
+
+from cStringIO import StringIO
+from collections import defaultdict
+
+from dulwich.objects import (
+    NotCommitError,
+    ZERO_SHA,
+    )
+from dulwich.repo import check_ref_format
+
+from ... import (
+    branch,
+    config,
+    controldir,
+    errors,
+    lock,
+    repository as _mod_repository,
+    revision,
+    tag,
+    trace,
+    transport,
+    urlutils,
+    )
+from ...revision import (
+    NULL_REVISION,
+    )
+from ...trace import (
+    is_quiet,
+    mutter,
+    warning,
+    )
+
+from .config import (
+    GitBranchConfig,
+    GitBranchStack,
+    )
+from .errors import (
+    NoPushSupport,
+    NoSuchRef,
+    )
+from .push import (
+    remote_divergence,
+    )
+from .refs import (
+    branch_name_to_ref,
+    is_tag,
+    ref_to_branch_name,
+    ref_to_tag_name,
+    remote_refs_dict_to_tag_refs,
+    tag_name_to_ref,
+    )
+from .unpeel_map import (
+    UnpeelMap,
+    )
+from .urls import git_url_to_bzr_url
+
+from ...foreign import ForeignBranch
+
+
+class GitPullResult(branch.PullResult):
+    """Result of a pull from a Git branch."""
+
+    def _lookup_revno(self, revid):
+        if type(revid) is not str:
+            raise TypeError(revid)
+        # Try in source branch first, it'll be faster
+        with self.target_branch.lock_read():
+            return self.target_branch.revision_id_to_revno(revid)
+
+    @property
+    def old_revno(self):
+        return self._lookup_revno(self.old_revid)
+
+    @property
+    def new_revno(self):
+        return self._lookup_revno(self.new_revid)
+
+
+class GitTags(tag.BasicTags):
+    """Ref-based tag dictionary."""
+
+    def __init__(self, branch):
+        self.branch = branch
+        self.repository = branch.repository
+
+    def _merge_to_remote_git(self, target_repo, source_tag_refs, overwrite=False):
+        updates = {}
+        conflicts = []
+        def get_changed_refs(old_refs):
+            ret = dict(old_refs)
+            for ref_name, tag_name, peeled, unpeeled in source_tag_refs.iteritems():
+                if old_refs.get(ref_name) == unpeeled:
+                    pass
+                elif overwrite or not ref_name in old_refs:
+                    ret[ref_name] = unpeeled
+                    updates[tag_name] = target_repo.lookup_foreign_revision_id(peeled)
+                else:
+                    conflicts.append(
+                        (tag_name,
+                        self.repository.lookup_foreign_revision_id(peeled),
+                        target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
+            return ret
+        target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])
+        return updates, conflicts
+
+    def _merge_to_local_git(self, target_repo, source_tag_refs, overwrite=False):
+        conflicts = []
+        updates = {}
+        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
+            if target_repo._git.refs.get(ref_name) == unpeeled:
+                pass
+            elif overwrite or not ref_name in target_repo._git.refs:
+                target_repo._git.refs[ref_name] = unpeeled or peeled
+                updates[tag_name] = self.repository.lookup_foreign_revision_id(peeled)
+            else:
+                source_revid = self.repository.lookup_foreign_revision_id(peeled)
+                try:
+                    target_revid = target_repo.lookup_foreign_revision_id(
+                            target_repo._git.refs[ref_name])
+                except KeyError:
+                    trace.warning('%s does not point to a valid object',
+                                  ref_name)
+                    continue
+                conflicts.append((tag_name, source_revid, target_revid))
+        return updates, conflicts
+
+    def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
+        target_repo = to_tags.repository
+        if self.repository.has_same_location(target_repo):
+            return {}, []
+        try:
+            if getattr(target_repo, "_git", None):
+                return self._merge_to_local_git(target_repo, source_tag_refs, overwrite)
+            else:
+                return self._merge_to_remote_git(target_repo, source_tag_refs, overwrite)
+        finally:
+            to_tags.branch._tag_refs = None
+
+    def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
+        unpeeled_map = defaultdict(set)
+        conflicts = []
+        updates = {}
+        result = dict(to_tags.get_tag_dict())
+        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
+            if unpeeled is not None:
+                unpeeled_map[peeled].add(unpeeled)
+            try:
+                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
+            except NotCommitError:
+                continue
+            if result.get(tag_name) == bzr_revid:
+                pass
+            elif tag_name not in result or overwrite:
+                result[tag_name] = bzr_revid
+                updates[tag_name] = bzr_revid
+            else:
+                conflicts.append((tag_name, bzr_revid, result[n]))
+        to_tags._set_tag_dict(result)
+        if len(unpeeled_map) > 0:
+            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
+            map_file.update(unpeeled_map)
+            map_file.save_in_repository(to_tags.branch.repository)
+        return updates, conflicts
+
+    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
+                 source_tag_refs=None):
+        """See Tags.merge_to."""
+        if source_tag_refs is None:
+            source_tag_refs = self.branch.get_tag_refs()
+        if self == to_tags:
+            return {}, []
+        if isinstance(to_tags, GitTags):
+            return self._merge_to_git(to_tags, source_tag_refs,
+                                      overwrite=overwrite)
+        else:
+            if ignore_master:
+                master = None
+            else:
+                master = to_tags.branch.get_master_branch()
+            if master is not None:
+                master.lock_write()
+            try:
+                updates, conflicts = self._merge_to_non_git(to_tags, source_tag_refs,
+                                                  overwrite=overwrite)
+                if master is not None:
+                    extra_updates, extra_conflicts = self.merge_to(
+                        master.tags, overwrite=overwrite,
+                                               source_tag_refs=source_tag_refs,
+                                               ignore_master=ignore_master)
+                    updates.update(extra_updates)
+                    conflicts += extra_conflicts
+                return updates, conflicts
+            finally:
+                if master is not None:
+                    master.unlock()
+
+    def get_tag_dict(self):
+        ret = {}
+        for (ref_name, tag_name, peeled, unpeeled) in self.branch.get_tag_refs():
+            try:
+                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
+            except NotCommitError:
+                continue
+            else:
+                ret[tag_name] = bzr_revid
+        return ret
+
+
+class LocalGitTagDict(GitTags):
+    """Dictionary with tags in a local repository."""
+
+    def __init__(self, branch):
+        super(LocalGitTagDict, self).__init__(branch)
+        self.refs = self.repository.controldir._git.refs
+
+    def _set_tag_dict(self, to_dict):
+        extra = set(self.refs.allkeys())
+        for k, revid in to_dict.iteritems():
+            name = tag_name_to_ref(k)
+            if name in extra:
+                extra.remove(name)
+            self.set_tag(k, revid)
+        for name in extra:
+            if is_tag(name):
+                del self.repository._git[name]
+
+    def set_tag(self, name, revid):
+        try:
+            git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
+        except errors.NoSuchRevision:
+            raise errors.GhostTagsNotSupported(self)
+        self.refs[tag_name_to_ref(name)] = git_sha
+        self.branch._tag_refs = None
+
+    def delete_tag(self, name):
+        ref = tag_name_to_ref(name)
+        if not ref in self.refs:
+            raise errors.NoSuchTag(name)
+        del self.refs[ref]
+        self.branch._tag_refs = None
+
+
+class GitBranchFormat(branch.BranchFormat):
+
+    def network_name(self):
+        return "git"
+
+    def supports_tags(self):
+        return True
+
+    def supports_leaving_lock(self):
+        return False
+
+    def supports_tags_referencing_ghosts(self):
+        return False
+
+    def tags_are_versioned(self):
+        return False
+
+    def get_foreign_tests_branch_factory(self):
+        from .tests.test_branch import ForeignTestsBranchFactory
+        return ForeignTestsBranchFactory()
+
+    def make_tags(self, branch):
+        try:
+            return branch.tags
+        except AttributeError:
+            pass
+        if getattr(branch.repository, "_git", None) is None:
+            from .remote import RemoteGitTagDict
+            return RemoteGitTagDict(branch)
+        else:
+            return LocalGitTagDict(branch)
+
+    def initialize(self, a_controldir, name=None, repository=None,
+                   append_revisions_only=None):
+        raise NotImplementedError(self.initialize)
+
+    def get_reference(self, controldir, name=None):
+        return controldir.get_branch_reference(name)
+
+    def set_reference(self, controldir, name, target):
+        return controldir.set_branch_reference(target, name)
+
+
+class LocalGitBranchFormat(GitBranchFormat):
+
+    def get_format_description(self):
+        return 'Local Git Branch'
+
+    @property
+    def _matchingcontroldir(self):
+        from .dir import LocalGitControlDirFormat
+        return LocalGitControlDirFormat()
+
+    def initialize(self, a_controldir, name=None, repository=None,
+                   append_revisions_only=None):
+        from .dir import LocalGitDir
+        if not isinstance(a_controldir, LocalGitDir):
+            raise errors.IncompatibleFormat(self, a_controldir._format)
+        return a_controldir.create_branch(repository=repository, name=name,
+            append_revisions_only=append_revisions_only)
+
+
+class GitBranch(ForeignBranch):
+    """An adapter to git repositories for bzr Branch objects."""
+
+    @property
+    def control_transport(self):
+        return self._control_transport
+
+    @property
+    def user_transport(self):
+        return self._user_transport
+
+    def __init__(self, controldir, repository, ref, format):
+        self.repository = repository
+        self._format = format
+        self.controldir = controldir
+        self._lock_mode = None
+        self._lock_count = 0
+        super(GitBranch, self).__init__(repository.get_mapping())
+        self.ref = ref
+        self._head = None
+        self._user_transport = controldir.user_transport.clone('.')
+        self._control_transport = controldir.control_transport.clone('.')
+        self._tag_refs = None
+        params = {}
+        try:
+            self.name = ref_to_branch_name(ref)
+        except ValueError:
+            self.name = None
+            if self.ref is not None:
+                params = {"ref": urlutils.escape(self.ref)}
+        else:
+            if self.name != "":
+                params = {"branch": urlutils.escape(self.name)}
+        for k, v in params.items():
+            self._user_transport.set_segment_parameter(k, v)
+            self._control_transport.set_segment_parameter(k, v)
+        self.base = controldir.user_transport.base
+
+    def _get_checkout_format(self, lightweight=False):
+        """Return the most suitable metadir for a checkout of this branch.
+        Weaves are used if this branch's repository uses weaves.
+        """
+        if lightweight:
+            return controldir.format_registry.make_controldir("git")
+        else:
+            return controldir.format_registry.make_controldir("default")
+
+    def get_child_submit_format(self):
+        """Return the preferred format of submissions to this branch."""
+        ret = self.get_config_stack().get("child_submit_format")
+        if ret is not None:
+            return ret
+        return "git"
+
+    def get_config(self):
+        return GitBranchConfig(self)
+
+    def get_config_stack(self):
+        return GitBranchStack(self)
+
+    def _get_nick(self, local=False, possible_master_transports=None):
+        """Find the nick name for this branch.
+
+        :return: Branch nick
+        """
+        cs = self.repository._git.get_config_stack()
+        try:
+            return cs.get((b"branch", self.name.encode('utf-8')), b"nick").decode("utf-8")
+        except KeyError:
+            pass
+        return self.name or u"HEAD"
+
+    def _set_nick(self, nick):
+        cf = self.repository._git.get_config()
+        cf.set((b"branch", self.name.encode('utf-8')), b"nick", nick.encode("utf-8"))
+        f = StringIO()
+        cf.write_to_file(f)
+        self.repository._git._put_named_file('config', f.getvalue())
+
+    nick = property(_get_nick, _set_nick)
+
+    def __repr__(self):
+        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
+            self.name)
+
+    def generate_revision_history(self, revid, last_rev=None, other_branch=None):
+        if last_rev is not None:
+            graph = self.repository.get_graph()
+            if not graph.is_ancestor(last_rev, revid):
+                # our previous tip is not merged into stop_revision
+                raise errors.DivergedBranches(self, other_branch)
+
+        self.set_last_revision(revid)
+
+    def lock_write(self, token=None):
+        if token is not None:
+            raise errors.TokenLockingNotSupported(self)
+        if self._lock_mode:
+            if self._lock_mode == 'r':
+                raise errors.ReadOnlyError(self)
+            self._lock_count += 1
+        else:
+            self._lock_ref()
+            self._lock_mode = 'w'
+            self._lock_count = 1
+        self.repository.lock_write()
+        return lock.LogicalLockResult(self.unlock)
+
+    def leave_lock_in_place(self):
+        raise NotImplementedError(self.leave_lock_in_place)
+
+    def dont_leave_lock_in_place(self):
+        raise NotImplementedError(self.dont_leave_lock_in_place)
+
+    def get_stacked_on_url(self):
+        # Git doesn't do stacking (yet...)
+        raise branch.UnstackableBranchFormat(self._format, self.base)
+
+    def _get_parent_location(self):
+        """See Branch.get_parent()."""
+        # FIXME: Set "origin" url from .git/config ?
+        cs = self.repository._git.get_config_stack()
+        try:
+            location = cs.get((b"remote", b'origin'), b"url")
+        except KeyError:
+            return None
+
+        params = {}
+        try:
+            ref = cs.get((b"remote", b"origin"), b"merge")
+        except KeyError:
+            pass
+        else:
+            if ref != 'HEAD':
+                try:
+                    params['branch'] = ref_to_branch_name(ref).encode('utf-8')
+                except ValueError:
+                    params['ref'] = ref.encode('utf-8')
+
+        url = git_url_to_bzr_url(location)
+        return urlutils.join_segment_parameters(url, params)
+
+    def set_parent(self, location):
+        # FIXME: Set "origin" url in .git/config ?
+        cs = self.repository._git.get_config()
+        this_url = urlutils.split_segment_parameters(self.user_url)[0]
+        target_url, target_params = urlutils.split_segment_parameters(location)
+        location = urlutils.relative_url(this_url, target_url)
+        cs.set((b"remote", b"origin"), b"url", location)
+        if 'branch' in target_params:
+            cs.set((b"remote", b"origin"), b"merge",
+                   branch_name_to_ref(target_params['branch']))
+        elif 'ref' in target_params:
+            cs.set((b"remote", b"origin"), b"merge",
+                   target_params['ref'])
+        else:
+            # TODO(jelmer): Maybe unset rather than setting to HEAD?
+            cs.set((b"remote", b"origin"), b"merge", 'HEAD')
+        f = StringIO()
+        cs.write_to_file(f)
+        self.repository._git._put_named_file('config', f.getvalue())
+
+    def break_lock(self):
+        raise NotImplementedError(self.break_lock)
+
+    def lock_read(self):
+        if self._lock_mode:
+            if self._lock_mode not in ('r', 'w'):
+                raise ValueError(self._lock_mode)
+            self._lock_count += 1
+        else:
+            self._lock_mode = 'r'
+            self._lock_count = 1
+        self.repository.lock_read()
+        return lock.LogicalLockResult(self.unlock)
+
+    def peek_lock_mode(self):
+        return self._lock_mode
+
+    def is_locked(self):
+        return (self._lock_mode is not None)
+
+    def _lock_ref(self):
+        pass
+
+    def _unlock_ref(self):
+        pass
+
+    def unlock(self):
+        """See Branch.unlock()."""
+        if self._lock_count == 0:
+            raise errors.LockNotHeld(self)
+        try:
+            self._lock_count -= 1
+            if self._lock_count == 0:
+                if self._lock_mode == 'w':
+                    self._unlock_ref()
+                self._lock_mode = None
+                self._clear_cached_state()
+        finally:
+            self.repository.unlock()
+
+    def get_physical_lock_status(self):
+        return False
+
+    def last_revision(self):
+        with self.lock_read():
+            # perhaps should escape this ?
+            if self.head is None:
+                return revision.NULL_REVISION
+            return self.lookup_foreign_revision_id(self.head)
+
+    def _basic_push(self, target, overwrite=False, stop_revision=None):
+        return branch.InterBranch.get(self, target)._basic_push(
+            overwrite, stop_revision)
+
+    def lookup_foreign_revision_id(self, foreign_revid):
+        try:
+            return self.repository.lookup_foreign_revision_id(foreign_revid,
+                self.mapping)
+        except KeyError:
+            # Let's try..
+            return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
+
+    def lookup_bzr_revision_id(self, revid):
+        return self.repository.lookup_bzr_revision_id(
+            revid, mapping=self.mapping)
+
+    def get_unshelver(self, tree):
+        raise errors.StoringUncommittedNotSupported(self)
+
+    def _clear_cached_state(self):
+        super(GitBranch, self)._clear_cached_state()
+        self._tag_refs = None
+
+    def _iter_tag_refs(self, refs):
+        """Iterate over the tag refs.
+
+        :param refs: Refs dictionary (name -> git sha1)
+        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
+        """
+        raise NotImplementedError(self._iter_tag_refs)
+
+    def get_tag_refs(self):
+        with self.lock_read():
+            if self._tag_refs is None:
+                self._tag_refs = list(self._iter_tag_refs())
+            return self._tag_refs
+
+
+class LocalGitBranch(GitBranch):
+    """A local Git branch."""
+
+    def __init__(self, controldir, repository, ref):
+        super(LocalGitBranch, self).__init__(controldir, repository, ref,
+                LocalGitBranchFormat())
+
+    def create_checkout(self, to_location, revision_id=None, lightweight=False,
+        accelerator_tree=None, hardlink=False):
+        t = transport.get_transport(to_location)
+        t.ensure_base()
+        format = self._get_checkout_format(lightweight=lightweight)
+        checkout = format.initialize_on_transport(t)
+        if lightweight:
+            from_branch = checkout.set_branch_reference(target_branch=self)
+        else:
+            policy = checkout.determine_repository_policy()
+            repo = policy.acquire_repository()[0]
+
+            checkout_branch = checkout.create_branch()
+            checkout_branch.bind(self)
+            checkout_branch.pull(self, stop_revision=revision_id)
+            from_branch = None
+        return checkout.create_workingtree(revision_id,
+                from_branch=from_branch, hardlink=hardlink)
+
+    def _lock_ref(self):
+        self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
+
+    def _unlock_ref(self):
+        self._ref_lock.unlock()
+
+    def break_lock(self):
+        self.repository._git.refs.unlock_ref(self.ref)
+
+    def fetch(self, from_branch, last_revision=None, limit=None):
+        return branch.InterBranch.get(from_branch, self).fetch(
+            stop_revision=last_revision, limit=limit)
+
+    def _gen_revision_history(self):
+        if self.head is None:
+            return []
+        graph = self.repository.get_graph()
+        ret = list(graph.iter_lefthand_ancestry(self.last_revision(),
+            (revision.NULL_REVISION, )))
+        ret.reverse()
+        return ret
+
+    def _get_head(self):
+        try:
+            return self.repository._git.refs[self.ref]
+        except KeyError:
+            return None
+
+    def _read_last_revision_info(self):
+        last_revid = self.last_revision()
+        graph = self.repository.get_graph()
+        revno = graph.find_distance_to_null(last_revid,
+            [(revision.NULL_REVISION, 0)])
+        return revno, last_revid
+
+    def set_last_revision_info(self, revno, revision_id):
+        self.set_last_revision(revision_id)
+        self._last_revision_info_cache = revno, revision_id
+
+    def set_last_revision(self, revid):
+        if not revid or not isinstance(revid, basestring):
+            raise errors.InvalidRevisionId(revision_id=revid, branch=self)
+        if revid == NULL_REVISION:
+            newhead = None
+        else:
+            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
+            if self.mapping is None:
+                raise AssertionError
+        self._set_head(newhead)
+
+    def _set_head(self, value):
+        if value == ZERO_SHA:
+            raise ValueError(value)
+        self._head = value
+        if value is None:
+            del self.repository._git.refs[self.ref]
+        else:
+            self.repository._git.refs[self.ref] = self._head
+        self._clear_cached_state()
+
+    head = property(_get_head, _set_head)
+
+    def get_push_location(self):
+        """See Branch.get_push_location."""
+        push_loc = self.get_config_stack().get('push_location')
+        return push_loc
+
+    def set_push_location(self, location):
+        """See Branch.set_push_location."""
+        self.get_config().set_user_option('push_location', location,
+                                          store=config.STORE_LOCATION)
+
+    def supports_tags(self):
+        return True
+
+    def store_uncommitted(self, creator):
+        raise errors.StoringUncommittedNotSupported(self)
+
+    def _iter_tag_refs(self):
+        """Iterate over the tag refs.
+
+        :param refs: Refs dictionary (name -> git sha1)
+        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
+        """
+        refs = self.repository._git.refs
+        for ref_name, unpeeled in refs.as_dict().iteritems():
+            try:
+                tag_name = ref_to_tag_name(ref_name)
+            except (ValueError, UnicodeDecodeError):
+                continue
+            peeled = refs.get_peeled(ref_name)
+            if peeled is None:
+                peeled = unpeeled
+            if type(tag_name) is not unicode:
+                raise TypeError(tag_name)
+            yield (ref_name, tag_name, peeled, unpeeled)
+
+    def create_memorytree(self):
+        from .memorytree import GitMemoryTree
+        return GitMemoryTree(self, self.repository._git.object_store, self.head)
+
+    def reference_parent(self, path, file_id=None, possible_transports=None):
+        """Return the parent branch for a tree-reference file_id
+
+        :param path: The path of the file_id in the tree
+        :param file_id: Optional file_id of the tree reference
+        :return: A branch associated with the file_id
+        """
+        # FIXME should provide multiple branches, based on config
+        url = urlutils.join(self.user_url, path)
+        return branch.Branch.open(
+                url,
+                possible_transports=possible_transports)
+
+
+
+def _quick_lookup_revno(local_branch, remote_branch, revid):
+    if type(revid) is not str:
+        raise TypeError(revid)
+    # Try in source branch first, it'll be faster
+    with local_branch.lock_read():
+        try:
+            return local_branch.revision_id_to_revno(revid)
+        except errors.NoSuchRevision:
+            graph = local_branch.repository.get_graph()
+            try:
+                return graph.find_distance_to_null(revid,
+                    [(revision.NULL_REVISION, 0)])
+            except errors.GhostRevisionsHaveNoRevno:
+                # FIXME: Check using graph.find_distance_to_null() ?
+                with remote_branch.lock_read():
+                    return remote_branch.revision_id_to_revno(revid)
+
+
+class GitBranchPullResult(branch.PullResult):
+
+    def __init__(self):
+        super(GitBranchPullResult, self).__init__()
+        self.new_git_head = None
+        self._old_revno = None
+        self._new_revno = None
+
+    def report(self, to_file):
+        if not is_quiet():
+            if self.old_revid == self.new_revid:
+                to_file.write('No revisions to pull.\n')
+            elif self.new_git_head is not None:
+                to_file.write('Now on revision %d (git sha: %s).\n' %
+                        (self.new_revno, self.new_git_head))
+            else:
+                to_file.write('Now on revision %d.\n' % (self.new_revno,))
+        self._show_tag_conficts(to_file)
+
+    def _lookup_revno(self, revid):
+        return _quick_lookup_revno(self.target_branch, self.source_branch,
+            revid)
+
+    def _get_old_revno(self):
+        if self._old_revno is not None:
+            return self._old_revno
+        return self._lookup_revno(self.old_revid)
+
+    def _set_old_revno(self, revno):
+        self._old_revno = revno
+
+    old_revno = property(_get_old_revno, _set_old_revno)
+
+    def _get_new_revno(self):
+        if self._new_revno is not None:
+            return self._new_revno
+        return self._lookup_revno(self.new_revid)
+
+    def _set_new_revno(self, revno):
+        self._new_revno = revno
+
+    new_revno = property(_get_new_revno, _set_new_revno)
+
+
+class GitBranchPushResult(branch.BranchPushResult):
+
+    def _lookup_revno(self, revid):
+        return _quick_lookup_revno(self.source_branch, self.target_branch,
+            revid)
+
+    @property
+    def old_revno(self):
+        return self._lookup_revno(self.old_revid)
+
+    @property
+    def new_revno(self):
+        new_original_revno = getattr(self, "new_original_revno", None)
+        if new_original_revno:
+            return new_original_revno
+        if getattr(self, "new_original_revid", None) is not None:
+            return self._lookup_revno(self.new_original_revid)
+        return self._lookup_revno(self.new_revid)
+
+
+class InterFromGitBranch(branch.GenericInterBranch):
+    """InterBranch implementation that pulls from Git into bzr."""
+
+    @staticmethod
+    def _get_branch_formats_to_test():
+        try:
+            default_format = branch.format_registry.get_default()
+        except AttributeError:
+            default_format = branch.BranchFormat._default_format
+        from .remote import RemoteGitBranchFormat
+        return [
+            (RemoteGitBranchFormat(), default_format),
+            (LocalGitBranchFormat(), default_format)]
+
+    @classmethod
+    def _get_interrepo(self, source, target):
+        return _mod_repository.InterRepository.get(source.repository, target.repository)
+
+    @classmethod
+    def is_compatible(cls, source, target):
+        if not isinstance(source, GitBranch):
+            return False
+        if isinstance(target, GitBranch):
+            # InterLocalGitRemoteGitBranch or InterToGitBranch should be used
+            return False
+        if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
+            # fetch_objects is necessary for this to work
+            return False
+        return True
+
+    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
+        self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
+
+    def fetch_objects(self, stop_revision, fetch_tags, limit=None):
+        interrepo = self._get_interrepo(self.source, self.target)
+        if fetch_tags is None:
+            c = self.source.get_config_stack()
+            fetch_tags = c.get('branch.fetch_tags')
+        def determine_wants(heads):
+            if stop_revision is None:
+                try:
+                    head = heads[self.source.ref]
+                except KeyError:
+                    self._last_revid = revision.NULL_REVISION
+                else:
+                    self._last_revid = self.source.lookup_foreign_revision_id(head)
+            else:
+                self._last_revid = stop_revision
+            real = interrepo.get_determine_wants_revids(
+                [self._last_revid], include_tags=fetch_tags)
+            return real(heads)
+        pack_hint, head, refs = interrepo.fetch_objects(
+            determine_wants, self.source.mapping, limit=limit)
+        if (pack_hint is not None and
+            self.target.repository._format.pack_compresses):
+            self.target.repository.pack(hint=pack_hint)
+        return head, refs
+
+    def _update_revisions(self, stop_revision=None, overwrite=False):
+        head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
+        if overwrite:
+            prev_last_revid = None
+        else:
+            prev_last_revid = self.target.last_revision()
+        self.target.generate_revision_history(self._last_revid,
+            last_rev=prev_last_revid, other_branch=self.source)
+        return head, refs
+
+    def _basic_pull(self, stop_revision, overwrite, run_hooks,
+              _override_hook_target, _hook_master):
+        if overwrite is True:
+            overwrite = set(["history", "tags"])
+        else:
+            overwrite = set()
+        result = GitBranchPullResult()
+        result.source_branch = self.source
+        if _override_hook_target is None:
+            result.target_branch = self.target
+        else:
+            result.target_branch = _override_hook_target
+        with self.target.lock_write(), self.source.lock_read():
+            # We assume that during 'pull' the target repository is closer than
+            # the source one.
+            (result.old_revno, result.old_revid) = \
+                self.target.last_revision_info()
+            result.new_git_head, remote_refs = self._update_revisions(
+                stop_revision, overwrite=("history" in overwrite))
+            tags_ret  = self.source.tags.merge_to(
+                    self.target.tags, ("tags" in overwrite), ignore_master=True)
+            if isinstance(tags_ret, tuple):
+                result.tag_updates, result.tag_conflicts = tags_ret
+            else:
+                result.tag_conflicts = tags_ret
+            (result.new_revno, result.new_revid) = \
+                self.target.last_revision_info()
+            if _hook_master:
+                result.master_branch = _hook_master
+                result.local_branch = result.target_branch
+            else:
+                result.master_branch = result.target_branch
+                result.local_branch = None
+            if run_hooks:
+                for hook in branch.Branch.hooks['post_pull']:
+                    hook(result)
+            return result
+
+    def pull(self, overwrite=False, stop_revision=None,
+             possible_transports=None, _hook_master=None, run_hooks=True,
+             _override_hook_target=None, local=False):
+        """See Branch.pull.
+
+        :param _hook_master: Private parameter - set the branch to
+            be supplied as the master to pull hooks.
+        :param run_hooks: Private parameter - if false, this branch
+            is being called because it's the master of the primary branch,
+            so it should not run its hooks.
+        :param _override_hook_target: Private parameter - set the branch to be
+            supplied as the target_branch to pull hooks.
+        """
+        # This type of branch can't be bound.
+        bound_location = self.target.get_bound_location()
+        if local and not bound_location:
+            raise errors.LocalRequiresBoundBranch()
+        master_branch = None
+        source_is_master = False
+        self.source.lock_read()
+        if bound_location:
+            # bound_location comes from a config file, some care has to be
+            # taken to relate it to source.user_url
+            normalized = urlutils.normalize_url(bound_location)
+            try:
+                relpath = self.source.user_transport.relpath(normalized)
+                source_is_master = (relpath == '')
+            except (errors.PathNotChild, urlutils.InvalidURL):
+                source_is_master = False
+        if not local and bound_location and not source_is_master:
+            # not pulling from master, so we need to update master.
+            master_branch = self.target.get_master_branch(possible_transports)
+            master_branch.lock_write()
+        try:
+            try:
+                if master_branch:
+                    # pull from source into master.
+                    master_branch.pull(self.source, overwrite, stop_revision,
+                        run_hooks=False)
+                result = self._basic_pull(stop_revision, overwrite, run_hooks,
+                    _override_hook_target, _hook_master=master_branch)
+            finally:
+                self.source.unlock()
+        finally:
+            if master_branch:
+                master_branch.unlock()
+        return result
+
+    def _basic_push(self, overwrite, stop_revision):
+        if overwrite is True:
+            overwrite = set(["history", "tags"])
+        else:
+            overwrite = set()
+        result = branch.BranchPushResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        result.old_revno, result.old_revid = self.target.last_revision_info()
+        result.new_git_head, remote_refs = self._update_revisions(
+            stop_revision, overwrite=("history" in overwrite))
+        tags_ret = self.source.tags.merge_to(self.target.tags,
+            "tags" in overwrite, ignore_master=True)
+        (result.tag_updates, result.tag_conflicts) = tags_ret
+        result.new_revno, result.new_revid = self.target.last_revision_info()
+        return result
+
+
+class InterGitBranch(branch.GenericInterBranch):
+    """InterBranch implementation that pulls between Git branches."""
+
+    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
+        raise NotImplementedError(self.fetch)
+
+
+class InterLocalGitRemoteGitBranch(InterGitBranch):
+    """InterBranch that copies from a local to a remote git branch."""
+
+    @staticmethod
+    def _get_branch_formats_to_test():
+        from .remote import RemoteGitBranchFormat
+        return [
+            (LocalGitBranchFormat(), RemoteGitBranchFormat())]
+
+    @classmethod
+    def is_compatible(self, source, target):
+        from .remote import RemoteGitBranch
+        return (isinstance(source, LocalGitBranch) and
+                isinstance(target, RemoteGitBranch))
+
+    def _basic_push(self, overwrite, stop_revision):
+        result = GitBranchPushResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        if stop_revision is None:
+            stop_revision = self.source.last_revision()
+        def get_changed_refs(old_refs):
+            old_ref = old_refs.get(self.target.ref, None)
+            if old_ref is None:
+                result.old_revid = revision.NULL_REVISION
+            else:
+                result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
+            new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[0]
+            if not overwrite:
+                if remote_divergence(old_ref, new_ref, self.source.repository._git.object_store):
+                    raise errors.DivergedBranches(self.source, self.target)
+            refs = { self.target.ref: new_ref }
+            result.new_revid = stop_revision
+            for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
+                refs[tag_name_to_ref(name)] = sha
+            return refs
+        self.target.repository.send_pack(get_changed_refs,
+            self.source.repository._git.object_store.generate_pack_data)
+        return result
+
+
+class InterGitLocalGitBranch(InterGitBranch):
+    """InterBranch that copies from a remote to a local git branch."""
+
+    @staticmethod
+    def _get_branch_formats_to_test():
+        from .remote import RemoteGitBranchFormat
+        return [
+            (RemoteGitBranchFormat(), LocalGitBranchFormat()),
+            (LocalGitBranchFormat(), LocalGitBranchFormat())]
+
+    @classmethod
+    def is_compatible(self, source, target):
+        return (isinstance(source, GitBranch) and
+                isinstance(target, LocalGitBranch))
+
+    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
+        interrepo = _mod_repository.InterRepository.get(self.source.repository,
+            self.target.repository)
+        if stop_revision is None:
+            stop_revision = self.source.last_revision()
+        determine_wants = interrepo.get_determine_wants_revids(
+            [stop_revision], include_tags=fetch_tags)
+        interrepo.fetch_objects(determine_wants, limit=limit)
+
+    def _basic_push(self, overwrite=False, stop_revision=None):
+        if overwrite is True:
+            overwrite = set(["history", "tags"])
+        else:
+            overwrite = set()
+        result = GitBranchPushResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        result.old_revid = self.target.last_revision()
+        refs, stop_revision = self.update_refs(stop_revision)
+        self.target.generate_revision_history(stop_revision,
+                (result.old_revid if ("history" not in overwrite) else None),
+                other_branch=self.source)
+        tags_ret = self.source.tags.merge_to(self.target.tags,
+            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
+            overwrite=("tags" in overwrite))
+        if isinstance(tags_ret, tuple):
+            (result.tag_updates, result.tag_conflicts) = tags_ret
+        else:
+            result.tag_conflicts = tags_ret
+        result.new_revid = self.target.last_revision()
+        return result
+
+    def update_refs(self, stop_revision=None):
+        interrepo = _mod_repository.InterRepository.get(
+                self.source.repository, self.target.repository)
+        c = self.source.get_config_stack()
+        fetch_tags = c.get('branch.fetch_tags')
+
+        if stop_revision is None:
+            refs = interrepo.fetch(branches=["HEAD"], include_tags=fetch_tags)
+            try:
+                head = refs["HEAD"]
+            except KeyError:
+                stop_revision = revision.NULL_REVISION
+            else:
+                stop_revision = self.target.lookup_foreign_revision_id(head)
+        else:
+            refs = interrepo.fetch(revision_id=stop_revision, include_tags=fetch_tags)
+        return refs, stop_revision
+
+    def pull(self, stop_revision=None, overwrite=False,
+             possible_transports=None, run_hooks=True, local=False):
+        # This type of branch can't be bound.
+        if local:
+            raise errors.LocalRequiresBoundBranch()
+        if overwrite is True:
+            overwrite = set(["history", "tags"])
+        else:
+            overwrite = set()
+
+        result = GitPullResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        with self.target.lock_write(), self.source.lock_read():
+            result.old_revid = self.target.last_revision()
+            refs, stop_revision = self.update_refs(stop_revision)
+            self.target.generate_revision_history(stop_revision,
+                    (result.old_revid if ("history" not in overwrite) else None),
+                    other_branch=self.source)
+            tags_ret = self.source.tags.merge_to(self.target.tags,
+                overwrite=("tags" in overwrite),
+                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
+            if isinstance(tags_ret, tuple):
+                (result.tag_updates, result.tag_conflicts) = tags_ret
+            else:
+                result.tag_conflicts = tags_ret
+            result.new_revid = self.target.last_revision()
+            result.local_branch = None
+            result.master_branch = result.target_branch
+            if run_hooks:
+                for hook in branch.Branch.hooks['post_pull']:
+                    hook(result)
+        return result
+
+
+class InterToGitBranch(branch.GenericInterBranch):
+    """InterBranch implementation that pulls from a non-bzr into a Git branch."""
+
+    def __init__(self, source, target):
+        super(InterToGitBranch, self).__init__(source, target)
+        self.interrepo = _mod_repository.InterRepository.get(source.repository,
+                                           target.repository)
+
+    @staticmethod
+    def _get_branch_formats_to_test():
+        try:
+            default_format = branch.format_registry.get_default()
+        except AttributeError:
+            default_format = branch.BranchFormat._default_format
+        from .remote import RemoteGitBranchFormat
+        return [
+            (default_format, LocalGitBranchFormat()),
+            (default_format, RemoteGitBranchFormat())]
+
+    @classmethod
+    def is_compatible(self, source, target):
+        return (not isinstance(source, GitBranch) and
+                isinstance(target, GitBranch))
+
+    def _get_new_refs(self, stop_revision=None, fetch_tags=None):
+        if not self.source.is_locked():
+            raise errors.ObjectNotLocked(self.source)
+        if stop_revision is None:
+            (stop_revno, stop_revision) = self.source.last_revision_info()
+        else:
+            stop_revno = self.source.revision_id_to_revno(stop_revision)
+        if type(stop_revision) is not str:
+            raise TypeError(stop_revision)
+        main_ref = self.target.ref
+        refs = { main_ref: (None, stop_revision) }
+        if fetch_tags is None:
+            c = self.source.get_config_stack()
+            fetch_tags = c.get('branch.fetch_tags')
+        for name, revid in self.source.tags.get_tag_dict().iteritems():
+            if self.source.repository.has_revision(revid):
+                ref = tag_name_to_ref(name)
+                if not check_ref_format(ref):
+                    warning("skipping tag with invalid characters %s (%s)",
+                        name, ref)
+                    continue
+                if fetch_tags:
+                    # FIXME: Skip tags that are not in the ancestry
+                    refs[ref] = (None, revid)
+        return refs, main_ref, (stop_revno, stop_revision)
+
+    def _update_refs(self, result, old_refs, new_refs, overwrite):
+        mutter("updating refs. old refs: %r, new refs: %r",
+               old_refs, new_refs)
+        result.tag_updates = {}
+        result.tag_conflicts = []
+        ret = dict(old_refs)
+        def ref_equals(refs, ref, git_sha, revid):
+            try:
+                value = refs[ref]
+            except KeyError:
+                return False
+            if (value[0] is not None and
+                git_sha is not None and
+                value[0] == git_sha):
+                return True
+            if (value[1] is not None and
+                revid is not None and
+                value[1] == revid):
+                return True
+            # FIXME: If one side only has the git sha available and the other only
+            # has the bzr revid, then this will cause us to show a tag as updated
+            # that hasn't actually been updated.
+            return False
+        # FIXME: Check for diverged branches
+        for ref, (git_sha, revid) in new_refs.iteritems():
+            if ref_equals(ret, ref, git_sha, revid):
+                # Already up to date
+                if git_sha is None:
+                    git_sha = old_refs[ref][0]
+                if revid is None:
+                    revid = old_refs[ref][1]
+                ret[ref] = new_refs[ref] = (git_sha, revid)
+            elif ref not in ret or overwrite:
+                try:
+                    tag_name = ref_to_tag_name(ref)
+                except ValueError:
+                    pass
+                else:
+                    result.tag_updates[tag_name] = revid
+                ret[ref] = (git_sha, revid)
+            else:
+                # FIXME: Check diverged
+                diverged = False
+                if diverged:
+                    try:
+                        name = ref_to_tag_name(ref)
+                    except ValueError:
+                        pass
+                    else:
+                        result.tag_conflicts.append((name, revid, ret[name][1]))
+                else:
+                    ret[ref] = (git_sha, revid)
+        return ret
+
+    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False, limit=None):
+        if stop_revision is None:
+            stop_revision = self.source.last_revision()
+        ret = []
+        if fetch_tags:
+            for k, v in self.source.tags.get_tag_dict().iteritems():
+                ret.append((None, v))
+        ret.append((None, stop_revision))
+        try:
+            self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
+        except NoPushSupport:
+            raise errors.NoRoundtrippingSupport(self.source, self.target)
+
+    def pull(self, overwrite=False, stop_revision=None, local=False,
+             possible_transports=None, run_hooks=True):
+        result = GitBranchPullResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        with self.source.lock_read(), self.target.lock_write():
+            new_refs, main_ref, stop_revinfo = self._get_new_refs(
+                stop_revision)
+            def update_refs(old_refs):
+                return self._update_refs(result, old_refs, new_refs, overwrite)
+            try:
+                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
+                    update_refs, lossy=False)
+            except NoPushSupport:
+                raise errors.NoRoundtrippingSupport(self.source, self.target)
+            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
+            if result.old_revid is None:
+                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
+            result.new_revid = new_refs[main_ref][1]
+            result.local_branch = None
+            result.master_branch = self.target
+            if run_hooks:
+                for hook in branch.Branch.hooks['post_pull']:
+                    hook(result)
+        return result
+
+    def push(self, overwrite=False, stop_revision=None, lossy=False,
+             _override_hook_source_branch=None):
+        result = GitBranchPushResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        result.local_branch = None
+        result.master_branch = result.target_branch
+        with self.source.lock_read(), self.target.lock_write():
+            new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
+            def update_refs(old_refs):
+                return self._update_refs(result, old_refs, new_refs, overwrite)
+            try:
+                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
+                    update_refs, lossy=lossy, overwrite=overwrite)
+            except NoPushSupport:
+                raise errors.NoRoundtrippingSupport(self.source, self.target)
+            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
+            if result.old_revid is None:
+                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
+            result.new_revid = new_refs[main_ref][1]
+            (result.new_original_revno, result.new_original_revid) = stop_revinfo
+            for hook in branch.Branch.hooks['post_push']:
+                hook(result)
+        return result
+
+
+branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
+branch.InterBranch.register_optimiser(InterFromGitBranch)
+branch.InterBranch.register_optimiser(InterToGitBranch)
+branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)

=== added file 'breezy/plugins/git/bzr-receive-pack'
--- breezy/plugins/git/bzr-receive-pack	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/bzr-receive-pack	2018-05-10 00:44:29 +0000
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+import breezy
+from breezy.plugin import load_plugins
+load_plugins()
+from breezy.plugins.git.server import BzrBackend
+from dulwich.server import ReceivePackHandler, serve_command
+import sys, os
+
+if len(sys.argv) < 2:
+    print >>sys.stderr, "usage: %s <git-dir>" % os.path.basename(sys.argv[0])
+    sys.exit(1)
+
+backend = BzrBackend(breezy.transport.get_transport("/"))
+sys.exit(serve_command(ReceivePackHandler, backend=backend))

=== added file 'breezy/plugins/git/bzr-upload-pack'
--- breezy/plugins/git/bzr-upload-pack	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/bzr-upload-pack	2018-05-10 00:44:29 +0000
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+import breezy
+from breezy.plugin import load_plugins
+load_plugins ()
+from breezy.plugins.git.server import BzrBackend
+from dulwich.server import UploadPackHandler, serve_command
+import sys, os
+
+if len(sys.argv) < 2:
+    print "usage: %s <git-dir>" % os.path.basename(sys.argv[0])
+    sys.exit(1)
+
+backend = BzrBackend(breezy.transport.get_transport("/"))
+sys.exit(serve_command(UploadPackHandler, backend=backend))

=== added file 'breezy/plugins/git/cache.py'
--- breezy/plugins/git/cache.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/cache.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,1008 @@
+# Copyright (C) 2009-2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Map from Git sha's to Bazaar objects."""
+
+from __future__ import absolute_import
+
+from dulwich.objects import (
+    sha_to_hex,
+    hex_to_sha,
+    )
+import os
+import threading
+
+from dulwich.objects import (
+    ShaFile,
+    )
+
+from ... import (
+    errors as bzr_errors,
+    osutils,
+    registry,
+    trace,
+    )
+from ...bzr import (
+    btree_index as _mod_btree_index,
+    index as _mod_index,
+    versionedfile,
+    )
+from ...transport import (
+    get_transport,
+    )
+
+
+def get_cache_dir():
+    try:
+        from xdg.BaseDirectory import xdg_cache_home
+    except ImportError:
+        from ...config import config_dir
+        ret = os.path.join(config_dir(), "git")
+    else:
+        ret = os.path.join(xdg_cache_home, "breezy", "git")
+    if not os.path.isdir(ret):
+        os.makedirs(ret)
+    return ret
+
+
+def get_remote_cache_transport(repository):
+    """Retrieve the transport to use when accessing (unwritable) remote 
+    repositories.
+    """
+    uuid = getattr(repository, "uuid", None)
+    if uuid is None:
+        path = get_cache_dir()
+    else:
+        path = os.path.join(get_cache_dir(), uuid)
+        if not os.path.isdir(path):
+            os.mkdir(path)
+    return get_transport(path)
+
+
+def check_pysqlite_version(sqlite3):
+    """Check that sqlite library is compatible.
+
+    """
+    if (sqlite3.sqlite_version_info[0] < 3 or
+            (sqlite3.sqlite_version_info[0] == 3 and
+             sqlite3.sqlite_version_info[1] < 3)):
+        trace.warning('Needs at least sqlite 3.3.x')
+        raise bzr_errors.BzrError("incompatible sqlite library")
+
+try:
+    try:
+        import sqlite3
+        check_pysqlite_version(sqlite3)
+    except (ImportError, bzr_errors.BzrError), e:
+        from pysqlite2 import dbapi2 as sqlite3
+        check_pysqlite_version(sqlite3)
+except:
+    trace.warning('Needs at least Python2.5 or Python2.4 with the pysqlite2 '
+            'module')
+    raise bzr_errors.BzrError("missing sqlite library")
+
+
+_mapdbs = threading.local()
+def mapdbs():
+    """Get a cache for this thread's db connections."""
+    try:
+        return _mapdbs.cache
+    except AttributeError:
+        _mapdbs.cache = {}
+        return _mapdbs.cache
+
+
+class GitShaMap(object):
+    """Git<->Bzr revision id mapping database."""
+
+    def lookup_git_sha(self, sha):
+        """Lookup a Git sha in the database.
+        :param sha: Git object sha
+        :return: list with (type, type_data) tuples with type_data:
+            commit: revid, tree_sha, verifiers
+            blob: fileid, revid
+            tree: fileid, revid
+        """
+        raise NotImplementedError(self.lookup_git_sha)
+
+    def lookup_blob_id(self, file_id, revision):
+        """Retrieve a Git blob SHA by file id.
+
+        :param file_id: File id of the file/symlink
+        :param revision: revision in which the file was last changed.
+        """
+        raise NotImplementedError(self.lookup_blob_id)
+
+    def lookup_tree_id(self, file_id, revision):
+        """Retrieve a Git tree SHA by file id.
+        """
+        raise NotImplementedError(self.lookup_tree_id)
+
+    def lookup_commit(self, revid):
+        """Retrieve a Git commit SHA by Bazaar revision id.
+        """
+        raise NotImplementedError(self.lookup_commit)
+
+    def revids(self):
+        """List the revision ids known."""
+        raise NotImplementedError(self.revids)
+
+    def missing_revisions(self, revids):
+        """Return set of all the revisions that are not present."""
+        present_revids = set(self.revids())
+        if not isinstance(revids, set):
+            revids = set(revids)
+        return revids - present_revids
+
+    def sha1s(self):
+        """List the SHA1s."""
+        raise NotImplementedError(self.sha1s)
+
+    def start_write_group(self):
+        """Start writing changes."""
+
+    def commit_write_group(self):
+        """Commit any pending changes."""
+
+    def abort_write_group(self):
+        """Abort any pending changes."""
+
+
+class ContentCache(object):
+    """Object that can cache Git objects."""
+
+    def add(self, object):
+        """Add an object."""
+        raise NotImplementedError(self.add)
+
+    def add_multi(self, objects):
+        """Add multiple objects."""
+        for obj in objects:
+            self.add(obj)
+
+    def __getitem__(self, sha):
+        """Retrieve an item, by SHA."""
+        raise NotImplementedError(self.__getitem__)
+
+
+class BzrGitCacheFormat(object):
+    """Bazaar-Git Cache Format."""
+
+    def get_format_string(self):
+        """Return a single-line unique format string for this cache format."""
+        raise NotImplementedError(self.get_format_string)
+
+    def open(self, transport):
+        """Open this format on a transport."""
+        raise NotImplementedError(self.open)
+
+    def initialize(self, transport):
+        """Create a new instance of this cache format at transport."""
+        transport.put_bytes('format', self.get_format_string())
+
+    @classmethod
+    def from_transport(self, transport):
+        """Open a cache file present on a transport, or initialize one.
+
+        :param transport: Transport to use
+        :return: A BzrGitCache instance
+        """
+        try:
+            format_name = transport.get_bytes('format')
+            format = formats.get(format_name)
+        except bzr_errors.NoSuchFile:
+            format = formats.get('default')
+            format.initialize(transport)
+        return format.open(transport)
+
+    @classmethod
+    def from_repository(cls, repository):
+        """Open a cache file for a repository.
+
+        This will use the repository's transport to store the cache file, or
+        use the users global cache directory if the repository has no 
+        transport associated with it.
+
+        :param repository: Repository to open the cache for
+        :return: A `BzrGitCache`
+        """
+        from ...transport.local import LocalTransport
+        repo_transport = getattr(repository, "_transport", None)
+        if (repo_transport is not None and
+            isinstance(repo_transport, LocalTransport)):
+            # Even if we don't write to this repo, we should be able
+            # to update its cache.
+            try:
+                repo_transport = remove_readonly_transport_decorator(repo_transport)
+            except bzr_errors.ReadOnlyError:
+                transport = None
+            else:
+                try:
+                    repo_transport.mkdir('git')
+                except bzr_errors.FileExists:
+                    pass
+                transport = repo_transport.clone('git')
+        else:
+            transport = None
+        if transport is None:
+            transport = get_remote_cache_transport(repository)
+        return cls.from_transport(transport)
+
+
+class CacheUpdater(object):
+    """Base class for objects that can update a bzr-git cache."""
+
+    def add_object(self, obj, bzr_key_data, path):
+        """Add an object.
+
+        :param obj: Object type ("commit", "blob" or "tree")
+        :param bzr_key_data: bzr key store data or testament_sha in case
+            of commit
+        :param path: Path of the object (optional)
+        """
+        raise NotImplementedError(self.add_object)
+
+    def finish(self):
+        raise NotImplementedError(self.finish)
+
+
+class BzrGitCache(object):
+    """Caching backend."""
+
+    def __init__(self, idmap, cache_updater_klass):
+        self.idmap = idmap
+        self._cache_updater_klass = cache_updater_klass
+
+    def get_updater(self, rev):
+        """Update an object that implements the CacheUpdater interface for 
+        updating this cache.
+        """
+        return self._cache_updater_klass(self, rev)
+
+
+DictBzrGitCache = lambda: BzrGitCache(DictGitShaMap(), DictCacheUpdater)
+
+
+class DictCacheUpdater(CacheUpdater):
+    """Cache updater for dict-based caches."""
+
+    def __init__(self, cache, rev):
+        self.cache = cache
+        self.revid = rev.revision_id
+        self.parent_revids = rev.parent_ids
+        self._commit = None
+        self._entries = []
+
+    def add_object(self, obj, bzr_key_data, path):
+        if isinstance(obj, tuple):
+            (type_name, hexsha) = obj
+        else:
+            type_name = obj.type_name
+            hexsha = obj.id
+        if type_name == "commit":
+            self._commit = obj
+            if type(bzr_key_data) is not dict:
+                raise TypeError(bzr_key_data)
+            key = self.revid
+            type_data = (self.revid, self._commit.tree, bzr_key_data)
+            self.cache.idmap._by_revid[self.revid] = hexsha
+        elif type_name in ("blob", "tree"):
+            if bzr_key_data is not None:
+                key = type_data = bzr_key_data
+                self.cache.idmap._by_fileid.setdefault(type_data[1], {})[type_data[0]] = hexsha
+        else:
+            raise AssertionError
+        entry = (type_name, type_data)
+        self.cache.idmap._by_sha.setdefault(hexsha, {})[key] = entry
+
+    def finish(self):
+        if self._commit is None:
+            raise AssertionError("No commit object added")
+        return self._commit
+
+
+class DictGitShaMap(GitShaMap):
+    """Git SHA map that uses a dictionary."""
+
+    def __init__(self):
+        self._by_sha = {}
+        self._by_fileid = {}
+        self._by_revid = {}
+
+    def lookup_blob_id(self, fileid, revision):
+        return self._by_fileid[revision][fileid]
+
+    def lookup_git_sha(self, sha):
+        for entry in self._by_sha[sha].itervalues():
+            yield entry
+
+    def lookup_tree_id(self, fileid, revision):
+        return self._by_fileid[revision][fileid]
+
+    def lookup_commit(self, revid):
+        return self._by_revid[revid]
+
+    def revids(self):
+        for key, entries in self._by_sha.iteritems():
+            for (type, type_data) in entries.values():
+                if type == "commit":
+                    yield type_data[0]
+
+    def sha1s(self):
+        return self._by_sha.iterkeys()
+
+
+class SqliteCacheUpdater(CacheUpdater):
+
+    def __init__(self, cache, rev):
+        self.cache = cache
+        self.db = self.cache.idmap.db
+        self.revid = rev.revision_id
+        self._commit = None
+        self._trees = []
+        self._blobs = []
+
+    def add_object(self, obj, bzr_key_data, path):
+        if isinstance(obj, tuple):
+            (type_name, hexsha) = obj
+        else:
+            type_name = obj.type_name
+            hexsha = obj.id
+        if type_name == "commit":
+            self._commit = obj
+            if type(bzr_key_data) is not dict:
+                raise TypeError(bzr_key_data)
+            self._testament3_sha1 = bzr_key_data.get("testament3-sha1")
+        elif type_name == "tree":
+            if bzr_key_data is not None:
+                self._trees.append((hexsha, bzr_key_data[0], bzr_key_data[1]))
+        elif type_name == "blob":
+            if bzr_key_data is not None:
+                self._blobs.append((hexsha, bzr_key_data[0], bzr_key_data[1]))
+        else:
+            raise AssertionError
+
+    def finish(self):
+        if self._commit is None:
+            raise AssertionError("No commit object added")
+        self.db.executemany(
+            "replace into trees (sha1, fileid, revid) values (?, ?, ?)",
+            self._trees)
+        self.db.executemany(
+            "replace into blobs (sha1, fileid, revid) values (?, ?, ?)",
+            self._blobs)
+        self.db.execute(
+            "replace into commits (sha1, revid, tree_sha, testament3_sha1) values (?, ?, ?, ?)",
+            (self._commit.id, self.revid, self._commit.tree, self._testament3_sha1))
+        return self._commit
+
+
+SqliteBzrGitCache = lambda p: BzrGitCache(SqliteGitShaMap(p), SqliteCacheUpdater)
+
+
+class SqliteGitCacheFormat(BzrGitCacheFormat):
+
+    def get_format_string(self):
+        return 'bzr-git sha map version 1 using sqlite\n'
+
+    def open(self, transport):
+        try:
+            basepath = transport.local_abspath(".")
+        except bzr_errors.NotLocalUrl:
+            basepath = get_cache_dir()
+        return SqliteBzrGitCache(os.path.join(basepath, "idmap.db"))
+
+
+class SqliteGitShaMap(GitShaMap):
+    """Bazaar GIT Sha map that uses a sqlite database for storage."""
+
+    def __init__(self, path=None):
+        self.path = path
+        if path is None:
+            self.db = sqlite3.connect(":memory:")
+        else:
+            if not mapdbs().has_key(path):
+                mapdbs()[path] = sqlite3.connect(path)
+            self.db = mapdbs()[path]
+        self.db.text_factory = str
+        self.db.executescript("""
+        create table if not exists commits(
+            sha1 text not null check(length(sha1) == 40),
+            revid text not null,
+            tree_sha text not null check(length(tree_sha) == 40)
+        );
+        create index if not exists commit_sha1 on commits(sha1);
+        create unique index if not exists commit_revid on commits(revid);
+        create table if not exists blobs(
+            sha1 text not null check(length(sha1) == 40),
+            fileid text not null,
+            revid text not null
+        );
+        create index if not exists blobs_sha1 on blobs(sha1);
+        create unique index if not exists blobs_fileid_revid on blobs(fileid, revid);
+        create table if not exists trees(
+            sha1 text unique not null check(length(sha1) == 40),
+            fileid text not null,
+            revid text not null
+        );
+        create unique index if not exists trees_sha1 on trees(sha1);
+        create unique index if not exists trees_fileid_revid on trees(fileid, revid);
+""")
+        try:
+            self.db.executescript(
+                "ALTER TABLE commits ADD testament3_sha1 TEXT;")
+        except sqlite3.OperationalError:
+            pass # Column already exists.
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.path)
+
+    def lookup_commit(self, revid):
+        cursor = self.db.execute("select sha1 from commits where revid = ?", 
+            (revid,))
+        row = cursor.fetchone()
+        if row is not None:
+            return row[0]
+        raise KeyError
+
+    def commit_write_group(self):
+        self.db.commit()
+
+    def lookup_blob_id(self, fileid, revision):
+        row = self.db.execute("select sha1 from blobs where fileid = ? and revid = ?", (fileid, revision)).fetchone()
+        if row is not None:
+            return row[0]
+        raise KeyError(fileid)
+
+    def lookup_tree_id(self, fileid, revision):
+        row = self.db.execute("select sha1 from trees where fileid = ? and revid = ?", (fileid, revision)).fetchone()
+        if row is not None:
+            return row[0]
+        raise KeyError(fileid)
+
+    def lookup_git_sha(self, sha):
+        """Lookup a Git sha in the database.
+
+        :param sha: Git object sha
+        :return: (type, type_data) with type_data:
+            commit: revid, tree sha, verifiers
+            tree: fileid, revid
+            blob: fileid, revid
+        """
+        found = False
+        cursor = self.db.execute("select revid, tree_sha, testament3_sha1 from commits where sha1 = ?", (sha,))
+        for row in cursor.fetchall():
+            found = True
+            if row[2] is not None:
+                verifiers = {"testament3-sha1": row[2]}
+            else:
+                verifiers = {}
+            yield ("commit", (row[0], row[1], verifiers))
+        cursor = self.db.execute("select fileid, revid from blobs where sha1 = ?", (sha,))
+        for row in cursor.fetchall():
+            found = True
+            yield ("blob", row)
+        cursor = self.db.execute("select fileid, revid from trees where sha1 = ?", (sha,))
+        for row in cursor.fetchall():
+            found = True
+            yield ("tree", row)
+        if not found:
+            raise KeyError(sha)
+
+    def revids(self):
+        """List the revision ids known."""
+        return (row for (row,) in self.db.execute("select revid from commits"))
+
+    def sha1s(self):
+        """List the SHA1s."""
+        for table in ("blobs", "commits", "trees"):
+            for (sha,) in self.db.execute("select sha1 from %s" % table):
+                yield sha
+
+
+class TdbCacheUpdater(CacheUpdater):
+    """Cache updater for tdb-based caches."""
+
+    def __init__(self, cache, rev):
+        self.cache = cache
+        self.db = cache.idmap.db
+        self.revid = rev.revision_id
+        self.parent_revids = rev.parent_ids
+        self._commit = None
+        self._entries = []
+
+    def add_object(self, obj, bzr_key_data, path):
+        if isinstance(obj, tuple):
+            (type_name, hexsha) = obj
+            sha = hex_to_sha(hexsha)
+        else:
+            type_name = obj.type_name
+            sha = obj.sha().digest()
+        if type_name == "commit":
+            self.db["commit\0" + self.revid] = "\0".join((sha, obj.tree))
+            if type(bzr_key_data) is not dict:
+                raise TypeError(bzr_key_data)
+            type_data = (self.revid, obj.tree)
+            try:
+                type_data += (bzr_key_data["testament3-sha1"],)
+            except KeyError:
+                pass
+            self._commit = obj
+        elif type_name == "blob":
+            if bzr_key_data is None:
+                return
+            self.db["\0".join(("blob", bzr_key_data[0], bzr_key_data[1]))] = sha
+            type_data = bzr_key_data
+        elif type_name == "tree":
+            if bzr_key_data is None:
+                return
+            type_data = bzr_key_data
+        else:
+            raise AssertionError
+        entry = "\0".join((type_name, ) + type_data) + "\n"
+        key = "git\0" + sha
+        try:
+            oldval = self.db[key]
+        except KeyError:
+            self.db[key] = entry
+        else:
+            if oldval[-1] != "\n":
+                self.db[key] = "".join([oldval, "\n", entry])
+            else:
+                self.db[key] = "".join([oldval, entry])
+
+    def finish(self):
+        if self._commit is None:
+            raise AssertionError("No commit object added")
+        return self._commit
+
+
+TdbBzrGitCache = lambda p: BzrGitCache(TdbGitShaMap(p), TdbCacheUpdater)
+
+
+class TdbGitCacheFormat(BzrGitCacheFormat):
+    """Cache format for tdb-based caches."""
+
+    def get_format_string(self):
+        return 'bzr-git sha map version 3 using tdb\n'
+
+    def open(self, transport):
+        try:
+            basepath = transport.local_abspath(".").encode(osutils._fs_enc)
+        except bzr_errors.NotLocalUrl:
+            basepath = get_cache_dir()
+        if type(basepath) is not str:
+            raise TypeError(basepath)
+        try:
+            return TdbBzrGitCache(os.path.join(basepath, "idmap.tdb"))
+        except ImportError:
+            raise ImportError(
+                "Unable to open existing bzr-git cache because 'tdb' is not "
+                "installed.")
+
+
+class TdbGitShaMap(GitShaMap):
+    """SHA Map that uses a TDB database.
+
+    Entries:
+
+    "git <sha1>" -> "<type> <type-data1> <type-data2>"
+    "commit revid" -> "<sha1> <tree-id>"
+    "tree fileid revid" -> "<sha1>"
+    "blob fileid revid" -> "<sha1>"
+    """
+
+    TDB_MAP_VERSION = 3
+    TDB_HASH_SIZE = 50000
+
+    def __init__(self, path=None):
+        import tdb
+        self.path = path
+        if path is None:
+            self.db = {}
+        else:
+            if type(path) is not str:
+                raise TypeError(path)
+            if not mapdbs().has_key(path):
+                mapdbs()[path] = tdb.Tdb(path, self.TDB_HASH_SIZE, tdb.DEFAULT,
+                                          os.O_RDWR|os.O_CREAT)
+            self.db = mapdbs()[path]
+        try:
+            if int(self.db["version"]) not in (2, 3):
+                trace.warning("SHA Map is incompatible (%s -> %d), rebuilding database.",
+                              self.db["version"], self.TDB_MAP_VERSION)
+                self.db.clear()
+        except KeyError:
+            pass
+        self.db["version"] = str(self.TDB_MAP_VERSION)
+
+    def start_write_group(self):
+        """Start writing changes."""
+        self.db.transaction_start()
+
+    def commit_write_group(self):
+        """Commit any pending changes."""
+        self.db.transaction_commit()
+
+    def abort_write_group(self):
+        """Abort any pending changes."""
+        self.db.transaction_cancel()
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.path)
+
+    def lookup_commit(self, revid):
+        try:
+            return sha_to_hex(self.db["commit\0" + revid][:20])
+        except KeyError:
+            raise KeyError("No cache entry for %r" % revid)
+
+    def lookup_blob_id(self, fileid, revision):
+        return sha_to_hex(self.db["\0".join(("blob", fileid, revision))])
+
+    def lookup_git_sha(self, sha):
+        """Lookup a Git sha in the database.
+
+        :param sha: Git object sha
+        :return: (type, type_data) with type_data:
+            commit: revid, tree sha
+            blob: fileid, revid
+            tree: fileid, revid
+        """
+        if len(sha) == 40:
+            sha = hex_to_sha(sha)
+        value = self.db["git\0" + sha]
+        for data in value.splitlines():
+            data = data.split("\0")
+            if data[0] == "commit":
+                if len(data) == 3:
+                    yield (data[0], (data[1], data[2], {}))
+                else:
+                    yield (data[0], (data[1], data[2], {"testament3-sha1": data[3]}))
+            elif data[0] in ("tree", "blob"):
+                yield (data[0], tuple(data[1:]))
+            else:
+                raise AssertionError("unknown type %r" % data[0])
+
+    def missing_revisions(self, revids):
+        ret = set()
+        for revid in revids:
+            if self.db.get("commit\0" + revid) is None:
+                ret.add(revid)
+        return ret
+
+    def revids(self):
+        """List the revision ids known."""
+        for key in self.db.iterkeys():
+            if key.startswith("commit\0"):
+                yield key[7:]
+
+    def sha1s(self):
+        """List the SHA1s."""
+        for key in self.db.iterkeys():
+            if key.startswith("git\0"):
+                yield sha_to_hex(key[4:])
+
+
+class VersionedFilesContentCache(ContentCache):
+
+    def __init__(self, vf):
+        self._vf = vf
+
+    def add(self, obj):
+        self._vf.insert_record_stream(
+            [versionedfile.ChunkedContentFactory((obj.id,), [], None,
+                obj.as_legacy_object_chunks())])
+
+    def __getitem__(self, sha):
+        stream = self._vf.get_record_stream([(sha,)], 'unordered', True)
+        entry = stream.next() 
+        if entry.storage_kind == 'absent':
+            raise KeyError(sha)
+        return ShaFile._parse_legacy_object(entry.get_bytes_as('fulltext'))
+
+
+class IndexCacheUpdater(CacheUpdater):
+
+    def __init__(self, cache, rev):
+        self.cache = cache
+        self.revid = rev.revision_id
+        self.parent_revids = rev.parent_ids
+        self._commit = None
+        self._entries = []
+
+    def add_object(self, obj, bzr_key_data, path):
+        if isinstance(obj, tuple):
+            (type_name, hexsha) = obj
+        else:
+            type_name = obj.type_name
+            hexsha = obj.id
+        if type_name == "commit":
+            self._commit = obj
+            if type(bzr_key_data) is not dict:
+                raise TypeError(bzr_key_data)
+            self.cache.idmap._add_git_sha(hexsha, "commit",
+                (self.revid, obj.tree, bzr_key_data))
+            self.cache.idmap._add_node(("commit", self.revid, "X"),
+                " ".join((hexsha, obj.tree)))
+        elif type_name == "blob":
+            self.cache.idmap._add_git_sha(hexsha, "blob", bzr_key_data)
+            self.cache.idmap._add_node(("blob", bzr_key_data[0],
+                bzr_key_data[1]), hexsha)
+        elif type_name == "tree":
+            self.cache.idmap._add_git_sha(hexsha, "tree", bzr_key_data)
+        else:
+            raise AssertionError
+
+    def finish(self):
+        return self._commit
+
+
+class IndexBzrGitCache(BzrGitCache):
+
+    def __init__(self, transport=None):
+        mapper = versionedfile.ConstantMapper("trees")
+        shamap = IndexGitShaMap(transport.clone('index'))
+        from .transportgit import TransportObjectStore
+        super(IndexBzrGitCache, self).__init__(shamap, IndexCacheUpdater)
+
+
+class IndexGitCacheFormat(BzrGitCacheFormat):
+
+    def get_format_string(self):
+        return 'bzr-git sha map with git object cache version 1\n'
+
+    def initialize(self, transport):
+        super(IndexGitCacheFormat, self).initialize(transport)
+        transport.mkdir('index')
+        transport.mkdir('objects')
+        from .transportgit import TransportObjectStore
+        TransportObjectStore.init(transport.clone('objects'))
+
+    def open(self, transport):
+        return IndexBzrGitCache(transport)
+
+
+class IndexGitShaMap(GitShaMap):
+    """SHA Map that uses the Bazaar APIs to store a cache.
+
+    BTree Index file with the following contents:
+
+    ("git", <sha1>, "X") -> "<type> <type-data1> <type-data2>"
+    ("commit", <revid>, "X") -> "<sha1> <tree-id>"
+    ("blob", <fileid>, <revid>) -> <sha1>
+
+    """
+
+    def __init__(self, transport=None):
+        if transport is None:
+            self._transport = None
+            self._index = _mod_index.InMemoryGraphIndex(0, key_elements=3)
+            self._builder = self._index
+        else:
+            self._builder = None
+            self._transport = transport
+            self._index = _mod_index.CombinedGraphIndex([])
+            for name in self._transport.list_dir("."):
+                if not name.endswith(".rix"):
+                    continue
+                x = _mod_btree_index.BTreeGraphIndex(self._transport, name,
+                    self._transport.stat(name).st_size)
+                self._index.insert_index(0, x)
+
+    @classmethod
+    def from_repository(cls, repository):
+        transport = getattr(repository, "_transport", None)
+        if transport is not None:
+            try:
+                transport.mkdir('git')
+            except bzr_errors.FileExists:
+                pass
+            return cls(transport.clone('git'))
+        from ...transport import get_transport
+        return cls(get_transport(get_cache_dir()))
+
+    def __repr__(self):
+        if self._transport is not None:
+            return "%s(%r)" % (self.__class__.__name__, self._transport.base)
+        else:
+            return "%s()" % (self.__class__.__name__)
+
+    def repack(self):
+        if self._builder is not None:
+            raise errors.BzrError('builder already open')
+        self.start_write_group()
+        self._builder.add_nodes(
+            ((key, value) for (_, key, value) in
+                self._index.iter_all_entries()))
+        to_remove = []
+        for name in self._transport.list_dir('.'):
+            if name.endswith('.rix'):
+                to_remove.append(name)
+        self.commit_write_group()
+        del self._index.indices[1:]
+        for name in to_remove:
+            self._transport.rename(name, name + '.old')
+
+    def start_write_group(self):
+        if self._builder is not None:
+            raise errors.BzrError('builder already open')
+        self._builder = _mod_btree_index.BTreeBuilder(0, key_elements=3)
+        self._name = osutils.sha()
+
+    def commit_write_group(self):
+        if self._builder is None:
+            raise errors.BzrError('builder not open')
+        stream = self._builder.finish()
+        name = self._name.hexdigest() + ".rix"
+        size = self._transport.put_file(name, stream)
+        index = _mod_btree_index.BTreeGraphIndex(self._transport, name, size)
+        self._index.insert_index(0, index)
+        self._builder = None
+        self._name = None
+
+    def abort_write_group(self):
+        if self._builder is None:
+            raise errors.BzrError('builder not open')
+        self._builder = None
+        self._name = None
+
+    def _add_node(self, key, value):
+        try:
+            self._get_entry(key)
+        except KeyError:
+            self._builder.add_node(key, value)
+            return False
+        else:
+            return True
+
+    def _get_entry(self, key):
+        entries = self._index.iter_entries([key])
+        try:
+            return entries.next()[2]
+        except StopIteration:
+            if self._builder is None:
+                raise KeyError
+            entries = self._builder.iter_entries([key])
+            try:
+                return entries.next()[2]
+            except StopIteration:
+                raise KeyError
+
+    def _iter_entries_prefix(self, prefix):
+        for entry in self._index.iter_entries_prefix([prefix]):
+            yield (entry[1], entry[2])
+        if self._builder is not None:
+            for entry in self._builder.iter_entries_prefix([prefix]):
+                yield (entry[1], entry[2])
+
+    def lookup_commit(self, revid):
+        return self._get_entry(("commit", revid, "X"))[:40]
+
+    def _add_git_sha(self, hexsha, type, type_data):
+        if hexsha is not None:
+            self._name.update(hexsha)
+            if type == "commit":
+                td = (type_data[0], type_data[1])
+                try:
+                    td += (type_data[2]["testament3-sha1"],)
+                except KeyError:
+                    pass
+            else:
+                td = type_data
+            self._add_node(("git", hexsha, "X"), " ".join((type,) + td))
+        else:
+            # This object is not represented in Git - perhaps an empty
+            # directory?
+            self._name.update(type + " ".join(type_data))
+
+    def lookup_blob_id(self, fileid, revision):
+        return self._get_entry(("blob", fileid, revision))
+
+    def lookup_git_sha(self, sha):
+        if len(sha) == 20:
+            sha = sha_to_hex(sha)
+        value = self._get_entry(("git", sha, "X"))
+        data = value.split(" ", 3)
+        if data[0] == "commit":
+            try:
+                if data[3]:
+                    verifiers = {"testament3-sha1": data[3]}
+                else:
+                    verifiers = {}
+            except IndexError:
+                verifiers = {}
+            yield ("commit", (data[1], data[2], verifiers))
+        else:
+            yield (data[0], tuple(data[1:]))
+
+    def revids(self):
+        """List the revision ids known."""
+        for key, value in self._iter_entries_prefix(("commit", None, None)):
+            yield key[1]
+
+    def missing_revisions(self, revids):
+        """Return set of all the revisions that are not present."""
+        missing_revids = set(revids)
+        for _, key, value in self._index.iter_entries((
+            ("commit", revid, "X") for revid in revids)):
+            missing_revids.remove(key[1])
+        return missing_revids
+
+    def sha1s(self):
+        """List the SHA1s."""
+        for key, value in self._iter_entries_prefix(("git", None, None)):
+            yield key[1]
+
+
+formats = registry.Registry()
+formats.register(TdbGitCacheFormat().get_format_string(),
+    TdbGitCacheFormat())
+formats.register(SqliteGitCacheFormat().get_format_string(),
+    SqliteGitCacheFormat())
+formats.register(IndexGitCacheFormat().get_format_string(),
+    IndexGitCacheFormat())
+# In the future, this will become the default:
+formats.register('default', IndexGitCacheFormat())
+
+
+
+def migrate_ancient_formats(repo_transport):
+    # Migrate older cache formats
+    repo_transport = remove_readonly_transport_decorator(repo_transport)
+    has_sqlite = repo_transport.has("git.db")
+    has_tdb = repo_transport.has("git.tdb")
+    if not has_sqlite or has_tdb:
+        return
+    try:
+        repo_transport.mkdir("git")
+    except bzr_errors.FileExists:
+        return
+    # Prefer migrating git.db over git.tdb, since the latter may not 
+    # be openable on some platforms.
+    if has_sqlite:
+        SqliteGitCacheFormat().initialize(repo_transport.clone("git"))
+        repo_transport.rename("git.db", "git/idmap.db")
+    elif has_tdb:
+        TdbGitCacheFormat().initialize(repo_transport.clone("git"))
+        repo_transport.rename("git.tdb", "git/idmap.tdb")
+
+
+def remove_readonly_transport_decorator(transport):
+    if transport.is_readonly():
+        try:
+            return transport._decorated
+        except AttributeError:
+            raise bzr_errors.ReadOnlyError(transport)
+    return transport
+
+
+def from_repository(repository):
+    """Open a cache file for a repository.
+
+    If the repository is remote and there is no transport available from it
+    this will use a local file in the users cache directory
+    (typically ~/.cache/bazaar/git/)
+
+    :param repository: A repository object
+    """
+    repo_transport = getattr(repository, "_transport", None)
+    if repo_transport is not None:
+        try:
+            migrate_ancient_formats(repo_transport)
+        except bzr_errors.ReadOnlyError:
+            pass # Not much we can do
+    return BzrGitCacheFormat.from_repository(repository)

=== added file 'breezy/plugins/git/commands.py'
--- breezy/plugins/git/commands.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/commands.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,340 @@
+# Copyright (C) 2006-2009 Canonical Ltd
+# Copyright (C) 2012-2018 Jelmer Vernooij <[e-mail]>
+
+# Authors: Robert Collins <[e-mail]>
+#          Jelmer Vernooij <[e-mail]>
+#          John Carr <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Git-specific subcommands for Bazaar."""
+
+from __future__ import absolute_import
+
+import breezy.bzr.bzrdir
+from ...commands import (
+    Command,
+    display_command,
+    )
+from ...option import (
+    Option,
+    )
+
+
+class cmd_git_import(Command):
+    """Import all branches from a git repository.
+
+    """
+
+    takes_args = ["src_location", "dest_location?"]
+
+    takes_options = [
+                     Option('colocated', help='Create colocated branches.'),
+                     ]
+
+    def _get_colocated_branch(self, target_controldir, name):
+        from ...errors import NotBranchError
+        try:
+            return target_controldir.open_branch(name=name)
+        except NotBranchError:
+            return target_controldir.create_branch(name=name)
+
+    def _get_nested_branch(self, dest_transport, dest_format, name):
+        from ...controldir import ControlDir
+        from ...errors import NotBranchError
+        head_transport = dest_transport.clone(name)
+        try:
+            head_controldir = ControlDir.open_from_transport(head_transport)
+        except NotBranchError:
+            head_controldir = dest_format.initialize_on_transport_ex(
+                head_transport, create_prefix=True)[1]
+        try:
+            return head_controldir.open_branch()
+        except NotBranchError:
+            return head_controldir.create_branch()
+
+    def run(self, src_location, dest_location=None, colocated=False):
+        import os
+        import urllib
+        from ... import (
+            controldir,
+            trace,
+            ui,
+            urlutils,
+            )
+        from ...controldir import (
+            ControlDir,
+            )
+        from ...errors import (
+            BzrCommandError,
+            NoRepositoryPresent,
+            NotBranchError,
+            )
+        from . import gettext
+        from ...repository import (
+            InterRepository,
+            Repository,
+            )
+        from ...transport import get_transport
+        from .branch import (
+            LocalGitBranch,
+            )
+        from .refs import (
+            ref_to_branch_name,
+            )
+        from .repository import GitRepository
+
+        dest_format = controldir.ControlDirFormat.get_default_format()
+        if dest_format is None:
+            raise errors.BzrError('no default format')
+
+        if dest_location is None:
+            dest_location = os.path.basename(src_location.rstrip("/\\"))
+
+        dest_transport = get_transport(dest_location)
+
+        source_repo = Repository.open(src_location)
+        if not isinstance(source_repo, GitRepository):
+            raise BzrCommandError(gettext("%r is not a git repository") % src_location)
+        try:
+            target_controldir = ControlDir.open_from_transport(dest_transport)
+        except NotBranchError:
+            target_controldir = dest_format.initialize_on_transport_ex(
+                dest_transport, shared_repo=True)[1]
+        try:
+            target_repo = target_controldir.find_repository()
+        except NoRepositoryPresent:
+            target_repo = target_controldir.create_repository(shared=True)
+
+        if not target_repo.supports_rich_root():
+            raise BzrCommandError(gettext("Target repository doesn't support rich roots"))
+
+        interrepo = InterRepository.get(source_repo, target_repo)
+        mapping = source_repo.get_mapping()
+        refs = interrepo.fetch()
+        pb = ui.ui_factory.nested_progress_bar()
+        try:
+            for i, (name, sha) in enumerate(refs.iteritems()):
+                try:
+                    branch_name = ref_to_branch_name(name)
+                except ValueError:
+                    # Not a branch, ignore
+                    continue
+                pb.update(gettext("creating branches"), i, len(refs))
+                if getattr(target_controldir._format, "colocated_branches", False) and colocated:
+                    if name == "HEAD":
+                        branch_name = None
+                    head_branch = self._get_colocated_branch(target_controldir, branch_name)
+                else:
+                    head_branch = self._get_nested_branch(dest_transport, dest_format, branch_name)
+                revid = mapping.revision_id_foreign_to_bzr(sha)
+                source_branch = LocalGitBranch(source_repo.controldir, source_repo,
+                    sha)
+                if head_branch.last_revision() != revid:
+                    head_branch.generate_revision_history(revid)
+                source_branch.tags.merge_to(head_branch.tags)
+                if not head_branch.get_parent():
+                    url = urlutils.join_segment_parameters(
+                        source_branch.base, {"branch": urllib.quote(branch_name.encode('utf-8'), '')})
+                    head_branch.set_parent(url)
+        finally:
+            pb.finished()
+        trace.note(gettext(
+            "Use 'bzr checkout' to create a working tree in "
+            "the newly created branches."))
+
+
+class cmd_git_object(Command):
+    """List or display Git objects by SHA.
+
+    Cat a particular object's Git representation if a SHA is specified.
+    List all available SHAs otherwise.
+    """
+
+    hidden = True
+
+    aliases = ["git-objects", "git-cat"]
+    takes_args = ["sha1?"]
+    takes_options = [Option('directory',
+        short_name='d',
+        help='Location of repository.', type=unicode),
+        Option('pretty', help='Pretty-print objects.')]
+    encoding_type = 'exact'
+
+    @display_command
+    def run(self, sha1=None, directory=".", pretty=False):
+        from ...errors import (
+            BzrCommandError,
+            )
+        from ...controldir import (
+            ControlDir,
+            )
+        from .object_store import (
+            get_object_store,
+            )
+        from . import gettext
+        controldir, _ = ControlDir.open_containing(directory)
+        repo = controldir.find_repository()
+        object_store = get_object_store(repo)
+        with object_store.lock_read():
+            if sha1 is not None:
+                try:
+                    obj = object_store[str(sha1)]
+                except KeyError:
+                    raise BzrCommandError(gettext("Object not found: %s") % sha1)
+                if pretty:
+                    text = obj.as_pretty_string()
+                else:
+                    text = obj.as_raw_string()
+                self.outf.write(text)
+            else:
+                for sha1 in object_store:
+                    self.outf.write("%s\n" % sha1)
+
+
+class cmd_git_refs(Command):
+    """Output all of the virtual refs for a repository.
+
+    """
+
+    hidden = True
+
+    takes_args = ["location?"]
+
+    @display_command
+    def run(self, location="."):
+        from ...controldir import (
+            ControlDir,
+            )
+        from .refs import (
+            get_refs_container,
+            )
+        from .object_store import (
+            get_object_store,
+            )
+        controldir, _ = ControlDir.open_containing(location)
+        repo = controldir.find_repository()
+        object_store = get_object_store(repo)
+        with object_store.lock_read():
+            refs = get_refs_container(controldir, object_store)
+            for k, v in refs.as_dict().iteritems():
+                self.outf.write("%s -> %s\n" % (k, v))
+
+
+class cmd_git_apply(Command):
+    """Apply a series of git-am style patches.
+
+    This command will in the future probably be integrated into 
+    "bzr pull".
+    """
+
+    takes_options = [
+        Option('signoff', short_name='s', help='Add a Signed-off-by line.'),
+        Option('force',
+            help='Apply patches even if tree has uncommitted changes.')
+        ]
+    takes_args = ["patches*"]
+
+    def _apply_patch(self, wt, f, signoff):
+        """Apply a patch.
+
+        :param wt: A Bazaar working tree object.
+        :param f: Patch file to read.
+        :param signoff: Add Signed-Off-By flag.
+        """
+        from . import gettext
+        from ...errors import BzrCommandError
+        from dulwich.patch import git_am_patch_split
+        import subprocess
+        (c, diff, version) = git_am_patch_split(f)
+        # FIXME: Cope with git-specific bits in patch
+        # FIXME: Add new files to working tree
+        p = subprocess.Popen(["patch", "-p1"], stdin=subprocess.PIPE,
+            cwd=wt.basedir)
+        p.communicate(diff)
+        exitcode = p.wait()
+        if exitcode != 0:
+            raise BzrCommandError(gettext("error running patch"))
+        message = c.message
+        if signoff:
+            signed_off_by = wt.branch.get_config().username()
+            message += "Signed-off-by: %s\n" % signed_off_by.encode('utf-8')
+        wt.commit(authors=[c.author], message=message)
+
+    def run(self, patches_list=None, signoff=False, force=False):
+        from ...errors import UncommittedChanges
+        from ...workingtree import WorkingTree
+        if patches_list is None:
+            patches_list = []
+
+        tree, _ = WorkingTree.open_containing(".")
+        if tree.basis_tree().changes_from(tree).has_changed() and not force:
+            raise UncommittedChanges(tree)
+        with tree.lock_write():
+            for patch in patches_list:
+                with open(patch, 'r') as f:
+                    self._apply_patch(tree, f, signoff=signoff)
+
+
+class cmd_git_push_pristine_tar_deltas(Command):
+    """Push pristine tar deltas to a git repository."""
+
+    takes_options = [Option('directory',
+        short_name='d',
+        help='Location of repository.', type=unicode)]
+    takes_args = ['target', 'package']
+
+    def run(self, target, package, directory='.'):
+        from ...branch import Branch
+        from ...errors import (
+            BzrCommandError,
+            NoSuchRevision,
+            )
+        from ...trace import warning
+        from ...repository import Repository
+        from .object_store import get_object_store
+        from .pristine_tar import (
+            revision_pristine_tar_data,
+            store_git_pristine_tar_data,
+            )
+        source = Branch.open_containing(directory)[0]
+        target_bzr = Repository.open(target)
+        target = getattr(target_bzr, '_git', None)
+        if target is None:
+            raise BzrCommandError("Target not a git repository")
+        git_store = get_object_store(source.repository)
+        with git_store.lock_read():
+            tag_dict = source.tags.get_tag_dict()
+            for name, revid in tag_dict.iteritems():
+                try:
+                    rev = source.repository.get_revision(revid)
+                except NoSuchRevision:
+                    continue
+                try:
+                    delta, kind = revision_pristine_tar_data(rev)
+                except KeyError:
+                    continue
+                gitid = git_store._lookup_revision_sha1(revid)
+                if not (name.startswith('upstream/') or name.startswith('upstream-')):
+                    warning("Unexpected pristine tar revision tagged %s. Ignoring.",
+                         name)
+                    continue
+                upstream_version = name[len("upstream/"):]
+                filename = '%s_%s.orig.tar.%s' % (package, upstream_version, kind)
+                if not gitid in target:
+                    warning("base git id %s for %s missing in target repository",
+                            gitid, filename)
+                store_git_pristine_tar_data(target, filename.encode('utf-8'),
+                    delta, gitid)

=== added file 'breezy/plugins/git/commit.py'
--- breezy/plugins/git/commit.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/commit.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,241 @@
+# Copyright (C) 2009-2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+"""Support for committing in native Git working trees."""
+
+from __future__ import absolute_import
+
+from dulwich.index import (
+    commit_tree,
+    )
+import os
+import stat
+
+from ... import (
+    config as _mod_config,
+    gpg,
+    osutils,
+    revision as _mod_revision,
+    )
+from ...errors import (
+    BzrError,
+    RootMissing,
+    UnsupportedOperation,
+    )
+from ...repository import (
+    CommitBuilder,
+    )
+
+from dulwich.objects import (
+    S_IFGITLINK,
+    Blob,
+    Commit,
+    )
+from dulwich.index import read_submodule_head
+from dulwich.repo import Repo
+
+
+from .mapping import (
+    entry_mode,
+    object_mode,
+    fix_person_identifier,
+    )
+from .tree import entry_factory
+
+
+class SettingCustomFileIdsUnsupported(UnsupportedOperation):
+
+    _fmt = "Unable to store addition of file with custom file ids: %(file_ids)r"
+
+    def __init__(self, file_ids):
+        BzrError.__init__(self)
+        self.file_ids = file_ids
+
+
+class GitCommitBuilder(CommitBuilder):
+    """Commit builder for Git repositories."""
+
+    supports_record_entry_contents = False
+
+    def __init__(self, *args, **kwargs):
+        super(GitCommitBuilder, self).__init__(*args, **kwargs)
+        self.random_revid = True
+        self._validate_revprops(self._revprops)
+        self.store = self.repository._git.object_store
+        self._blobs = {}
+        self._inv_delta = []
+        self._any_changes = False
+        self._override_fileids = {}
+        self._mapping = self.repository.get_mapping()
+
+    def any_changes(self):
+        return self._any_changes
+
+    def record_iter_changes(self, workingtree, basis_revid, iter_changes):
+        seen_root = False
+        for (file_id, path, changed_content, versioned, parent, name, kind,
+             executable) in iter_changes:
+            if kind[1] in ("directory",):
+                self._inv_delta.append((path[0], path[1], file_id, entry_factory[kind[1]](file_id, name[1], parent[1])))
+                if kind[0] in ("file", "symlink"):
+                    self._blobs[path[0].encode("utf-8")] = None
+                    self._any_changes = True
+                if path[1] == "":
+                    seen_root = True
+                continue
+            self._any_changes = True
+            if path[1] is None:
+                self._inv_delta.append((path[0], path[1], file_id, None))
+                self._blobs[path[0].encode("utf-8")] = None
+                continue
+            try:
+                entry_kls = entry_factory[kind[1]]
+            except KeyError:
+                raise KeyError("unknown kind %s" % kind[1])
+            entry = entry_kls(file_id, name[1], parent[1])
+            if kind[1] == "file":
+                entry.executable = executable[1]
+                blob = Blob()
+                f, st = workingtree.get_file_with_stat(path[1], file_id)
+                try:
+                    blob.data = f.read()
+                finally:
+                    f.close()
+                entry.text_size = len(blob.data)
+                entry.text_sha1 = osutils.sha_string(blob.data)
+                self.store.add_object(blob)
+                sha = blob.id
+            elif kind[1] == "symlink":
+                symlink_target = workingtree.get_symlink_target(path[1], file_id)
+                blob = Blob()
+                blob.data = symlink_target.encode("utf-8")
+                self.store.add_object(blob)
+                sha = blob.id
+                entry.symlink_target = symlink_target
+                st = None
+            elif kind[1] == "tree-reference":
+                sha = read_submodule_head(workingtree.abspath(path[1]))
+                reference_revision = workingtree.get_reference_revision(path[1], file_id)
+                entry.reference_revision = reference_revision
+                st = None
+            else:
+                raise AssertionError("Unknown kind %r" % kind[1])
+            mode = object_mode(kind[1], executable[1])
+            self._inv_delta.append((path[0], path[1], file_id, entry))
+            encoded_new_path = path[1].encode("utf-8")
+            self._blobs[encoded_new_path] = (mode, sha)
+            if st is not None:
+                yield file_id, path[1], (entry.text_sha1, st)
+            if self._mapping.generate_file_id(encoded_new_path) != file_id:
+                self._override_fileids[encoded_new_path] = file_id
+            else:
+                self._override_fileids[encoded_new_path] = None
+        if not seen_root and len(self.parents) == 0:
+            raise RootMissing()
+        if getattr(workingtree, "basis_tree", False):
+            basis_tree = workingtree.basis_tree()
+        else:
+            if len(self.parents) == 0:
+                basis_revid = _mod_revision.NULL_REVISION
+            else:
+                basis_revid = self.parents[0]
+            basis_tree = self.repository.revision_tree(basis_revid)
+        # Fill in entries that were not changed
+        for entry in basis_tree._iter_tree_contents(include_trees=False):
+            if entry.path in self._blobs:
+                continue
+            self._blobs[entry.path] = (entry.mode, entry.sha)
+        if not self._lossy:
+            try:
+                fileid_map = dict(basis_tree._fileid_map.file_ids)
+            except AttributeError:
+                fileid_map = {}
+            for path, file_id in self._override_fileids.iteritems():
+                if type(path) is not str:
+                    raise TypeError(path)
+                if file_id is None:
+                    if path in fileid_map:
+                        del fileid_map[path]
+                else:
+                    if type(file_id) is not str:
+                        raise TypeError(file_id)
+                    fileid_map[path] = file_id
+            if fileid_map:
+                fileid_blob = self._mapping.export_fileid_map(fileid_map)
+            else:
+                fileid_blob = None
+            if fileid_blob is not None:
+                if self._mapping.BZR_FILE_IDS_FILE is None:
+                    raise SettingCustomFileIdsUnsupported(fileid_map)
+                self.store.add_object(fileid_blob)
+                self._blobs[self._mapping.BZR_FILE_IDS_FILE] = (stat.S_IFREG | 0644, fileid_blob.id)
+            else:
+                self._blobs[self._mapping.BZR_FILE_IDS_FILE] = None
+        self.new_inventory = None
+
+    def update_basis(self, tree):
+        # Nothing to do here
+        pass
+
+    def finish_inventory(self):
+        # eliminate blobs that were removed
+        for path, entry in iter(self._blobs.items()):
+            if entry is None:
+                del self._blobs[path]
+
+    def _iterblobs(self):
+        return ((path, sha, mode) for (path, (mode, sha)) in self._blobs.iteritems())
+
+    def commit(self, message):
+        self._validate_unicode_text(message, 'commit message')
+        c = Commit()
+        c.parents = [self.repository.lookup_bzr_revision_id(revid)[0] for revid in self.parents]
+        c.tree = commit_tree(self.store, self._iterblobs())
+        c.encoding = self._revprops.pop('git-explicit-encoding', 'utf-8')
+        c.committer = fix_person_identifier(self._committer.encode(c.encoding))
+        c.author = fix_person_identifier(self._revprops.pop('author', self._committer).encode(c.encoding))
+        if self._revprops:
+            raise NotImplementedError(self._revprops)
+        c.commit_time = int(self._timestamp)
+        c.author_time = int(self._timestamp)
+        c.commit_timezone = self._timezone
+        c.author_timezone = self._timezone
+        c.message = message.encode(c.encoding)
+        if self._config_stack.get('create_signatures') == _mod_config.SIGN_ALWAYS:
+            strategy = gpg.GPGStrategy(self._config_stack)
+            c.gpgsig = strategy.sign(c.as_raw_string(), gpg.MODE_DETACH)
+        self.store.add_object(c)
+        self.repository.commit_write_group()
+        self._new_revision_id = self._mapping.revision_id_foreign_to_bzr(c.id)
+        return self._new_revision_id
+
+    def abort(self):
+        if self.repository.is_in_write_group():
+            self.repository.abort_write_group()
+
+    def revision_tree(self):
+        return self.repository.revision_tree(self._new_revision_id)
+
+    def get_basis_delta(self):
+        # TODO(jelmer): remove this logic when lp:~jelmer/brz/remaining lands
+        for (oldpath, newpath, file_id, entry) in self._inv_delta:
+            if entry is not None:
+                entry.revision = self._new_revision_id
+        return self._inv_delta
+
+    def update_basis_by_delta(self, revid, delta):
+        pass

=== added file 'breezy/plugins/git/config.py'
--- breezy/plugins/git/config.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/config.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,63 @@
+# Copyright (C) 2009-2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Config file handling for Git."""
+
+from __future__ import absolute_import
+
+from ... import (
+    config,
+    )
+
+class GitBranchConfig(config.BranchConfig):
+    """BranchConfig that uses locations.conf in place of branch.conf"""
+
+    def __init__(self, branch):
+        super(GitBranchConfig, self).__init__(branch)
+        # do not provide a BranchDataConfig
+        self.option_sources = self.option_sources[0], self.option_sources[2]
+
+    def __repr__(self):
+        return "<%s of %r>" % (self.__class__.__name__, self.branch)
+
+    def set_user_option(self, name, value, store=config.STORE_BRANCH,
+            warn_masked=False):
+        """Force local to True"""
+        config.BranchConfig.set_user_option(self, name, value,
+            store=config.STORE_LOCATION, warn_masked=warn_masked)
+
+    def _get_user_id(self):
+        # TODO: Read from ~/.gitconfig
+        return self._get_best_value('_get_user_id')
+
+
+class GitBranchStack(config._CompatibleStack):
+    """GitBranch stack."""
+
+    def __init__(self, branch):
+        lstore = config.LocationStore()
+        loc_matcher = config.LocationMatcher(lstore, branch.base)
+        # FIXME: This should also be looking in .git/config for
+        # local git branches.
+        gstore = config.GlobalStore()
+        super(GitBranchStack, self).__init__(
+            [self._get_overrides,
+             loc_matcher.get_sections,
+             gstore.get_sections],
+            # All modifications go to the corresponding section in
+            # locations.conf
+            lstore, branch.base)
+        self.branch = branch

=== added file 'breezy/plugins/git/dir.py'
--- breezy/plugins/git/dir.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/dir.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,693 @@
+# Copyright (C) 2007 Canonical Ltd
+# Copyright (C) 2010-2018 Jelmer Vernooij
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""An adapter between a Git control dir and a Bazaar ControlDir."""
+
+from __future__ import absolute_import
+
+import urllib
+
+from ... import (
+    branch as _mod_branch,
+    errors as bzr_errors,
+    trace,
+    osutils,
+    repository as _mod_repository,
+    revision as _mod_revision,
+    urlutils,
+    )
+from ...transport import (
+    do_catching_redirections,
+    get_transport_from_path,
+    )
+
+from ...controldir import (
+    BranchReferenceLoop,
+    ControlDir,
+    ControlDirFormat,
+    format_registry,
+    RepositoryAcquisitionPolicy,
+    )
+from .object_store import (
+    get_object_store,
+    )
+
+from .push import (
+    GitPushResult,
+    )
+from .transportgit import (
+    OBJECTDIR,
+    TransportObjectStore,
+    )
+
+
+class GitDirConfig(object):
+
+    def get_default_stack_on(self):
+        return None
+
+    def set_default_stack_on(self, value):
+        raise bzr_errors.BzrError("Cannot set configuration")
+
+
+class GitControlDirFormat(ControlDirFormat):
+
+    colocated_branches = True
+    fixed_components = True
+
+    def __eq__(self, other):
+        return type(self) == type(other)
+
+    def is_supported(self):
+        return True
+
+    def network_name(self):
+        return "git"
+
+
+class UseExistingRepository(RepositoryAcquisitionPolicy):
+    """A policy of reusing an existing repository"""
+
+    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
+                 require_stacking=False):
+        """Constructor.
+
+        :param repository: The repository to use.
+        :param stack_on: A location to stack on
+        :param stack_on_pwd: If stack_on is relative, the location it is
+            relative to.
+        """
+        super(UseExistingRepository, self).__init__(
+                stack_on, stack_on_pwd, require_stacking)
+        self._repository = repository
+
+    def acquire_repository(self, make_working_trees=None, shared=False,
+            possible_transports=None):
+        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
+
+        Returns an existing repository to use.
+        """
+        return self._repository, False
+
+
+class GitDir(ControlDir):
+    """An adapter to the '.git' dir used by git."""
+
+    def is_supported(self):
+        return True
+
+    def can_convert_format(self):
+        return False
+
+    def break_lock(self):
+        # There are no global locks, so nothing to break.
+        raise NotImplementedError(self.break_lock)
+
+    def cloning_metadir(self, stacked=False):
+        return format_registry.make_controldir("git")
+
+    def checkout_metadir(self, stacked=False):
+        return format_registry.make_controldir("git")
+
+    def _get_selected_ref(self, branch, ref=None):
+        if ref is not None and branch is not None:
+            raise bzr_errors.BzrError("can't specify both ref and branch")
+        if ref is not None:
+            return ref
+        if branch is not None:
+            from .refs import branch_name_to_ref
+            return branch_name_to_ref(branch)
+        segment_parameters = getattr(
+            self.user_transport, "get_segment_parameters", lambda: {})()
+        ref = segment_parameters.get("ref")
+        if ref is not None:
+            return urlutils.unescape(ref)
+        if branch is None and getattr(self, "_get_selected_branch", False):
+            branch = self._get_selected_branch()
+            if branch is not None:
+                from .refs import branch_name_to_ref
+                return branch_name_to_ref(branch)
+        return b"HEAD"
+
+    def get_config(self):
+        return GitDirConfig()
+
+    def _available_backup_name(self, base):
+        return osutils.available_backup_name(base, self.root_transport.has)
+
+    def sprout(self, url, revision_id=None, force_new_repo=False,
+               recurse='down', possible_transports=None,
+               accelerator_tree=None, hardlink=False, stacked=False,
+               source_branch=None, create_tree_if_local=True):
+        from ...repository import InterRepository
+        from ...transport.local import LocalTransport
+        from ...transport import get_transport
+        target_transport = get_transport(url, possible_transports)
+        target_transport.ensure_base()
+        cloning_format = self.cloning_metadir()
+        # Create/update the result branch
+        try:
+            result = ControlDir.open_from_transport(target_transport)
+        except bzr_errors.NotBranchError:
+            result = cloning_format.initialize_on_transport(target_transport)
+        source_branch = self.open_branch()
+        source_repository = self.find_repository()
+        try:
+            result_repo = result.find_repository()
+        except bzr_errors.NoRepositoryPresent:
+            result_repo = result.create_repository()
+            target_is_empty = True
+        else:
+            target_is_empty = None # Unknown
+        if stacked:
+            raise _mod_branch.UnstackableBranchFormat(self._format, self.user_url)
+        interrepo = InterRepository.get(source_repository, result_repo)
+
+        if revision_id is not None:
+            determine_wants = interrepo.get_determine_wants_revids(
+                [revision_id], include_tags=True)
+        else:
+            determine_wants = interrepo.determine_wants_all
+        interrepo.fetch_objects(determine_wants=determine_wants,
+            mapping=source_branch.mapping)
+        result_branch = source_branch.sprout(result,
+            revision_id=revision_id, repository=result_repo)
+        if (create_tree_if_local
+            and isinstance(target_transport, LocalTransport)
+            and (result_repo is None or result_repo.make_working_trees())):
+            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
+                hardlink=hardlink, from_branch=result_branch)
+        return result
+
+    def clone_on_transport(self, transport, revision_id=None,
+        force_new_repo=False, preserve_stacking=False, stacked_on=None,
+        create_prefix=False, use_existing_dir=True, no_tree=False):
+        """See ControlDir.clone_on_transport."""
+        from ...repository import InterRepository
+        from .mapping import default_mapping
+        if stacked_on is not None:
+            raise _mod_branch.UnstackableBranchFormat(self._format, self.user_url)
+        if no_tree:
+            format = BareLocalGitControlDirFormat()
+        else:
+            format = LocalGitControlDirFormat()
+        (target_repo, target_controldir, stacking,
+                repo_policy) = format.initialize_on_transport_ex(
+                        transport, use_existing_dir=use_existing_dir,
+                        create_prefix=create_prefix,
+                        force_new_repo=force_new_repo)
+        target_repo = target_controldir.find_repository()
+        target_git_repo = target_repo._git
+        source_repo = self.find_repository()
+        source_git_repo = source_repo._git
+        interrepo = InterRepository.get(source_repo, target_repo)
+        if revision_id is not None:
+            determine_wants = interrepo.get_determine_wants_revids([revision_id], include_tags=True)
+        else:
+            determine_wants = interrepo.determine_wants_all
+        (pack_hint, _, refs) = interrepo.fetch_objects(determine_wants,
+            mapping=default_mapping)
+        for name, val in refs.iteritems():
+            target_git_repo.refs[name] = val
+        result_dir = self.__class__(transport, target_git_repo, format)
+        if revision_id is not None:
+            result_dir.open_branch().set_last_revision(revision_id)
+        try:
+            # Cheaper to check if the target is not local, than to try making
+            # the tree and fail.
+            result_dir.root_transport.local_abspath('.')
+            if result_dir.open_repository().make_working_trees():
+                self.open_workingtree().clone(result_dir, revision_id=revision_id)
+        except (bzr_errors.NoWorkingTree, bzr_errors.NotLocalUrl):
+            pass
+
+        return result_dir
+
+    def find_repository(self):
+        """Find the repository that should be used.
+
+        This does not require a branch as we use it to find the repo for
+        new branches as well as to hook existing branches up to their
+        repository.
+        """
+        return self._gitrepository_class(self._find_commondir())
+
+    def get_refs_container(self):
+        """Retrieve the refs container.
+        """
+        raise NotImplementedError(self.get_refs_container)
+
+    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
+                                    stack_on_pwd=None, require_stacking=False):
+        """Return an object representing a policy to use.
+
+        This controls whether a new repository is created, and the format of
+        that repository, or some existing shared repository used instead.
+
+        If stack_on is supplied, will not seek a containing shared repo.
+
+        :param force_new_repo: If True, require a new repository to be created.
+        :param stack_on: If supplied, the location to stack on.  If not
+            supplied, a default_stack_on location may be used.
+        :param stack_on_pwd: If stack_on is relative, the location it is
+            relative to.
+        """
+        return UseExistingRepository(self.find_repository())
+
+    def get_branches(self):
+        from .refs import ref_to_branch_name
+        ret = {}
+        for ref in self.get_refs_container().keys():
+            try:
+                branch_name = ref_to_branch_name(ref)
+            except ValueError:
+                continue
+            except UnicodeDecodeError:
+                trace.warning("Ignoring branch %r with unicode error ref", ref)
+                continue
+            ret[branch_name] = self.open_branch(ref=ref)
+        return ret
+
+    def list_branches(self):
+        return self.get_branches().values()
+
+    def push_branch(self, source, revision_id=None, overwrite=False,
+                    remember=False, create_prefix=False, lossy=False,
+                    name=None):
+        """Push the source branch into this ControlDir."""
+        push_result = GitPushResult()
+        push_result.workingtree_updated = None
+        push_result.master_branch = None
+        push_result.source_branch = source
+        push_result.stacked_on = None
+        repo = self.find_repository()
+        refname = self._get_selected_ref(name)
+        from .branch import GitBranch
+        if isinstance(source, GitBranch) and lossy:
+            raise bzr_errors.LossyPushToSameVCS(source.controldir, self)
+        target = self.open_branch(name, nascent_ok=True)
+        push_result.branch_push_result = source.push(
+                target, overwrite=overwrite, stop_revision=revision_id,
+                lossy=lossy)
+        push_result.new_revid = push_result.branch_push_result.new_revid
+        push_result.old_revid = push_result.branch_push_result.old_revid
+        push_result.target_branch = self.open_branch(name)
+        if source.get_push_location() is None or remember:
+            source.set_push_location(push_result.target_branch.base)
+        return push_result
+
+
+class LocalGitControlDirFormat(GitControlDirFormat):
+    """The .git directory control format."""
+
+    bare = False
+
+    @classmethod
+    def _known_formats(self):
+        return set([LocalGitControlDirFormat()])
+
+    @property
+    def repository_format(self):
+        from .repository import GitRepositoryFormat
+        return GitRepositoryFormat()
+
+    @property
+    def workingtree_format(self):
+        from .workingtree import GitWorkingTreeFormat
+        return GitWorkingTreeFormat()
+
+    def get_branch_format(self):
+        from .branch import LocalGitBranchFormat
+        return LocalGitBranchFormat()
+
+    def open(self, transport, _found=None):
+        """Open this directory.
+
+        """
+        from .transportgit import TransportRepo
+        gitrepo = TransportRepo(transport, self.bare,
+                refs_text=getattr(self, "_refs_text", None))
+        if not gitrepo._controltransport.has('HEAD'):
+            raise bzr_errors.NotBranchError(path=transport.base)
+        return LocalGitDir(transport, gitrepo, self)
+
+    def get_format_description(self):
+        return "Local Git Repository"
+
+    def initialize_on_transport(self, transport):
+        from .transportgit import TransportRepo
+        repo = TransportRepo.init(transport, bare=self.bare)
+        return self.open(transport)
+
+    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
+        create_prefix=False, force_new_repo=False, stacked_on=None,
+        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
+        shared_repo=False, vfs_only=False):
+        def make_directory(transport):
+            transport.mkdir('.')
+            return transport
+        def redirected(transport, e, redirection_notice):
+            trace.note(redirection_notice)
+            return transport._redirected_to(e.source, e.target)
+        try:
+            transport = do_catching_redirections(make_directory, transport,
+                redirected)
+        except bzr_errors.FileExists:
+            if not use_existing_dir:
+                raise
+        except bzr_errors.NoSuchFile:
+            if not create_prefix:
+                raise
+            transport.create_prefix()
+        controldir = self.initialize_on_transport(transport)
+        if repo_format_name:
+            result_repo = controldir.find_repository()
+            repository_policy = UseExistingRepository(result_repo)
+            result_repo.lock_write()
+        else:
+            result_repo = None
+            repository_policy = None
+        return (result_repo, controldir, False,
+                repository_policy)
+
+    def is_supported(self):
+        return True
+
+    def supports_transport(self, transport):
+        try:
+            external_url = transport.external_url()
+        except bzr_errors.InProcessTransport:
+            raise bzr_errors.NotBranchError(path=transport.base)
+        return external_url.startswith("file:")
+
+
+class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
+
+    bare = True
+    supports_workingtrees = False
+
+    def get_format_description(self):
+        return "Local Git Repository (bare)"
+
+
+class LocalGitDir(GitDir):
+    """An adapter to the '.git' dir used by git."""
+
+    def _get_gitrepository_class(self):
+        from .repository import LocalGitRepository
+        return LocalGitRepository
+
+    def __repr__(self):
+        return "<%s at %r>" % (
+            self.__class__.__name__, self.root_transport.base)
+
+    _gitrepository_class = property(_get_gitrepository_class)
+
+    @property
+    def user_transport(self):
+        return self.root_transport
+
+    @property
+    def control_transport(self):
+        return self._git._controltransport
+
+    def __init__(self, transport, gitrepo, format):
+        self._format = format
+        self.root_transport = transport
+        self._mode_check_done = False
+        self._git = gitrepo
+        if gitrepo.bare:
+            self.transport = transport
+        else:
+            self.transport = transport.clone('.git')
+        self._mode_check_done = None
+
+    def is_control_filename(self, filename):
+        return (filename == '.git' or
+                filename.startswith('.git/') or
+                filename.startswith('.git\\'))
+
+    def _get_symref(self, ref):
+        from dulwich.repo import SYMREF
+        ref_chain, unused_sha = self._git.refs.follow(ref)
+        if len(ref_chain) == 1:
+            return None
+        return ref_chain[1]
+
+    def set_branch_reference(self, target_branch, name=None):
+        ref = self._get_selected_ref(name)
+        if self.control_transport.base == target_branch.controldir.control_transport.base:
+            if ref == target_branch.ref:
+                raise BranchReferenceLoop(target_branch)
+            self._git.refs.set_symbolic_ref(ref, target_branch.ref)
+        else:
+            try:
+                target_path = target_branch.controldir.control_transport.local_abspath('.')
+            except bzr_errors.NotLocalUrl:
+                raise bzr_errors.IncompatibleFormat(target_branch._format, self._format)
+            # TODO(jelmer): Do some consistency checking across branches..
+            self.control_transport.put_bytes('commondir', target_path.encode('utf-8'))
+            # TODO(jelmer): Urgh, avoid mucking about with internals.
+            self._git._commontransport = target_branch.repository._git._commontransport.clone()
+            self._git.object_store = TransportObjectStore(self._git._commontransport.clone(OBJECTDIR))
+            self._git.refs.transport = self._git._commontransport
+            target_ref_chain, unused_sha = target_branch.controldir._git.refs.follow(target_branch.ref)
+            for target_ref in target_ref_chain:
+                if target_ref == b'HEAD':
+                    continue
+                break
+            else:
+                # Can't create a reference to something that is not a in a repository.
+                raise bzr_errors.IncompatibleFormat(self.set_branch_reference, self)
+            self._git.refs.set_symbolic_ref(ref, target_ref)
+
+    def get_branch_reference(self, name=None):
+        ref = self._get_selected_ref(name)
+        target_ref = self._get_symref(ref)
+        if target_ref is not None:
+            from .refs import ref_to_branch_name
+            try:
+                branch_name = ref_to_branch_name(target_ref)
+            except ValueError:
+                params = {'ref': urllib.quote(target_ref, '')}
+            else:
+                if branch_name != b'':
+                    params = {'branch': urllib.quote(branch_name.encode('utf-8'), '')}
+                else:
+                    params = {}
+            try:
+                base_url = urlutils.local_path_to_url(self.control_transport.get_bytes('commondir')).rstrip('/.git/')+'/'
+            except bzr_errors.NoSuchFile:
+                base_url = self.user_url.rstrip('/')
+            return urlutils.join_segment_parameters(base_url, params)
+        return None
+
+    def find_branch_format(self, name=None):
+        from .branch import (
+            LocalGitBranchFormat,
+            )
+        ref = self._get_selected_ref(name)
+        return LocalGitBranchFormat()
+
+    def get_branch_transport(self, branch_format, name=None):
+        if branch_format is None:
+            return self.transport
+        if isinstance(branch_format, LocalGitControlDirFormat):
+            return self.transport
+        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
+
+    def get_repository_transport(self, format):
+        if format is None:
+            return self.transport
+        if isinstance(format, LocalGitControlDirFormat):
+            return self.transport
+        raise bzr_errors.IncompatibleFormat(format, self._format)
+
+    def get_workingtree_transport(self, format):
+        if format is None:
+            return self.transport
+        if isinstance(format, LocalGitControlDirFormat):
+            return self.transport
+        raise bzr_errors.IncompatibleFormat(format, self._format)
+
+    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=None,
+            ref=None, possible_transports=None, nascent_ok=False):
+        """'create' a branch for this dir."""
+        repo = self.find_repository()
+        from .branch import LocalGitBranch
+        ref = self._get_selected_ref(name, ref)
+        if not nascent_ok and ref not in self._git.refs:
+            raise bzr_errors.NotBranchError(self.root_transport.base,
+                    controldir=self)
+        ref_chain, unused_sha = self._git.refs.follow(ref)
+        if ref_chain[-1] == b'HEAD':
+            controldir = self
+        else:
+            controldir = self._find_commondir()
+        return LocalGitBranch(controldir, repo, ref_chain[-1])
+
+    def destroy_branch(self, name=None):
+        refname = self._get_selected_ref(name)
+        if refname == b'HEAD':
+            # HEAD can't be removed
+            raise bzr_errors.UnsupportedOperation(
+                self.destroy_branch, self)
+        try:
+            del self._git.refs[refname]
+        except KeyError:
+            raise bzr_errors.NotBranchError(self.root_transport.base,
+                    controldir=self)
+
+    def destroy_repository(self):
+        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
+
+    def destroy_workingtree(self):
+        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
+
+    def destroy_workingtree_metadata(self):
+        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree_metadata, self)
+
+    def needs_format_conversion(self, format=None):
+        return not isinstance(self._format, format.__class__)
+
+    def open_repository(self):
+        """'open' a repository for this dir."""
+        if self.control_transport.has('commondir'):
+            raise bzr_errors.NoRepositoryPresent(self)
+        return self._gitrepository_class(self)
+
+    def has_workingtree(self):
+        return not self._git.bare
+
+    def open_workingtree(self, recommend_upgrade=True, unsupported=False):
+        if not self._git.bare:
+            from dulwich.errors import NoIndexPresent
+            repo = self.find_repository()
+            from .workingtree import GitWorkingTree
+            branch = self.open_branch(ref=b'HEAD', nascent_ok=True)
+            return GitWorkingTree(self, repo, branch)
+        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
+        raise bzr_errors.NoWorkingTree(loc)
+
+    def create_repository(self, shared=False):
+        from .repository import GitRepositoryFormat
+        if shared:
+            raise bzr_errors.IncompatibleFormat(GitRepositoryFormat(), self._format)
+        return self.find_repository()
+
+    def create_branch(self, name=None, repository=None,
+                      append_revisions_only=None, ref=None):
+        refname = self._get_selected_ref(name, ref)
+        if refname != b'HEAD' and refname in self._git.refs:
+            raise bzr_errors.AlreadyBranchError(self.user_url)
+        repo = self.open_repository()
+        if refname in self._git.refs:
+            ref_chain, unused_sha = self._git.refs.follow(self._get_selected_ref(None))
+            if ref_chain[0] == b'HEAD':
+                refname = ref_chain[1]
+        from .branch import LocalGitBranch
+        branch = LocalGitBranch(self, repo, refname)
+        if append_revisions_only:
+            branch.set_append_revisions_only(append_revisions_only)
+        return branch
+
+    def backup_bzrdir(self):
+        if not self._git.bare:
+            self.root_transport.copy_tree(".git", ".git.backup")
+            return (self.root_transport.abspath(".git"),
+                    self.root_transport.abspath(".git.backup"))
+        else:
+            basename = urlutils.basename(self.root_transport.base)
+            parent = self.root_transport.clone('..')
+            parent.copy_tree(basename, basename + ".backup")
+
+    def create_workingtree(self, revision_id=None, from_branch=None,
+        accelerator_tree=None, hardlink=False):
+        if self._git.bare:
+            raise bzr_errors.UnsupportedOperation(self.create_workingtree, self)
+        if from_branch is None:
+            from_branch = self.open_branch(nascent_ok=True)
+        if revision_id is None:
+            revision_id = from_branch.last_revision()
+        repo = self.find_repository()
+        from .workingtree import GitWorkingTree
+        wt = GitWorkingTree(self, repo, from_branch)
+        wt.set_last_revision(revision_id)
+        wt._build_checkout_with_index()
+        return wt
+
+    def _find_or_create_repository(self, force_new_repo=None):
+        return self.create_repository(shared=False)
+
+    def _find_creation_modes(self):
+        """Determine the appropriate modes for files and directories.
+
+        They're always set to be consistent with the base directory,
+        assuming that this transport allows setting modes.
+        """
+        # TODO: Do we need or want an option (maybe a config setting) to turn
+        # this off or override it for particular locations? -- mbp 20080512
+        if self._mode_check_done:
+            return
+        self._mode_check_done = True
+        try:
+            st = self.transport.stat('.')
+        except bzr_errors.TransportNotPossible:
+            self._dir_mode = None
+            self._file_mode = None
+        else:
+            # Check the directory mode, but also make sure the created
+            # directories and files are read-write for this user. This is
+            # mostly a workaround for filesystems which lie about being able to
+            # write to a directory (cygwin & win32)
+            if (st.st_mode & 07777 == 00000):
+                # FTP allows stat but does not return dir/file modes
+                self._dir_mode = None
+                self._file_mode = None
+            else:
+                self._dir_mode = (st.st_mode & 07777) | 00700
+                # Remove the sticky and execute bits for files
+                self._file_mode = self._dir_mode & ~07111
+
+    def _get_file_mode(self):
+        """Return Unix mode for newly created files, or None.
+        """
+        if not self._mode_check_done:
+            self._find_creation_modes()
+        return self._file_mode
+
+    def _get_dir_mode(self):
+        """Return Unix mode for newly created directories, or None.
+        """
+        if not self._mode_check_done:
+            self._find_creation_modes()
+        return self._dir_mode
+
+    def get_refs_container(self):
+        return self._git.refs
+
+    def get_peeled(self, ref):
+        return self._git.get_peeled(ref)
+
+    def _find_commondir(self):
+        try:
+            commondir = self.control_transport.get_bytes('commondir')
+        except bzr_errors.NoSuchFile:
+            return self
+        else:
+            commondir = commondir.rstrip('/.git/')
+            return ControlDir.open_from_transport(get_transport_from_path(commondir))

=== added file 'breezy/plugins/git/directory.py'
--- breezy/plugins/git/directory.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/directory.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,30 @@
+# Copyright (C) 2012-2018 Jelmer Vernooij <[e-mail]>
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+"""Directory service for gitorious."""
+
+from __future__ import absolute_import
+
+from ... import transport
+
+transport.register_urlparse_netloc_protocol('github')
+
+class GitHubDirectory(object):
+
+    def look_up(self, name, url):
+        """See DirectoryService.look_up"""
+        return "git+ssh://[e-mail]/" + name

=== added file 'breezy/plugins/git/errors.py'
--- breezy/plugins/git/errors.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/errors.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,80 @@
+# Copyright (C) 2007 Canonical Ltd
+# Copyright (C) 2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+"""A grouping of Exceptions for bzr-git"""
+
+from __future__ import absolute_import
+
+from dulwich import errors as git_errors
+
+from ... import errors as bzr_errors
+
+
+class BzrGitError(bzr_errors.BzrError):
+    """The base-level exception for bzr-git errors."""
+
+
+class NoSuchRef(BzrGitError):
+    """Raised when a ref can not be found."""
+
+    _fmt = "The ref %(ref)s was not found in the repository at %(location)s."
+
+    def __init__(self, ref, location, present_refs=None):
+        self.ref = ref
+        self.location = location
+        self.present_refs = present_refs
+
+
+def convert_dulwich_error(error):
+    """Convert a Dulwich error to a Bazaar error."""
+
+    if isinstance(error, git_errors.HangupException):
+        raise bzr_errors.ConnectionReset(error.msg, "")
+    raise error
+
+
+class NoPushSupport(bzr_errors.BzrError):
+    _fmt = "Push is not yet supported from %(source)r to %(target)r using %(mapping)r for %(revision_id)r. Try dpush instead."
+
+    def __init__(self, source, target, mapping, revision_id=None):
+        self.source = source
+        self.target = target
+        self.mapping = mapping
+        self.revision_id = revision_id
+
+
+class GitSmartRemoteNotSupported(bzr_errors.UnsupportedOperation):
+    _fmt = "This operation is not supported by the Git smart server protocol."
+
+
+class UnknownCommitExtra(bzr_errors.BzrError):
+    _fmt = "Unknown extra fields in %(object)r: %(fields)r."
+
+    def __init__(self, object, fields):
+        bzr_errors.BzrError.__init__(self)
+        self.object = object
+        self.fields = ",".join(fields)
+
+
+class UnknownMercurialCommitExtra(bzr_errors.BzrError):
+    _fmt = "Unknown mercurial extra fields in %(object)r: %(fields)r."
+
+    def __init__(self, object, fields):
+        bzr_errors.BzrError.__init__(self)
+        self.object = object
+        self.fields = ",".join(fields)

=== added file 'breezy/plugins/git/fetch.py'
--- breezy/plugins/git/fetch.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/git/fetch.py	2018-05-10 00:44:29 +0000
@@ -0,0 +1,550 @@
+# Copyright (C) 2008-2018 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Fetching from git into bzr."""
+
+from __future__ import absolute_import
+
+from dulwich.objects import (
+    Commit,
+    Tag,
+    Tree,
+    S_IFGITLINK,
+    S_ISGITLINK,
+    ZERO_SHA,
+    )
+from dulwich.object_store import (
+    tree_lookup_path,
+    )
+from dulwich.walk import Walker
+from itertools import (
+    imap,
+    )
+import posixpath
+import stat
+
+from ... import (
+    debug,
+    errors,
+    osutils,
+    trace,
+    ui,
+    )
+from ...errors import (
+    BzrError,
+    )
+from ...bzr.inventory import (
+    InventoryDirectory,
+    InventoryFile,
+    InventoryLink,
+    TreeReference,
+    )
+from ...repository import (
+    InterRepository,
+    )
+from ...revision import (
+    NULL_REVISION,
+    )
+from ...bzr.inventorytree import InventoryRevisionTree
+from ...testament import (
+    StrictTestament3,
+    )
+from ...tsort import (
+    topo_sort,
+    )
+from ...bzr.versionedfile import (
+    ChunkedContentFactory,
+    )
+
+from .mapping import (
+    DEFAULT_FILE_MODE,
+    mode_is_executable,
+    mode_kind,
+    warn_unusual_mode,
+    )
+from .object_store import (
+    LRUTreeCache,
+    _tree_to_objects,
+    )
+from .refs import (
+    is_tag,
+    )
+from .remote import (
+    RemoteGitRepository,
+    )
+from .repository import (
+    GitRepository,
+    GitRepositoryFormat,
+    LocalGitRepository,
+    )
+
+
+def import_git_blob(texts, mapping, path, name, (base_hexsha, hexsha),
+        base_bzr_tree, parent_id, revision_id,
+        parent_bzr_trees, lookup_object, (base_mode, mode), store_updater,
+        lookup_file_id):
+    """Import a git blob object into a bzr repository.
+
+    :param texts: VersionedFiles to add to
+    :param path: Path in the tree
+    :param blob: A git blob
+    :return: Inventory delta for this file
+    """
+    if mapping.is_special_file(path):
+        return []
+    if base_hexsha == hexsha and base_mode == mode:
+        # If nothing has changed since the base revision, we're done
+        return []
+    file_id = lookup_file_id(path)
+    if stat.S_ISLNK(mode):
+        cls = InventoryLink
+    else:
+        cls = InventoryFile
+    ie = cls(file_id, name.decode("utf-8"), parent_id)
+    if ie.kind == "file":
+        ie.executable = mode_is_executable(mode)
+    if base_hexsha == hexsha and mode_kind(base_mode) == mode_kind(mode):
+        base_exec = base_bzr_tree.is_executable(path)
+        if ie.kind == "symlink":
+            ie.symlink_target = base_bzr_tree.get_symlink_target(path)
+        else:
+            ie.text_size = base_bzr_tree.get_file_size(path)
+            ie.text_sha1 = base_bzr_tree.get_file_sha1(path)
+        if ie.kind == "symlink" or ie.executable == base_exec:
+            ie.revision = base_bzr_tree.get_file_revision(path)
+        else:
+            blob = lookup_object(hexsha)
+    else:
+        blob = lookup_object(hexsha)
+        if ie.kind == "symlink":
+            ie.revision = None
+            ie.symlink_target = blob.data.decode("utf-8")
+        else:
+            ie.text_size = sum(imap(len, blob.chunked))
+            ie.text_sha1 = osutils.sha_strings(blob.chunked)
+    # Check what revision we should store
+    parent_keys = []
+    for ptree in parent_bzr_trees:
+        try:
+            ppath = ptree.id2path(file_id)
+        except errors.NoSuchId:
+            continue
+        pkind = ptree.kind(ppath, file_id)
+        if (pkind == ie.kind and
+            ((pkind == "symlink" and ptree.get_symlink_target(ppath, file_id) == ie.symlink_target) or
+             (pkind == "file" and ptree.get_file_sha1(ppath, file_id) == ie.text_sha1 and
+                ptree.is_executable(ppath, file_id) == ie.executable))):
+            # found a revision in one of the parents to use
+            ie.revision = ptree.get_file_revision(ppath, file_id)
+            break
+        parent_key = (file_id, ptree.get_file_revision(ppath, file_id))
+        if not parent_key in parent_keys:
+            parent_keys.append(parent_key)
+    if ie.revision is None:
+        # Need to store a new revision
+        ie.revision = revision_id
+        if ie.revision is None:
+            raise ValueError("no file revision set")
+        if ie.kind == 'symlink':
+            chunks = []
+        else:
+            chunks = blob.chunked
+        texts.insert_record_stream([
+            ChunkedContentFactory((file_id, ie.revision),
+                tuple(parent_keys), ie.text_sha1, chunks)])
+    invdelta = []
+    if base_hexsha is not None:
+        old_path = path.decode("utf-8") # Renames are not supported yet
+        if stat.S_ISDIR(base_mode):
+            invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
+                lookup_object(base_hexsha), [], lookup_object))
+    else:
+        old_path = None
+    new_path = path.decode("utf-8")
+    invdelta.append((old_path, new_path, file_id, ie))
+    if base_hexsha != hexsha:
+        store_updater.add_object(blob, (ie.file_id, ie.revision), path)
+    return invdelta
+
+
+class SubmodulesRequireSubtrees(BzrError):
+    _fmt = ("The repository you are fetching from contains submodules, "
+            "which require a Bazaar format that supports tree references.")
+    internal = False
+
+
+def import_git_submodule(texts, mapping, path, name, (base_hexsha, hexsha),
+    base_bzr_tree, parent_id, revision_id, parent_bzr_trees, lookup_object,
+    (base_mode, mode), store_updater, lookup_file_id):
+    """Import a git submodule."""
+    if base_hexsha == hexsha and base_mode == mode:
+        return [], {}
+    file_id = lookup_file_id(path)
+    invdelta = []
+    ie = TreeReference(file_id, name.decode("utf-8"), parent_id)
+    ie.revision = revision_id
+    if base_hexsha is not None:
+        old_path = path.decode("utf-8") # Renames are not supported yet
+        if stat.S_ISDIR(base_mode):
+            invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
+                lookup_object(base_hexsha), [], lookup_object))
+    else:
+        old_path = None
+    ie.reference_revision = mapping.revision_id_foreign_to_bzr(hexsha)
+    texts.insert_record_stream([
+        ChunkedContentFactory((file_id, ie.revision), (), None, [])])
+    invdelta.append((old_path, path, file_id, ie))
+    return invdelta, {}
+
+
+def remove_disappeared_children(base_bzr_tree, path, base_tree, existing_children,
+        lookup_object):
+    """Generate an inventory delta for removed children.
+
+    :param base_bzr_tree: Base bzr tree against which to generate the
+        inventory delta.
+    :param path: Path to process (unicode)
+    :param base_tree: Git Tree base object
+    :param existing_children: Children that still exist
+    :param lookup_object: Lookup a git object by its SHA1
+    :return: Inventory delta, as list
+    """
+    if type(path) is not unicode:
+        raise TypeError(path)
+    ret = []
+    for name, mode, hexsha in base_tree.iteritems():
+        if name in existing_children:
+            continue
+        c_path = posixpath.join(path, name.decode("utf-8"))
+        file_id = base_bzr_tree.path2id(c_path)
+        if file_id is None:
+            raise TypeError(file_id)
+        ret.append((c_path, None, file_id, None))
+        if stat.S_ISDIR(mode):
+            ret.extend(remove_disappeared_children(
+                base_bzr_tree, c_path, lookup_object(hexsha), [], lookup_object))
+    return ret
+
+
+def import_git_tree(texts, mapping, path, name, (base_hexsha, hexsha),
+        base_bzr_tree, parent_id, revision_id, parent_bzr_trees,
+        lookup_object, (base_mode, mode), store_updater,
+        lookup_file_id, allow_submodules=False):
+    """Import a git tree object into a bzr repository.
+
+    :param texts: VersionedFiles object to add to
+    :param path: Path in the tree (str)
+    :param name: Name of the tree (str)
+    :param tree: A git tree object
+    :param base_bzr_tree: Base inventory against which to return inventory delta
+    :return: Inventory delta for this subtree
+    """
+    if type(path) is not str:
+        raise TypeError(path)
+    if type(name) is not str:
+        raise TypeError(name)
+    if base_hexsha == hexsha and base_mode == mode:
+        # If nothing has changed since the base revision, we're done
+        return [], {}
+    invdelta = []
+    file_id = lookup_file_id(path)
+    # We just have to hope this is indeed utf-8:
+    ie = InventoryDirectory(file_id, name.decode("utf-8"), parent_id)
+    tree = lookup_object(hexsha)
+    if base_hexsha is None:
+        base_tree = None
+        old_path = None # Newly appeared here
+    else:
+        base_tree = lookup_object(base_hexsha)
+        old_path = path.decode("utf-8") # Renames aren't supported yet
+    new_path = path.decode("utf-8")
+    if base_tree is None or type(base_tree) is not Tree:
+        ie.revision = revision_id
+        invdelta.append((old_path, new_path, ie.file_id, ie))
+        texts.insert_record_stream([
+            ChunkedContentFactory((ie.file_id, ie.revision), (), None, [])])
+    # Remember for next time
+    existing_children = set()
+    child_modes = {}
+    for name, child_mode, child_hexsha in tree.iteritems():
+        existing_children.add(name)
+        child_path = posixpath.join(path, name)
+        if type(base_tree) is Tree:
+            try:
+                child_base_mode, child_base_hexsha = base_tree[name]
+            except KeyError:
+                child_base_hexsha = None
+                child_base_mode = 0
+        else:
+            child_base_hexsha = None
+            child_base_mode = 0
+        if stat.S_ISDIR(child_mode):
+            subinvdelta, grandchildmodes = import_git_tree(texts, mapping,
+                child_path, name, (child_base_hexsha, child_hexsha),
+                base_bzr_tree, file_id, revision_id, parent_bzr_trees,
+                lookup_object, (child_base_mode, child_mode), store_updater,
+                lookup_file_id, allow_submodules=allow_submodules)
+        elif S_ISGITLINK(child_mode): # submodule
+            if not allow_submodules:
+                raise SubmodulesRequireSubtrees()
+            subinvdelta, grandchildmodes = import_git_submodule(texts, mapping,
+                child_path, name, (child_base_hexsha, child_hexsha),
+                base_bzr_tree, file_id, revision_id, parent_bzr_trees,
+                lookup_object, (child_base_mode, child_mode), store_updater,
+                lookup_file_id)
+        else:
+            if not mapping.is_special_file(name):
+                subinvdelta = import_git_blob(texts, mapping, child_path, name,
+                    (child_base_hexsha, child_hexsha), base_bzr_tree, file_id,
+                    revision_id, parent_bzr_trees, lookup_object,
+                    (child_base_mode, child_mode), store_updater, lookup_file_id)
+            else:
+                subinvdelta = []
+            grandchildmodes = {}
+        child_modes.update(grandchildmodes)
+        invdelta.extend(subinvdelta)
+        if child_mode not in (stat.S_IFDIR, DEFAULT_FILE_MODE,
+                        stat.S_IFLNK, DEFAULT_FILE_MODE|0111,
+                        S_IFGITLINK):
+            child_modes[child_path] = child_mode
+    # Remove any children that have disappeared
+    if base_tree is not None and type(base_tree) is Tree:
+        invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
+            base_tree, existing_children, lookup_object))
+    store_updater.add_object(tree, (file_id, revision_id), path)
+    return invdelta, child_modes
+
+
+def verify_commit_reconstruction(target_git_object_retriever, lookup_object,
+    o, rev, ret_tree, parent_trees, mapping, unusual_modes, verifiers):
+    new_unusual_modes = mapping.export_unusual_file_modes(rev)
+    if new_unusual_modes != unusual_modes:
+        raise AssertionError("unusual modes don't match: %r != %r" % (
+            unusual_modes, new_unusual_modes))
+    # Verify that we can reconstruct the commit properly
+    rec_o = target_git_object_retriever._reconstruct_commit(rev, o.tree, True,
+        verifiers)
+    if rec_o != o:
+        raise AssertionError("Reconstructed commit differs: %r != %r" % (
+            rec_o, o))
+    diff = []
+    new_objs = {}
+    for path, obj, ie in _tree_to_objects(ret_tree, parent_trees,
+        target_git_object_retriever._cache.idmap, unusual_modes,
+        mapping.BZR_DUMMY_FILE):
+        old_obj_id = tree_lookup_path(lookup_object, o.tree, path)[1]
+        new_objs[path] = obj
+        if obj.id != old_obj_id:
+            diff.append((path, lookup_object(old_obj_id), obj))
+    for (path, old_obj, new_obj) in diff:
+        while (old_obj.type_name == "tree" and
+               new_obj.type_name == "tree" and
+               sorted(old_obj) == sorted(new_obj)):
+            for name in old_obj:
+                if old_obj[name][0] != new_obj[name][0]:
+                    raise AssertionError("Modes for %s differ: %o != %o" %
+                        (path, old_obj[name][0], new_obj[name][0]))
+                if old_obj[name][1] != new_obj[name][1]:
+                    # Found a differing child, delve deeper
+                    path = posixpath.join(path, name)
+                    old_obj = lookup_object(old_obj[name][1])
+                    new_obj = new_objs[path]
+                    break
+        raise AssertionError("objects differ for %s: %r != %r" % (path,
+            old_obj, new_obj))
+
+
+def ensure_inventories_in_repo(repo, trees):
+    real_inv_vf = repo.inventories.without_fallbacks()
+    for t in trees:
+        revid = t.get_revision_id()
+        if not real_inv_vf.get_parent_map([(revid, )]):
+            repo.add_inventory(revid, t.inventory, t.get_parent_ids())
+
+
+def import_git_commit(repo, mapping, head, lookup_object,
+                      target_git_object_retriever, trees_cache):
+    o = lookup_object(head)
+    # Note that this uses mapping.revision_id_foreign_to_bzr. If the parents
+    # were bzr roundtripped revisions they would be specified in the
+    # roundtrip data.
+    rev, roundtrip_revid, verifiers = mapping.import_commit(
+        o, mapping.revision_id_foreign_to_bzr)
+    if roundtrip_revid is not None:
+        original_revid = rev.revision_id
+        rev.revision_id = roundtrip_revid
+    # We have to do this here, since we have to walk the tree and
+    # we need to make sure to import the blobs / trees with the right
+    # path; this may involve adding them more than once.
+    parent_trees = trees_cache.revision_trees(rev.parent_ids)
+    ensure_inventories_in_repo(repo, parent_trees)
+    if parent_trees == []:
+        base_bzr_tree = trees_cache.revision_tree(NULL_REVISION)
+        base_tree = None
+        base_mode = None
+    else:
+        base_bzr_tree = parent_trees[0]
+        base_tree = lookup_object(o.parents[0]).tree
+        base_mode = stat.S_IFDIR
+    store_updater = target_git_object_retriever._get_updater(rev)
+    tree_supplement = mapping.get_fileid_map(lookup_object, o.tree)
+    inv_delta, unusual_modes = import_git_tree(repo.texts,
+            mapping, "", "", (base_tree, o.tree), base_bzr_tree,
+            None, rev.revision_id, parent_trees,
+            lookup_object, (base_mode, stat.S_IFDIR), store_updater,
+            tree_supplement.lookup_file_id,
+            allow_submodules=getattr(repo._format, "supports_tree_reference",
+                False))
+    if unusual_modes != {}:
+        for path, mode in unusual_modes.iteritems():
+            warn_unusual_mode(rev.foreign_revid, path, mode)
+        mapping.import_unusual_file_modes(rev, unusual_modes)
+    try:
+        basis_id = rev.parent_ids[0]
+    except IndexError:
+        basis_id = NULL_REVISION
+        base_bzr_inventory = None
+    else:
+        try:
+            base_bzr_inventory = base_bzr_tree.root_inventory
+        except AttributeError: # bzr < 2.6
+            base_bzr_inventory = base_bzr_tree.inventory
+    rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
+              inv_delta, rev.revision_id, rev.parent_ids,
+              base_bzr_inventory)
+    ret_tree = InventoryRevisionTree(repo, inv, rev.revision_id)
+    # Check verifiers
+    if verifiers and roundtrip_revid is not None:
+        testament = StrictTestament3(rev, ret_tree)
+        calculated_verifiers = { "testament3-sha1": testament.as_sha1() }
+        if calculated_verifiers != verifiers:
+            trace.mutter("Testament SHA1 %r for %r did not match %r.",