/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

Indicate .git directories are supported.

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
 
 
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
    invdelta = []
 
162
    if base_ie is not None: 
 
163
        old_path = base_inv.id2path(file_id)
 
164
        if base_ie.kind == "directory":
 
165
            invdelta.extend(remove_disappeared_children(old_path, base_ie.children, []))
 
166
    else:
 
167
        old_path = None
 
168
    invdelta.append((old_path, path, file_id, ie))
 
169
    return (invdelta, shamap)
 
170
 
 
171
 
 
172
def import_git_submodule(texts, mapping, path, hexsha, base_inv, base_ie, parent_id, 
 
173
    revision_id, parent_invs, shagitmap, lookup_object):
 
174
    raise NotImplementedError(import_git_submodule)
 
175
 
 
176
 
 
177
def remove_disappeared_children(path, base_children, existing_children):
 
178
    ret = []
 
179
    deletable = [(osutils.pathjoin(path, k), v) for k,v in base_children.iteritems() if k not in existing_children]
 
180
    while deletable:
 
181
        (path, ie) = deletable.pop()
 
182
        ret.append((path, None, ie.file_id, None))
 
183
        if ie.kind == "directory":
 
184
            for name, child_ie in ie.children.iteritems():
 
185
                deletable.append((osutils.pathjoin(path, name), child_ie))
 
186
    return ret
 
187
 
 
188
 
 
189
def import_git_tree(texts, mapping, path, hexsha, base_inv, base_ie, parent_id, 
 
190
    revision_id, parent_invs, shagitmap, lookup_object):
100
191
    """Import a git tree object into a bzr repository.
101
192
 
102
 
    :param repo: A Bzr repository object
 
193
    :param texts: VersionedFiles object to add to
103
194
    :param path: Path in the tree
104
195
    :param tree: A git tree object
105
 
    :param inv: Inventory object
 
196
    :param base_inv: Base inventory against which to return inventory delta
 
197
    :return: Inventory delta for this subtree
106
198
    """
 
199
    invdelta = []
107
200
    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
 
201
    # We just have to hope this is indeed utf-8:
 
202
    ie = InventoryDirectory(file_id, urlutils.basename(path.decode("utf-8")), 
 
203
        parent_id)
 
204
    if base_ie is None:
 
205
        # Newly appeared here
 
206
        ie.revision = revision_id
 
207
        texts.insert_record_stream([FulltextContentFactory((file_id, ie.revision), (), None, "")])
 
208
        invdelta.append((None, path, file_id, ie))
 
209
    else:
 
210
        # See if this has changed at all
 
211
        try:
 
212
            base_sha = shagitmap.lookup_tree(file_id, base_inv.revision_id)
 
213
        except KeyError:
 
214
            pass
 
215
        else:
 
216
            if base_sha == hexsha:
 
217
                # If nothing has changed since the base revision, we're done
 
218
                return [], {}, []
 
219
        if base_ie.kind != "directory":
 
220
            ie.revision = revision_id
 
221
            texts.insert_record_stream([FulltextContentFactory((ie.file_id, ie.revision), (), None, "")])
 
222
            invdelta.append((base_inv.id2path(ie.file_id), path, ie.file_id, ie))
 
223
    if base_ie is not None and base_ie.kind == "directory":
 
224
        base_children = base_ie.children
 
225
    else:
 
226
        base_children = {}
 
227
    # Remember for next time
 
228
    existing_children = set()
 
229
    child_modes = {}
 
230
    shamap = []
 
231
    tree = lookup_object(hexsha)
 
232
    for mode, name, child_hexsha in tree.entries():
117
233
        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,))
 
234
        existing_children.add(basename)
 
235
        child_path = osutils.pathjoin(path, name)
 
236
        if stat.S_ISDIR(mode):
 
237
            subinvdelta, grandchildmodes, subshamap = import_git_tree(
 
238
                    texts, mapping, child_path, child_hexsha, base_inv, 
 
239
                    base_children.get(basename), file_id, revision_id, parent_invs, shagitmap,
 
240
                    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, base_ie.get(basename),
 
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, base_children.get(basename), file_id,
 
254
                    revision_id, 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
    if base_ie is not None and base_ie.kind == "directory":
 
263
        invdelta.extend(remove_disappeared_children(base_inv.id2path(file_id), 
 
264
            base_children, existing_children))
 
265
    shamap.append((hexsha, "tree", (file_id, revision_id)))
 
266
    return invdelta, child_modes, shamap
131
267
 
132
268
 
133
269
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever, 
134
 
        pb=None):
 
