/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to fetch.py

Move commands to a separate python module and register them lazily.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fetch.py
1
 
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
 
1
# Copyright (C) 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from cStringIO import (
18
 
    StringIO,
19
 
    )
 
17
from bzrlib import osutils, ui, urlutils
 
18
from bzrlib.errors import InvalidRevisionId
 
19
from bzrlib.inventory import Inventory
 
20
from bzrlib.repository import InterRepository
 
21
from bzrlib.trace import info
 
22
from bzrlib.tsort import topo_sort
 
23
 
 
24
from bzrlib.plugins.git.repository import (
 
25
        LocalGitRepository, 
 
26
        GitRepository, 
 
27
        GitFormat,
 
28
        )
 
29
from bzrlib.plugins.git.remote import RemoteGitRepository
 
30
 
20
31
import dulwich as git
21
 
from dulwich.objects import (
22
 
    Commit,
23
 
    Tag,
24
 
    )
25
 
from dulwich.object_store import (
26
 
    tree_lookup_path,
27
 
    )
28
 
import stat
29
 
 
30
 
from bzrlib import (
31
 
    debug,
32
 
    osutils,
33
 
    trace,
34
 
    ui,
35
 
    urlutils,
36
 
    )
37
 
from bzrlib.errors import (
38
 
    InvalidRevisionId,
39
 
    NoSuchId,
40
 
    NoSuchRevision,
41
 
    )
42
 
from bzrlib.inventory import (
43
 
    Inventory,
44
 
    InventoryDirectory,
45
 
    InventoryFile,
46
 
    InventoryLink,
47
 
    )
48
 
from bzrlib.lru_cache import (
49
 
    LRUCache,
50
 
    )
51
 
from bzrlib.repository import (
52
 
    InterRepository,
53
 
    )
54
 
from bzrlib.revision import (
55
 
    NULL_REVISION,
56
 
    )
57
 
from bzrlib.tsort import (
58
 
    topo_sort,
59
 
    )
60
 
from bzrlib.versionedfile import (
61
 
    FulltextContentFactory,
62
 
    )
63
 
 
64
 
from bzrlib.plugins.git.mapping import (
65
 
    DEFAULT_FILE_MODE,
66
 
    inventory_to_tree_and_blobs,
67
 
    mode_is_executable,
68
 
    text_to_blob,
69
 
    warn_unusual_mode,
70
 
    )
71
 
from bzrlib.plugins.git.object_store import (
72
 
    BazaarObjectStore,
73
 
    )
74
 
from bzrlib.plugins.git.remote import (
75
 
    RemoteGitRepository,
76
 
    )
77
 
from bzrlib.plugins.git.repository import (
78
 
    GitRepository, 
79
 
    GitRepositoryFormat,
80
 
    LocalGitRepository,
81
 
    )
82
 
 
83
 
 
84
 
def import_git_blob(texts, mapping, path, hexsha, base_inv, parent_id, 
85
 
    revision_id, parent_invs, shagitmap, lookup_object, executable, symlink):
 
32
from dulwich.client import SimpleFetchGraphWalker
 
33
from dulwich.objects import Commit
 
34
 
 
35
from cStringIO import StringIO
 
36
 
 
37
 
 
38
class BzrFetchGraphWalker(object):
 
39
    """GraphWalker implementation that uses a Bazaar repository."""
 
40
 
 
41
    def __init__(self, repository, mapping):
 
42
        self.repository = repository
 
43
        self.mapping = mapping
 
44
        self.done = set()
 
45
        self.heads = set(repository.all_revision_ids())
 
46
        self.parents = {}
 
47
 
 
48
    def __iter__(self):
 
49
        return iter(self.next, None)
 
50
 
 
51
    def ack(self, sha):
 
52
        revid = self.mapping.revision_id_foreign_to_bzr(sha)
 
53
        self.remove(revid)
 
54
 
 
55
    def remove(self, revid):
 
56
        self.done.add(revid)
 
