def export_unusual_file_modes(self, rev):
try:
file_modes = rev.properties[u'file-modes']
except KeyError:
return {}
else:
return dict(bencode.bdecode(file_modes.encode("utf-8")))
def read_revision_from_string(self, text):
# TODO: consider writing a Revision decoder, rather than using the
# generic bencode decoder
# However, to decode all 25k revisions of bzr takes approx 1.3s
# If we remove all extra validation that goes down to about 1.2s.
# Of that time, probably 0.6s is spend in bencode.bdecode().
# Regardless 'time brz log' of everything is 7+s, so 1.3s to
# extract revision texts isn't a majority of time.
ret = bencode.bdecode(text)
if not isinstance(ret, list):
raise ValueError("invalid revision text")
schema = self._schema
# timezone is allowed to be missing, but should be set
bits = {'timezone': None}
for key, value in ret:
# Will raise KeyError if not a valid part of the schema, or an
# entry is given 2 times.
var_name, expected_type, validator = schema[key]
if value.__class__ is not expected_type:
raise ValueError('key %s did not conform to the expected type'
' %s, but was %s'
% (key, expected_type, type(value)))
if validator is not None:
value = validator(value)
bits[var_name] = value
if len(bits) != len(schema):
missing = [key for key, (var_name, _, _) in schema.items()
if var_name not in bits]
raise ValueError('Revision text was missing expected keys %s.'
' text %r' % (missing, text))
del bits[None] # Get rid of 'format' since it doesn't get mapped
rev = _mod_revision.Revision(**bits)
return rev
def parse_metadata(records):
names, metadata_bytes = next(records)
if names[0] != (b'metadata', ):
raise ShelfCorrupt
metadata = bencode.bdecode(metadata_bytes)
message = metadata.get(b'message')
if message is not None:
metadata[b'message'] = message.decode('utf-8')
return metadata
def do_with_locked_branch(self, branch, value_dict, name, section):
utf8_dict = bencode.bdecode(value_dict)
value_dict = {}
for key, value in utf8_dict.items():
value_dict[key.decode('utf8')] = value.decode('utf8')
if not section:
section = None
else:
section = section.decode('utf-8')
branch._get_config().set_option(value_dict, name.decode('utf-8'),
section)
return SuccessfulSmartServerResponse(())
def _deserialize_tag_dict(self, tag_content):
"""Convert the tag file into a dictionary of tags"""
# was a special case to make initialization easy, an empty definition
# is an empty dictionary
if tag_content == b'':
return {}
try:
r = {}
for k, v in bencode.bdecode(tag_content).items():
r[k.decode('utf-8')] = v
return r
except ValueError as e:
raise ValueError("failed to deserialize tag dictionary %r: %s" %
(tag_content, e))
def iter_records(self):
"""Iterate through bundle records
:return: a generator of (bytes, metadata, content_kind, revision_id,
file_id)
"""
iterator = pack.iter_records_from_file(self._container_file)
for names, bytes in iterator:
if len(names) != 1:
raise errors.BadBundle('Record has %d names instead of 1' %
len(names))
metadata = bencode.bdecode(bytes)
if metadata[b'storage_kind'] == b'header':
bytes = None
else:
_unused, bytes = next(iterator)
yield (bytes, metadata) + self.decode_name(names[0][0])
def _generate_hg_message_tail(self, rev):
extra = {}
renames = []
branch = 'default'
for name in rev.properties:
if name == u'hg:extra:branch':
branch = rev.properties[u'hg:extra:branch']
elif name.startswith(u'hg:extra'):
extra[name[len(u'hg:extra:'):]] = base64.b64decode(
rev.properties[name])
elif name == u'hg:renames':
renames = bencode.bdecode(
base64.b64decode(rev.properties[u'hg:renames']))
# TODO: Export other properties as 'bzr:' extras?
ret = format_hg_metadata(renames, branch, extra)
if not isinstance(ret, bytes):
raise TypeError(ret)
return ret
def load(self):
import fastbencode as bencode
with open(self._filename + '.mpidx', 'rb') as f:
self._parents, snapshots, self._diff_offset = bencode.bdecode(
f.read())
self._snapshots = set(snapshots)