270
        heads, pb=None):
135
271
    """Import a set of git objects into a bzr repository.
136
272
 
137
 
    :param repo: Bazaar repository
 
273
    :param repo: Target Bazaar repository
138
274
    :param mapping: Mapping to use
139
275
    :param object_iter: Iterator over Git objects.
140
276
    """
 
277
    def lookup_object(sha):
 
278
        try:
 
279
            return object_iter[sha]
 
280
        except KeyError:
 
281
            return target_git_object_retriever[sha]
141
282
    # TODO: a more (memory-)efficient implementation of this
142
283
    graph = []
143
284
    root_trees = {}
144
285
    revisions = {}
 
286
    checked = set()
 
287
    heads = list(heads)
 
288
    parent_invs_cache = LRUCache(50)
145
289
    # Find and convert commit objects
146
 
    for o in object_iter.iterobjects():
 
290
    while heads:
 
291
        if pb is not None:
 
292
            pb.update("finding revisions to fetch", len(graph), None)
 
293
        head = heads.pop()
 
294
        assert isinstance(head, str)
 
295
        try:
 
296
            o = lookup_object(head)
 
297
        except KeyError:
 
298
            continue
147
299
        if isinstance(o, Commit):
148
300
            rev = mapping.import_commit(o)
149
 
            root_trees[rev.revision_id] = object_iter[o.tree]
 
301
            if repo.has_revision(rev.revision_id):
 
302
                continue
 
303
            squash_revision(repo, rev)
 
304
            root_trees[rev.revision_id] = o.tree
150
305
            revisions[rev.revision_id] = rev
151
306
            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))
 
307
            target_git_object_retriever._idmap.add_entry(o.id, "commit", 
 
308
                    (rev.revision_id, o.tree))
 
309
            heads.extend([p for p in o.parents if p not in checked])
 
310
        elif isinstance(o, Tag):
 
311
            heads.append(o.object[1])
 
312
        else:
 
313
            trace.warning("Unable to import head object %r" % o)
 
314
        checked.add(head)
153
315
    # Order the revisions
154
316
    # Create the inventory objects
155
317
    for i, revid in enumerate(topo_sort(graph)):
156
318
        if pb is not None:
157
319
            pb.update("fetching revisions", i, len(graph))
158
 
        root_tree = root_trees[revid]
159
320
        rev = revisions[revid]
160
321
        # 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 
 
322
        # we need to make sure to import the blobs / trees with the right 
162
323
        # 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()
 
324
        parent_invs = []
 
325
        for parent_id in rev.parent_ids:
 
326
            try:
 
327
                parent_invs.append(parent_invs_cache[parent_id])
 
328
            except KeyError:
 
329
                parent_inv = repo.get_inventory(parent_id)
 
330
                parent_invs.append(parent_inv)
 
331
                parent_invs_cache[parent_id] = parent_inv
 
332
        if parent_invs == []:
 
333
            base_inv = Inventory(root_id=None)
 
334
            base_ie = None
 
335
        else:
 
336
            base_inv = parent_invs[0]
 
337
            base_ie = base_inv.root
 
338
        inv_delta, unusual_modes, shamap = import_git_tree(repo.texts, 
 
339
                mapping, "", root_trees[revid], base_inv, base_ie, None, revid, 
 
340
                parent_invs, target_git_object_retriever._idmap, lookup_object)
 
341
        target_git_object_retriever._idmap.add_entries(shamap)
 
342
        if unusual_modes != {}:
 
343
            for path, mode in unusual_modes.iteritems():
 
344
                warn_unusual_mode(rev.foreign_revid, path, mode)
 
345
            mapping.import_unusual_file_modes(rev, unusual_modes)
 
346
        try:
 
347
            basis_id = rev.parent_ids[0]
 
348
        except IndexError:
 
349
            basis_id = NULL_REVISION
 
350
        rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
 
351
                  inv_delta, rev.revision_id, rev.parent_ids)
 
352
        parent_invs_cache[rev.revision_id] = inv
 