57
        if revid in self.heads:
 
58
            self.heads.remove(revid)
 
59
        if revid in self.parents:
 
60
            for p in self.parents[revid]:
 
61
                self.remove(p)
 
62
 
 
63
    def next(self):
 
64
        while self.heads:
 
65
            ret = self.heads.pop()
 
66
            ps = self.repository.get_parent_map([ret])[ret]
 
67
            self.parents[ret] = ps
 
68
            self.heads.update([p for p in ps if not p in self.done])
 
69
            try:
 
70
                self.done.add(ret)
 
71
                return self.mapping.revision_id_bzr_to_foreign(ret)[0]
 
72
            except InvalidRevisionId:
 
73
                pass
 
74
        return None
 
75
 
 
76
 
 
77
def import_git_blob(repo, mapping, path, blob, inv, parent_invs, executable):
86
78
    """Import a git blob object into a bzr repository.
87
79
 
88
 
    :param texts: VersionedFiles to add to
 
80
    :param repo: bzr repository
89
81
    :param path: Path in the tree
90
82
    :param blob: A git blob
91
 
    :return: Inventory delta for this file
92
83
    """
93
84
    file_id = mapping.generate_file_id(path)
94
 
    if symlink:
95
 
        cls = InventoryLink
96
 
    else:
97
 
        cls = InventoryFile
98
 
    # We just have to hope this is indeed utf-8:
99
 
    ie = cls(file_id, urlutils.basename(path).decode("utf-8"), parent_id)
 
85
    text_revision = inv.revision_id
 
