/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 converter.py

Fix updates of sha map during fetch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
converter.py
1
 
# Copyright (C) 2009 Canonical Ltd
 
1
# Copyright (C) 2009 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
16
16
 
17
17
"""Map from Git sha's to Bazaar objects."""
18
18
 
19
 
import bzrlib
20
 
 
21
 
from bzrlib import ui
22
 
 
23
 
from bzrlib.errors import NoSuchRevision
 
19
from dulwich.objects import (
 
20
    Blob,
 
21
    Tree,
 
22
    )
 
23
import stat
 
24
 
 
25
from bzrlib import (
 
26
    errors,
 
27
    ui,
 
28
    )
24
29
 
25
30
from bzrlib.plugins.git.mapping import (
26
 
    inventory_to_tree_and_blobs,
 
31
    directory_to_tree,
 
32
    mapping_registry,
27
33
    revision_to_commit,
28
34
    )
29
 
from bzrlib.plugins.git.shamap import GitShaMap
30
 
 
31
 
from dulwich.objects import (
32
 
    Blob,
 
35
from bzrlib.plugins.git.shamap import (
 
36
    SqliteGitShaMap,
33
37
    )
34
38
 
35
39
 
36
 
class GitObjectConverter(object):
 
40
class BazaarObjectStore(object):
 
41
    """A Git-style object store backed onto a Bazaar repository."""
37
42
 
38
43
    def __init__(self, repository, mapping=None):
39
44
        self.repository = repository
41
46
            self.mapping = self.repository.get_mapping()
42
47
        else:
43
48
            self.mapping = mapping
44
 
        self._idmap = GitShaMap(self.repository._transport)
 
49
        self._idmap = SqliteGitShaMap(self.repository._transport)
45
50
 
46
51
    def _update_sha_map(self):
47
52
        all_revids = self.repository.all_revision_ids()
48
53
        graph = self.repository.get_graph()
49
54
        present_revids = set(self._idmap.revids())
 
55
        missing_revids = [revid for revid in graph.iter_topo_order(all_revids) if revid not in present_revids]
50
56
        pb = ui.ui_factory.nested_progress_bar()
51
57
        try:
52
 
            for i, revid in enumerate(graph.iter_topo_order(all_revids)):
53
 
                if revid in present_revids:
54
 
                    continue
55
 
                pb.update("updating git map", i, len(all_revids))
 
58
            for i, revid in enumerate(missing_revids):
 
59
                pb.update("updating git map", i, len(missing_revids))
56
60
                self._update_sha_map_revision(revid)
57
61
        finally:
 
62
            self._idmap.commit()
58
63
            pb.finished()
59
64
 
60
65
    def _update_sha_map_revision(self, revid):
61
66
        inv = self.repository.get_inventory(revid)
62
 
        objects = inventory_to_tree_and_blobs(self.repository, self.mapping, revid)
63
 
        for sha, o, path in objects:
64
 
            if path == "":
65
 
                tree_sha = sha
66
 
            ie = inv[inv.path2id(path)]
67
 
            if ie.kind in ("file", "symlink"):
68
 
                self._idmap.add_entry(sha, "blob", (ie.file_id, ie.revision))
69
 
            else:
70
 
                self._idmap.add_entry(sha, "tree", (ie.file_id, ie.revision))
 
67
        tree_sha = self._get_ie_sha1(inv.root, inv)
71
68
        rev = self.repository.get_revision(revid)
72
 
        commit_obj = revision_to_commit(rev, tree_sha, self._idmap._parent_lookup)
73
 
        self._idmap.add_entry(commit_obj.sha().hexdigest(), "commit", (revid, tree_sha))
74
 
 
75
 
    def _get_blob(self, fileid, revision):
76
 
        text = self.repository.texts.get_record_stream([(fileid, revision)], "unordered", True).next().get_bytes_as("fulltext")
 
69
        commit_obj = revision_to_commit(rev, tree_sha,
 
70
            self._idmap._parent_lookup)
 
71
        try:
 
72
            foreign_revid, mapping = mapping_registry.parse_revision_id(revid)
 
73
        except errors.InvalidRevisionId:
 
74
            pass
 
75
        else:
 
76
            if foreign_revid != commit_obj.id:
 
77
                raise AssertionError("recreated git commit had different sha1: expected %s, got %s" % (foreign_revid, commit_obj.id))
 
78
        self._idmap.add_entry(commit_obj.id, "commit", (revid, tree_sha))
 
79
 
 
80
    def _check_expected_sha(self, expected_sha, object):
 
81
        if expected_sha is None:
 
82
            return
 
83
        if expected_sha != object.id:
 
84
            raise AssertionError("Invalid sha for %r: %s" % (object, expected_sha))
 
85
 
 
86
    def _get_ie_sha1(self, entry, inv):
 
87
        if entry.kind == "directory":
 
88
            try:
 
89
                return self._idmap.lookup_tree(entry.file_id, inv.revision_id)
 
90
            except KeyError:
 
91
                ret = self._get_tree(entry.file_id, inv.revision_id, inv=inv).id
 
92
                self._idmap.add_entry(ret, "tree", (entry.file_id, inv.revision_id))
 
93
                return ret
 
94
        else:
 
95
            try:
 
96
                return self._idmap.lookup_blob(entry.file_id, entry.revision)
 
97
            except KeyError:
 
98
                ret = self._get_blob(entry.file_id, entry.revision).id
 
99
                self._idmap.add_entry(ret, "blob", (entry.file_id, entry.revision))
 
100
                return ret
 
101
 
 
102
    def _get_blob(self, fileid, revision, expected_sha=None):
 
103
        """Return a Git Blob object from a fileid and revision stored in bzr.
 
104
        
 
105
        :param fileid: File id of the text
 
106
        :param revision: Revision of the text
 
107
        """
 
108
        text = self.repository.texts.get_record_stream([(fileid, revision)],
 
109
            "unordered", True).next().get_bytes_as("fulltext")
77
110
        blob = Blob()
78
111
        blob._text = text
 
112
        self._check_expected_sha(expected_sha, blob)
79
113
        return blob
80
114
 
81
 
    def _get_tree(self, fileid, revid):
82
 
        raise NotImplementedError(self._get_tree)
83
 
 
84
 
    def _get_commit(self, revid, tree_sha):
 
115
    def _get_tree(self, fileid, revid, inv=None, expected_sha=None):
 
116
        """Return a Git Tree object from a file id and a revision stored in bzr.
 
117
 
 
118
        :param fileid: fileid in the tree.
 
119
        :param revision: Revision of the tree.
 
120
        """
 
121
        if inv is None:
 
122
            inv = self.repository.get_inventory(revid)
 
123
        tree = directory_to_tree(inv[fileid], lambda ie: self._get_ie_sha1(ie, inv))
 
124
        self._check_expected_sha(expected_sha, tree)
 
125
        return tree
 
126
 
 
127
    def _get_commit(self, revid, tree_sha, expected_sha=None):
85
128
        rev = self.repository.get_revision(revid)
86
 
        return revision_to_commit(rev, tree_sha, self._idmap._parent_lookup)
 
129
        commit = revision_to_commit(rev, tree_sha, self._idmap._parent_lookup)
 
130
        self._check_expected_sha(expected_sha, commit)
 
131
        return commit
 
132
 
 
133
    def get_raw(self, sha):
 
134
        return self[sha]._text
87
135
 
88
136
    def __getitem__(self, sha):
89
137
        # See if sha is in map
96
144
            (type, type_data) = self._idmap.lookup_git_sha(sha)
97
145
        # convert object to git object
98
146
        if type == "commit":
99
 
            return self._get_commit(*type_data)
 
147
            return self._get_commit(type_data[0], type_data[1], 
 
148
                                    expected_sha=sha)
100
149
        elif type == "blob":
101
 
            return self._get_blob(*type_data)
 
150
            return self._get_blob(type_data[0], type_data[1], expected_sha=sha)
102
151
        elif type == "tree":
103
 
            return self._get_tree(*type_data)
 
152
            return self._get_tree(type_data[0], type_data[1], expected_sha=sha)
104
153
        else:
105
154
            raise AssertionError("Unknown object type '%s'" % type)