353
        repo.add_revision(rev.revision_id, rev)
 
354
        if "verify" in debug.debug_flags:
 
355
            new_unusual_modes = mapping.export_unusual_file_modes(rev)
 
356
            if new_unusual_modes != unusual_modes:
 
357
                raise AssertionError("unusual modes don't match: %r != %r" % (unusual_modes, new_unusual_modes))
 
358
            objs = inventory_to_tree_and_blobs(inv, repo.texts, mapping, unusual_modes)
 
359
            for sha1, newobj, path in objs:
 
360
                assert path is not None
 
361
                oldobj = tree_lookup_path(lookup_object, root_trees[revid], path)
 
362
                if oldobj != newobj:
 
363
                    raise AssertionError("%r != %r in %s" % (oldobj, newobj, path))
 
364
 
 
365
    target_git_object_retriever._idmap.commit()
 
366
 
 
367
 
 
368
class InterGitRepository(InterRepository):
 
369
 
 
370
    _matching_repo_format = GitRepositoryFormat()
178
371
 
179
372
    @staticmethod
180
373
    def _get_repo_format_to_test():
184
377
        """See InterRepository.copy_content."""
185
378
        self.fetch(revision_id, pb, find_ghosts=False)
186
379
 
 
380
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, mapping=None,
 
381
            fetch_spec=None):
 
382
        self.fetch_refs(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts,
 
383
                mapping=mapping, fetch_spec=fetch_spec)
 
384
 
 
385
 
 
386
class InterGitNonGitRepository(InterGitRepository):
 
387
    """Base InterRepository that copies revisions from a Git into a non-Git 
 
388
    repository."""
 
389
 
 
390
    def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False, 
 
391
              mapping=None, fetch_spec=None):
 
392
        if mapping is None:
 
393
            mapping = self.source.get_mapping()
 
394
        if revision_id is not None:
 
395
            interesting_heads = [revision_id]
 
396
        elif fetch_spec is not None:
 
397
            interesting_heads = fetch_spec.heads
 
398
        else:
 
399
            interesting_heads = None
 
400
        self._refs = {}
 
401
        def determine_wants(refs):
 
402
            self._refs = refs
 
403
            if interesting_heads is None:
 
404
                ret = [sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")]
 
405
            else:
 
406
                ret = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in interesting_heads if revid not in (None, NULL_REVISION)]
 
407
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
 
408
        pack_hint = self.fetch_objects(determine_wants, mapping, pb)
 
409
        if pack_hint is not None and self.target._format.pack_compresses:
 
410
            self.target.pack(hint=pack_hint)
 
411
        return self._refs
 
412
 
 
413
 
 
414
_GIT_PROGRESS_RE = re.compile(r"(.*?): +(\d+)% \((\d+)/(\d+)\)")
 
415
def report_git_progress(pb, text):
 
416
    text = text.rstrip("\r\n")
 
417
    g = _GIT_PROGRESS_RE.match(text)
 
418
    if g is not None:
 
419
        (text, pct, current, total) = g.groups()
 
420
        pb.update(text, int(current), int(total))
 
421
    else:
 
422
        pb.update(text, 0, 0)
 
423
 
 
424
 
 
425
class InterRemoteGitNonGitRepository(InterGitNonGitRepository):
 
426
    """InterRepository that copies revisions from a remote Git into a non-Git 
 
427
    repository."""
 
428
 
 
429
    def get_target_heads(self):
 
430
        # FIXME: This should be more efficient
 
431
        all_revs = self.target.all_revision_ids()
 
432
        parent_map = self.target.get_parent_map(all_revs)
 
433
        all_parents = set()
 
434
        map(all_parents.update, parent_map.itervalues())
 
435
        return set(all_revs) - all_parents
 
436
 
187
437
    def fetch_objects(self, determine_wants, mapping, pb=None):
188
438
        def progress(text):
189
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
190
 
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
439
            report_git_progress(pb, text)
 
440
        store = BazaarObjectStore(self.target, mapping)
 
441
        self.target.lock_write()
 
442
        try:
 
443
            heads = self.get_target_heads()
 
444
            graph_walker = store.get_graph_walker(
 
445
                    [store._lookup_revision_sha1(head) for head in heads])
 
446
            recorded_wants = []
 
