/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

Pass along thin pack settings.

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