comparison mercurial/revlog.py @ 47245:616b8f412676

revlogv2: introduce a very basic docket file

This is the first stone toward using a docket file in revlogv2. Right now the
docket is very basic and only store the version number (which is -also- stored
into the index file…) and the other files have fixed name. This new
implementation break transactionally… but they are no test checking
transactionally for revlogv2… So I take this as an opportunity to start small.
They are no usage of revlogv2 outside of tests anyway.

The docket keeps the `.i` naming used by previous version index to preserve a
unique entry point. We could decide to use a different name and look it up
first, or to fully rework this in a future "store" version. However that does
not seems necessary right now.

We will re-introduces transactionality (and associated testing…) in a later
changesets.


A long list of TODOs have been added to the relevant comment.

Differential Revision: https://phab.mercurial-scm.org/D10624

47244:bcafcd779d2e

    repository,
    util as interfaceutil,
)
from .revlogutils import (
    deltas as deltautil,
    flagutil,
    nodemap as nodemaputil,
    revlogv0,
    sidedata as sidedatautil,
)

        """
        self.upperboundcomp = upperboundcomp

        self.radix = radix

        self._indexfile = None
        self._datafile = None
        self._nodemap_file = None
        self.postfix = postfix
        self.opener = opener

        # How much data to read and cache into the raw revlog data cache.
        self._chunkcachesize = 65536
        self._maxchainlen = None
        self._deltabothparents = True
        self.index = None
        self._nodemap_docket = None
        # Mapping of partial identifiers to full nodes.
        self._pcache = {}
        # Mapping of revision integer to full node.
        self._compengine = b'zlib'

        features = FEATURES_BY_VERSION[self._format_version]
        self._inline = features[b'inline'](self._format_flags)
        self._generaldelta = features[b'generaldelta'](self._format_flags)
        self.hassidedata = features[b'sidedata']

        index_data = entry_data
        self._indexfile = entry_point

        if self.postfix is None or self.postfix == b'a':
            self._datafile = b'%s.d' % self.radix
        else:
            self._datafile = b'%s.d.%s' % (self.radix, self.postfix)

                    transaction.add(self._indexfile, isize)
                try:
                    self._writinghandles = (ifh, dfh)
                    try:
                        yield
                    finally:
                        self._writinghandles = None
                finally:
                    ifh.close()
            finally:

        return d

    def rewrite_sidedata(self, transaction, helpers, startrev, endrev):
        if not self.hassidedata:
            return
        # inline are not yet supported because they suffer from an issue when
        # rewriting them (since it's not an append-only operation).
        # See issue6485.
        assert not self._inline
        if not helpers[1] and not helpers[2]:
            # Nothing to generate or remove
            return

47245:616b8f412676

    repository,
    util as interfaceutil,
)
from .revlogutils import (
    deltas as deltautil,
    docket as docketutil,
    flagutil,
    nodemap as nodemaputil,
    revlogv0,
    sidedata as sidedatautil,
)

        """
        self.upperboundcomp = upperboundcomp

        self.radix = radix

        self._docket_file = None
        self._indexfile = None
        self._datafile = None
        self._nodemap_file = None
        self.postfix = postfix
        self.opener = opener

        # How much data to read and cache into the raw revlog data cache.
        self._chunkcachesize = 65536
        self._maxchainlen = None
        self._deltabothparents = True
        self.index = None
        self._docket = None
        self._nodemap_docket = None
        # Mapping of partial identifiers to full nodes.
        self._pcache = {}
        # Mapping of revision integer to full node.
        self._compengine = b'zlib'

        features = FEATURES_BY_VERSION[self._format_version]
        self._inline = features[b'inline'](self._format_flags)
        self._generaldelta = features[b'generaldelta'](self._format_flags)
        self.hassidedata = features[b'sidedata']

        if not features[b'docket']:
            self._indexfile = entry_point
            index_data = entry_data
        else:
            self._docket_file = entry_point
            if self._initempty:
                self._docket = docketutil.default_docket(self, header)
            else:
                self._docket = docketutil.parse_docket(self, entry_data)
            self._indexfile = self._docket.index_filepath()
            index_data = self._get_data(self._indexfile, mmapindexthreshold)
            self._inline = False
            # generaldelta implied by version 2 revlogs.
            self._generaldelta = True
            # the logic for persistent nodemap will be dealt with within the
            # main docket, so disable it for now.
            self._nodemap_file = None

        if self.postfix is None or self.postfix == b'a':
            self._datafile = b'%s.d' % self.radix
        else:
            self._datafile = b'%s.d.%s' % (self.radix, self.postfix)

                    transaction.add(self._indexfile, isize)
                try:
                    self._writinghandles = (ifh, dfh)
                    try:
                        yield
                        if self._docket is not None:
                            self._docket.write(transaction)
                    finally:
                        self._writinghandles = None
                finally:
                    ifh.close()
            finally:

        return d

    def rewrite_sidedata(self, transaction, helpers, startrev, endrev):
        if not self.hassidedata:
            return
        # revlog formats with sidedata support does not support inline
        assert not self._inline
        if not helpers[1] and not helpers[2]:
            # Nothing to generate or remove
            return