/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 breezy/bzr/xml_serializer.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/bzr/xml_serializer.py
16
16
 
17
17
"""XML externalization support."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
# "XML is like violence: if it doesn't solve your problem, you aren't
20
22
# using enough of it." -- various
21
23
 
22
24
# importing this module is fairly slow because it has to load several
23
25
# ElementTree bits
24
26
 
25
 
from bzrlib.serializer import Serializer
26
 
from bzrlib.trace import mutter
 
27
import re
27
28
 
28
29
try:
 
30
    import xml.etree.cElementTree as elementtree
 
31
    from xml.etree.ElementTree import ParseError
 
32
except ImportError:
 
33
    # Fall back to pure python implementation if C extension is unavailable
 
34
    import xml.etree.ElementTree as elementtree
29
35
    try:
30
 
        # it's in this package in python2.5
31
 
        from xml.etree.cElementTree import (ElementTree, SubElement, Element,
32
 
            XMLTreeBuilder, fromstring, tostring)
33
 
        import xml.etree as elementtree
 
36
        from xml.etree.ElementTree import ParseError
34
37
    except ImportError:
35
 
        from cElementTree import (ElementTree, SubElement, Element,
36
 
                                  XMLTreeBuilder, fromstring, tostring)
37
 
        import elementtree.ElementTree
38
 
    ParseError = SyntaxError
39
 
except ImportError:
40
 
    mutter('WARNING: using slower ElementTree; consider installing cElementTree'
41
 
           " and make sure it's on your PYTHONPATH")
42
 
    # this copy is shipped with bzr
43
 
    from util.elementtree.ElementTree import (ElementTree, SubElement,
44
 
                                              Element, XMLTreeBuilder,
45
 
                                              fromstring, tostring)
46
 
    import util.elementtree as elementtree
47
 
    from xml.parsers.expat import ExpatError as ParseError
48
 
 
49
 
from bzrlib import errors
50
 
 
51
 
 
52
 
class XMLSerializer(Serializer):
 
38
        from xml.parsers.expat import ExpatError as ParseError
 
39
 
 
40
(ElementTree, SubElement, Element, fromstringlist, tostringlist, tostring,
 
41
 fromstring) = (
 
42
    elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
 
43
    elementtree.fromstringlist, elementtree.tostringlist, elementtree.tostring,
 
44
    elementtree.fromstring)
 
45
 
 
46
 
 
47
from .. import (
 
48
    cache_utf8,
 
49
    errors,
 
50
    lazy_regex,
 
51
    )
 
52
from ..sixish import text_type, bytesintern
 
53
from . import (
 
54
    inventory,
 
55
    serializer,
 
56
    )
 
57
 
 
58
 
 
59
class XMLSerializer(serializer.Serializer):
53
60
    """Abstract XML object serialize/deserialize"""
54
61
 
55
62
    squashes_xml_invalid_characters = True
56
63
 
57
 
    def read_inventory_from_string(self, xml_string, revision_id=None,
58
 
                                   entry_cache=None, return_from_cache=False):
 
64
    def read_inventory_from_lines(self, lines, revision_id=None,
 
65
                                  entry_cache=None, return_from_cache=False):
59
66
        """Read xml_string into an inventory object.
60
67
 
61
 
        :param xml_string: The xml to read.
 
68
        :param chunks: The xml to read.
62
69
        :param revision_id: If not-None, the expected revision id of the
63
70
            inventory. Some serialisers use this to set the results' root
64
71
            revision. This should be supplied for deserialising all
75
82
            make some operations significantly faster.
