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