mercurial-scm/hg-stable: mercurial/revlogutils/docket.py comparison

comparison mercurial/revlogutils/docket.py @ 47459:c252631500e4

revlog: add a way to keep track of older uids in the docket When the revlog content is rewritten, we will use new files, to avoid truncating the previous ones. We need some way to keep track of the older files before we clean them up. Differential Revision: https://phab.mercurial-scm.org/D10866

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Thu, 20 May 2021 21:47:09 +0200
parents	be903d043099
children	865c260d7163

comparison

equal deleted inserted replaced

-:c6844912c327
+:c252631500e4
 #
 # * 4 bytes: revlog version
 #          |   This is mandatory as docket must be compatible with the previous
 #          |   revlog index header.
 # * 1 bytes: size of index uuid
+# * 1 bytes: number of outdated index uuid
 # * 1 bytes: size of data uuid
+# * 1 bytes: number of outdated data uuid
 # * 1 bytes: size of sizedata uuid
+# * 1 bytes: number of outdated data uuid
 # * 8 bytes: size of index-data
 # * 8 bytes: pending size of index-data
 # * 8 bytes: size of data
 # * 8 bytes: size of sidedata
 # * 8 bytes: pending size of data
 # * 8 bytes: pending size of sidedata
 # * 1 bytes: default compression header
-S_HEADER = struct.Struct(constants.INDEX_HEADER_FMT + b'BBBLLLLLLc')
+S_HEADER = struct.Struct(constants.INDEX_HEADER_FMT + b'BBBBBBLLLLLLc')
+# * 1 bytes: size of index uuid
+# * 8 bytes: size of file
+S_OLD_UID = struct.Struct('>BL')
 class RevlogDocket(object):
 """metadata associated with revlog"""
 self,
 revlog,
 use_pending=False,
 version_header=None,
 index_uuid=None,
+older_index_uuids=(),
 data_uuid=None,
+older_data_uuids=(),
 sidedata_uuid=None,
+older_sidedata_uuids=(),
 index_end=0,
 pending_index_end=0,
 data_end=0,
 pending_data_end=0,
 sidedata_end=0,
 self._dirty = False
 self._radix = revlog.radix
 self._path = revlog._docket_file
 self._opener = revlog.opener
 self._index_uuid = index_uuid
+self._older_index_uuids = older_index_uuids
 self._data_uuid = data_uuid
+self._older_data_uuids = older_data_uuids
 self._sidedata_uuid = sidedata_uuid
+self._older_sidedata_uuids = older_sidedata_uuids
+assert not set(older_index_uuids) & set(older_data_uuids)
+assert not set(older_data_uuids) & set(older_sidedata_uuids)
+assert not set(older_index_uuids) & set(older_sidedata_uuids)
 # thes asserts should be True as long as we have a single index filename
 assert index_end <= pending_index_end
 assert data_end <= pending_data_end
 assert sidedata_end <= pending_sidedata_end
 self._initial_index_end = index_end
 assert official_data_end <= self._data_end
 assert official_sidedata_end <= self._sidedata_end
 data = (
 self._version_header,
 len(self._index_uuid),
+len(self._older_index_uuids),
 len(self._data_uuid),
+len(self._older_data_uuids),
 len(self._sidedata_uuid),
+len(self._older_sidedata_uuids),
 official_index_end,
 self._index_end,
 official_data_end,
 self._data_end,
 official_sidedata_end,
 self._sidedata_end,
 self.default_compression_header,
 )
 s = []
 s.append(S_HEADER.pack(*data))
 s.append(self._index_uuid)
+for u, size in self._older_index_uuids:
+s.append(S_OLD_UID.pack(len(u), size))
+for u, size in self._older_index_uuids:
+s.append(u)
 s.append(self._data_uuid)
+for u, size in self._older_data_uuids:
+s.append(S_OLD_UID.pack(len(u), size))
+for u, size in self._older_data_uuids:
+s.append(u)
 s.append(self._sidedata_uuid)
+for u, size in self._older_sidedata_uuids:
+s.append(S_OLD_UID.pack(len(u), size))
+for u, size in self._older_sidedata_uuids:
+s.append(u)
 return b''.join(s)
 def default_docket(revlog, version_header):
 """given a revlog version a new docket object for the given revlog"""
 )
 docket._dirty = True
 return docket
+def _parse_old_uids(get_data, count):
+all_sizes = []
+all_uids = []
+for i in range(0, count):
+raw = get_data(S_OLD_UID.size)
+all_sizes.append(S_OLD_UID.unpack(raw))
+for uid_size, file_size in all_sizes:
+uid = get_data(uid_size)
+all_uids.append((uid, file_size))
+return all_uids
 def parse_docket(revlog, data, use_pending=False):
 """given some docket data return a docket object for the given revlog"""
 header = S_HEADER.unpack(data[: S_HEADER.size])
 # this is a mutable closure capture used in `get_data`
 version_header = next(iheader)
 index_uuid_size = next(iheader)
 index_uuid = get_data(index_uuid_size)
+older_index_uuid_count = next(iheader)
+older_index_uuids = _parse_old_uids(get_data, older_index_uuid_count)
 data_uuid_size = next(iheader)
 data_uuid = get_data(data_uuid_size)
+older_data_uuid_count = next(iheader)
+older_data_uuids = _parse_old_uids(get_data, older_data_uuid_count)
 sidedata_uuid_size = next(iheader)
 sidedata_uuid = get_data(sidedata_uuid_size)
+older_sidedata_uuid_count = next(iheader)
+older_sidedata_uuids = _parse_old_uids(get_data, older_sidedata_uuid_count)
 index_size = next(iheader)
 pending_index_size = next(iheader)
 docket = RevlogDocket(
 revlog,
 use_pending=use_pending,
 version_header=version_header,
 index_uuid=index_uuid,
+older_index_uuids=older_index_uuids,
 data_uuid=data_uuid,
+older_data_uuids=older_data_uuids,
 sidedata_uuid=sidedata_uuid,
+older_sidedata_uuids=older_sidedata_uuids,
 index_end=index_size,
 pending_index_end=pending_index_size,
 data_end=data_size,
 pending_data_end=pending_data_size,
 sidedata_end=sidedata_size,

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revlogutils/docket.py @ 47459:c252631500e4