This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10771

revlogv2: use a unique filename for index
ClosedPublic

Authored by marmoute on May 27 2021, 3:05 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGf612db768c7a: revlogv2: use a unique filename for index
rHGce0e8971f7ee: revlogv2: use a unique filename for index
Summary

Having a unique index will allow for ambiguity less rewriting of revlog content,
something useful to clarify handling of some operation like censoring or
stripping.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.May 27 2021, 3:05 AM
marmoute added a commit: rHGce0e8971f7ee: revlogv2: use a unique filename for index.May 27 2021, 5:36 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGce0e8971f7ee: revlogv2: use a unique filename for index (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revlogutils/docket.py (30 lines)
Mtests/test-revlog-v2.t (16 lines)

Diff 28223

mercurial/revlogutils/docket.py

return new return new
# Docket format # Docket format
# #
# * 4 bytes: revlog version # * 4 bytes: revlog version
# | This is mandatory as docket must be compatible with the previous # | This is mandatory as docket must be compatible with the previous
# | revlog index header. # | revlog index header.
# * 1 bytes: size of index uuid
# * 8 bytes: size of index-data # * 8 bytes: size of index-data
# * 8 bytes: pending size of index-data # * 8 bytes: pending size of index-data
# * 8 bytes: size of data # * 8 bytes: size of data
# * 8 bytes: pending size of data # * 8 bytes: pending size of data
# * 1 bytes: default compression header # * 1 bytes: default compression header
S_HEADER = struct.Struct(constants.INDEX_HEADER.format + 'LLLLc') S_HEADER = struct.Struct(constants.INDEX_HEADER.format + 'BLLLLc')
class RevlogDocket(object): class RevlogDocket(object):
"""metadata associated with revlog""" """metadata associated with revlog"""
def __init__( def __init__(
self, self,
revlog, revlog,
use_pending=False, use_pending=False,
version_header=None, version_header=None,
index_uuid=None,
index_end=0, index_end=0,
pending_index_end=0, pending_index_end=0,
data_end=0, data_end=0,
pending_data_end=0, pending_data_end=0,
default_compression_header=None, default_compression_header=None,
): ):
self._version_header = version_header self._version_header = version_header
self._read_only = bool(use_pending) self._read_only = bool(use_pending)
self._dirty = False self._dirty = False
self._radix = revlog.radix self._radix = revlog.radix
self._path = revlog._docket_file self._path = revlog._docket_file
self._opener = revlog.opener self._opener = revlog.opener
self._index_uuid = index_uuid
# thes asserts should be True as long as we have a single index filename # thes asserts should be True as long as we have a single index filename
assert index_end <= pending_index_end assert index_end <= pending_index_end
assert data_end <= pending_data_end assert data_end <= pending_data_end
self._initial_index_end = index_end self._initial_index_end = index_end
self._pending_index_end = pending_index_end self._pending_index_end = pending_index_end
self._initial_data_end = data_end self._initial_data_end = data_end
self._pending_data_end = pending_data_end self._pending_data_end = pending_data_end
if use_pending: if use_pending:
self._index_end = self._pending_index_end self._index_end = self._pending_index_end
self._data_end = self._pending_data_end self._data_end = self._pending_data_end
else: else:
self._index_end = self._initial_index_end self._index_end = self._initial_index_end
self._data_end = self._initial_data_end self._data_end = self._initial_data_end
self.default_compression_header = default_compression_header self.default_compression_header = default_compression_header
def index_filepath(self): def index_filepath(self):
"""file path to the current index file associated to this docket""" """file path to the current index file associated to this docket"""
# very simplistic version at first # very simplistic version at first
return b"%s.idx" % self._radix if self._index_uuid is None:
self._index_uuid = make_uid()
return b"%s-%s.idx" % (self._radix, self._index_uuid)
@property @property
def index_end(self): def index_end(self):
return self._index_end return self._index_end
@index_end.setter @index_end.setter
def index_end(self, new_size): def index_end(self, new_size):
if new_size != self._index_end: if new_size != self._index_end:
else: else:
official_index_end = self._index_end official_index_end = self._index_end
official_data_end = self._data_end official_data_end = self._data_end
# this assert should be True as long as we have a single index filename # this assert should be True as long as we have a single index filename
assert official_data_end <= self._data_end assert official_data_end <= self._data_end
data = ( data = (
self._version_header, self._version_header,
len(self._index_uuid),
official_index_end, official_index_end,
self._index_end, self._index_end,
official_data_end, official_data_end,
self._data_end, self._data_end,
self.default_compression_header, self.default_compression_header,
) )
return S_HEADER.pack(*data) s = []
s.append(S_HEADER.pack(*data))
s.append(self._index_uuid)
return b''.join(s)
def default_docket(revlog, version_header): def default_docket(revlog, version_header):
"""given a revlog version a new docket object for the given revlog""" """given a revlog version a new docket object for the given revlog"""
rl_version = version_header & 0xFFFF rl_version = version_header & 0xFFFF
if rl_version not in (constants.REVLOGV2, constants.CHANGELOGV2): if rl_version not in (constants.REVLOGV2, constants.CHANGELOGV2):
return None return None
comp = util.compengines[revlog._compengine].revlogheader() comp = util.compengines[revlog._compengine].revlogheader()
docket = RevlogDocket( docket = RevlogDocket(
revlog, revlog,
version_header=version_header, version_header=version_header,
default_compression_header=comp, default_compression_header=comp,
) )
docket._dirty = True docket._dirty = True
return docket return docket
def parse_docket(revlog, data, use_pending=False): def parse_docket(revlog, data, use_pending=False):
"""given some docket data return a docket object for the given revlog""" """given some docket data return a docket object for the given revlog"""
header = S_HEADER.unpack(data[: S_HEADER.size]) header = S_HEADER.unpack(data[: S_HEADER.size])
offset = S_HEADER.size
version_header = header[0] version_header = header[0]
index_size = header[1] index_uuid_size = header[1]
pending_index_size = header[2] index_uuid = data[offset : offset + index_uuid_size]
data_size = header[3] offset += index_uuid_size
pending_data_size = header[4] index_size = header[2]
default_compression_header = header[5] pending_index_size = header[3]
data_size = header[4]
pending_data_size = header[5]
default_compression_header = header[6]
docket = RevlogDocket( docket = RevlogDocket(
revlog, revlog,
use_pending=use_pending, use_pending=use_pending,
version_header=version_header, version_header=version_header,
index_uuid=index_uuid,
index_end=index_size, index_end=index_size,
pending_index_end=pending_index_size, pending_index_end=pending_index_size,
data_end=data_size, data_end=data_size,
pending_data_end=pending_data_size, pending_data_end=pending_data_size,
default_compression_header=default_compression_header, default_compression_header=default_compression_header,
) )
return docket return docket

tests/test-revlog-v2.t

$ f --hexdump --bytes 4 .hg/store/00changelog.i $ f --hexdump --bytes 4 .hg/store/00changelog.i
.hg/store/00changelog.i: .hg/store/00changelog.i:
0000: 00 00 de ad |....| 0000: 00 00 de ad |....|
$ f --hexdump --bytes 4 .hg/store/data/foo.i $ f --hexdump --bytes 4 .hg/store/data/foo.i
.hg/store/data/foo.i: .hg/store/data/foo.i:
0000: 00 00 de ad |....| 0000: 00 00 de ad |....|
The expected files are generated
--------------------------------
We should have have:
- a docket
- a index file with a unique name
- a data file
$ ls .hg/store/00changelog* .hg/store/00manifest*
.hg/store/00changelog-b870a51b.idx
.hg/store/00changelog.d
.hg/store/00changelog.i
.hg/store/00manifest-88698448.idx
.hg/store/00manifest.d
.hg/store/00manifest.i