76
83
        """
77
84
        try:
78
 
            return self._unpack_inventory(fromstring(xml_string), revision_id,
 
85
            return self._unpack_inventory(fromstringlist(lines), revision_id,
79
86
                                          entry_cache=entry_cache,
80
87
                                          return_from_cache=return_from_cache)
81
 
        except ParseError, e:
82
 
            raise errors.UnexpectedInventoryFormat(e)
 
88
        except ParseError as e:
 
89
            raise errors.UnexpectedInventoryFormat(str(e))
83
90
 
84
91
    def read_inventory(self, f, revision_id=None):
85
92
        try:
86
 
            return self._unpack_inventory(self._read_element(f),
87
 
                revision_id=None)
88
 
        except ParseError, e:
89
 
            raise errors.UnexpectedInventoryFormat(e)
90
 
 
91
 
    def write_revision(self, rev, f):
92
 
        self._write_element(self._pack_revision(rev), f)
 
93
            try:
 
94
                return self._unpack_inventory(self._read_element(f),
 
95
                                              revision_id=None)
 
96
            finally:
 
97
                f.close()
 
98
        except ParseError as e:
 
99
            raise errors.UnexpectedInventoryFormat(str(e))
93
100
 
94
101
    def write_revision_to_string(self, rev):
95
 
        return tostring(self._pack_revision(rev)) + '\n'
 
102
        return b''.join(self.write_revision_to_lines(rev))
96
103
 
97
104
    def read_revision(self, f):
98
105
        return self._unpack_revision(self._read_element(f))
100
107
    def read_revision_from_string(self, xml_string):
101
108
        return self._unpack_revision(fromstring(xml_string))
102
109
 
103
 
    def _write_element(self, elt, f):
104
 
        ElementTree(elt).write(f, 'utf-8')
105
 
        f.write('\n')
106
 
 
107
110
    def _read_element(self, f):
108
111
        return ElementTree().parse(f)
109
112
 
110
113
 
111
 
# performance tuning for elementree's serialiser. This should be
112
 
# sent upstream - RBC 20060523.
113
 
# the functions here are patched into elementtree at runtime.
114
 
import re
115
 
escape_re = re.compile("[&'\"<>]")
116
 
escape_map = {
117
 
    "&":'&amp;',
118
 
    "'":"&apos;", # FIXME: overkill
119
 
    "\"":"&quot;",
120
 
    "<":"&lt;",
121
 
    ">":"&gt;",
122
 
    }
123
 
def _escape_replace(match, map=escape_map):
124
 
    return map[match.group()]
125
 
 
126
 
def _escape_attrib(text, encoding=None, replace=None):
127
 
    # escape attribute value
128
 
    try:
129
 
        if encoding:
130
 
            try:
131
 
                text = elementtree.ElementTree._encode(text, encoding)
132
 
            except UnicodeError:
133
 
                return elementtree.ElementTree._encode_entity(text)
134
 
        if replace is None:
135
 
            return escape_re.sub(_escape_replace, text)
136
 
        else:
137
 
            text = replace(text, "&", "&amp;")
138
 
            text = replace(text, "'", "&apos;") # FIXME: overkill
139
 
            text = replace(text, "\"", "&quot;")
140
 
            text = replace(text, "<", "&lt;")
141
 
            text = replace(text, ">", "&gt;")
142
 
            return text
143
 
    except (TypeError, AttributeError):
144
 
        elementtree.ElementTree._raise_serialization_error(text)
145
 
 
146
 
elementtree.ElementTree._escape_attrib = _escape_attrib
147
 
 
148
 
escape_cdata_re = re.compile("[&<>]")
149
 
escape_cdata_map = {
150
 
    "&":'&amp;',
151
 
    "<":"&lt;",
152
 
    ">":"&gt;",
153
 
    }
154
 
def _escape_cdata_replace(match, map=escape_cdata_map):
155
 
    return map[match.group()]
156
 
 
157
 
def _escape_cdata(text, encoding=None, replace=None):
158
 
    # escape character data
159
 
    try:
160
 
        if encoding:
161
 
            try:
162
 
                text = elementtree.ElementTree._encode(text, encoding)
163
 
            except UnicodeError:
164
 
                return elementtree.ElementTree._encode_entity(text)
165
 
        if replace is None:
166
 
            return escape_cdata_re.sub(_escape_cdata_replace, text)
167
 
        else:
168
 
            text = replace(text, "&", "&amp;")
169
 
            text = replace(text, "<", "&lt;")
170
 
            text = replace(text, ">", "&gt;")
171
 
            return text
172
 
    except (TypeError, AttributeError):
173
 
        elementtree.ElementTree._raise_serialization_error(text)
174
 
 
175
 
elementtree.ElementTree._escape_cdata = _escape_cdata
176
 
 
177
 
 
178
114
def escape_invalid_chars(message):
179
115
    """Escape the XML-invalid characters in a commit message.
