/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

Accept 'binary' shas.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fetch.py
1
 
# Copyright (C) 2008 Canonical Ltd
 
1
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from bzrlib import osutils
18
 
from bzrlib.errors import InvalidRevisionId
19
 
from bzrlib.inventory import Inventory
20
 
from bzrlib.repository import InterRepository
21
 
from bzrlib.trace import info
22
 
 
23
 
from bzrlib.plugins.git import git
24
 
from bzrlib.plugins.git.repository import LocalGitRepository, GitRepository, GitFormat
25
 
from bzrlib.plugins.git.remote import RemoteGitRepository
26
 
 
27
 
from dulwich.objects import Commit
28
 
 
29
 
from cStringIO import StringIO
30
 
 
31
 
 
32
 
class BzrFetchGraphWalker(object):
33
 
 
34
 
    def __init__(self, repository, mapping):
35
 
        self.repository = repository
36
 
        self.mapping = mapping
37
 
        self.done = set()
38
 
        self.heads = set(repository.all_revision_ids())
39
 
        self.parents = {}
40
 
 
41
 
    def ack(self, sha):
42
 
        revid = self.mapping.revision_id_foreign_to_bzr(sha)
43
 
        self.remove(revid)
44
 
 
45
 
    def remove(self, revid):
46
 
        self.done.add(revid)
47
 
        if ref in self.heads:
48
 
            self.heads.remove(revid)
49
 
        if revid in self.parents:
50
 
            for p in self.parents[revid]:
51
 
                self.remove(p)
52
 
 
53
 
    def next(self):
54
 
        while self.heads:
55
 
            ret = self.heads.pop()
56
 
            ps = self.repository.get_parent_map([ret])[ret]
57
 
            self.parents[ret] = ps
58
 
            self.heads.update([p for p in ps if not p in self.done])
59
 
            try:
60
 
                self.done.add(ret)
61
 
                return self.mapping.revision_id_bzr_to_foreign(ret)
62
 
            except InvalidRevisionId:
63
 
                pass
64
 
        return None
65
 
 
66
 
 
67
 
def import_git_blob(repo, mapping, path, blob):
 
17
from cStringIO import (
 
18
    StringIO,
 
19
    )
 
20
import dulwich as git
 
21
from dulwich.objects import (
 
22
    Commit,
 
23
    Tag,
 
24
    S_ISGITLINK,
 
25
    )
 
26
from dulwich.object_store import (
 
27
    tree_lookup_path,
 
28
    )
 
29
import re
 
30
import stat
 
31
 
 
32
from bzrlib import (
 
33
    debug,
 
34
    osutils,
 
35
    trace,
 
36
    ui,
 
37
    urlutils,
 
38
    )
 
39
from bzrlib.errors import (
 
40
    InvalidRevisionId,
 
41
    NoSuchId,
 
42
    NoSuchRevision,
 
43
    )
 
44
from bzrlib.inventory import (
 
45
    Inventory,
 
46
    InventoryDirectory,
 
47
    InventoryFile,
 
48
    InventoryLink,
 
49
    )
 
50
from bzrlib.lru_cache import (
 
51
    LRUCache,
 
52
    )
 
53
from bzrlib.repository import (
 
54
    InterRepository,
 
55
    )
 
56
from bzrlib.revision import (
 
57
    NULL_REVISION,
 
58
    )
 
59
from bzrlib.tsort import (
 
60
    topo_sort,
 
61
    )
 
62
from bzrlib.versionedfile import (
 
63
    FulltextContentFactory,
 
64
    )
 
65
 
 
66
from bzrlib.plugins.git.mapping import (
 
67
    DEFAULT_FILE_MODE,
 
68
    inventory_to_tree_and_blobs,
 
69
    mode_is_executable,
 
70
    squash_revision,
 
71
    text_to_blob,
 
72
    warn_unusual_mode,
 
73
    )
 
74
from bzrlib.plugins.git.object_store import (
 
75
    BazaarObjectStore,
 
76
    )
 
77
from bzrlib.plugins.git.remote import (
 
78
    RemoteGitRepository,
 
79
    )
 
80
from bzrlib.plugins.git.repository import (
 
81
    GitRepository, 
 
82
    GitRepositoryFormat,
 
83
    LocalGitRepository,
 
84
    )
 
85
 
 
86
 
 
87
def import_git_blob(texts, mapping, path, hexsha, base_inv, parent_id, 
 
88
    revision_id, parent_invs, shagitmap, lookup_object, executable, symlink):
68
89
    """Import a git blob object into a bzr repository.
69
90
 
70
 
    :param repo: bzr repository
 
91
    :param texts: VersionedFiles to add to
71
92
    :param path: Path in the tree
72
93
    :param blob: A git blob
 
94
    :return: Inventory delta for this file
73
95
    """
74
96
    file_id = mapping.generate_file_id(path)
75
 
    repo.texts.add_lines((file_id, blob.id),
76
 
        [], #FIXME 
77
 
        osutils.split_lines(blob.data))