86
    repo.texts.add_lines((file_id, text_revision),
 
87
        [(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
 
88
        osutils.split_lines(blob.data))
 
89
    ie = inv.add_path(path, "file", file_id)
 
90
    ie.revision = text_revision
 
91
    ie.text_size = len(blob.data)
 
92
    ie.text_sha1 = osutils.sha_string(blob.data)
100
93
    ie.executable = executable
101
 
    ie.text_id = hexsha
102
 
    # See if this has changed at all
103
 
    try:
104
 
        base_ie = base_inv[file_id]
105
 
    except NoSuchId:
106
 
        base_ie = None
107
 
        base_sha = None
108
 
    else:
109
 
        base_sha = base_ie.text_id
110
 
        try:
111
 
            if base_sha is None:
112
 
                base_sha = shagitmap.lookup_blob(file_id, base_ie.revision)
113
 
        except KeyError:
114
 
            base_sha = None
115
 
        else:
116
 
            if (base_sha == hexsha and base_ie.executable == ie.executable
117
 
                and base_ie.kind == ie.kind):
118
 
                # If nothing has changed since the base revision, we're done
119
 
                return [], []
120
 
    if base_sha == hexsha and base_ie.kind == ie.kind:
121
 
        ie.text_size = base_ie.text_size
122
 
        ie.text_sha1 = base_ie.text_sha1
123
 
        ie.symlink_target = base_ie.symlink_target
124
 
        ie.revision = base_ie.revision
125
 
    else:
126
 
        blob = lookup_object(hexsha)
127
 
        if ie.kind == "symlink":
128
 
            ie.symlink_target = blob.data
129
 
            ie.text_size = None
130
 
            ie.text_sha1 = None
131
 
        else:
132
 
            ie.text_size = len(blob.data)
133
 
            ie.text_sha1 = osutils.sha_string(blob.data)
134
 
    # Check what revision we should store
135
 
    parent_keys = []
136
 
    for pinv in parent_invs:
137
 
        if pinv.revision_id == base_inv.revision_id:
138
 
            pie = base_ie
139
 
            if pie is None:
140
 
                continue
141
 
        else:
142
 
            try:
143
 
                pie = pinv[file_id]
144
 
            except NoSuchId:
145
 
                continue
146
 
        if pie.text_sha1 == ie.text_sha1:
147
 
            # found a revision in one of the parents to use
148
 
            ie.revision = pie.revision
149
 
            break
150
 
        parent_keys.append((file_id, pie.revision))
151
 
    if ie.revision is None:
152
 
        # Need to store a new revision
153
 
        ie.revision = revision_id
154
 
        assert file_id is not None
155
 
        assert ie.revision is not None
156
 
        texts.insert_record_stream([FulltextContentFactory((file_id, ie.revision), tuple(parent_keys), ie.text_sha1, blob.data)])
157
 
        shamap = [(hexsha, "blob", (ie.file_id, ie.revision))]
158
 
    else:
159
 
        shamap = []
160
 
    if file_id in base_inv:
161
 
        old_path = base_inv.id2path(file_id)
162
 
    else:
163
 
        old_path = None
164
 
    return ([(old_path, path, file_id, ie)], shamap)
165
 
 
166
 
 
167
 
def import_git_tree(texts, mapping, path, hexsha, base_inv, parent_id, 
168
 
    revision_id, parent_invs, shagitmap, lookup_object):
 
94
 
 
95
 
 
96
def import_git_tree(repo, mapping, path, tree, inv, parent_invs, lookup_object):
169
97
    """Import a git tree object into a bzr repository.
170
98
 
171
 
    :param texts: VersionedFiles object to add to
 
99
    :param repo: A Bzr repository object
172
100
    :param path: Path in the tree
173
101
    :param tree: A git tree object
174
 
    :param base_inv: Base inventory against which to return inventory delta
175
 
    :return: Inventory delta for this subtree
 
102
    :param inv: Inventory object
176
103
    """
177
 
    invdelta = []
178
104
    file_id = mapping.generate_file_id(path)
179
 
    # We just have to hope this is indeed utf-8:
180
 
    ie = InventoryDirectory(file_id, urlutils.basename(path.decode("utf-8")), 
181
 
        parent_id)
182
 
    ie.text_id = hexsha
183
 
    try:
184
 
        base_ie = base_inv[file_id]
185
 
    except NoSuchId:
186
 
        # Newly appeared here
187
 
        base_ie = None
188
 
        ie.revision = revision_id
189
 
        texts.add_lines((file_id, ie.revision), (), [])
190
 
        invdelta.append((None, path, file_id, ie))
191
 
    else:
192
 
        base_sha = base_ie.text_id
193
 
        # See if this has changed at all
194
 
        try:
195
 
            if base_sha is None:
196
 
                base_sha = shagitmap.lookup_tree(file_id, base_inv.revision_id)
197
 
        except KeyError:
198
 
            pass
199
 
        else:
200
 
            if base_sha == hexsha:
201
 
                # If nothing has changed since the base revision, we're done
202
 
                return [], {}, []
203
 
    # Remember for next time
204
 
    existing_children = set()
205
 
    child_modes = {}
206
 
    shamap = []
207
 
    tree = lookup_object(hexsha)
208
 
    for mode, name, child_hexsha in tree.entries():
 
105
    text_revision = inv.revision_id
 
106
    repo.texts.add_lines((file_id, text_revision),
 
107
        [(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
 
108
        [])
 
109
    ie = inv.add_path(path, "directory", file_id)
 
110
    ie.revision = text_revision
 
111
    for mode, name, hexsha in tree.entries():
 
112
        entry_kind = (mode & 0700000) / 0100000
209
113
        basename = name.decode("utf-8")
210
 
        existing_children.add(basename)
211
 
        child_path = osutils.pathjoin(path, name)
212
 
        if stat.S_ISDIR(mode):
213
 
            subinvdelta, grandchildmodes, subshamap = import_git_tree(texts, 
214
 
                    mapping, child_path, child_hexsha, base_inv, file_id, 
215
 
                    revision_id, parent_invs, shagitmap, lookup_object)
216
 
            invdelta.extend(subinvdelta)
217
 
            child_modes.update(grandchildmodes)
218
 
            shamap.extend(subshamap)
219
 
        else:
220
 
            subinvdelta, subshamap = import_git_blob(texts, mapping, 
221
 
                    child_path, child_hexsha, base_inv, file_id, revision_id, 
222
 
                    parent_invs, shagitmap, lookup_object, 
223
 
                    mode_is_executable(mode), stat.S_ISLNK(mode))
224
 
            invdelta.extend(subinvdelta)
225
 
            shamap.extend(subshamap)
226
 
        if mode not in (stat.S_IFDIR, DEFAULT_FILE_MODE,
227
 
                        stat.S_IFLNK, DEFAULT_FILE_MODE|0111):
228
 
            child_modes[child_path] = mode
229
 
    # Remove any children that have disappeared
230
 
    if base_ie is not None and base_ie.kind == 'directory':
231
 
        deletable = [v for k,v in base_ie.children.iteritems() if k not in existing_children]
232
 
        while deletable:
233
 
            ie = deletable.pop()
234
 
            invdelta.append((base_inv.id2path(ie.file_id), None, ie.file_id, None))
235
 
            if ie.kind == "directory":
236
 
                deletable.extend(ie.children.values())
237
 
    shamap.append((hexsha, "tree", (file_id, revision_id)))
238
 
    return invdelta, child_modes, shamap
239
 
 
240
 
 
241
 
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever, 
242
 
        heads, pb=None):
 
114
        if path == "":
 
115
            child_path = name
 
116
        else:
 
117
            child_path = urlutils.join(path, name)
 
118
        if entry_kind == 0:
 
119
            tree = lookup_object(hexsha)
 
120
            import_git_tree(repo, mapping, child_path, tree, inv, parent_invs, lookup_object)
 
121
        elif entry_kind == 1:
 
122
            blob = lookup_object(hexsha)
 
123
            fs_mode = mode & 0777
 
124
            import_git_blob(repo, mapping, child_path, blob, inv, parent_invs, bool(fs_mode & 0111))
 
125
        else:
 
126
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
 
127
 
 
128
 
 
129
def import_git_objects(repo, mapping, num_objects, object_iter, pb=None):
243
130
    """Import a set of git objects into a bzr repository.
244
131
 
245
 
    :param repo: Target Bazaar repository
 
132
    :param repo: Bazaar repository
246
133
    :param mapping: Mapping to use
 
134
    :param num_objects: Number of objects.
247
135
    :param object_iter: Iterator over Git objects.
248
136
    """
249
 
    def lookup_object(sha):
250
 
        try:
251
 
            return object_iter[sha]
252
 
        except KeyError:
253
 
            return target_git_object_retriever[sha]
254
137
    # TODO: a more (memory-)efficient implementation of this
 
138
    objects = {}
 
139
    for i, (o, _) in enumerate(object_iter):
 
140
        if pb is not None:
 
141
            pb.update("fetching objects", i, num_objects) 
 
142
        objects[o.id] = o
255
143
    graph = []
256
144
    root_trees = {}
257
145
    revisions = {}
258
 
    checked = set()
259
 
    heads = list(heads)
260
 
    parent_invs_cache = LRUCache(50)
261
146
    # Find and convert commit objects
262
 
    while heads:
263
 
        if pb is not None:
264
 
            pb.update("finding revisions to fetch", len(graph), None)
265
 
        head = heads.pop()
266
 
        assert isinstance(head, str)
267
 
        try:
268
 
            o = lookup_object(head)
269
 
        except KeyError:
270
 
            continue
 
147
    for o in objects.itervalues():
271
148
        if isinstance(o, Commit):
272
149
            rev = mapping.import_commit(o)
273
 
            if repo.has_revision(rev.revision_id):
274
 
                continue
275
 
            root_trees[rev.revision_id] = o.tree
 
150
            root_trees[rev.revision_id] = objects[o.tree]
276
151
            revisions[rev.revision_id] = rev
277
152
            graph.append((rev.revision_id, rev.parent_ids))
278
 
            target_git_object_retriever._idmap.add_entry(o.id, "commit", 
279
 
                    (rev.revision_id, o.tree))
280
 
            heads.extend([p for p in o.parents if p not in checked])
281
 
        elif isinstance(o, Tag):
282
 
            heads.append(o.object[1])
283
 
        else:
284
 
            trace.warning("Unable to import head object %r" % o)
285
 
        checked.add(head)
286
153
    # Order the revisions
287
154
    # Create the inventory objects
288
155
    for i, revid in enumerate(topo_sort(graph)):
289
156
        if pb is not None:
290
157
            pb.update("fetching revisions", i, len(graph))
 
158
        root_tree = root_trees[revid]
291
159
        rev = revisions[revid]
292
160
        # We have to do this here, since we have to walk the tree and 
293
 
        # we need to make sure to import the blobs / trees with the right 
 
161
        # we need to make sure to import the blobs / trees with the riht 
294
162
        # path; this may involve adding them more than once.
295
 
        parent_invs = []
296
 
        for parent_id in rev.parent_ids:
297
 
            try:
298
 
                parent_invs.append(parent_invs_cache[parent_id])
299
 
            except KeyError:
300
 
                parent_inv = repo.get_inventory(parent_id)
301
 
                parent_invs.append(parent_inv)
302
 
                parent_invs_cache[parent_id] = parent_inv
303
 
        if parent_invs == []:
304
 
            base_inv = Inventory(root_id=None)
305
 
        else:
306
 
            base_inv = parent_invs[0]
307
 
        inv_delta, unusual_modes, shamap = import_git_tree(repo.texts, 
308
 
                mapping, "", root_trees[revid], base_inv, None, revid, 
309
 
                parent_invs, target_git_object_retriever._idmap, lookup_object)
310
 
        target_git_object_retriever._idmap.add_entries(shamap)
311
 
        if unusual_modes != {}:
312
 
            for path, mode in unusual_modes.iteritems():
313
 
                warn_unusual_mode(rev.foreign_revid, path, mode)
314
 
        try:
315
 
            basis_id = rev.parent_ids[0]
316
 
        except IndexError:
317
 
            basis_id = NULL_REVISION
318
 
        rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
319
 
                  inv_delta, rev.revision_id, rev.parent_ids)
320
 
        parent_invs_cache[rev.revision_id] = inv
321
 
        repo.add_revision(rev.revision_id, rev)
322
 
        if "verify" in debug.debug_flags:
323
 
            objs = inventory_to_tree_and_blobs(inv, repo.texts, mapping)
324
 
            for sha1, newobj, path in objs:
325
 
                assert path is not None
326
 
                oldobj = tree_lookup_path(lookup_object, root_trees[revid], path)
327
 
                assert oldobj == newobj, "%r != %r in %s" % (oldobj, newobj, path)
328
 
 
329
 
    target_git_object_retriever._idmap.commit()
330
 
 
331
 
 
332
 
class InterGitRepository(InterRepository):
333
 
 
334
 
    _matching_repo_format = GitRepositoryFormat()
 
163
        inv = Inventory()
 
164
        inv.revision_id = rev.revision_id
 
165
        def lookup_object(sha):
 
166
            if sha in objects:
 
167
                return objects[sha]
 
168
            return reconstruct_git_object(repo, mapping, sha)
 
169
        parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
 
170
        import_git_tree(repo, mapping, "", root_tree, inv, parent_invs, 
 
171
            lookup_object)
 
172
        repo.add_revision(rev.revision_id, rev, inv)
 
173
 
 
174
 
 
175
def reconstruct_git_commit(repo, rev):
 
176
    raise NotImplementedError(self.reconstruct_git_commit)
 
177
 
 
178
 
 
179
def reconstruct_git_object(repo, mapping, sha):
 
180
    # Commit
 
181
    revid = mapping.revision_id_foreign_to_bzr(sha)
 
182
    try:
 
183
        rev = repo.get_revision(revid)
 
184
    except NoSuchRevision:
 
185
        pass
 
186
    else:
 
187
        return reconstruct_git_commit(rev)
 
188
 
 
189
    # TODO: Tree
 
190
    # TODO: Blob
 
191
    raise KeyError("No such object %s" % sha)
 
192
 
 
193
 
 
194
class InterGitNonGitRepository(InterRepository):
 
195
 
 
196
    _matching_repo_format = GitFormat()
335
197
 
336
198
    @staticmethod
337
199
    def _get_repo_format_to_test():
341
203
        """See InterRepository.copy_content."""
342
204
        self.fetch(revision_id, pb, find_ghosts=False)
343
205
 
344
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, mapping=None,
345
 
            fetch_spec=None):
346
 
        self.fetch_refs(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts,
347
 
                mapping=mapping, fetch_spec=fetch_spec)
348
 
 
349
 
 
350
 
class InterGitNonGitRepository(InterGitRepository):
351
 
    """Base InterRepository that copies revisions from a Git into a non-Git 
352
 
    repository."""
353
 
 
354
 
    def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False, 
355
 
              mapping=None, fetch_spec=None):
 