180
116
 
188
124
    # aren't listed in the XML specification
189
125
    # (http://www.w3.org/TR/REC-xml/#NT-Char).
190
126
    return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
191
 
            lambda match: match.group(0).encode('unicode_escape'),
192
 
            message)
 
127
                   lambda match: match.group(0).encode(
 
128
                       'unicode_escape').decode('ascii'),
 
129
                   message)
 
130
 
 
131
 
 
132
def get_utf8_or_ascii(a_str, _encode_utf8=cache_utf8.encode):
 
133
    """Return a cached version of the string.
 
134
 
 
135
    cElementTree will return a plain string if the XML is plain ascii. It only
 
136
    returns Unicode when it needs to. We want to work in utf-8 strings. So if
 
137
    cElementTree returns a plain string, we can just return the cached version.
 
138
    If it is Unicode, then we need to encode it.
 
139
 
 
140
    :param a_str: An 8-bit string or Unicode as returned by
 
141
                  cElementTree.Element.get()
 
142
    :return: A utf-8 encoded 8-bit string.
 
143
    """
 
144
    # This is fairly optimized because we know what cElementTree does, this is
 
145
    # not meant as a generic function for all cases. Because it is possible for
 
146
    # an 8-bit string to not be ascii or valid utf8.
 
147
    if a_str.__class__ is text_type:
 
148
        return _encode_utf8(a_str)
 
149
    else:
 
150
        return bytesintern(a_str)
 
151
 
 
152
 
 
153
_utf8_re = lazy_regex.lazy_compile(b'[&<>\'\"]|[\x80-\xff]+')
 
154
_unicode_re = lazy_regex.lazy_compile(u'[&<>\'\"\u0080-\uffff]')
 
155
 
 
156
 
 
157
_xml_escape_map = {
 
158
    "&": '&amp;',
 
159
    "'": "&apos;",  # FIXME: overkill
 
160
    "\"": "&quot;",
 
161
    "<": "&lt;",
 
162
    ">": "&gt;",
 
163
    }
 
164
 
 
165
 
 
166
def _unicode_escape_replace(match, _map=_xml_escape_map):
 
167
    """Replace a string of non-ascii, non XML safe characters with their escape
 
168
 
 
169
    This will escape both Standard XML escapes, like <>"', etc.
 
170
    As well as escaping non ascii characters, because ElementTree did.
 
171
    This helps us remain compatible to older versions of bzr. We may change
 
172
    our policy in the future, though.
 
173
    """
 
174
    # jam 20060816 Benchmarks show that try/KeyError is faster if you
 
175
    # expect the entity to rarely miss. There is about a 10% difference
 
176
    # in overall time. But if you miss frequently, then if None is much
 
177
    # faster. For our use case, we *rarely* have a revision id, file id
 
178
    # or path name that is unicode. So use try/KeyError.
 
179
    try:
 
180
        return _map[match.group()]
 
181
    except KeyError:
 
182
        return "&#%d;" % ord(match.group())
 
183
 
 
184
 
 
185
def _utf8_escape_replace(match, _map=_xml_escape_map):
 
186
    """Escape utf8 characters into XML safe ones.
 
187
 
 
188
    This uses 2 tricks. It is either escaping "standard" characters, like "&<>,
 
189
    or it is handling characters with the high-bit set. For ascii characters,
 
190
    we just lookup the replacement in the dictionary. For everything else, we
 
191
    decode back into Unicode, and then use the XML escape code.
 
192
    """
 
193
    try:
 
194
        return _map[match.group().decode('ascii', 'replace')].encode()
 
195
    except KeyError:
 
