27
from bzrlib.serializer import Serializer
28
from bzrlib.trace import mutter
30
import xml.etree.cElementTree as elementtree
31
ParseError = getattr(elementtree, "ParseError", SyntaxError)
32
# it's in this package in python2.5
33
from xml.etree.cElementTree import (ElementTree, SubElement, Element,
34
XMLTreeBuilder, fromstring, tostring)
35
import xml.etree as elementtree
36
# Also import ElementTree module so monkey-patching below always works
37
import xml.etree.ElementTree
39
from cElementTree import (ElementTree, SubElement, Element,
40
XMLTreeBuilder, fromstring, tostring)
41
import elementtree.ElementTree
42
ParseError = SyntaxError
32
43
except ImportError:
33
# Fall back to pure python implementation if C extension is unavailable
34
import xml.etree.ElementTree as elementtree
36
from xml.etree.ElementTree import ParseError
38
from xml.parsers.expat import ExpatError as ParseError
40
(ElementTree, SubElement, Element, XMLTreeBuilder, fromstring, tostring) = (
41
elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
42
elementtree.XMLTreeBuilder, elementtree.fromstring, elementtree.tostring)
54
class XMLSerializer(serializer.Serializer):
44
mutter('WARNING: using slower ElementTree; consider installing cElementTree'
45
" and make sure it's on your PYTHONPATH")
46
# this copy is shipped with bzr
47
from util.elementtree.ElementTree import (ElementTree, SubElement,
48
Element, XMLTreeBuilder,
50
import util.elementtree as elementtree
51
from xml.parsers.expat import ExpatError as ParseError
53
from bzrlib import errors
56
class XMLSerializer(Serializer):
55
57
"""Abstract XML object serialize/deserialize"""
57
59
squashes_xml_invalid_characters = True
128
130
return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
129
131
lambda match: match.group(0).encode('unicode_escape'),
133
def get_utf8_or_ascii(a_str, _encode_utf8=cache_utf8.encode):
134
"""Return a cached version of the string.
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.
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.
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)
154
_utf8_re = lazy_regex.lazy_compile('[&<>\'\"]|[\x80-\xff]+')
155
_unicode_re = lazy_regex.lazy_compile(u'[&<>\'\"\u0080-\uffff]')
160
"'":"'", # FIXME: overkill
167
def _unicode_escape_replace(match, _map=_xml_escape_map):
168
"""Replace a string of non-ascii, non XML safe characters with their escape
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.
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.
181
return _map[match.group()]
183
return "&#%d;" % ord(match.group())
186
def _utf8_escape_replace(match, _map=_xml_escape_map):
187
"""Escape utf8 characters into XML safe ones.
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.
195
return _map[match.group()]
197
return ''.join('&#%d;' % ord(uni_chr)
198
for uni_chr in match.group().decode('utf8'))
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)
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
217
text = str(_unicode_re.sub(_unicode_escape_replace,
218
unicode_or_utf8_str)) + '"'
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
229
"""Clean out the unicode => escaped map"""
230
_to_escaped_map.clear()
233
def unpack_inventory_entry(elt, entry_cache=None, return_from_cache=False):
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)"
240
# unmodified 4.1s 40.8s
242
# using fifo 2.83s 29.1s
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)
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
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)
271
# We copy it, because some operations may mutate it
272
cached_ie = entry_cache[key]
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()
281
return cached_ie.copy()
284
if not inventory.InventoryEntry.versionable_kind(kind):
285
raise AssertionError('unsupported entry kind %s' % kind)
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)
294
if kind == 'directory':
295
ie = inventory.InventoryDirectory(file_id,
299
ie = inventory.InventoryFile(file_id,
302
ie.text_sha1 = elt_get('text_sha1')
303
if elt_get('executable') == 'yes':
305
v = elt_get('text_size')
306
ie.text_size = v and int(v)
307
elif kind == 'symlink':
308
ie = inventory.InventoryLink(file_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,
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()
333
def unpack_inventory_flat(elt, format_num, unpack_entry,
334
entry_cache=None, return_from_cache=False):
335
"""Unpack a flat XML inventory.
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
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'
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)
355
ie = unpack_entry(e, entry_cache, return_from_cache)
360
def serialize_inventory_flat(inv, append, root_id, supported_kinds, working):
361
"""Serialize an inventory to a flat XML file.
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)
368
entries = inv.iter_entries()
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)
378
if ie.kind == 'file':
380
executable = ' executable="yes"'
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,
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':
396
append('<directory file_id="%s name="%s%s%s revision="%s '
398
encode_and_escape(ie.file_id),
399
encode_and_escape(ie.name),
400
parent_str, parent_id,
401
encode_and_escape(ie.revision)))
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':
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)))
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)
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)))
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))
438
raise errors.UnsupportedInventoryKind(ie.kind)
439
append('</inventory>\n')
added
removed
bzrlib/xml_serializer.py
