← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml_serializer.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-09-03 22:30:56 UTC
  • mfrom: (3644.2.13 index_builder_cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20080903223056-b108iytb38xkznci
(jam) Streamline BTreeBuilder.add_node et al to make btree creation
        faster.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml_serializer.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
 
25
from bzrlib import registry
 
26
from bzrlib.trace import mutter, warning
28
27
 
29
28
try:
30
 
    import xml.etree.cElementTree as elementtree
31
 
    ParseError = getattr(elementtree, "ParseError", SyntaxError)
 
29
    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
 
34
    except ImportError:
 
35
        from cElementTree import (ElementTree, SubElement, Element,
 
36
                                  XMLTreeBuilder, fromstring, tostring)
 
37
        import elementtree.ElementTree
 
38
    ParseError = SyntaxError
32
39
except ImportError:
33
 
    # Fall back to pure python implementation if C extension is unavailable
34
 
    import xml.etree.ElementTree as elementtree
35
 
    try:
36
 
        from xml.etree.ElementTree import ParseError
37
 
    except ImportError:
38
 
        from xml.parsers.expat import ExpatError as ParseError
39
 
 
40
 
(ElementTree, SubElement, Element, XMLTreeBuilder, fromstring, tostring) = (
41
 
    elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
42
 
    elementtree.XMLTreeBuilder, elementtree.fromstring, elementtree.tostring)
43
 
 
44
 
 
45
 
from bzrlib import (
46
 
    cache_utf8,
47
 
    errors,
48
 
    inventory,
49
 
    lazy_regex,
50
 
    serializer,
51
 
    )
52
 
 
53
 
 
54
 
class XMLSerializer(serializer.Serializer):
55
 
    """Abstract XML object serialize/deserialize"""
56
 
 
57
 
    squashes_xml_invalid_characters = True
58
 
 
59
 
    def read_inventory_from_string(self, xml_string, revision_id=None,
60
 
                                   entry_cache=None, return_from_cache=False):
 
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 Serializer(object):
 
53
    """Abstract object serialize/deserialize"""
 
54
 
 
55
    def write_inventory(self, inv, f):
 
56
        """Write inventory to a file"""
 
57
        raise NotImplementedError(self.write_inventory)
 
58
 
 
59
    def write_inventory_to_string(self, inv):
 
60
        raise NotImplementedError(self.write_inventory_to_string)
 
61
 
 
62
    def read_inventory_from_string(self, xml_string, revision_id=None):
61
63
        """Read xml_string into an inventory object.
62
64
 
63
65
        :param xml_string: The xml to read.
68
70
            serialised without a revision identifier can be given the right
69
71
            revision id (but not for working tree inventories where users can
70
72
            edit the data without triggering checksum errors or anything).
71
 
        :param entry_cache: An optional cache of InventoryEntry objects. If
72
 
            supplied we will look up entries via (file_id, revision_id) which
73
 
            should map to a valid InventoryEntry (File/Directory/etc) object.
74
 
        :param return_from_cache: Return entries directly from the cache,
75
 
            rather than copying them first. This is only safe if the caller
76
 
            promises not to mutate the returned inventory entries, but it can
77
 
            make some operations significantly faster.
78
73
        """
79
74
        try:
80
 
            return self._unpack_inventory(fromstring(xml_string), revision_id,
81
 
                                          entry_cache=entry_cache,
82
 
                                          return_from_cache=return_from_cache)
 
75
            return self._unpack_inventory(fromstring(xml_string), revision_id)
83
76
        except ParseError, e:
84
77
            raise errors.UnexpectedInventoryFormat(e)
85
78
 
86
79
    def read_inventory(self, f, revision_id=None):
87
80
        try:
88
 
            try:
89
 
                return self._unpack_inventory(self._read_element(f),
90
 
                    revision_id=None)
91
 
            finally:
92
 
                f.close()
 
81
            return self._unpack_inventory(self._read_element(f),
 
82
                revision_id=None)
93
83
        except ParseError, e:
94
84
            raise errors.UnexpectedInventoryFormat(e)
95
85
 
113
103
        return ElementTree().parse(f)
114
104
 
115
105
 
116
 
def escape_invalid_chars(message):
117
 
    """Escape the XML-invalid characters in a commit message.
118
 
 
119
 
    :param message: Commit message to escape
120
 
    :return: tuple with escaped message and number of characters escaped
121
 
    """
122
 
    if message is None:
123
 
        return None, 0
124
 
    # Python strings can include characters that can't be
125
 
    # represented in well-formed XML; escape characters that
126
 
    # aren't listed in the XML specification
127
 
    # (http://www.w3.org/TR/REC-xml/#NT-Char).
128
 
    return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
129
 
            lambda match: match.group(0).encode('unicode_escape'),
130
 
            message)
