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

  • Committer: Jelmer Vernooij
  • Date: 2009-07-22 13:10:44 UTC
  • mfrom: (0.200.588 trunk)
  • mto: (0.200.597 trunk)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@samba.org-20090722131044-r30g8w06xd8f40fl
merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
object_store.py
18
18
 
19
19
from dulwich.objects import (
20
20
    Blob,
21
 
    Tree,
 
21
    sha_to_hex,
22
22
    )
23
23
from dulwich.object_store import (
24
24
    BaseObjectStore,
25
 
    ObjectStoreIterator,
26
25
    )
27
 
import stat
28
26
 
29
27
from bzrlib import (
30
28
    debug,
32
30
    trace,
33
31
    ui,
34
32
    )
 
33
from bzrlib.revision import (
 
34
    NULL_REVISION,
 
35
    )
35
36
 
36
37
from bzrlib.plugins.git.errors import (
37
38
    GhostRevision,
40
41
from bzrlib.plugins.git.mapping import (
41
42
    default_mapping,
42
43
    directory_to_tree,
 
44
    extract_unusual_modes,
43
45
    mapping_registry,
44
46
    revision_to_commit,
45
47
    )
95
97
 
96
98
    def _update_sha_map_revision(self, revid):
97
99
        inv = self.repository.get_inventory(revid)
98
 
        tree_sha = self._get_ie_sha1(inv.root, inv)
99
100
        rev = self.repository.get_revision(revid)
 
101
        unusual_modes = extract_unusual_modes(rev)
 
102
        tree_sha = self._get_ie_sha1(inv.root, inv, unusual_modes)
100
103
        commit_obj = revision_to_commit(rev, tree_sha,
101
104
                                        self._idmap.lookup_commit)
102
105
        try:
112
115
    def _check_expected_sha(self, expected_sha, object):
113
116
        if expected_sha is None:
114
117
            return
115
 
        if expected_sha != object.id:
116
 
            raise AssertionError("Invalid sha for %r: %s" % (object, expected_sha))
 
118
        if len(expected_sha) == 40:
 
119
            if expected_sha != object.sha().hexdigest():
 
120
                raise AssertionError("Invalid sha for %r: %s" % (object, expected_sha))
 
121
        elif len(expected_sha) == 20:
 
122
            if expected_sha != object.sha().digest():
 
123
                raise AssertionError("Invalid sha for %r: %s" % (object, sha_to_hex(expected_sha)))
 
124
        else:
 
125
            raise AssertionError("Unknown length %d for %r" % (len(expected_sha), expected_sha))
117
126
 
118
 
    def _get_ie_object(self, entry, inv):  
 
127
    def _get_ie_object(self, entry, inv, unusual_modes):  
119
128
        if entry.kind == "directory":
120
 
            return self._get_tree(entry.file_id, inv.revision_id, inv=inv)
 
129
            return self._get_tree(entry.file_id, inv.revision_id, inv, unusual_modes)
121
130
        else:
122
131
            return self._get_blob(entry.file_id, entry.revision)
123
132
 
124
 
    def _get_ie_object_or_sha1(self, entry, inv):
 
133
    def _get_ie_object_or_sha1(self, entry, inv, unusual_modes):
125
134
        if entry.kind == "directory":
126
135
            try:
127
136
                return self._idmap.lookup_tree(entry.file_id, inv.revision_id), None
128
137
            except KeyError:
129
 
                ret = self._get_ie_object(entry, inv)
 
138
                ret = self._get_ie_object(entry, inv, unusual_modes)
130
139
                self._idmap.add_entry(ret.id, "tree", (entry.file_id, inv.revision_id))
131
140
                return ret.id, ret
132
141
        else:
133
142
            try:
134
143
                return self._idmap.lookup_blob(entry.file_id, entry.revision), None
135
144
            except KeyError:
136
 
                ret = self._get_ie_object(entry, inv)
 
145
                ret = self._get_ie_object(entry, inv, unusual_modes)
137
146
                self._idmap.add_entry(ret.id, "blob", (entry.file_id, entry.revision))
138
147
                return ret.id, ret
139
148
 
140
 
    def _get_ie_sha1(self, entry, inv):
141
 
        return self._get_ie_object_or_sha1(entry, inv)[0]
 
149
    def _get_ie_sha1(self, entry, inv, unusual_modes):
 
150
        return self._get_ie_object_or_sha1(entry, inv, unusual_modes)[0]
142
151
 
143
152
    def _get_blob(self, fileid, revision, expected_sha=None):
144
153
        """Return a Git Blob object from a fileid and revision stored in bzr.
153
162
        self._check_expected_sha(expected_sha, blob)
154
163
        return blob
155
164
 
156
 
    def _get_tree(self, fileid, revid, inv=None, expected_sha=None):
 
165
    def _get_tree(self, fileid, revid, inv, unusual_modes, expected_sha=None):
157
166
        """Return a Git Tree object from a file id and a revision stored in bzr.
158
167
 
159
168
        :param fileid: fileid in the tree.
160
169
        :param revision: Revision of the tree.
161
170
        """
162
 
        if inv is None:
163
 
            inv = self.repository.get_inventory(revid)
164
 
        tree = directory_to_tree(inv[fileid], lambda ie: self._get_ie_sha1(ie, inv))
 
171
        tree = directory_to_tree(inv[fileid], 
 
172
            lambda ie: self._get_ie_sha1(ie, inv, unusual_modes),
 
173
            unusual_modes)
165
174
        self._check_expected_sha(expected_sha, tree)
166
175
        return tree
167
176
 
168
 
    def _get_commit(self, revid, tree_sha, expected_sha=None):
169
 
        rev = self.repository.get_revision(revid)
 
177
    def _get_commit(self, rev, tree_sha, expected_sha=None):
170
178
        try:
171
179
            commit = revision_to_commit(rev, tree_sha, self._lookup_revision_sha1)
172
180
        except errors.NoSuchRevision, e:
184
192
 
185
193
    def _lookup_revision_sha1(self, revid):
186
194
        """Return the SHA1 matching a Bazaar revision."""
 
195
        if revid == NULL_REVISION:
 
196
            return "0" * 40
187
197
        try:
188
198
            return self._idmap.lookup_commit(revid)
189
199
        except KeyError:
195
205
 
196
206
        :param sha: SHA1 of the git object
197
207
        """
198
 
        return self[sha].as_raw_string()
 
208
        obj = self[sha]
 
209
        return (obj.type, obj.as_raw_string())
199
210
 
200
211
    def __contains__(self, sha):
201
212
        # See if sha is in map
202
213
        try:
203
 
            self._lookup_git_sha(sha)
 
214
            (type, type_data) = self._lookup_git_sha(sha)
 
215
            if type == "commit":
 
216
                return self.repository.has_revision(type_data[0])
 
217
            elif type == "blob":
 
218
                return self.repository.texts.has_version(type_data)
 
219
            elif type == "tree":
 
220
                return self.repository.has_revision(type_data[1])
 
221
            else:
 
222
                raise AssertionError("Unknown object type '%s'" % type)
204
223
        except KeyError:
205
224
            return False
206
225
        else:
221
240
        # convert object to git object
222
241
        if type == "commit":
223
242
            try:
224
 
                return self._get_commit(type_data[0], type_data[1], 
225
 
                                        expected_sha=sha)
 
243
                rev = self.repository.get_revision(type_data[0])
226
244
            except errors.NoSuchRevision:
227
245
                trace.mutter('entry for %s %s in shamap: %r, but not found in repository', type, sha, type_data)
228
246
                raise KeyError(sha)
 
247
            return self._get_commit(rev, type_data[1], expected_sha=sha)
229
248
        elif type == "blob":
230
249
            return self._get_blob(type_data[0], type_data[1], expected_sha=sha)
231
250
        elif type == "tree":
232
251
            try:
233
 
                return self._get_tree(type_data[0], type_data[1], 
 
252
                inv = self.repository.get_inventory(type_data[1])
 
253
                rev = self.repository.get_revision(type_data[1])
 
254
            except errors.NoSuchRevision:
 
255
                trace.mutter('entry for %s %s in shamap: %r, but not found in repository', type, sha, type_data)
 
256
                raise KeyError(sha)
 
257
            unusual_modes = extract_unusual_modes(rev)
 
258
            try:
 
259
                return self._get_tree(type_data[0], type_data[1], inv, unusual_modes,
234
260
                                      expected_sha=sha)
235
261
            except errors.NoSuchRevision:
236
262
                raise KeyError(sha)