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

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml_serializer.py
16
16
 
17
17
"""XML externalization support."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
# "XML is like violence: if it doesn't solve your problem, you aren't
22
20
# using enough of it." -- various
23
21
 
24
22
# importing this module is fairly slow because it has to load several
25
23
# ElementTree bits
26
24
 
27
 
import re
28
 
 
29
25
from bzrlib.serializer import Serializer
30
26
from bzrlib.trace import mutter
31
27
 
35
31
        from xml.etree.cElementTree import (ElementTree, SubElement, Element,
36
32
            XMLTreeBuilder, fromstring, tostring)
37
33
        import xml.etree as elementtree
38
 
        # Also import ElementTree module so monkey-patching below always works
39
 
        import xml.etree.ElementTree
40
34
    except ImportError:
41
35
        from cElementTree import (ElementTree, SubElement, Element,
42
36
                                  XMLTreeBuilder, fromstring, tostring)
52
46
    import util.elementtree as elementtree
53
47
    from xml.parsers.expat import ExpatError as ParseError
54
48
 
55
 
from bzrlib import (
56
 
    cache_utf8,
57
 
    inventory,
58
 
    lazy_regex,
59
 
    errors,
60
 
    )
 
49
from bzrlib import errors
61
50
 
62
51
 
63
52
class XMLSerializer(Serializer):
94
83
 
95
84
    def read_inventory(self, f, revision_id=None):
96
85
        try:
97
 
            try:
98
 
                return self._unpack_inventory(self._read_element(f),
99
 
                    revision_id=None)
100
 
            finally:
101
 
                f.close()
 
86
            return self._unpack_inventory(self._read_element(f),
 
87
                revision_id=None)
102
88
        except ParseError, e:
103
89
            raise errors.UnexpectedInventoryFormat(e)
104
90
 
122
108
        return ElementTree().parse(f)
123
109
 
124
110
 
 
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
 
125
178
def escape_invalid_chars(message):
126
179
    """Escape the XML-invalid characters in a commit message.
127
180
 
137
190
    return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
138
191
            lambda match: match.group(0).encode('unicode_escape'),
139
192
            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')