/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

Partially fix pull.

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