( )⚙ D10625 revlogv2: store version information in the docket only

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10625

revlogv2: store version information in the docket only
ClosedPublic

Authored by marmoute on May 3 2021, 7:54 AM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHG6b1eae313b2f: revlogv2: store version information in the docket only
Summary

Having it duplicated in the index was both useless and a risk of discrepancy.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.May 3 2021, 7:54 AM
baymax updated this revision to Diff 27468.May 3 2021, 9:32 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute updated this revision to Diff 27543.May 4 2021, 10:13 AM
baymax updated this revision to Diff 27871.May 11 2021, 1:44 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.May 17 2021, 5:48 PM
This revision is now accepted and ready to land.May 17 2021, 5:48 PM
marmoute added a commit: rHG6b1eae313b2f: revlogv2: store version information in the docket only.May 17 2021, 5:51 PM
Closed by commit rHG6b1eae313b2f: revlogv2: store version information in the docket only (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27402

mercurial/cext/revlog.c

*/ */
static PyObject *index_pack_header(indexObject *self, PyObject *args) static PyObject *index_pack_header(indexObject *self, PyObject *args)
{ {
int header; int header;
char out[4]; char out[4];
if (!PyArg_ParseTuple(args, "I", &header)) { if (!PyArg_ParseTuple(args, "I", &header)) {
return NULL; return NULL;
} }
if (self->format_version != format_v1) {
PyErr_Format(PyExc_RuntimeError,
"version header should go in the docket, not the "
"index: %lu",
header);
return NULL;
}
putbe32(header, out); putbe32(header, out);
return PyBytes_FromStringAndSize(out, 4); return PyBytes_FromStringAndSize(out, 4);
} }
/* /*
* Return the raw binary string representing a revision * Return the raw binary string representing a revision
*/ */
static PyObject *index_entry_binary(indexObject *self, PyObject *value) static PyObject *index_entry_binary(indexObject *self, PyObject *value)
{ {
long rev; long rev;
const char *data; const char *data;
Py_ssize_t length = index_length(self); Py_ssize_t length = index_length(self);
if (!pylong_to_long(value, &rev)) { if (!pylong_to_long(value, &rev)) {
return NULL; return NULL;
} }
if (rev < 0 || rev >= length) { if (rev < 0 || rev >= length) {
PyErr_Format(PyExc_ValueError, "revlog index out of range: %ld", PyErr_Format(PyExc_ValueError, "revlog index out of range: %ld",
rev); rev);
return NULL; return NULL;
}; };
data = index_deref(self, rev); data = index_deref(self, rev);
if (data == NULL) if (data == NULL)
return NULL; return NULL;
if (rev == 0) { if (rev == 0 && self->format_version == format_v1) {
/* the header is eating the start of the first entry */ /* the header is eating the start of the first entry */
return PyBytes_FromStringAndSize(data + 4, return PyBytes_FromStringAndSize(data + 4,
self->entry_size - 4); self->entry_size - 4);
} }
return PyBytes_FromStringAndSize(data, self->entry_size); return PyBytes_FromStringAndSize(data, self->entry_size);
} }
/* /*

mercurial/configitems.py

) )
coreconfigitem( coreconfigitem(
b'experimental', b'experimental',
b'revisions.prefixhexnode', b'revisions.prefixhexnode',
default=False, default=False,
) )
# "out of experimental" todo list. # "out of experimental" todo list.
# #
# * stop storing version information in the index (it is already in the docket)
# * properly hide uncommitted content to other process # * properly hide uncommitted content to other process
# * expose transaction content hooks during pre-commit validation # * expose transaction content hooks during pre-commit validation
# * include management of a persistent nodemap in the main docket # * include management of a persistent nodemap in the main docket
# * enforce a "no-truncate" policy for mmap safety # * enforce a "no-truncate" policy for mmap safety
# - for censoring operation # - for censoring operation
# - for stripping operation # - for stripping operation
# - for rollback operation # - for rollback operation
# * to grow a docket file to at least store the last offset of the data # * to grow a docket file to at least store the last offset of the data

mercurial/pure/parsers.py

import struct import struct
import zlib import zlib
from ..node import ( from ..node import (
nullrev, nullrev,
sha1nodeconstants, sha1nodeconstants,
) )
from .. import ( from .. import (
error,
pycompat, pycompat,
util, util,
) )
from ..revlogutils import nodemap as nodemaputil from ..revlogutils import nodemap as nodemaputil
from ..revlogutils import constants as revlog_constants from ..revlogutils import constants as revlog_constants
stringio = pycompat.bytesio stringio = pycompat.bytesio
def _pack_entry(self, entry): def _pack_entry(self, entry):
return self.index_format.pack(*entry) return self.index_format.pack(*entry)
def entry_binary(self, rev): def entry_binary(self, rev):
"""return the raw binary string representing a revision""" """return the raw binary string representing a revision"""
entry = self[rev] entry = self[rev]
p = revlog_constants.INDEX_ENTRY_V2.pack(*entry) p = revlog_constants.INDEX_ENTRY_V2.pack(*entry)
if rev == 0:
p = p[revlog_constants.INDEX_HEADER.size :]
return p return p
def pack_header(self, header):
"""pack header information as binary"""
msg = 'version header should go in the docket, not the index: %d'
msg %= header
raise error.ProgrammingError(msg)
class IndexObject2(Index2Mixin, IndexObject): class IndexObject2(Index2Mixin, IndexObject):
pass pass
class InlinedIndexObject2(Index2Mixin, InlinedIndexObject): class InlinedIndexObject2(Index2Mixin, InlinedIndexObject):
def _inline_scan(self, lgt): def _inline_scan(self, lgt):
sidedata_length_pos = 72 sidedata_length_pos = 72

mercurial/revlog.py

trindex = r trindex = r
new_dfh.flush() new_dfh.flush()
with self.__index_new_fp() as fp: with self.__index_new_fp() as fp:
self._format_flags &= ~FLAG_INLINE_DATA self._format_flags &= ~FLAG_INLINE_DATA
self._inline = False self._inline = False
for i in self: for i in self:
e = self.index.entry_binary(i) e = self.index.entry_binary(i)
if i == 0: if i == 0 and self._docket is None:
header = self._format_flags | self._format_version header = self._format_flags | self._format_version
header = self.index.pack_header(header) header = self.index.pack_header(header)
e = header + e e = header + e
fp.write(e) fp.write(e)
# the temp file replace the real index when we exit the context # the temp file replace the real index when we exit the context
# manager # manager
tr.replace(self._indexfile, trindex * self.index.entry_size) tr.replace(self._indexfile, trindex * self.index.entry_size)
p2r, p2r,
node, node,
sidedata_offset, sidedata_offset,
len(serialized_sidedata), len(serialized_sidedata),
) )
self.index.append(e) self.index.append(e)
entry = self.index.entry_binary(curr) entry = self.index.entry_binary(curr)
if curr == 0: if curr == 0 and self._docket is None:
header = self._format_flags | self._format_version header = self._format_flags | self._format_version
header = self.index.pack_header(header) header = self.index.pack_header(header)
entry = header + entry entry = header + entry
self._writeentry( self._writeentry(
transaction, transaction,
entry, entry,
deltainfo.data, deltainfo.data,
link, link,
current_offset += len(serialized_sidedata) current_offset += len(serialized_sidedata)
# rewrite the new index entries # rewrite the new index entries
ifh.seek(startrev * self.index.entry_size) ifh.seek(startrev * self.index.entry_size)
for i, e in enumerate(new_entries): for i, e in enumerate(new_entries):
rev = startrev + i rev = startrev + i
self.index.replace_sidedata_info(rev, e[8], e[9], e[0]) self.index.replace_sidedata_info(rev, e[8], e[9], e[0])
packed = self.index.entry_binary(rev) packed = self.index.entry_binary(rev)
if rev == 0: if rev == 0 and self._docket is None:
header = self._format_flags | self._format_version header = self._format_flags | self._format_version
header = self.index.pack_header(header) header = self.index.pack_header(header)
packed = header + packed packed = header + packed
ifh.write(packed) ifh.write(packed)