/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

Add basic infrastructure for dpush.

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