← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml_serializer.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-30 12:52:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6418.
  • Revision ID: jelmer@samba.org-20111230125254-igy1abnixsvulfqd
Simplify code a bit.

Show diffs side-by-side

added added

removed removed

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