78
 
    inv.add_path(path, "file", file_id)
79
 
 
80
 
 
81
 
def import_git_tree(repo, mapping, path, tree, inv, lookup_object):
 
97
    if symlink:
 
98
        cls = InventoryLink
 
99
    else:
 
100
        cls = InventoryFile
 
101
    # We just have to hope this is indeed utf-8:
 
102
    ie = cls(file_id, urlutils.basename(path).decode("utf-8"), parent_id)
 
103
    ie.executable = executable
 
104
    # See if this has changed at all
 
105
    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):
82
193
    """Import a git tree object into a bzr repository.
83
194
 
84
 
    :param repo: A Bzr repository object
 
195
    :param texts: VersionedFiles object to add to
85
196
    :param path: Path in the tree
86
197
    :param tree: A git tree object
87
 
    :param inv: Inventory object
 
198
    :param base_inv: Base inventory against which to return inventory delta
 
199
    :return: Inventory delta for this subtree
88
200
    """
 
201
    invdelta = []
89
202
    file_id = mapping.generate_file_id(path)
90
 
    repo.texts.add_lines((file_id, tree.id),
91
 
        [], #FIXME 
92
 
        [])
93
 
    inv.add_path(path, "directory", file_id)
94
 
    for mode, name, hexsha in tree.entries():
95
 
        entry_kind = (mode & 0700000) / 0100000
 
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():
96
234
        basename = name.decode("utf-8")
97
 
        if path == "":
98
 
            child_path = name
99
 
        else:
100
 
            child_path = urlutils.join(path, name)
101
 
        if entry_kind == 0:
102
 
            import_git_tree(repo, mapping, child_path, lookup_object, inv)
103
 
        elif entry_kind == 1:
104
 
            import_git_blob(repo, mapping, child_path, lookup_object, inv)
105
 
        else:
106
 
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
107
 
 
108
 
 
109
 
def import_git_objects(repo, mapping, object_iter):
 
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
 
265
 
 
266
 
 
267
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever, 
 
268
        heads, pb=None):
110
269
    """Import a set of git objects into a bzr repository.
111
270
 
112
 
    :param repo: Bazaar repository
 
271
    :param repo: Target Bazaar repository
113
272
    :param mapping: Mapping to use
114
273
    :param object_iter: Iterator over Git objects.
115
274
    """
 
275
    def lookup_object(sha):
 
276
        try:
 
277
            return object_iter[sha]
 
278
        except KeyError:
 
279
            return target_git_object_retriever[sha]
116
280
    # TODO: a more (memory-)efficient implementation of this
117
 
    objects = {}
118
 
    for o in object_iter:
119
 
        objects[o.id] = o
 
281
    graph = []
120
282
    root_trees = {}
 
283
    revisions = {}
 
284
    checked = set()
 
285
    heads = list(heads)
 
286
    parent_invs_cache = LRUCache(50)
121
287
    # Find and convert commit objects
122
 
    for o in objects.iterkeys():
 
288
    while heads:
 
289
        if pb is not None:
 
290
            pb.update("finding revisions to fetch", len(graph), None)
 
291
        head = heads.pop()
 
292
        assert isinstance(head, str)
 
293
        try:
 
294
            o = lookup_object(head)
 
295
        except KeyError:
 
296
            continue
123
297
        if isinstance(o, Commit):
124
298
            rev = mapping.import_commit(o)
125
 
            root_trees[rev] = objects[o.tree_sha]
 
299
            if repo.has_revision(rev.revision_id):
 
300
                continue
 
301
            squash_revision(repo, rev)
 
302
            root_trees[rev.revision_id] = o.tree
 
303
            revisions[rev.revision_id] = rev
 
304
            graph.append((rev.revision_id, rev.parent_ids))
 
305
            target_git_object_retriever._idmap.add_entry(o.id, "commit", 
 
306
                    (rev.revision_id, o.tree))
 
307
            heads.extend([p for p in o.parents if p not in checked])
 
308
        elif isinstance(o, Tag):
 
309
            heads.append(o.object[1])
 
310
        else:
 
311
            trace.warning("Unable to import head object %r" % o)
 
312
        checked.add(head)
 
313
    # Order the revisions
126
314
    # Create the inventory objects
127
 
    for rev, root_tree in root_trees.iteritems():
 
315
    for i, revid in enumerate(topo_sort(graph)):
 
316
        if pb is not None:
 
317
            pb.update("fetching revisions", i, len(graph))
 
318
        rev = revisions[revid]
128
319
        # We have to do this here, since we have to walk the tree and 
129
 
        # we need to make sure to import the blobs / trees with the riht 
 
320
        # we need to make sure to import the blobs / trees with the right 
130
321
        # path; this may involve adding them more than once.
131
 
        inv = Inventory()
132
 
        def lookup_object(sha):
133
 
            if sha in objects:
134
 
                return objects[sha]
135
 
            return reconstruct_git_object(repo, mapping, sha)