206
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
 
207
              mapping=None):
356
208
        if mapping is None:
357
209
            mapping = self.source.get_mapping()
358
 
        if revision_id is not None:
359
 
            interesting_heads = [revision_id]
360
 
        elif fetch_spec is not None:
361
 
            interesting_heads = fetch_spec.heads
362
 
        else:
363
 
            interesting_heads = None
364
 
        self._refs = {}
365
 
        def determine_wants(refs):
366
 
            self._refs = refs
367
 
            if interesting_heads is None:
368
 
                ret = [sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")]
 
210
        def progress(text):
 
211
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
 
212
        def determine_wants(heads):
 
213
            if revision_id is None:
 
214
                ret = heads.values()
369
215
            else:
370
 
                ret = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in interesting_heads if revid not in (None, NULL_REVISION)]
 
216
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
371
217
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
372
 
        self.fetch_objects(determine_wants, mapping, pb)
373
 
        return self._refs
374
 
 
375
 
 
376
 
class InterRemoteGitNonGitRepository(InterGitNonGitRepository):
377
 
    """InterRepository that copies revisions from a remote Git into a non-Git 
378
 
    repository."""
379
 
 
380
 
    def fetch_objects(self, determine_wants, mapping, pb=None):
381
 
        def progress(text):
382
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
383
 
        store = BazaarObjectStore(self.target, mapping)
