/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

Keep inventory entry children around once we've fetched them.

Show diffs side-by-side

added added

removed removed

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