447
 
 
448
            def record_determine_wants(heads):
 
449
                wants = determine_wants(heads)
 
450
                recorded_wants.extend(wants)
 
451
                return wants
 
452
        
 
453
            create_pb = None
 
454
            if pb is None:
 
455
                create_pb = pb = ui.ui_factory.nested_progress_bar()
 
456
            try:
 
457
                self.target.start_write_group()
 
458
                try:
 
459
                    objects_iter = self.source.fetch_objects(
 
460
                                record_determine_wants, graph_walker, 
 
461
                                store.get_raw, progress)
 
462
                    import_git_objects(self.target, mapping, objects_iter, 
 
463
                            store, recorded_wants, pb)
 
464
                finally:
 
465
                    return self.target.commit_write_group()
 
466
            finally:
 
467
                if create_pb:
 
468
                    create_pb.finished()
 
469
        finally:
 
470
            self.target.unlock()
 
471
 
 
472
    @staticmethod
 
473
    def is_compatible(source, target):
 
474
        """Be compatible with GitRepository."""
 
475
        # FIXME: Also check target uses VersionedFile
 
476
        return (isinstance(source, RemoteGitRepository) and 
 
477
                target.supports_rich_root() and
 
478
                not isinstance(target, GitRepository))
 
479
 
 
480
 
 
481
class InterLocalGitNonGitRepository(InterGitNonGitRepository):
 
482
    """InterRepository that copies revisions from a local Git into a non-Git 
 
483
    repository."""
 
484
 
 
485
    def fetch_objects(self, determine_wants, mapping, pb=None):
 
486
        wants = determine_wants(self.source._git.get_refs())
191
487
        create_pb = None
192
488
        if pb is None:
193
489
            create_pb = pb = ui.ui_factory.nested_progress_bar()
194
 
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
195
 
        
 
490
        target_git_object_retriever = BazaarObjectStore(self.target, mapping)
196
491
        try:
197
492
            self.target.lock_write()
198
493
            try:
199
494
                self.target.start_write_group()
200
495
                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)
 
496
                    import_git_objects(self.target, mapping, 
 
497
                            self.source._git.object_store, 
 
498
                            target_git_object_retriever, wants, pb)
207
499
                finally:
208
 
                    self.target.commit_write_group()
 
500
                    return self.target.commit_write_group()
209
501
            finally:
210
502
                self.target.unlock()
211
503
        finally:
212
504
            if create_pb:
213
505
                create_pb.finished()
214
506
 
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
507
    @staticmethod
228
508
    def is_compatible(source, target):
229
509
        """Be compatible with GitRepository."""
230
510
        # FIXME: Also check target uses VersionedFile
231
 
        return (isinstance(source, GitRepository) and 
 
511
        return (isinstance(source, LocalGitRepository) and 
232
512
                target.supports_rich_root() and
233
513
                not isinstance(target, GitRepository))
234
514
 
235
515
 
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):
 
516
class InterGitGitRepository(InterGitRepository):
 
517
    """InterRepository that copies between Git repositories."""
 
518
 
 
519
    def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False, 
 
520
              mapping=None, fetch_spec=None, branches=None):
250
521
        if mapping is None:
251
522
            mapping = self.source.get_mapping()
252
523
        def progress(text):
253
 
            info("git: %s", text)
 
524
            trace.info("git: %s", text)
254
525
        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:
 
526
        if revision_id is not None:
258
527
            args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
 
528
        elif fetch_spec is not None:
 
529
            args = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in fetch_spec.heads]
 
530
        if branches is not None:
 
531
            determine_wants = lambda x: [x[y] for y in branches if not x[y] in r.object_store]
 
532
        elif fetch_spec is None and revision_id is None:
 
533
            determine_wants = r.object_store.determine_wants_all
 
534
        else:
259
535
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
260
536
 
261
 
        graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
262
 
        f, commit = r.object_store.add_pack()
 
537
        graphwalker = r.get_graph_walker()
 
538
        f, commit = r.object_store.add_thin_pack()
263
539
        try:
264
 
            self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
265
 
            f.close()
 
540
            refs = self.source.fetch_pack(determine_wants, graphwalker,
 
541
                                          f.write, progress)
266
542
            commit()
 
543
            return refs
267
544
        except:
268
545
            f.close()
269
546
            raise