196
        return b''.join(b'&#%d;' % ord(uni_chr)
 
197
                        for uni_chr in match.group().decode('utf8'))
 
198
 
 
199
 
 
200
_to_escaped_map = {}
 
201
 
 
202
 
 
203
def encode_and_escape(unicode_or_utf8_str, _map=_to_escaped_map):
 
204
    """Encode the string into utf8, and escape invalid XML characters"""
 
205
    # We frequently get entities we have not seen before, so it is better
 
206
    # to check if None, rather than try/KeyError
 
207
    text = _map.get(unicode_or_utf8_str)
 
208
    if text is None:
 
209
        if isinstance(unicode_or_utf8_str, text_type):
 
210
            # The alternative policy is to do a regular UTF8 encoding
 
211
            # and then escape only XML meta characters.
 
212
            # Performance is equivalent once you use cache_utf8. *However*
 
213
            # this makes the serialized texts incompatible with old versions
 
214
            # of bzr. So no net gain. (Perhaps the read code would handle utf8
 
215
            # better than entity escapes, but cElementTree seems to do just
 
216
            # fine either way)
 
217
            text = _unicode_re.sub(
 
218
                _unicode_escape_replace, unicode_or_utf8_str).encode()
 
219
        else:
 
220
            # Plain strings are considered to already be in utf-8 so we do a
 
221
            # slightly different method for escaping.
 
222
            text = _utf8_re.sub(_utf8_escape_replace,
 
223
                                unicode_or_utf8_str)
 
224
        _map[unicode_or_utf8_str] = text
 
225
    return text
 
226
 
 
227
 
 
228
def _clear_cache():
 
229
    """Clean out the unicode => escaped map"""
 
230
    _to_escaped_map.clear()
 
231
 
 
232
 
 
233
def unpack_inventory_entry(elt, entry_cache=None, return_from_cache=False):
 
234
    elt_get = elt.get
 
235
    file_id = elt_get('file_id')
 
236
    revision = elt_get('revision')
 
237
    # Check and see if we have already unpacked this exact entry
 
238
    # Some timings for "repo.revision_trees(last_100_revs)"
 
239
    #               bzr     mysql
 
240
    #   unmodified  4.1s    40.8s
 
241
    #   using lru   3.5s
 
242
    #   using fifo  2.83s   29.1s
 
243
    #   lru._cache  2.8s
 
244
    #   dict        2.75s   26.8s
 
245
    #   inv.add     2.5s    26.0s
 
246
    #   no_copy     2.00s   20.5s
 
247
    #   no_c,dict   1.95s   18.0s
 
248
    # Note that a cache of 10k nodes is more than sufficient to hold all of
 
249
    # the inventory for the last 100 revs for bzr, but not for mysql (20k
 
250
    # is enough for mysql, which saves the same 2s as using a dict)
 
251
 
 
252
    # Breakdown of mysql using time.clock()
 
253
    #   4.1s    2 calls to element.get for file_id, revision_id
 
254
    #   4.5s    cache_hit lookup
 
255
    #   7.1s    InventoryFile.copy()
 
256
    #   2.4s    InventoryDirectory.copy()
 
257
    #   0.4s    decoding unique entries
 
258
    #   1.6s    decoding entries after FIFO fills up
 
259
    #   0.8s    Adding nodes to FIFO (including flushes)
 
260
    #   0.1s    cache miss lookups
 
261
    # Using an LRU cache
 
262
    #   4.1s    2 calls to element.get for file_id, revision_id
 
263
    #   9.9s    cache_hit lookup
 
264
    #   10.8s   InventoryEntry.copy()
 
265
    #   0.3s    cache miss lookus
 
266
    #   1.2s    decoding entries
 
267
    #   1.0s    adding nodes to LRU
 
268
    if entry_cache is not None and revision is not None:
 
269
        key = (file_id, revision)
 
270
        try:
 
271
            # We copy it, because some operations may mutate it
 
272
            cached_ie = entry_cache[key]
 
273
        except KeyError:
 
274
            pass
 
275
        else:
 
276
            # Only copying directory entries drops us 2.85s => 2.35s
 
