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