138
144
_to_escaped_map.clear()
141
class Serializer_v5(Serializer):
142
"""Version 5 serializer
147
class Serializer_v8(XMLSerializer):
148
"""This serialiser adds rich roots.
144
Packs objects into XML and vice versa.
150
Its revision format number matches its inventory number.
150
156
support_altered_by_hack = True
151
157
# This format supports the altered-by hack that reads file ids directly out
152
158
# of the versionedfile, without doing XML parsing.
154
160
supported_kinds = set(['file', 'directory', 'symlink'])
162
revision_format_num = None
157
164
def _check_revisions(self, inv):
158
165
"""Extension point for subclasses to check during serialisation.
160
By default no checking is done.
162
167
:param inv: An inventory about to be serialised, to be checked.
163
:raises: AssertionError if an error has occured.
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)
166
203
def write_inventory_to_lines(self, inv):
167
204
"""Return a list of lines with the encoded inventory."""
274
311
def _append_inventory_root(self, append, inv):
275
312
"""Append the inventory root to output."""
276
if inv.root.file_id not in (None, ROOT_ID):
277
fileid1 = ' file_id="'
278
fileid2 = _encode_and_escape(inv.root.file_id)
282
313
if inv.revision_id is not None:
283
314
revid1 = ' revision_id="'
284
315
revid2 = _encode_and_escape(inv.revision_id)
288
append('<inventory%s%s format="5"%s%s>\n' % (
289
fileid1, fileid2, revid1, revid2))
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)))
291
326
def _pack_revision(self, rev):
292
327
"""Revision object -> xml tree"""
293
328
# For the XML format, we need to write them as Unicode rather than as
297
332
revision_id = rev.revision_id
298
333
if isinstance(revision_id, str):
299
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
300
338
root = Element('revision',
301
339
committer = rev.committer,
302
340
timestamp = '%.3f' % rev.timestamp,
303
341
revision_id = revision_id,
304
342
inventory_sha1 = rev.inventory_sha1,
307
345
if rev.timezone is not None:
308
346
root.set('timezone', str(rev.timezone))
310
348
msg = SubElement(root, 'message')
311
msg.text = rev.message
349
msg.text = escape_invalid_chars(rev.message)[0]
313
351
if rev.parent_ids:
314
352
pelts = SubElement(root, 'parents')
315
353
pelts.tail = pelts.text = '\n'
316
354
for parent_id in rev.parent_ids:
317
assert isinstance(parent_id, basestring)
318
355
_mod_revision.check_not_reserved_id(parent_id)
319
356
p = SubElement(pelts, 'revision_ref')
328
365
def _pack_revision_properties(self, rev, under_element):
329
366
top_elt = SubElement(under_element, 'properties')
330
367
for prop_name, prop_value in sorted(rev.properties.items()):
331
assert isinstance(prop_name, basestring)
332
assert isinstance(prop_value, basestring)
333
368
prop_elt = SubElement(top_elt, 'property')
334
369
prop_elt.set('name', prop_name)
335
370
prop_elt.text = prop_value
336
371
prop_elt.tail = '\n'
337
372
top_elt.tail = '\n'
339
def _unpack_inventory(self, elt, revision_id):
340
"""Construct from XML Element
342
assert elt.tag == 'inventory'
343
root_id = elt.get('file_id') or ROOT_ID
344
root_id = _get_utf8_or_ascii(root_id)
374
def _unpack_inventory(self, elt, revision_id=None, entry_cache=None,
375
return_from_cache=False):
376
"""Construct from XML Element"""
377
if elt.tag != 'inventory':
378
raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
346
379
format = elt.get('format')
347
if format is not None:
349
raise BzrError("invalid format version %r on inventory"
351
data_revision_id = elt.get('revision_id')
352
if data_revision_id is not None:
353
revision_id = cache_utf8.encode(data_revision_id)
354
inv = Inventory(root_id, revision_id=revision_id)
380
if format != self.format_num:
381
raise errors.UnexpectedInventoryFormat('Invalid format version %r'
383
revision_id = elt.get('revision_id')
384
if revision_id is not None:
385
revision_id = cache_utf8.encode(revision_id)
386
inv = inventory.Inventory(root_id=None, revision_id=revision_id)
356
ie = self._unpack_entry(e)
357
if ie.parent_id is None:
358
ie.parent_id = root_id
388
ie = self._unpack_entry(e, entry_cache=entry_cache,
389
return_from_cache=return_from_cache)
360
if revision_id is not None:
361
inv.root.revision = revision_id
391
self._check_cache_size(len(inv), entry_cache)
364
def _unpack_entry(self, elt):
394
def _unpack_entry(self, elt, entry_cache=None, return_from_cache=False):
396
file_id = elt_get('file_id')
397
revision = elt_get('revision')
398
# Check and see if we have already unpacked this exact entry
399
# Some timings for "repo.revision_trees(last_100_revs)"
401
# unmodified 4.1s 40.8s
403
# using fifo 2.83s 29.1s
407
# no_copy 2.00s 20.5s
408
# no_c,dict 1.95s 18.0s
409
# Note that a cache of 10k nodes is more than sufficient to hold all of
410
# the inventory for the last 100 revs for bzr, but not for mysql (20k
411
# is enough for mysql, which saves the same 2s as using a dict)
413
# Breakdown of mysql using time.clock()
414
# 4.1s 2 calls to element.get for file_id, revision_id
415
# 4.5s cache_hit lookup
416
# 7.1s InventoryFile.copy()
417
# 2.4s InventoryDirectory.copy()
418
# 0.4s decoding unique entries
419
# 1.6s decoding entries after FIFO fills up
420
# 0.8s Adding nodes to FIFO (including flushes)
421
# 0.1s cache miss lookups
423
# 4.1s 2 calls to element.get for file_id, revision_id
424
# 9.9s cache_hit lookup
425
# 10.8s InventoryEntry.copy()
426
# 0.3s cache miss lookus
427
# 1.2s decoding entries
428
# 1.0s adding nodes to LRU
429
if entry_cache is not None and revision is not None:
430
key = (file_id, revision)
432
# We copy it, because some operations may mutate it
433
cached_ie = entry_cache[key]
437
# Only copying directory entries drops us 2.85s => 2.35s
438
if return_from_cache:
439
if cached_ie.kind == 'directory':
440
return cached_ie.copy()
442
return cached_ie.copy()
366
445
if not InventoryEntry.versionable_kind(kind):
367
446
raise AssertionError('unsupported entry kind %s' % kind)
369
448
get_cached = _get_utf8_or_ascii
371
parent_id = elt.get('parent_id')
450
file_id = get_cached(file_id)
451
if revision is not None:
452
revision = get_cached(revision)
453
parent_id = elt_get('parent_id')
372
454
if parent_id is not None:
373
455
parent_id = get_cached(parent_id)
374
file_id = get_cached(elt.get('file_id'))
376
457
if kind == 'directory':
377
458
ie = inventory.InventoryDirectory(file_id,
380
461
elif kind == 'file':
381
462
ie = inventory.InventoryFile(file_id,
384
ie.text_sha1 = elt.get('text_sha1')
385
if elt.get('executable') == 'yes':
465
ie.text_sha1 = elt_get('text_sha1')
466
if elt_get('executable') == 'yes':
386
467
ie.executable = True
387
v = elt.get('text_size')
468
v = elt_get('text_size')
388
469
ie.text_size = v and int(v)
389
470
elif kind == 'symlink':
390
471
ie = inventory.InventoryLink(file_id,
393
ie.symlink_target = elt.get('symlink_target')
474
ie.symlink_target = elt_get('symlink_target')
395
476
raise errors.UnsupportedInventoryKind(kind)
396
revision = elt.get('revision')
397
if revision is not None:
398
revision = get_cached(revision)
399
477
ie.revision = revision
478
if revision is not None and entry_cache is not None:
479
# We cache a copy() because callers like to mutate objects, and
480
# that would cause the item in cache to mutate as well.
481
# This has a small effect on many-inventory performance, because
482
# the majority fraction is spent in cache hits, not misses.
483
entry_cache[key] = ie.copy()
403
487
def _unpack_revision(self, elt):
404
488
"""XML Element -> Revision object"""
405
assert elt.tag == 'revision'
406
489
format = elt.get('format')
490
format_num = self.format_num
491
if self.revision_format_num is not None:
492
format_num = self.revision_format_num
407
493
if format is not None:
409
raise BzrError("invalid format version %r on inventory"
494
if format != format_num:
495
raise BzrError("invalid format version %r on revision"
411
497
get_cached = _get_utf8_or_ascii
412
498
rev = Revision(committer = elt.get('committer'),
added
removed
bzrlib/xml8.py
