← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory_delta.py

  • Committer: Vincent Ladeuil
  • Date: 2017-01-17 13:48:10 UTC
  • mfrom: (6615.3.6 merges)
  • mto: This revision was merged to the branch mainline in revision 6620.
  • Revision ID: v.ladeuil+lp@free.fr-20170117134810-j9p3lidfy6pfyfsc
Merge 2.7, resolving conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory_delta.py
22
22
 - InventoryDeltaSerializer - object to read/write inventory deltas.
23
23
"""
24
24
 
 
25
from __future__ import absolute_import
 
26
 
25
27
__all__ = ['InventoryDeltaSerializer']
26
28
 
27
29
from bzrlib import errors
29
31
from bzrlib import inventory
30
32
from bzrlib.revision import NULL_REVISION
31
33
 
 
34
FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
 
35
 
 
36
 
 
37
class InventoryDeltaError(errors.BzrError):
 
38
    """An error when serializing or deserializing an inventory delta."""
 
39
    
 
40
    # Most errors when serializing and deserializing are due to bugs, although
 
41
    # damaged input (i.e. a bug in a different process) could cause
 
42
    # deserialization errors too.
 
43
    internal_error = True
 
44
 
 
45
 
 
46
class IncompatibleInventoryDelta(errors.BzrError):
 
47
    """The delta could not be deserialised because its contents conflict with
 
48
    the allow_versioned_root or allow_tree_references flags of the
 
49
    deserializer.
 
50
    """
 
51
    internal_error = False
 
52
 
32
53
 
33
54
def _directory_content(entry):
34
55
    """Serialize the content component of entry which is a directory.
49
70
        exec_bytes = ''
50
71
    size_exec_sha = (entry.text_size, exec_bytes, entry.text_sha1)
51
72
    if None in size_exec_sha:
52
 
        raise errors.BzrError('Missing size or sha for %s' % entry.file_id)
 
73
        raise InventoryDeltaError('Missing size or sha for %s' % entry.file_id)
53
74
    return "file\x00%d\x00%s\x00%s" % size_exec_sha
54
75
 
55
76
 
60
81
    """
61
82
    target = entry.symlink_target
62
83
    if target is None:
63
 
        raise errors.BzrError('Missing target for %s' % entry.file_id)
 
84
        raise InventoryDeltaError('Missing target for %s' % entry.file_id)
64
85
    return "link\x00%s" % target.encode('utf8')
65
86
 
66
87
 
71
92
    """
72
93
    tree_revision = entry.reference_revision
73
94
    if tree_revision is None:
74
 
        raise errors.BzrError('Missing reference revision for %s' % entry.file_id)
 
95
        raise InventoryDeltaError(
 
96
            'Missing reference revision for %s' % entry.file_id)
75
97
    return "tree\x00%s" % tree_revision
76
98
 
77
99
 
115
137
    return result
116
138
 
117
139
 
118
 
 
119
140
class InventoryDeltaSerializer(object):
120
 
    """Serialize and deserialize inventory deltas."""
121
 
 
122
 
    FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
 
141
    """Serialize inventory deltas."""
123
142
 
124
143
    def __init__(self, versioned_root, tree_references):
125
144
        """Create an InventoryDeltaSerializer.
141
160
    def delta_to_lines(self, old_name, new_name, delta_to_new):
142
161
        """Return a line sequence for delta_to_new.
143
162
 
 
163
        Both the versioned_root and tree_references flags must be set via
 
164
        require_flags before calling this.
 
165
 
144
166
        :param old_name: A UTF8 revision id for the old inventory.  May be
145
167
            NULL_REVISION if there is no older inventory and delta_to_new
146
168
            includes the entire inventory contents.
150
172
            takes.
151
173
        :return: The serialized delta as lines.