131
 
 
132
 
 
133
 
def get_utf8_or_ascii(a_str, _encode_utf8=cache_utf8.encode):
134
 
    """Return a cached version of the string.
135
 
 
136
 
    cElementTree will return a plain string if the XML is plain ascii. It only
137
 
    returns Unicode when it needs to. We want to work in utf-8 strings. So if
138
 
    cElementTree returns a plain string, we can just return the cached version.
139
 
    If it is Unicode, then we need to encode it.
140
 
 
141
 
    :param a_str: An 8-bit string or Unicode as returned by
142
 
                  cElementTree.Element.get()
143
 
    :return: A utf-8 encoded 8-bit string.
144
 
    """
145
 
    # This is fairly optimized because we know what cElementTree does, this is
146
 
    # not meant as a generic function for all cases. Because it is possible for
147
 
    # an 8-bit string to not be ascii or valid utf8.
148
 
    if a_str.__class__ is unicode:
149
 
        return _encode_utf8(a_str)
150
 
    else:
151
 
        return intern(a_str)
152
 
 
153
 
 
154
 
_utf8_re = lazy_regex.lazy_compile('[&<>\'\"]|[\x80-\xff]+')
155
 
_unicode_re = lazy_regex.lazy_compile(u'[&<>\'\"\u0080-\uffff]')
156
 
 
157
 
 
158
 