277
            if return_from_cache:
 
278
                if cached_ie.kind == 'directory':
 
279
                    return cached_ie.copy()
 
280
                return cached_ie
 
281
            return cached_ie.copy()
 
282
 
 
283
    kind = elt.tag
 
284
    if not inventory.InventoryEntry.versionable_kind(kind):
 
285
        raise AssertionError('unsupported entry kind %s' % kind)
 
286
 
 
287
    file_id = get_utf8_or_ascii(file_id)
 
288
    if revision is not None:
 
289
        revision = get_utf8_or_ascii(revision)
 
290
    parent_id = elt_get('parent_id')
 
291
    if parent_id is not None:
 
292
        parent_id = get_utf8_or_ascii(parent_id)
 
293
 
 
294
    if kind == 'directory':
 
295
        ie = inventory.InventoryDirectory(file_id,
 
296
                                          elt_get('name'),
 
297
                                          parent_id)
 
298
    elif kind == 'file':
 
299
        ie = inventory.InventoryFile(file_id,
 
300
                                     elt_get('name'),
 
301
                                     parent_id)
 
302
        ie.text_sha1 = elt_get('text_sha1')
 
303
        if ie.text_sha1 is not None:
 
304
            ie.text_sha1 = ie.text_sha1.encode('ascii')
 
305
        if elt_get('executable') == 'yes':
 
306
            ie.executable = True
 
307
        v = elt_get('text_size')
 
308
        ie.text_size = v and int(v)
 
309
    elif kind == 'symlink':
 
310
        ie = inventory.InventoryLink(file_id,
 
311
                                     elt_get('name'),
 
312
                                     parent_id)
 
313
        ie.symlink_target = elt_get('symlink_target')
 
314
    elif kind == 'tree-reference':
 
315
        file_id = get_utf8_or_ascii(elt.attrib['file_id'])
 
316
        name = elt.attrib['name']
 
317
        parent_id = get_utf8_or_ascii(elt.attrib['parent_id'])
 
318
        revision = get_utf8_or_ascii(elt.get('revision'))
 
319
        reference_revision = get_utf8_or_ascii(elt.get('reference_revision'))
 
320
        ie = inventory.TreeReference(file_id, name, parent_id, revision,
 
321
                                     reference_revision)
 
322
    else:
 
323
        raise errors.UnsupportedInventoryKind(kind)
 
324
    ie.revision = revision
 
325
    if revision is not None and entry_cache is not None:
 
326
        # We cache a copy() because callers like to mutate objects, and
 
327
        # that would cause the item in cache to mutate as well.
 
328
        # This has a small effect on many-inventory performance, because
 
329
        # the majority fraction is spent in cache hits, not misses.
 
330
        entry_cache[key] = ie.copy()
 
331
 
 
332
    return ie
 
333
 
 
334
 
 
335
def unpack_inventory_flat(elt, format_num, unpack_entry,
 
336
                          entry_cache=None, return_from_cache=False):
 
337
    """Unpack a flat XML inventory.
 
338
 
 
339
    :param elt: XML element for the inventory
 
340
    :param format_num: Expected format number
 
341
    :param unpack_entry: Function for unpacking inventory entries
 
342
    :return: An inventory
 
343
    :raise UnexpectedInventoryFormat: When unexpected elements or data is
 
344
        encountered
 
345
    """
 
346
    if elt.tag != 'inventory':
 
347
        raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
 
348
    format = elt.get('format')
 
349
    if ((format is None and format_num is not None) or
 
350
            format.encode() != format_num):
 
351
        raise errors.UnexpectedInventoryFormat('Invalid format version %r'
 
352
                                               % format)
 
353
    revision_id = elt.get('revision_id')
 
354
    if revision_id is not None:
 
355
        revision_id = cache_utf8.encode(revision_id)
 
356
    inv = inventory.Inventory(root_id=None, revision_id=revision_id)
 
357
    for e in elt:
 
358
        ie = unpack_entry(e, entry_cache, return_from_cache)
 
359
        inv.add(ie)
 
