/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

Try to import nothing other than __init__ when not opening git repositories.

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