152
174
        """
 
175
        if type(old_name) is not str:
 
176
            raise TypeError('old_name should be str, got %r' % (old_name,))
 
177
        if type(new_name) is not str:
 
178
            raise TypeError('new_name should be str, got %r' % (new_name,))
153
179
        lines = ['', '', '', '', '']
154
180
        to_line = self._delta_item_to_line
155
181
        for delta_item in delta_to_new:
156
 
            lines.append(to_line(delta_item))
157
 
            if lines[-1].__class__ != str:
158
 
                raise errors.BzrError(
 
182
            line = to_line(delta_item, new_name)
 
183
            if line.__class__ != str:
 
184
                raise InventoryDeltaError(
159
185
                    'to_line generated non-str output %r' % lines[-1])
 
186
            lines.append(line)
160
187
        lines.sort()
161
 
        lines[0] = "format: %s\n" % InventoryDeltaSerializer.FORMAT_1
 
188
        lines[0] = "format: %s\n" % FORMAT_1
162
189
        lines[1] = "parent: %s\n" % old_name
163
190
        lines[2] = "version: %s\n" % new_name
164
191
        lines[3] = "versioned_root: %s\n" % self._serialize_bool(
173
200
        else:
174
201
            return "false"
175
202
 
176
 
    def _delta_item_to_line(self, delta_item):
 
203
    def _delta_item_to_line(self, delta_item, new_version):
177
204
        """Convert delta_item to a line."""
178
205
        oldpath, newpath, file_id, entry = delta_item
179
206
        if newpath is None:
188
215
                oldpath_utf8 = 'None'
189
216
            else:
190
217
                oldpath_utf8 = '/' + oldpath.encode('utf8')
 
218
            if newpath == '/':
 
219
                raise AssertionError(
 
220
                    "Bad inventory delta: '/' is not a valid newpath "
 
221
                    "(should be '') in delta item %r" % (delta_item,))
191
222
            # TODO: Test real-world utf8 cache hit rate. It may be a win.
192
223
            newpath_utf8 = '/' + newpath.encode('utf8')
193
224
            # Serialize None as ''
196
227
            last_modified = entry.revision
197
228
            # special cases for /
198
229
            if newpath_utf8 == '/' and not self._versioned_root:
199
 
                if file_id != 'TREE_ROOT':
200
 
                    raise errors.BzrError(
201
 
                        'file_id %s is not TREE_ROOT for /' % file_id)
202
 
                if last_modified is not None:
203
 
                    raise errors.BzrError(
204
 
                        'Version present for / in %s' % file_id)
205
 
                last_modified = NULL_REVISION
 
230
                # This is an entry for the root, this inventory does not
 
231
                # support versioned roots.  So this must be an unversioned
 
232
                # root, i.e. last_modified == new revision.  Otherwise, this
 
233
                # delta is invalid.
 
234
                # Note: the non-rich-root repositories *can* have roots with
 
235
                # file-ids other than TREE_ROOT, e.g. repo formats that use the
 
236
                # xml5 serializer.
 
237
                if last_modified != new_version:
 
238
                    raise InventoryDeltaError(
 
239
                        'Version present for / in %s (%s != %s)'
 
240
                        % (file_id, last_modified, new_version))
206
241
            if last_modified is None:
207
 
                raise errors.BzrError("no version for fileid %s" % file_id)
 
242
                raise InventoryDeltaError("no version for fileid %s" % file_id)
208
243
            content = self._entry_to_content[entry.kind](entry)
209
244
        return ("%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
210
245
            (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
211
246
                content))
212
247
 
 
248
 
 
249
class InventoryDeltaDeserializer(object):
 
250
    """Deserialize inventory deltas."""
 
251
 
 
252
    def __init__(self, allow_versioned_root=True, allow_tree_references=True):
 
253
        """Create an InventoryDeltaDeserializer.
 
254
 
 
255
        :param versioned_root: If True, any root entry that is seen is expected
 
256
            to be versioned, and root entries can have any fileid.
 
257
        :param tree_references: If True support tree-reference entries.
 