384
 
        self.target.lock_write()
385
 
        try:
386
 
            heads = self.target.get_graph().heads(self.target.all_revision_ids())
387
 
            graph_walker = store.get_graph_walker(
388
 
                    [store._lookup_revision_sha1(head) for head in heads])
389
 
            recorded_wants = []
390
 
 
391
 
            def record_determine_wants(heads):
392
 
                wants = determine_wants(heads)
393
 
                recorded_wants.extend(wants)
394
 
                return wants
395
 
        
396
 
            create_pb = None
397
 
            if pb is None:
398
 
                create_pb = pb = ui.ui_factory.nested_progress_bar()
399
 
            try:
400
 
                self.target.start_write_group()
401
 
                try:
402
 
                    objects_iter = self.source.fetch_objects(
403
 
                                record_determine_wants, graph_walker, 
404
 
                                store.get_raw, progress)
405
 
                    import_git_objects(self.target, mapping, objects_iter, 
406
 
                            store, recorded_wants, pb)
407
 
                finally:
408
 
                    self.target.commit_write_group()
409
 
            finally:
410
 
                if create_pb:
411
 
                    create_pb.finished()
412
 
        finally:
413
 
            self.target.unlock()
414
 
 
415
 
    @staticmethod
416
 
    def is_compatible(source, target):
