1
# Copyright (C) 2005-2010 Canonical Ltd
2
# -*- coding: UTF-8 -*-
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
12
# GNU General Public License for more details.
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
"""XML externalization support."""
19
from __future__ import absolute_import
21
20
# "XML is like violence: if it doesn't solve your problem, you aren't
22
21
# using enough of it." -- various
24
23
# importing this module is fairly slow because it has to load several
26
from bzrlib.trace import mutter, warning
30
import xml.etree.cElementTree as elementtree
31
from xml.etree.ElementTree import ParseError
29
from cElementTree import (ElementTree, SubElement, Element,
30
XMLTreeBuilder, fromstring, tostring)
32
31
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, fromstringlist, tostringlist, tostring,
42
elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
43
elementtree.fromstringlist, elementtree.tostringlist, elementtree.tostring,
44
elementtree.fromstring)
52
from ..sixish import text_type, bytesintern
59
class XMLSerializer(serializer.Serializer):
60
"""Abstract XML object serialize/deserialize"""
62
squashes_xml_invalid_characters = True
64
def read_inventory_from_lines(self, lines, revision_id=None,
65
entry_cache=None, return_from_cache=False):
66
"""Read xml_string into an inventory object.
68
:param chunks: The xml to read.
69
:param revision_id: If not-None, the expected revision id of the
70
inventory. Some serialisers use this to set the results' root
71
revision. This should be supplied for deserialising all
72
from-repository inventories so that xml5 inventories that were
73
serialised without a revision identifier can be given the right
74
revision id (but not for working tree inventories where users can
75
edit the data without triggering checksum errors or anything).
76
:param entry_cache: An optional cache of InventoryEntry objects. If
77
supplied we will look up entries via (file_id, revision_id) which
78
should map to a valid InventoryEntry (File/Directory/etc) object.
79
:param return_from_cache: Return entries directly from the cache,
80
rather than copying them first. This is only safe if the caller
81
promises not to mutate the returned inventory entries, but it can
82
make some operations significantly faster.
85
return self._unpack_inventory(fromstringlist(lines), revision_id,
86
entry_cache=entry_cache,
87
return_from_cache=return_from_cache)
88
except ParseError as e:
89
raise errors.UnexpectedInventoryFormat(str(e))
91
def read_inventory(self, f, revision_id=None):
94
return self._unpack_inventory(self._read_element(f),
98
except ParseError as e:
99
raise errors.UnexpectedInventoryFormat(str(e))
32
## from warnings import warn
33
## warn('using slower ElementTree; consider installing cElementTree')
34
from util.elementtree.ElementTree import (ElementTree, SubElement,
35
Element, XMLTreeBuilder,
38
from bzrlib.errors import BzrError
41
class Serializer(object):
42
"""Abstract object serialize/deserialize"""
43
def write_inventory(self, inv, f):
44
"""Write inventory to a file"""
45
elt = self._pack_inventory(inv)
46
self._write_element(elt, f)
48
def write_inventory_to_string(self, inv):
49
return tostring(self._pack_inventory(inv))
51
def read_inventory_from_string(self, xml_string):
52
return self._unpack_inventory(fromstring(xml_string))
54
def read_inventory(self, f):
55
return self._unpack_inventory(self._read_element(f))
57
def write_revision(self, rev, f):
58
self._write_element(self._pack_revision(rev), f)
101
60
def write_revision_to_string(self, rev):
102
return b''.join(self.write_revision_to_lines(rev))
61
return tostring(self._pack_revision(rev), f)
104
63
def read_revision(self, f):
105
64
return self._unpack_revision(self._read_element(f))
107
66
def read_revision_from_string(self, xml_string):
108
67
return self._unpack_revision(fromstring(xml_string))
69
def _write_element(self, elt, f):
70
ElementTree(elt).write(f, 'utf-8')
110
73
def _read_element(self, f):
111
74
return ElementTree().parse(f)
114
def escape_invalid_chars(message):
115
"""Escape the XML-invalid characters in a commit message.
117
:param message: Commit message to escape
118
:return: tuple with escaped message and number of characters escaped
122
# Python strings can include characters that can't be
123
# represented in well-formed XML; escape characters that
124
# aren't listed in the XML specification
125
# (http://www.w3.org/TR/REC-xml/#NT-Char).
126
return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
127
lambda match: match.group(0).encode(
128
'unicode_escape').decode('ascii'),
132
def get_utf8_or_ascii(a_str, _encode_utf8=cache_utf8.encode):
133
"""Return a cached version of the string.
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.
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.
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)
150
return bytesintern(a_str)
153
_utf8_re = lazy_regex.lazy_compile(b'[&<>\'\"]|[\x80-\xff]+')
154
_unicode_re = lazy_regex.lazy_compile(u'[&<>\'\"\u0080-\uffff]')
159
"'": "'", # FIXME: overkill
166
def _unicode_escape_replace(match, _map=_xml_escape_map):
167
"""Replace a string of non-ascii, non XML safe characters with their escape
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.
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.
180
return _map[match.group()]
182
return "&#%d;" % ord(match.group())
185
def _utf8_escape_replace(match, _map=_xml_escape_map):
186
"""Escape utf8 characters into XML safe ones.
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.
194
return _map[match.group().decode('ascii', 'replace')].encode()
196
return b''.join(b'&#%d;' % ord(uni_chr)
197
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 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
217
text = _unicode_re.sub(
218
_unicode_escape_replace, unicode_or_utf8_str).encode()
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,
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 ie.text_sha1 is not None:
304
ie.text_sha1 = ie.text_sha1.encode('ascii')
305
if elt_get('executable') == 'yes':
307
v = elt_get('text_size')
308
ie.text_size = v and int(v)
309
elif kind == 'symlink':
310
ie = inventory.InventoryLink(file_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,
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()
335
def unpack_inventory_flat(elt, format_num, unpack_entry,
336
entry_cache=None, return_from_cache=False):
337
"""Unpack a flat XML inventory.
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
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'
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)
358
ie = unpack_entry(e, entry_cache, return_from_cache)
363
def serialize_inventory_flat(inv, append, root_id, supported_kinds, working):
364
"""Serialize an inventory to a flat XML file.
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)
371
entries = inv.iter_entries()
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'"'])
380
if ie.kind == 'file':
382
executable = b' executable="yes"'
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,
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':
398
append(b'<directory file_id="%s" name="%s"%s revision="%s" '
400
encode_and_escape(ie.file_id),
401
encode_and_escape(ie.name),
403
encode_and_escape(ie.revision)))
405
append(b'<directory file_id="%s" name="%s"%s />\n' % (
406
encode_and_escape(ie.file_id),
407
encode_and_escape(ie.name),
409
elif ie.kind == 'symlink':
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),
416
encode_and_escape(ie.revision),
417
encode_and_escape(ie.symlink_target)))
419
append(b'<symlink file_id="%s" name="%s"%s />\n' % (
420
encode_and_escape(ie.file_id),
421
encode_and_escape(ie.name),
423
elif ie.kind == 'tree-reference':
424
if ie.kind not in supported_kinds:
425
raise errors.UnsupportedInventoryKind(ie.kind)
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),
432
encode_and_escape(ie.revision),
433
encode_and_escape(ie.reference_revision)))
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),
440
raise errors.UnsupportedInventoryKind(ie.kind)
441
append(b'</inventory>\n')
added
removed
bzrlib/xml.py
