This is an archive of the discontinued Mercurial Phabricator instance.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	16648		Sep 27 2019, 12:16 PM	★	★
Diff 2	16657		Sep 27 2019, 2:09 PM	★	★
Diff 3	16737		Oct 1 2019, 12:06 PM	★	★
Diff 4	16762	rHG294afb982a8834db6d97cd2cefea5d643024285b	Sep 3 2019, 6:59 PM	★	★

Commit	Parents	Author	Summary	Date
13cb0eaa95e3	2e088adf12af	Pierre-Yves David		Sep 3 2019, 6:59 PM

Status	Author	Revision
Closed	marmoute	D6898 sidedata: check that the sidedata safely roundtrip
Closed	marmoute	D6897 sidedata: add a debugsidedata command
Closed	marmoute	D6896 sidedata: test we can successfully write sidedata
Closed	marmoute	D6895 sidedata: make sure we don't use the flag if there are not sidedata
Closed	marmoute	D6894 revlog: add the appropriate flag is sidedata are passed to `addrevision`
Closed	marmoute	D6893 sidedata: register the flag processors if the repository allows for it
Closed	marmoute	D6892 sidedata: add a function for _processflagsraw usage
Closed	marmoute	D6891 sidedata: add a function to write sidedata into a raw text
Closed	marmoute	D6890 sidedata: add a function to read sidedata from revlog raw text
Closed	marmoute	D6889 sidedata: add a new module with basic documentation
Closed	marmoute	D6888 sidedata: add a new revision flag constant for side data
Closed	marmoute	D6887 upgrade: detect the side-data format variants
Closed	marmoute	D6886 sidedata: introduce a new requirement to protect the feature

Diff 16657


	Usually subclassed by a storage-specific exception.			Usually subclassed by a storage-specific exception.
	"""			"""
	__bytes__ = _tobytes			__bytes__ = _tobytes

	class RevlogError(StorageError):			class RevlogError(StorageError):
	__bytes__ = _tobytes			__bytes__ = _tobytes

				class SidedataHashError(RevlogError):

				def __init__(self, key, expected, got):
				self.sidedatakey = key
				self.expecteddigest = expected
				self.actualdigest = got

	class FilteredIndexError(IndexError):			class FilteredIndexError(IndexError):
	__bytes__ = _tobytes			__bytes__ = _tobytes

	class LookupError(RevlogError, KeyError):			class LookupError(RevlogError, KeyError):
	def __init__(self, name, index, message):			def __init__(self, name, index, message):
	self.name = name			self.name = name
	self.index = index			self.index = index
	# this can't be called 'message' because at least some installs of			# this can't be called 'message' because at least some installs of

	# no extra flags set, no flag processor runs, text = rawtext			# no extra flags set, no flag processor runs, text = rawtext
	return rawtext, {}			return rawtext, {}

	sidedata = {}			sidedata = {}
	if raw:			if raw:
	validatehash = flagutil.processflagsraw(self, rawtext, flags)			validatehash = flagutil.processflagsraw(self, rawtext, flags)
	text = rawtext			text = rawtext
	else:			else:
				try:
	r = flagutil.processflagsread(self, rawtext, flags)			r = flagutil.processflagsread(self, rawtext, flags)
				except error.SidedataHashError as exc:
				msg = _("integrity check failed on %s:%s sidedata key %d")
				msg %= (self.indexfile, pycompat.bytestr(rev),
				exc.sidedatakey)
				raise error.RevlogError(msg)
	text, validatehash, sidedata = r			text, validatehash, sidedata = r
	if validatehash:			if validatehash:
	self.checkhash(text, node, rev=rev)			self.checkhash(text, node, rev=rev)
	if not validated:			if not validated:
	self._revisioncache = (node, rev, rawtext)			self._revisioncache = (node, rev, rawtext)

	return text, sidedata			return text, sidedata

	normal raw text:			normal raw text:
	<all bytes remaining in the rawtext>			<all bytes remaining in the rawtext>

	This is a simple and effective format. It should be enought to experiment with			This is a simple and effective format. It should be enought to experiment with
	the concept.			the concept.
	"""			"""

	from __future__ import absolute_import			from __future__ import absolute_import

				import hashlib
				import struct

				from .. import error

				SIDEDATA_HEADER = struct.Struct('>H')
				SIDEDATA_ENTRY = struct.Struct('>HL20s')
				indygregUnsubmitted Not Done Python 3 will require a `r''` because of source transformation. indygreg: Python 3 will require a `r''` because of source transformation.

				def sidedatareadprocessor(rl, text):
				sidedata = {}
				offset = 0
				nbentry, = SIDEDATA_HEADER.unpack(text[:SIDEDATA_HEADER.size])
				offset += SIDEDATA_HEADER.size
				dataoffset = SIDEDATA_HEADER.size + (SIDEDATA_ENTRY.size * nbentry)
				for i in range(nbentry):
				nextoffset = offset + SIDEDATA_ENTRY.size
				key, size, storeddigest = SIDEDATA_ENTRY.unpack(text[offset:nextoffset])
				offset = nextoffset
				# read the data associated with that entry
				nextdataoffset = dataoffset + size
				entrytext = text[dataoffset:nextdataoffset]
				readdigest = hashlib.sha1(entrytext).digest()
				if storeddigest != readdigest:
				raise error.SidedataHashError(key, storeddigest, readdigest)
				sidedata[key] = entrytext
				dataoffset = nextdataoffset
				text = text[dataoffset:]
				return text, True, sidedata