1
# Copyright (C) 2005, 2006, 2007, 2008 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
18
from bzrlib.xml import ElementTree, SubElement, Element, Serializer
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24
revision as _mod_revision,
27
from bzrlib.xml_serializer import (
19
33
from bzrlib.inventory import ROOT_ID, Inventory, InventoryEntry
20
import bzrlib.inventory as inventory
21
from bzrlib.revision import Revision
34
from bzrlib.revision import Revision
22
35
from bzrlib.errors import BzrError
28
class Serializer_v5(Serializer):
29
"""Version 5 serializer
31
Packs objects into XML and vice versa.
42
"'":"'", # FIXME: overkill
49
def _ensure_utf8_re():
50
"""Make sure the _utf8_re and _unicode_re regexes have been compiled."""
51
global _utf8_re, _unicode_re
53
_utf8_re = re.compile('[&<>\'\"]|[\x80-\xff]+')
54
if _unicode_re is None:
55
_unicode_re = re.compile(u'[&<>\'\"\u0080-\uffff]')
58
def _unicode_escape_replace(match, _map=_xml_escape_map):
59
"""Replace a string of non-ascii, non XML safe characters with their escape
61
This will escape both Standard XML escapes, like <>"', etc.
62
As well as escaping non ascii characters, because ElementTree did.
63
This helps us remain compatible to older versions of bzr. We may change
64
our policy in the future, though.
66
# jam 20060816 Benchmarks show that try/KeyError is faster if you
67
# expect the entity to rarely miss. There is about a 10% difference
68
# in overall time. But if you miss frequently, then if None is much
69
# faster. For our use case, we *rarely* have a revision id, file id
70
# or path name that is unicode. So use try/KeyError.
72
return _map[match.group()]
74
return "&#%d;" % ord(match.group())
77
def _utf8_escape_replace(match, _map=_xml_escape_map):
78
"""Escape utf8 characters into XML safe ones.
80
This uses 2 tricks. It is either escaping "standard" characters, like "&<>,
81
or it is handling characters with the high-bit set. For ascii characters,
82
we just lookup the replacement in the dictionary. For everything else, we
83
decode back into Unicode, and then use the XML escape code.
86
return _map[match.group()]
88
return ''.join('&#%d;' % ord(uni_chr)
89
for uni_chr in match.group().decode('utf8'))
94
def _encode_and_escape(unicode_or_utf8_str, _map=_to_escaped_map):
95
"""Encode the string into utf8, and escape invalid XML characters"""
96
# We frequently get entities we have not seen before, so it is better
97
# to check if None, rather than try/KeyError
98
text = _map.get(unicode_or_utf8_str)
100
if unicode_or_utf8_str.__class__ is unicode:
101
# The alternative policy is to do a regular UTF8 encoding
102
# and then escape only XML meta characters.
103
# Performance is equivalent once you use cache_utf8. *However*
104
# this makes the serialized texts incompatible with old versions
105
# of bzr. So no net gain. (Perhaps the read code would handle utf8
106
# better than entity escapes, but cElementTree seems to do just fine
108
text = str(_unicode_re.sub(_unicode_escape_replace,
109
unicode_or_utf8_str)) + '"'
111
# Plain strings are considered to already be in utf-8 so we do a
112
# slightly different method for escaping.
113
text = _utf8_re.sub(_utf8_escape_replace,
114
unicode_or_utf8_str) + '"'
115
_map[unicode_or_utf8_str] = text
119
def _get_utf8_or_ascii(a_str,
120
_encode_utf8=cache_utf8.encode,
121
_get_cached_ascii=cache_utf8.get_cached_ascii):
122
"""Return a cached version of the string.
124
cElementTree will return a plain string if the XML is plain ascii. It only
125
returns Unicode when it needs to. We want to work in utf-8 strings. So if
126
cElementTree returns a plain string, we can just return the cached version.
127
If it is Unicode, then we need to encode it.
129
:param a_str: An 8-bit string or Unicode as returned by
130
cElementTree.Element.get()
131
:return: A utf-8 encoded 8-bit string.
133
# This is fairly optimized because we know what cElementTree does, this is
134
# not meant as a generic function for all cases. Because it is possible for
135
# an 8-bit string to not be ascii or valid utf8.
136
if a_str.__class__ is unicode:
137
return _encode_utf8(a_str)
143
"""Clean out the unicode => escaped map"""
144
_to_escaped_map.clear()
147
class Serializer_v8(XMLSerializer):
148
"""This serialiser adds rich roots.
150
Its revision format number matches its inventory number.
36
def _pack_inventory(self, inv):
37
"""Convert to XML Element"""
38
e = Element('inventory')
40
if inv.root.file_id not in (None, ROOT_ID):
41
e.set('file_id', inv.root.file_id)
42
for path, ie in inv.iter_entries():
43
e.append(self._pack_entry(ie))
47
def _pack_entry(self, ie):
48
"""Convert InventoryEntry to XML element"""
49
if not InventoryEntry.versionable_kind(ie.kind):
50
raise AssertionError('unsupported entry kind %s' % ie.kind)
52
e.set('name', ie.name)
53
e.set('file_id', ie.file_id)
55
if ie.text_size != None:
56
e.set('text_size', '%d' % ie.text_size)
58
for f in ['text_sha1', 'revision', 'symlink_target']:
64
e.set('executable', 'yes')
66
# to be conservative, we don't externalize the root pointers
67
# for now, leaving them as null in the xml form. in a future
68
# version it will be implied by nested elements.
69
if ie.parent_id != ROOT_ID:
70
assert isinstance(ie.parent_id, basestring)
71
e.set('parent_id', ie.parent_id)
156
support_altered_by_hack = True
157
# This format supports the altered-by hack that reads file ids directly out
158
# of the versionedfile, without doing XML parsing.
160
supported_kinds = set(['file', 'directory', 'symlink'])
162
revision_format_num = None
164
def _check_revisions(self, inv):
165
"""Extension point for subclasses to check during serialisation.
167
:param inv: An inventory about to be serialised, to be checked.
168
:raises: AssertionError if an error has occurred.
170
if inv.revision_id is None:
171
raise AssertionError("inv.revision_id is None")
172
if inv.root.revision is None:
173
raise AssertionError("inv.root.revision is None")
175
def _check_cache_size(self, inv_size, entry_cache):
176
"""Check that the entry_cache is large enough.
178
We want the cache to be ~2x the size of an inventory. The reason is
179
because we use a FIFO cache, and how Inventory records are likely to
180
change. In general, you have a small number of records which change
181
often, and a lot of records which do not change at all. So when the
182
cache gets full, you actually flush out a lot of the records you are
183
interested in, which means you need to recreate all of those records.
184
An LRU Cache would be better, but the overhead negates the cache
187
One way to look at it, only the size of the cache > len(inv) is your
188
'working' set. And in general, it shouldn't be a problem to hold 2
189
inventories in memory anyway.
191
:param inv_size: The number of entries in an inventory.
193
if entry_cache is None:
195
# 1.5 times might also be reasonable.
196
recommended_min_cache_size = inv_size * 1.5
197
if entry_cache.cache_size() < recommended_min_cache_size:
198
recommended_cache_size = inv_size * 2
199
trace.mutter('Resizing the inventory entry cache from %d to %d',
200
entry_cache.cache_size(), recommended_cache_size)
201
entry_cache.resize(recommended_cache_size)
203
def write_inventory_to_lines(self, inv):
204
"""Return a list of lines with the encoded inventory."""
205
return self.write_inventory(inv, None)
207
def write_inventory_to_string(self, inv, working=False):
208
"""Just call write_inventory with a StringIO and return the value.
210
:param working: If True skip history data - text_sha1, text_size,
211
reference_revision, symlink_target.
213
sio = cStringIO.StringIO()
214
self.write_inventory(inv, sio, working)
215
return sio.getvalue()
217
def write_inventory(self, inv, f, working=False):
218
"""Write inventory to a file.
220
:param inv: the inventory to write.
221
:param f: the file to write. (May be None if the lines are the desired
223
:param working: If True skip history data - text_sha1, text_size,
224
reference_revision, symlink_target.
225
:return: The inventory as a list of lines.
228
self._check_revisions(inv)
230
append = output.append
231
self._append_inventory_root(append, inv)
232
entries = inv.iter_entries()
234
root_path, root_ie = entries.next()
235
for path, ie in entries:
236
if ie.parent_id != self.root_id:
237
parent_str = ' parent_id="'
238
parent_id = _encode_and_escape(ie.parent_id)
242
if ie.kind == 'file':
244
executable = ' executable="yes"'
248
append('<file%s file_id="%s name="%s%s%s revision="%s '
249
'text_sha1="%s" text_size="%d" />\n' % (
250
executable, _encode_and_escape(ie.file_id),
251
_encode_and_escape(ie.name), parent_str, parent_id,
252
_encode_and_escape(ie.revision), ie.text_sha1,
255
append('<file%s file_id="%s name="%s%s%s />\n' % (
256
executable, _encode_and_escape(ie.file_id),
257
_encode_and_escape(ie.name), parent_str, parent_id))
258
elif ie.kind == 'directory':
260
append('<directory file_id="%s name="%s%s%s revision="%s '
262
_encode_and_escape(ie.file_id),
263
_encode_and_escape(ie.name),
264
parent_str, parent_id,
265
_encode_and_escape(ie.revision)))
267
append('<directory file_id="%s name="%s%s%s />\n' % (
268
_encode_and_escape(ie.file_id),
269
_encode_and_escape(ie.name),
270
parent_str, parent_id))
271
elif ie.kind == 'symlink':
273
append('<symlink file_id="%s name="%s%s%s revision="%s '
274
'symlink_target="%s />\n' % (
275
_encode_and_escape(ie.file_id),
276
_encode_and_escape(ie.name),
277
parent_str, parent_id,
278
_encode_and_escape(ie.revision),
279
_encode_and_escape(ie.symlink_target)))
281
append('<symlink file_id="%s name="%s%s%s />\n' % (
282
_encode_and_escape(ie.file_id),
283
_encode_and_escape(ie.name),
284
parent_str, parent_id))
285
elif ie.kind == 'tree-reference':
286
if ie.kind not in self.supported_kinds:
287
raise errors.UnsupportedInventoryKind(ie.kind)
289
append('<tree-reference file_id="%s name="%s%s%s '
290
'revision="%s reference_revision="%s />\n' % (
291
_encode_and_escape(ie.file_id),
292
_encode_and_escape(ie.name),
293
parent_str, parent_id,
294
_encode_and_escape(ie.revision),
295
_encode_and_escape(ie.reference_revision)))
297
append('<tree-reference file_id="%s name="%s%s%s />\n' % (
298
_encode_and_escape(ie.file_id),
299
_encode_and_escape(ie.name),
300
parent_str, parent_id))
302
raise errors.UnsupportedInventoryKind(ie.kind)
303
append('</inventory>\n')
306
# Just to keep the cache from growing without bounds
307
# but we may actually not want to do clear the cache
311
def _append_inventory_root(self, append, inv):
312
"""Append the inventory root to output."""
313
if inv.revision_id is not None:
314
revid1 = ' revision_id="'
315
revid2 = _encode_and_escape(inv.revision_id)
319
append('<inventory format="%s"%s%s>\n' % (
320
self.format_num, revid1, revid2))
321
append('<directory file_id="%s name="%s revision="%s />\n' % (
322
_encode_and_escape(inv.root.file_id),
323
_encode_and_escape(inv.root.name),
324
_encode_and_escape(inv.root.revision)))
78
326
def _pack_revision(self, rev):
79
327
"""Revision object -> xml tree"""
328
# For the XML format, we need to write them as Unicode rather than as
329
# utf-8 strings. So that cElementTree can handle properly escaping
331
decode_utf8 = cache_utf8.decode
332
revision_id = rev.revision_id
333
if isinstance(revision_id, str):
334
revision_id = decode_utf8(revision_id)
335
format_num = self.format_num
336
if self.revision_format_num is not None:
337
format_num = self.revision_format_num
80
338
root = Element('revision',
81
339
committer = rev.committer,
82
timestamp = '%.9f' % rev.timestamp,
83
revision_id = rev.revision_id,
340
timestamp = '%.3f' % rev.timestamp,
341
revision_id = revision_id,
84
342
inventory_sha1 = rev.inventory_sha1,
345
if rev.timezone is not None:
87
346
root.set('timezone', str(rev.timezone))
90
348
msg = SubElement(root, 'message')
91
msg.text = rev.message
349
msg.text = escape_invalid_chars(rev.message)[0]
94
351
if rev.parent_ids:
95
352
pelts = SubElement(root, 'parents')
96
353
pelts.tail = pelts.text = '\n'
97
354
for parent_id in rev.parent_ids:
98
assert isinstance(parent_id, basestring)
355
_mod_revision.check_not_reserved_id(parent_id)
99
356
p = SubElement(pelts, 'revision_ref')
358
if isinstance(parent_id, str):
359
parent_id = decode_utf8(parent_id)
101
360
p.set('revision_id', parent_id)
362
self._pack_revision_properties(rev, root)
365
def _pack_revision_properties(self, rev, under_element):
366
top_elt = SubElement(under_element, 'properties')
367
for prop_name, prop_value in sorted(rev.properties.items()):
368
prop_elt = SubElement(top_elt, 'property')
369
prop_elt.set('name', prop_name)
370
prop_elt.text = prop_value
106
def _unpack_inventory(self, elt):
107
"""Construct from XML Element
109
assert elt.tag == 'inventory'
110
root_id = elt.get('file_id') or ROOT_ID
111
inv = Inventory(root_id)
374
def _unpack_inventory(self, elt, revision_id=None, entry_cache=None):
375
"""Construct from XML Element"""
376
if elt.tag != 'inventory':
377
raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
378
format = elt.get('format')
379
if format != self.format_num:
380
raise errors.UnexpectedInventoryFormat('Invalid format version %r'
382
revision_id = elt.get('revision_id')
383
if revision_id is not None:
384
revision_id = cache_utf8.encode(revision_id)
385
inv = inventory.Inventory(root_id=None, revision_id=revision_id)
113
ie = self._unpack_entry(e)
114
if ie.parent_id == ROOT_ID:
115
ie.parent_id = root_id
387
ie = self._unpack_entry(e, entry_cache=entry_cache)
389
self._check_cache_size(len(inv), entry_cache)
120
def _unpack_entry(self, elt):
392
def _unpack_entry(self, elt, entry_cache=None):
394
file_id = elt_get('file_id')
395
revision = elt_get('revision')
396
# Check and see if we have already unpacked this exact entry
397
# Some timings for "repo.revision_trees(last_100_revs)"
399
# unmodified 4.1s 40.8s
401
# using fifo 2.83s 29.1s
405
# no_copy 2.00s 20.5s
406
# no_c,dict 1.95s 18.0s
407
# Note that a cache of 10k nodes is more than sufficient to hold all of
408
# the inventory for the last 100 revs for bzr, but not for mysql (20k
409
# is enough for mysql, which saves the same 2s as using a dict)
411
# Breakdown of mysql using time.clock()
412
# 4.1s 2 calls to element.get for file_id, revision_id
413
# 4.5s cache_hit lookup
414
# 7.1s InventoryFile.copy()
415
# 2.4s InventoryDirectory.copy()
416
# 0.4s decoding unique entries
417
# 1.6s decoding entries after FIFO fills up
418
# 0.8s Adding nodes to FIFO (including flushes)
419
# 0.1s cache miss lookups
421
# 4.1s 2 calls to element.get for file_id, revision_id
422
# 9.9s cache_hit lookup
423
# 10.8s InventoryEntry.copy()
424
# 0.3s cache miss lookus
425
# 1.2s decoding entries
426
# 1.0s adding nodes to LRU
427
if entry_cache is not None and revision is not None:
428
key = (file_id, revision)
430
# We copy it, because some operations may mutate it
431
cached_ie = entry_cache[key]
435
# Only copying directory entries drops us 2.85s => 2.35s
436
# if cached_ie.kind == 'directory':
437
# return cached_ie.copy()
439
return cached_ie.copy()
122
442
if not InventoryEntry.versionable_kind(kind):
123
443
raise AssertionError('unsupported entry kind %s' % kind)
125
parent_id = elt.get('parent_id')
126
if parent_id == None:
445
get_cached = _get_utf8_or_ascii
447
file_id = get_cached(file_id)
448
if revision is not None:
449
revision = get_cached(revision)
450
parent_id = elt_get('parent_id')
451
if parent_id is not None:
452
parent_id = get_cached(parent_id)
129
454
if kind == 'directory':
130
ie = inventory.InventoryDirectory(elt.get('file_id'),
455
ie = inventory.InventoryDirectory(file_id,
133
458
elif kind == 'file':
134
ie = inventory.InventoryFile(elt.get('file_id'),
459
ie = inventory.InventoryFile(file_id,
137
ie.text_sha1 = elt.get('text_sha1')
138
if elt.get('executable') == 'yes':
462
ie.text_sha1 = elt_get('text_sha1')
463
if elt_get('executable') == 'yes':
139
464
ie.executable = True
140
v = elt.get('text_size')
465
v = elt_get('text_size')
141
466
ie.text_size = v and int(v)
142
467
elif kind == 'symlink':
143
ie = inventory.InventoryLink(elt.get('file_id'),
468
ie = inventory.InventoryLink(file_id,
146
ie.symlink_target = elt.get('symlink_target')
471
ie.symlink_target = elt_get('symlink_target')
148
raise BzrError("unknown kind %r" % kind)
149
ie.revision = elt.get('revision')
473
raise errors.UnsupportedInventoryKind(kind)
474
ie.revision = revision
475
if revision is not None and entry_cache is not None:
476
# We cache a copy() because callers like to mutate objects, and
477
# that would cause the item in cache to mutate as well.
478
# This has a small effect on many-inventory performance, because
479
# the majority fraction is spent in cache hits, not misses.
480
entry_cache[key] = ie.copy()
154
484
def _unpack_revision(self, elt):
155
485
"""XML Element -> Revision object"""
156
assert elt.tag == 'revision'
486
format = elt.get('format')
487
format_num = self.format_num
488
if self.revision_format_num is not None:
489
format_num = self.revision_format_num
490
if format is not None:
491
if format != format_num:
492
raise BzrError("invalid format version %r on revision"
494
get_cached = _get_utf8_or_ascii
158
495
rev = Revision(committer = elt.get('committer'),
159
496
timestamp = float(elt.get('timestamp')),
160
revision_id = elt.get('revision_id'),
497
revision_id = get_cached(elt.get('revision_id')),
161
498
inventory_sha1 = elt.get('inventory_sha1')
164
500
parents = elt.find('parents') or []
165
501
for p in parents:
166
assert p.tag == 'revision_ref', \
167
"bad parent node tag %r" % p.tag
168
rev.parent_ids.append(p.get('revision_id'))
502
rev.parent_ids.append(get_cached(p.get('revision_id')))
503
self._unpack_revision_properties(elt, rev)
170
504
v = elt.get('timezone')
171
rev.timezone = v and int(v)
508
rev.timezone = int(v)
173
509
rev.message = elt.findtext('message') # text of <message>
178
serializer_v5 = Serializer_v5()
512
def _unpack_revision_properties(self, elt, rev):
513
"""Unpack properties onto a revision."""
514
props_elt = elt.find('properties')
517
for prop_elt in props_elt:
518
if prop_elt.tag != 'property':
519
raise AssertionError(
520
"bad tag under properties list: %r" % prop_elt.tag)
521
name = prop_elt.get('name')
522
value = prop_elt.text
523
# If a property had an empty value ('') cElementTree reads
524
# that back as None, convert it back to '', so that all
525
# properties have string values
528
if name in rev.properties:
529
raise AssertionError("repeated property %r" % name)
530
rev.properties[name] = value
533
serializer_v8 = Serializer_v8()
added
removed
bzrlib/xml8.py