136
 
        import_git_tree(repo, mapping, "", tree, inv, lookup_object)
137
 
        repo.add_revision(rev.revision_id, rev, inv)
138
 
 
139
 
 
140
 
def reconstruct_git_commit(repo, rev):
141
 
    raise NotImplementedError(self.reconstruct_git_commit)
142
 
 
143
 
 
144
 
def reconstruct_git_object(repo, mapping, sha):
145
 
    # Commit
146
 
    revid = mapping.revision_id_foreign_to_bzr(sha)
147
 
    try:
148
 
        rev = repo.get_revision(revid)
149
 
    except NoSuchRevision:
150
 
        pass
151
 
    else:
152
 
        return reconstruct_git_commit(rev)
153
 
 
154
 
    # TODO: Tree
155
 
    # TODO: Blob
156
 
    raise KeyError("No such object %s" % sha)
 
322
        parent_invs = []
 
323
        for parent_id in rev.parent_ids:
 
324
            try:
 
325
                parent_invs.append(parent_invs_cache[parent_id])
 
326
            except KeyError:
 
327
                parent_inv = repo.get_inventory(parent_id)
 
328
                parent_invs.append(parent_inv)
 
329
                parent_invs_cache[parent_id] = parent_inv
 
330
        if parent_invs == []:
 
331
            base_inv = Inventory(root_id=None)
 
332
        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()
157
362
 
158
363
 
159
364
class InterGitRepository(InterRepository):
160
365
 
161
 
    _matching_repo_format = GitFormat()
 
366
    _matching_repo_format = GitRepositoryFormat()
162
367
 
163
368
    @staticmethod
164
369
    def _get_repo_format_to_test():
168
373
        """See InterRepository.copy_content."""
169
374
        self.fetch(revision_id, pb, find_ghosts=False)
170
375
 
171
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
172
 
              mapping=None):
 
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):
173
388
        if mapping is None:
174
389
            mapping = self.source.get_mapping()
175
 
        def progress(text):
176
 
            if pb is not None:
177
 
                pb.note("git: %s" % text)
178
 
            else:
179
 
                info("git: %s" % text)
180
 
        def determine_wants(heads):
181
 
            if revision_id is None:
182
 
                ret = heads.values()
183
 
            else:
184
 
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
 
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)]
185
403
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
186
 
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
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
 
 
423
    def fetch_objects(self, determine_wants, mapping, pb=None):
 
424
        def progress(text):
 
425
            report_git_progress(pb, text)
 
426
        store = BazaarObjectStore(self.target, mapping)
187
427
        self.target.lock_write()
188
428
        try:
189
 
            import_git_objects(self.target, mapping,
190
 
                self.source.fetch_objects(determine_wants, graph_walker, 
191
 
                    progress))
 
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()
192
456
        finally:
193
457
            self.target.unlock()
194
458
 
196
460
    def is_compatible(source, target):
197
461
        """Be compatible with GitRepository."""
198
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())
 
474
        create_pb = None
 
475
        if pb is None:
 
476
            create_pb = pb = ui.ui_factory.nested_progress_bar()
 
477
        target_git_object_retriever = BazaarObjectStore(self.target, mapping)
 
478
        try:
 
479
            self.target.lock_write()
 
480
            try:
 
481
                self.target.start_write_group()
 
482
                try:
 
483
                    import_git_objects(self.target, mapping, 
 
484
                            self.source._git.object_store, 
 
485
                            target_git_object_retriever, wants, pb)
 
486
                finally:
 
487
                    self.target.commit_write_group()
 
488
            finally:
 
489
                self.target.unlock()
 
490
        finally:
 
491
            if create_pb:
 
492
                create_pb.finished()
 
493
 
 
494
    @staticmethod
 
495
    def is_compatible(source, target):
 
496
        """Be compatible with GitRepository."""
 
497
        # FIXME: Also check target uses VersionedFile
199
498
        return (isinstance(source, LocalGitRepository) and 
200
 
                target.supports_rich_root())
 
499
                target.supports_rich_root() and
 
500
                not isinstance(target, GitRepository))
 
501
 
 
502
 
 
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):
 
508
        if mapping is None:
 
509
            mapping = self.source.get_mapping()
 
510
        def progress(text):
 
511
            trace.info("git: %s", text)
 
512
        r = self.target._git
 
513
        if revision_id is not None:
 
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:
 
522
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
 
523
 
 
524
        graphwalker = r.get_graph_walker()
 
525
        f, commit = r.object_store.add_thin_pack()
 
526
        try:
 
527
            refs = self.source.fetch_pack(determine_wants, graphwalker,
 
528
                                          f.write, progress)
 
529
            commit()
 
530
            return refs
 
531
        except:
 
532
            f.close()
 
533
            raise
 
534
 
 
535
    @staticmethod
 
536
    def is_compatible(source, target):
 
537
        """Be compatible with GitRepository."""
 
538
        return (isinstance(source, GitRepository) and 
 
539
                isinstance(target, GitRepository))