417
 
        """Be compatible with GitRepository."""
418
 
        # FIXME: Also check target uses VersionedFile
419
 
        return (isinstance(source, RemoteGitRepository) and 
420
 
                target.supports_rich_root() and
421
 
                not isinstance(target, GitRepository))
422
 
 
423
 
 
424
 
class InterLocalGitNonGitRepository(InterGitNonGitRepository):
425
 
    """InterRepository that copies revisions from a local Git into a non-Git 
426
 
    repository."""
427
 
 
428
 
    def fetch_objects(self, determine_wants, mapping, pb=None):
429
 
        wants = determine_wants(self.source._git.get_refs())
 
218
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
430
219
        create_pb = None
431
220
        if pb is None:
432
221
            create_pb = pb = ui.ui_factory.nested_progress_bar()
433
 
        target_git_object_retriever = BazaarObjectStore(self.target, mapping)
434
222
        try:
435
223
            self.target.lock_write()
436
224
            try:
437
225
                self.target.start_write_group()
438
226
                try:
439
 
                    import_git_objects(self.target, mapping, 
440
 
                            self.source._git.object_store, 
441
 
                            target_git_object_retriever, wants, pb)
 
227
                    (num_objects, objects_iter) = \
 
228
                            self.source.fetch_objects(determine_wants, 
 
229
                                graph_walker, progress)
 
