This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4479

[RFC] obsolete: add mechanism to filter obsstore
Needs RevisionPublic

Authored by lothiraldan on Sep 4 2018, 7:19 PM.

Details

Reviewers
baymax
Group Reviewers
hg-reviewers
Summary

This patch is not ready to land and only sent for discussion.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

lothiraldan created this revision.Sep 4 2018, 7:19 PM
martinvonz added a subscriber: martinvonz.Sep 4 2018, 7:22 PM

Why? (Sorry if I'm asking to early and you were just about to send an update.)

martinvonz added a comment.Sep 4 2018, 7:29 PM

I'll reply to my own question: The context is in D2679.

pulkit added a subscriber: pulkit.Sep 5 2018, 5:45 PM

I just had a quick look. obsmarker repr hash, are we kind of inventing a way to index obsmarkers? I am pretty sure you people have thought about that, can you explain why you went with obsmarker repr hash instead of including a real index?

Also, feel free to point me to old discussions if this was discussed earlier.

baymax requested changes to this revision.Jan 24 2020, 12:32 PM

There seems to have been no activities on this Diff for the past 3 Months.

By policy, we are automatically moving it out of the need-review state.

Please, move it back to need-review without hesitation if this diff should still be discussed.

:baymax:need-review-idle:

This revision now requires changes to proceed.Jan 24 2020, 12:32 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/obsolete.py (24 lines)

Diff 10777

mercurial/obsolete.py

The header is followed by the markers. Marker format depend of the version. See The header is followed by the markers. Marker format depend of the version. See
comment associated with each format for details. comment associated with each format for details.
""" """
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import hashlib
import struct import struct
from .i18n import _ from .i18n import _
from . import ( from . import (
encoding, encoding,
error, error,
node, node,
obsutil, obsutil,
# <version> -> (decoder, encoder) # <version> -> (decoder, encoder)
formats = {_fm0version: (_fm0readmarkers, _fm0encodeonemarker), formats = {_fm0version: (_fm0readmarkers, _fm0encodeonemarker),
_fm1version: (_fm1readmarkers, _fm1encodeonemarker)} _fm1version: (_fm1readmarkers, _fm1encodeonemarker)}
def _readmarkerversion(data): def _readmarkerversion(data):
return _unpack('>B', data[0:1])[0] return _unpack('>B', data[0:1])[0]
@util.nogc @util.nogc
def _readmarkers(data, off=None, stop=None): def _readmarkers(data, off=None, stop=None, filterfunc=None):
"""Read and enumerate markers from raw data""" """Read and enumerate markers from raw data"""
diskversion = _readmarkerversion(data) diskversion = _readmarkerversion(data)
if not off: if not off:
off = 1 # skip 1 byte version number off = 1 # skip 1 byte version number
if stop is None: if stop is None:
stop = len(data) stop = len(data)
if diskversion not in formats: if diskversion not in formats:
msg = _('parsing obsolete marker: unknown version %r') % diskversion msg = _('parsing obsolete marker: unknown version %r') % diskversion
raise error.UnknownVersion(msg, version=diskversion) raise error.UnknownVersion(msg, version=diskversion)
return diskversion, formats[diskversion][0](data, off, stop) markers = formats[diskversion][0](data, off, stop)
if filterfunc:
markers = filterfunc(markers)
return diskversion, markers
def encodeheader(version=_fm0version): def encodeheader(version=_fm0version):
return _pack('>B', version) return _pack('>B', version)
def encodemarkers(markers, addheader=False, version=_fm0version): def encodemarkers(markers, addheader=False, version=_fm0version):
# Kept separate from flushmarkers(), it will be reused for # Kept separate from flushmarkers(), it will be reused for
# markers exchange. # markers exchange.
encodeone = formats[version][1] encodeone = formats[version][1]
Exist as a separated function to allow the evolve extension for a more Exist as a separated function to allow the evolve extension for a more
subtle handling. subtle handling.
""" """
for mark in markers: for mark in markers:
if node.nullid in mark[1]: if node.nullid in mark[1]:
raise error.Abort(_('bad obsolescence marker detected: ' raise error.Abort(_('bad obsolescence marker detected: '
'invalid successors nullid')) 'invalid successors nullid'))
def _filtermarkers(data):
"""
Return a generator that will filter markers based on the data param passed.
data: a newline-separated list of obsmarker repr hashes
"""
filterset = set(filter(lambda x: x != '', data.split('\n')))
def filtermarkers(markers):
for marker in markers:
markerhash = hashlib.md5(marker.__repr__()).hexdigest()
if markerhash not in filterset:
yield marker
return filtermarkers
class obsstore(object): class obsstore(object):
"""Store obsolete markers """Store obsolete markers
Markers can be accessed with two mappings: Markers can be accessed with two mappings:
- predecessors[x] -> set(markers on predecessors edges of x) - predecessors[x] -> set(markers on predecessors edges of x)
- successors[x] -> set(markers on successors edges of x) - successors[x] -> set(markers on successors edges of x)
- children[x] -> set(markers on predecessors edges of children(x) - children[x] -> set(markers on predecessors edges of children(x)
""" """
else: else:
return self._defaultformat return self._defaultformat
@propertycache @propertycache
def _all(self): def _all(self):
data = self._data data = self._data
if not data: if not data:
return [] return []
self._version, markers = _readmarkers(data) filterfunc = _filtermarkers(self.svfs.tryread('obsfilter'))
self._version, markers = _readmarkers(data, filterfunc=filterfunc)
markers = list(markers) markers = list(markers)
_checkinvalidmarkers(markers) _checkinvalidmarkers(markers)
return markers return markers
@propertycache @propertycache
def successors(self): def successors(self):
successors = {} successors = {}
_addsuccessors(successors, self._all) _addsuccessors(successors, self._all)