258
        """
 
259
        self._allow_versioned_root = allow_versioned_root
 
260
        self._allow_tree_references = allow_tree_references
 
261
 
213
262
    def _deserialize_bool(self, value):
214
263
        if value == "true":
215
264
            return True
216
265
        elif value == "false":
217
266
            return False
218
267
        else:
219
 
            raise errors.BzrError("value %r is not a bool" % (value,))
 
268
            raise InventoryDeltaError("value %r is not a bool" % (value,))
220
269
 
221
270
    def parse_text_bytes(self, bytes):
222
271
        """Parse the text bytes of a serialized inventory delta.
223
272
 
 
273
        If versioned_root and/or tree_references flags were set via
 
274
        require_flags, then the parsed flags must match or a BzrError will be
 
275
        raised.
 
276
 
224
277
        :param bytes: The bytes to parse. This can be obtained by calling
225
278
            delta_to_lines and then doing ''.join(delta_lines).
226
 
        :return: (parent_id, new_id, inventory_delta)
 
279
        :return: (parent_id, new_id, versioned_root, tree_references,
 
280
            inventory_delta)
227
281
        """
 
282
        if bytes[-1:] != '\n':
 
283
            last_line = bytes.rsplit('\n', 1)[-1]
 
284
            raise InventoryDeltaError('last line not empty: %r' % (last_line,))
228
285
        lines = bytes.split('\n')[:-1] # discard the last empty line
229
 
        if not lines or lines[0] != 'format: %s' % InventoryDeltaSerializer.FORMAT_1:
230
 
            raise errors.BzrError('unknown format %r' % lines[0:1])
 
286
        if not lines or lines[0] != 'format: %s' % FORMAT_1:
 
287
            raise InventoryDeltaError('unknown format %r' % lines[0:1])
231
288
        if len(lines) < 2 or not lines[1].startswith('parent: '):
232
 
            raise errors.BzrError('missing parent: marker')
 
289
            raise InventoryDeltaError('missing parent: marker')
233
290
        delta_parent_id = lines[1][8:]
234
291
        if len(lines) < 3 or not lines[2].startswith('version: '):
235
 
            raise errors.BzrError('missing version: marker')
 
292
            raise InventoryDeltaError('missing version: marker')
236
293
        delta_version_id = lines[2][9:]
237
294
        if len(lines) < 4 or not lines[3].startswith('versioned_root: '):
238
 
            raise errors.BzrError('missing versioned_root: marker')
 
295
            raise InventoryDeltaError('missing versioned_root: marker')
239
296
        delta_versioned_root = self._deserialize_bool(lines[3][16:])
240
297
        if len(lines) < 5 or not lines[4].startswith('tree_references: '):
241
 
            raise errors.BzrError('missing tree_references: marker')
 
298
            raise InventoryDeltaError('missing tree_references: marker')
242
299
        delta_tree_references = self._deserialize_bool(lines[4][17:])
243
 
        if delta_versioned_root != self._versioned_root:
244
 
            raise errors.BzrError(
245
 
                "serialized versioned_root flag is wrong: %s" %
246
 
                (delta_versioned_root,))
247
 
        if delta_tree_references != self._tree_references:
248
 
            raise errors.BzrError(
249
 
                "serialized tree_references flag is wrong: %s" %
250
 
                (delta_tree_references,))
 
300
        if (not self._allow_versioned_root and delta_versioned_root):
 
301
            raise IncompatibleInventoryDelta("versioned_root not allowed")
251
302
        result = []
252
303
        seen_ids = set()
253
304
        line_iter = iter(lines)
258
309
                content) = line.split('\x00', 5)
259
310
            parent_id = parent_id or None
260
311
            if file_id in seen_ids:
261
 
                raise errors.BzrError(
 
312
                raise InventoryDeltaError(
262
313
                    "duplicate file id in inventory delta %r" % lines)
263
314
            seen_ids.add(file_id)
264
 
            if newpath_utf8 == '/' and not delta_versioned_root and (
265
 
                last_modified != 'null:' or file_id != 'TREE_ROOT'):
266
 
                    raise errors.BzrError("Versioned root found: %r" % line)
267
 
            elif last_modified[-1] == ':':
268
 
                    raise errors.BzrError('special revisionid found: %r' % line)
269
 
            if not delta_tree_references and content.startswith('tree\x00'):
270
 
                raise errors.BzrError("Tree reference found: %r" % line)
271
 
            content_tuple = tuple(content.split('\x00'))
272
 
            entry = _parse_entry(
273
 
                newpath_utf8, file_id, parent_id, last_modified, content_tuple)
 
315
            if (newpath_utf8 == '/' and not delta_versioned_root and
 
316
                last_modified != delta_version_id):
 
317
                    # Delta claims to be not have a versioned root, yet here's
 
318
                    # a root entry with a non-default version.
 
319
                    raise InventoryDeltaError("Versioned root found: %r" % line)
 
320
            elif newpath_utf8 != 'None' and last_modified[-1] == ':':
 
321
                # Deletes have a last_modified of null:, but otherwise special
 
322
                # revision ids should not occur.
 
323
                raise InventoryDeltaError('special revisionid found: %r' % line)
 
324
            if content.startswith('tree\x00'):
 
325
                if delta_tree_references is False:
 
326
                    raise InventoryDeltaError(
 
327
                            "Tree reference found (but header said "
 
328
                            "tree_references: false): %r" % line)
 
329
                elif not self._allow_tree_references:
 
330
                    raise IncompatibleInventoryDelta(
 
331
                        "Tree reference not allowed")
274
332
            if oldpath_utf8 == 'None':
275
333
                oldpath = None
 
334
            elif oldpath_utf8[:1] != '/':
 
335
                raise InventoryDeltaError(
 
336
                    "oldpath invalid (does not start with /): %r"
 
337
                    % (oldpath_utf8,))
276
338
            else:
 
339
                oldpath_utf8 = oldpath_utf8[1:]
277
340
                oldpath = oldpath_utf8.decode('utf8')
278
341
            if newpath_utf8 == 'None':
279
342
                newpath = None
 
343
            elif newpath_utf8[:1] != '/':
 
344
                raise InventoryDeltaError(
 
345
                    "newpath invalid (does not start with /): %r"
 
346
                    % (newpath_utf8,))
280
347
            else:
 
348
                # Trim leading slash
 
349
                newpath_utf8 = newpath_utf8[1:]
281
350
                newpath = newpath_utf8.decode('utf8')
 
351
            content_tuple = tuple(content.split('\x00'))
 
352
            if content_tuple[0] == 'deleted':
 
353
                entry = None
 
354
            else:
 
355
                entry = _parse_entry(
 
356
                    newpath, file_id, parent_id, last_modified, content_tuple)
282
357
            delta_item = (oldpath, newpath, file_id, entry)
283
358
            result.append(delta_item)
284
 
        return delta_parent_id, delta_version_id, result
285
 
 
286
 
 
287
 
def _parse_entry(utf8_path, file_id, parent_id, last_modified, content):
 
359
        return (delta_parent_id, delta_version_id, delta_versioned_root,
 
360
                delta_tree_references, result)
 
361
 
 
362
 
 
363
def _parse_entry(path, file_id, parent_id, last_modified, content):
288
364
    entry_factory = {
289
365
        'dir': _dir_to_entry,
290
366
        'file': _file_to_entry,
292
368
        'tree': _tree_to_entry,
293
369
    }
294
370
    kind = content[0]
295
 
    path = utf8_path[1:].decode('utf8')
 
371
    if path.startswith('/'):
 
372
        raise AssertionError
296
373
    name = basename(path)
297
374
    return entry_factory[content[0]](
298
375
            content, name, parent_id, file_id, last_modified)
299
376
 
 
377