1
# Copyright (C) 2005-2010 Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
"""XML externalization support."""
19
from __future__ import absolute_import
19
21
# "XML is like violence: if it doesn't solve your problem, you aren't
20
22
# using enough of it." -- various
22
24
# importing this module is fairly slow because it has to load several
26
from util.cElementTree import (ElementTree, SubElement, Element,
30
import xml.etree.cElementTree as elementtree
31
ParseError = getattr(elementtree, "ParseError", SyntaxError)
28
32
except ImportError:
29
from util.elementtree.ElementTree import (ElementTree, SubElement,
30
Element, XMLTreeBuilder)
32
from bzrlib.inventory import ROOT_ID, Inventory, InventoryEntry
33
from bzrlib.revision import Revision, RevisionReference
34
from bzrlib.errors import BzrError
37
class Serializer(object):
38
"""Abstract object serialize/deserialize"""
39
def write_inventory(self, inv, f):
40
"""Write inventory to a file"""
41
elt = self._pack_inventory(inv)
42
self._write_element(elt, f)
44
def read_inventory_from_string(self, xml_string):
45
return self._unpack_inventory(self._parse_string(xml_string))
47
def read_inventory(self, f):
48
return self._unpack_inventory(self._read_element(f))
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):
55
"""Abstract XML object serialize/deserialize"""
57
squashes_xml_invalid_characters = True
59
def read_inventory_from_string(self, xml_string, revision_id=None,
60
entry_cache=None, return_from_cache=False):
61
"""Read xml_string into an inventory object.
63
:param xml_string: The xml to read.
64
:param revision_id: If not-None, the expected revision id of the
65
inventory. Some serialisers use this to set the results' root
66
revision. This should be supplied for deserialising all
67
from-repository inventories so that xml5 inventories that were
68
serialised without a revision identifier can be given the right
69
revision id (but not for working tree inventories where users can
70
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.
80
return self._unpack_inventory(fromstring(xml_string), revision_id,
81
entry_cache=entry_cache,
82
return_from_cache=return_from_cache)
84
raise errors.UnexpectedInventoryFormat(e)
86
def read_inventory(self, f, revision_id=None):
89
return self._unpack_inventory(self._read_element(f),
94
raise errors.UnexpectedInventoryFormat(e)
50
96
def write_revision(self, rev, f):
51
97
self._write_element(self._pack_revision(rev), f)
99
def write_revision_to_string(self, rev):
100
return tostring(self._pack_revision(rev)) + '\n'
53
102
def read_revision(self, f):
54
103
return self._unpack_revision(self._read_element(f))
56
105
def read_revision_from_string(self, xml_string):
57
return self._unpack_revision(self._parse_string(xml_string))
106
return self._unpack_revision(fromstring(xml_string))
59
108
def _write_element(self, elt, f):
60
109
ElementTree(elt).write(f, 'utf-8')
63
112
def _read_element(self, f):
64
113
return ElementTree().parse(f)
66
def _parse_string(self, xml_string):
67
parser = XMLTreeBuilder()
68
parser.feed(xml_string)
73
class _Serializer_v4(Serializer):
74
"""Version 0.0.4 serializer
76
You should use the serialzer_v4 singleton."""
80
def _pack_inventory(self, inv):
81
"""Convert to XML Element"""
82
e = Element('inventory')
84
if inv.root.file_id not in (None, ROOT_ID):
85
e.set('file_id', inv.root.file_id)
86
for path, ie in inv.iter_entries():
87
e.append(self._pack_entry(ie))
91
def _pack_entry(self, ie):
92
"""Convert InventoryEntry to XML element"""
94
e.set('name', ie.name)
95
e.set('file_id', ie.file_id)
96
e.set('kind', ie.kind)
98
if ie.text_size != None:
99
e.set('text_size', '%d' % ie.text_size)
101
for f in ['text_id', 'text_sha1']:
106
# to be conservative, we don't externalize the root pointers
107
# for now, leaving them as null in the xml form. in a future
108
# version it will be implied by nested elements.
109
if ie.parent_id != ROOT_ID:
110
assert isinstance(ie.parent_id, basestring)
111
e.set('parent_id', ie.parent_id)
118
def _unpack_inventory(self, elt):
119
"""Construct from XML Element
121
assert elt.tag == 'inventory'
122
root_id = elt.get('file_id') or ROOT_ID
123
inv = Inventory(root_id)
125
ie = self._unpack_entry(e)
126
if ie.parent_id == ROOT_ID:
127
ie.parent_id = root_id
132
def _unpack_entry(self, elt):
133
assert elt.tag == 'entry'
135
## original format inventories don't have a parent_id for
136
## nodes in the root directory, but it's cleaner to use one
138
parent_id = elt.get('parent_id')
139
if parent_id == None:
142
ie = InventoryEntry(elt.get('file_id'),
146
ie.text_id = elt.get('text_id')
147
ie.text_sha1 = elt.get('text_sha1')
149
## mutter("read inventoryentry: %r" % (elt.attrib))
151
v = elt.get('text_size')
116
def escape_invalid_chars(message):
117
"""Escape the XML-invalid characters in a commit message.
119
:param message: Commit message to escape
120
:return: tuple with escaped message and number of characters escaped
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'),
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')
152
306
ie.text_size = v and int(v)
157
def _pack_revision(self, rev):
158
"""Revision object -> xml tree"""
159
root = Element('revision',
160
committer = rev.committer,
161
timestamp = '%.9f' % rev.timestamp,
162
revision_id = rev.revision_id,
163
inventory_id = rev.inventory_id,
164
inventory_sha1 = rev.inventory_sha1,
167
root.set('timezone', str(rev.timezone))
170
msg = SubElement(root, 'message')
171
msg.text = rev.message
175
pelts = SubElement(root, 'parents')
176
pelts.tail = pelts.text = '\n'
177
for rr in rev.parents:
178
assert isinstance(rr, RevisionReference)
179
p = SubElement(pelts, 'revision_ref')
181
assert rr.revision_id
182
p.set('revision_id', rr.revision_id)
184
p.set('revision_sha1', rr.revision_sha1)
189
def _unpack_revision(self, elt):
190
"""XML Element -> Revision object"""
192
# <changeset> is deprecated...
193
if elt.tag not in ('revision', 'changeset'):
194
raise BzrError("unexpected tag in revision file: %r" % elt)
196
rev = Revision(committer = elt.get('committer'),
197
timestamp = float(elt.get('timestamp')),
198
revision_id = elt.get('revision_id'),
199
inventory_id = elt.get('inventory_id'),
200
inventory_sha1 = elt.get('inventory_sha1')
203
precursor = elt.get('precursor')
204
precursor_sha1 = elt.get('precursor_sha1')
206
pelts = elt.find('parents')
210
assert p.tag == 'revision_ref', \
211
"bad parent node tag %r" % p.tag
212
rev_ref = RevisionReference(p.get('revision_id'),
213
p.get('revision_sha1'))
214
rev.parents.append(rev_ref)
218
prec_parent = rev.parents[0].revision_id
219
assert prec_parent == precursor
221
# revisions written prior to 0.0.5 have a single precursor
222
# give as an attribute
223
rev_ref = RevisionReference(precursor, precursor_sha1)
224
rev.parents.append(rev_ref)
226
v = elt.get('timezone')
227
rev.timezone = v and int(v)
229
rev.message = elt.findtext('message') # text of <message>
235
"""singleton instance"""
236
serializer_v4 = _Serializer_v4()
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