_xml_escape_map = {
 
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 = {
159
112
    "&":'&amp;',
160
113
    "'":"&apos;", # FIXME: overkill
161
114
    "\"":"&quot;",
162
115
    "<":"&lt;",
163
116
    ">":"&gt;",
164
117
    }
165
 
 
166
 
 
167
 
def _unicode_escape_replace(match, _map=_xml_escape_map):
168
 
    """Replace a string of non-ascii, non XML safe characters with their escape
169
 
 
170
 
    This will escape both Standard XML escapes, like <>"', etc.
171
 
    As well as escaping non ascii characters, because ElementTree did.
172
 
    This helps us remain compatible to older versions of bzr. We may change
173
 
    our policy in the future, though.
174
 
    """
175
 
    # jam 20060816 Benchmarks show that try/KeyError is faster if you
176
 
    # expect the entity to rarely miss. There is about a 10% difference
177
 
    # in overall time. But if you miss frequently, then if None is much
178
 
    # faster. For our use case, we *rarely* have a revision id, file id
179
 
    # or path name that is unicode. So use try/KeyError.
180
 
    try:
181
 
        return _map[match.group()]
182
 
    except KeyError:
183
 
        return "&#%d;" % ord(match.group())
184
 
 
185
 
 
186
 
def _utf8_escape_replace(match, _map=_xml_escape_map):
187
 
    """Escape utf8 characters into XML safe ones.
188
 
 
189
 
    This uses 2 tricks. It is either escaping "standard" characters, like "&<>,
190
 
    or it is handling characters with the high-bit set. For ascii characters,
191
 
    we just lookup the replacement in the dictionary. For everything else, we
192
 
    decode back into Unicode, and then use the XML escape code.
193
 
    """
194
 
    try:
195
 
        return _map[match.group()]
196
 
    except KeyError:
197
 
        return ''.join('&#%d;' % ord(uni_chr)
198
 
                       for uni_chr in match.group().decode('utf8'))
199
 
 
200
 
 
201
 
_to_escaped_map = {}
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 unicode_or_utf8_str.__class__ is unicode:
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 fine
216
 
            # either way)
217
 
            text = str(_unicode_re.sub(_unicode_escape_replace,
218
 
                                       unicode_or_utf8_str)) + '"'
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 elt_get('executable') == 'yes':
304
 
            ie.executable = True
305
 
        v = elt_get('text_size')
306
 
        ie.text_size = v and int(v)
307
 
    elif kind == 'symlink':
308
 
        ie = inventory.InventoryLink(file_id,
309
 
                                     elt_get('name'),
310
 
                                     parent_id)
311
 
        ie.symlink_target = elt_get('symlink_target')
312
 
    elif kind == 'tree-reference':
313
 
        file_id = elt.attrib['file_id']
314
 
        name = elt.attrib['name']
315
 
        parent_id = elt.attrib['parent_id']
316
 
        revision = elt.get('revision')
317
 
        reference_revision = elt.get('reference_revision')
318
 
        ie = inventory.TreeReference(file_id, name, parent_id, revision,
319
 
                                       reference_revision)
320
 
    else:
321
 
        raise errors.UnsupportedInventoryKind(kind)
322
 
    ie.revision = revision
323
 
    if revision is not None and entry_cache is not None:
324
 
        # We cache a copy() because callers like to mutate objects, and
325
 
        # that would cause the item in cache to mutate as well.
326
 
        # This has a small effect on many-inventory performance, because
327
 
        # the majority fraction is spent in cache hits, not misses.
328
 
        entry_cache[key] = ie.copy()
329
 
 
330
 
    return ie
331
 
 
332
 
 
333
 
def unpack_inventory_flat(elt, format_num, unpack_entry,
334
 
            entry_cache=None, return_from_cache=False):
335
 
    """Unpack a flat XML inventory.
336
 
 
337
 
    :param elt: XML element for the inventory
338
 
    :param format_num: Expected format number
339
 
    :param unpack_entry: Function for unpacking inventory entries
340
 
    :return: An inventory
341
 
    :raise UnexpectedInventoryFormat: When unexpected elements or data is
342
 
        encountered
343
 
    """
344
 
    if elt.tag != 'inventory':
345
 
        raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
346
 
    format = elt.get('format')
347
 
    if format != format_num:
348
 
        raise errors.UnexpectedInventoryFormat('Invalid format version %r'
349
 
                                               % format)
350
 
    revision_id = elt.get('revision_id')
351
 
    if revision_id is not None:
352
 
        revision_id = cache_utf8.encode(revision_id)
353
 
    inv = inventory.Inventory(root_id=None, revision_id=revision_id)
354
 
    for e in elt:
355
 
        ie = unpack_entry(e, entry_cache, return_from_cache)
356
 
        inv.add(ie)
357
 
    return inv
358
 
 
359
 
 
360
 
def serialize_inventory_flat(inv, append, root_id, supported_kinds, working):
361
 
    """Serialize an inventory to a flat XML file.
362
 
 
363
 
    :param inv: Inventory to serialize
364
 
    :param append: Function for writing a line of output
365
 
    :param working: If True skip history data - text_sha1, text_size,
366
 
        reference_revision, symlink_target.    self._check_revisions(inv)
367
 
    """
368
 
    entries = inv.iter_entries()
369
 
    # Skip the root
370
 
    root_path, root_ie = entries.next()
371
 
    for path, ie in entries:
372
 
        if ie.parent_id != root_id:
373
 
            parent_str = ' parent_id="'
374
 
            parent_id  = encode_and_escape(ie.parent_id)
375
 
        else:
376
 
            parent_str = ''
377
 
            parent_id  = ''
378
 
        if ie.kind == 'file':
379
 
            if ie.executable:
380
 
                executable = ' executable="yes"'
381
 
            else:
382
 
                executable = ''
383
 
            if not working:
384
 
                append('<file%s file_id="%s name="%s%s%s revision="%s '
385
 
                    'text_sha1="%s" text_size="%d" />\n' % (
386
 
                    executable, encode_and_escape(ie.file_id),
387
 
                    encode_and_escape(ie.name), parent_str, parent_id,
388
 
                    encode_and_escape(ie.revision), ie.text_sha1,
389
 
                    ie.text_size))
390
 
            else:
391
 
                append('<file%s file_id="%s name="%s%s%s />\n' % (
392
 
                    executable, encode_and_escape(ie.file_id),
393
 
                    encode_and_escape(ie.name), parent_str, parent_id))
394
 
        elif ie.kind == 'directory':
395
 
            if not working:
396
 
                append('<directory file_id="%s name="%s%s%s revision="%s '
397
 
                    '/>\n' % (
398
 
                    encode_and_escape(ie.file_id),
399
 
                    encode_and_escape(ie.name),
400
 
                    parent_str, parent_id,
401
 
                    encode_and_escape(ie.revision)))
402
 
            else:
403
 
                append('<directory file_id="%s name="%s%s%s />\n' % (
404
 
                    encode_and_escape(ie.file_id),
405
 
                    encode_and_escape(ie.name),
406
 
                    parent_str, parent_id))
407
 
        elif ie.kind == 'symlink':
408
 
            if not working:
409
 
                append('<symlink file_id="%s name="%s%s%s revision="%s '
410
 
                    'symlink_target="%s />\n' % (
411
 
                    encode_and_escape(ie.file_id),
412
 
                    encode_and_escape(ie.name),
413
 
                    parent_str, parent_id,
414
 
                    encode_and_escape(ie.revision),
415
 
                    encode_and_escape(ie.symlink_target)))
416
 
            else:
417
 
                append('<symlink file_id="%s name="%s%s%s />\n' % (
418
 
                    encode_and_escape(ie.file_id),
419
 
                    encode_and_escape(ie.name),
420
 
                    parent_str, parent_id))
421
 
        elif ie.kind == 'tree-reference':
422
 
            if ie.kind not in supported_kinds:
423
 
                raise errors.UnsupportedInventoryKind(ie.kind)
424
 
            if not working:
425
 
                append('<tree-reference file_id="%s name="%s%s%s '
426
 
                    'revision="%s reference_revision="%s />\n' % (
427
 
                    encode_and_escape(ie.file_id),
428
 
                    encode_and_escape(ie.name),
429
 
                    parent_str, parent_id,
430
 
                    encode_and_escape(ie.revision),
431
 
                    encode_and_escape(ie.reference_revision)))
432
 
            else:
433
 
                append('<tree-reference file_id="%s name="%s%s%s />\n' % (
434
 
                    encode_and_escape(ie.file_id),
435
 
                    encode_and_escape(ie.name),
436
 
                    parent_str, parent_id))
437
 
        else:
438
 
            raise errors.UnsupportedInventoryKind(ie.kind)
439
 
    append('</inventory>\n')
 
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
class SerializerRegistry(registry.Registry):
 
174
    """Registry for serializer objects"""
 
175
 
 
176
 
 
177
format_registry = SerializerRegistry()
 
178
format_registry.register_lazy('4', 'bzrlib.xml4', 'serializer_v4')
 
179
format_registry.register_lazy('5', 'bzrlib.xml5', 'serializer_v5')
 
180
format_registry.register_lazy('6', 'bzrlib.xml6', 'serializer_v6')
 
181
format_registry.register_lazy('7', 'bzrlib.xml7', 'serializer_v7')
 
182
format_registry.register_lazy('8', 'bzrlib.xml8', 'serializer_v8')