360
    return inv
 
361
 
 
362
 
 
363
def serialize_inventory_flat(inv, append, root_id, supported_kinds, working):
 
364
    """Serialize an inventory to a flat XML file.
 
365
 
 
366
    :param inv: Inventory to serialize
 
367
    :param append: Function for writing a line of output
 
368
    :param working: If True skip history data - text_sha1, text_size,
 
369
        reference_revision, symlink_target.    self._check_revisions(inv)
 
370
    """
 
371
    entries = inv.iter_entries()
 
372
    # Skip the root
 
373
    root_path, root_ie = next(entries)
 
374
    for path, ie in entries:
 
375
        if ie.parent_id != root_id:
 
376
            parent_str = b''.join(
 
377
                [b' parent_id="', encode_and_escape(ie.parent_id), b'"'])
 
378
        else:
 
379
            parent_str = b''
 
380
        if ie.kind == 'file':
 
381
            if ie.executable:
 
382
                executable = b' executable="yes"'
 
383
            else:
 
384
                executable = b''
 
385
            if not working:
 
386
                append(b'<file%s file_id="%s" name="%s"%s revision="%s" '
 
387
                       b'text_sha1="%s" text_size="%d" />\n' % (
 
388
                           executable, encode_and_escape(ie.file_id),
 
389
                           encode_and_escape(ie.name), parent_str,
 
390
                           encode_and_escape(ie.revision), ie.text_sha1,
 
391
                           ie.text_size))
 
392
            else:
 
393
                append(b'<file%s file_id="%s" name="%s"%s />\n' % (
 
394
                    executable, encode_and_escape(ie.file_id),
 
395
                    encode_and_escape(ie.name), parent_str))
 
396
        elif ie.kind == 'directory':
 
397
            if not working:
 
398
                append(b'<directory file_id="%s" name="%s"%s revision="%s" '
 
399
                       b'/>\n' % (
 
400
                           encode_and_escape(ie.file_id),
 
401
                           encode_and_escape(ie.name),
 
402
                           parent_str,
 
403
                           encode_and_escape(ie.revision)))
 
404
            else:
 
405
                append(b'<directory file_id="%s" name="%s"%s />\n' % (
 
406
                    encode_and_escape(ie.file_id),
 
407
                    encode_and_escape(ie.name),
 
408
                    parent_str))
 
409
        elif ie.kind == 'symlink':
 
410
            if not working:
 
411
                append(b'<symlink file_id="%s" name="%s"%s revision="%s" '
 
412
                       b'symlink_target="%s" />\n' % (
 
413
                           encode_and_escape(ie.file_id),
 
414
                           encode_and_escape(ie.name),
 
415
                           parent_str,
 
416
                           encode_and_escape(ie.revision),
 
417
                           encode_and_escape(ie.symlink_target)))
 
418
            else:
 
419
                append(b'<symlink file_id="%s" name="%s"%s />\n' % (
 
420
                    encode_and_escape(ie.file_id),
 
421
                    encode_and_escape(ie.name),
 
422
                    parent_str))
 
423
        elif ie.kind == 'tree-reference':
 
424
            if ie.kind not in supported_kinds:
 
425
                raise errors.UnsupportedInventoryKind(ie.kind)
 
426
            if not working:
 
427
                append(b'<tree-reference file_id="%s" name="%s"%s '
 
428
                       b'revision="%s" reference_revision="%s" />\n' % (
 
429
                           encode_and_escape(ie.file_id),
 
430
                           encode_and_escape(ie.name),
 
431
                           parent_str,
 
432
                           encode_and_escape(ie.revision),
 
433
                           encode_and_escape(ie.reference_revision)))
 
434
            else:
 
435
                append(b'<tree-reference file_id="%s" name="%s"%s />\n' % (
 
436
                    encode_and_escape(ie.file_id),
 
437
                    encode_and_escape(ie.name),
 
438
                    parent_str))
 
439
        else:
 
440
            raise errors.UnsupportedInventoryKind(ie.kind)
 
441
    append(b'</inventory>\n')