230
                    import_git_objects(self.target, mapping, num_objects, 
 
231
                                       objects_iter, pb)
442
232
                finally:
443
233
                    self.target.commit_write_group()
444
234
            finally:
451
241
    def is_compatible(source, target):
452
242
        """Be compatible with GitRepository."""
453
243
        # FIXME: Also check target uses VersionedFile
454
 
        return (isinstance(source, LocalGitRepository) and 
 
244
        return (isinstance(source, GitRepository) and 
455
245
                target.supports_rich_root() and
456
246
                not isinstance(target, GitRepository))
457
247
 
458
248
 
459
 
class InterGitGitRepository(InterGitRepository):
460
 
    """InterRepository that copies between Git repositories."""
461
 
 
462
 
    def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False, 
463
 
              mapping=None, fetch_spec=None, branches=None):
 
249
class InterGitRepository(InterRepository):
 
250
 
 
251
    _matching_repo_format = GitFormat()
 
252
 
 
253
    @staticmethod
 
254
    def _get_repo_format_to_test():
 
255
        return None
 
256
 
 
257
    def copy_content(self, revision_id=None, pb=None):
 
258
        """See InterRepository.copy_content."""
 
259
        self.fetch(revision_id, pb, find_ghosts=False)
 
260
 
 
261
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
 
262
              mapping=None):
464
263
        if mapping is None:
465
264
            mapping = self.source.get_mapping()
466
265
        def progress(text):
467
 
            trace.info("git: %s", text)
 
266
            info("git: %s", text)
468
267
        r = self.target._git
469
 
        if revision_id is not None:
 
268
        if revision_id is None:
 
269
            determine_wants = lambda x: [y for y in x.values() if not y in r.object_store]
 
270
        else:
470
271
            args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
471
 
        elif fetch_spec is not None:
472
 
            args = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in fetch_spec.heads]
473
 
        if branches is not None:
474
 
            determine_wants = lambda x: [x[y] for y in branches if not x[y] in r.object_store]
475
 
        elif fetch_spec is None and revision_id is None:
476
 
            determine_wants = r.object_store.determine_wants_all
477
 
        else:
478
272
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
479
273
 
480
 
        graphwalker = r.get_graph_walker()
481
 
        f, commit = r.object_store.add_thin_pack()
 
274
        graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
 
275
        f, commit = r.object_store.add_pack()
482
276
        try:
483
 
            refs = self.source.fetch_pack(determine_wants, graphwalker,
484
 
                                          f.write, progress)
 
277
            self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
 
278
            f.close()
485
279
            commit()
486
 
            return refs
487
280
        except:
488
281
            f.close()
489
282
            raise