/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, 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, base_ie, 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
    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):
100
189
    """Import a git tree object into a bzr repository.
101
190
 
102
 
    :param repo: A Bzr repository object
 
191
    :param texts: VersionedFiles object to add to
103
192
    :param path: Path in the tree
104
193
    :param tree: A git tree object
105
 
    :param inv: Inventory object
 
194
    :param base_inv: Base inventory against which to return inventory delta
 
195
    :return: Inventory delta for this subtree
106
196
    """
 
197
    invdelta = []
107
198
    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
 
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():
117
231
        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,))
 
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
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
            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()
 
364
 
 
365
 
 
366
class InterGitRepository(InterRepository):
 
367
 
 
368
    _matching_repo_format = GitRepositoryFormat()
178
369
 
179
370
    @staticmethod
180
371
    def _get_repo_format_to_test():
184
375
        """See InterRepository.copy_content."""
185
376
        self.fetch(revision_id, pb, find_ghosts=False)
186
377
 
 
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):
 
390
        if mapping is None:
 
391
            mapping = self.source.get_mapping()
 
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)]
 
405
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
 
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
 
187
425
    def fetch_objects(self, determine_wants, mapping, pb=None):
188
426
        def progress(text):
189
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
190
 
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
427
            report_git_progress(pb, text)
 
428
        store = BazaarObjectStore(self.target, mapping)
 
429
        self.target.lock_write()
 
430
        try:
 
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()
 
458
        finally:
 
459
            self.target.unlock()
 
460
 
 
461
    @staticmethod
 
462
    def is_compatible(source, target):
 
463
        """Be compatible with GitRepository."""
 
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())
191
476
        create_pb = None
192
477
        if pb is None:
193
478
            create_pb = pb = ui.ui_factory.nested_progress_bar()
194
 
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
195
 
        
 
479
        target_git_object_retriever = BazaarObjectStore(self.target, mapping)
196
480
        try:
197
481
            self.target.lock_write()
198
482
            try:
199
483
                self.target.start_write_group()
200
484
                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)
 
485
                    import_git_objects(self.target, mapping, 
 
486
                            self.source._git.object_store, 
 
487
                            target_git_object_retriever, wants, pb)
207
488
                finally:
208
489
                    self.target.commit_write_group()
209
490
            finally:
212
493
            if create_pb:
213
494
                create_pb.finished()
214
495
 
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
496
    @staticmethod
228
497
    def is_compatible(source, target):
229
498
        """Be compatible with GitRepository."""
230
499
        # FIXME: Also check target uses VersionedFile
231
 
        return (isinstance(source, GitRepository) and 
 
500
        return (isinstance(source, LocalGitRepository) and 
232
501
                target.supports_rich_root() and
233
502
                not isinstance(target, GitRepository))
234
503
 
235
504
 
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):
 
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):
250
510
        if mapping is None:
251
511
            mapping = self.source.get_mapping()
252
512
        def progress(text):
253
 
            info("git: %s", text)
 
513
            trace.info("git: %s", text)
254
514
        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:
 
515
        if revision_id is not None:
258
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:
259
524
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
260
525
 
261
 
        graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
262
 
        f, commit = r.object_store.add_pack()
 
526
        graphwalker = r.get_graph_walker()
 
527
        f, commit = r.object_store.add_thin_pack()
263
528
        try:
264
 
            self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
265
 
            f.close()
 
529
            refs = self.source.fetch_pack(determine_wants, graphwalker,
 
530
                                          f.write, progress)
266
531
            commit()
 
532
            return refs
267
533
        except:
268
534
            f.close()
269
535
            raise