( )⚙ D5508 narrow: extract repo property for store narrowmatcher

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5508

narrow: extract repo property for store narrowmatcher
ClosedPublic

Authored by martinvonz on Jan 7 2019, 3:45 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGd2d716cc0700: narrow: extract repo property for store narrowmatcher
Summary

When a repo lock is released, we try to persist the manifest
cache. That involves getting the narrowmatcher for the
manifestlog. That should not fail if the store and working copy
narrowspecs are out of sync. Without this patch, the later patches in
this series will fail because of that.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

martinvonz created this revision.Jan 7 2019, 3:45 AM
martinvonz updated this revision to Diff 13036.Jan 7 2019, 4:18 AM
martinvonz updated this revision to Diff 13057.Jan 7 2019, 2:02 PM
martinvonz updated this revision to Diff 13148.Jan 10 2019, 4:50 PM
pulkit accepted this revision.Jan 16 2019, 2:29 AM
pulkit added a subscriber: pulkit.
pulkit added inline comments.
mercurial/localrepo.py
1227

In future, we can add a boolean store argument to narrowmatch() function. That will be better than accessing private attributes of the localrepo class.

Closed by commit rHGd2d716cc0700: narrow: extract repo property for store narrowmatcher (authored by martinvonz). · Explain WhyJan 16 2019, 2:49 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/lfs/__init__.py (2 lines)
Mmercurial/localrepo.py (11 lines)

Diff 13036

hgext/lfs/__init__.py

return 0 return 0
last = kwargs.get(r'node_last') last = kwargs.get(r'node_last')
_bin = node.bin _bin = node.bin
if last: if last:
s = repo.set('%n:%n', _bin(kwargs[r'node']), _bin(last)) s = repo.set('%n:%n', _bin(kwargs[r'node']), _bin(last))
else: else:
s = repo.set('%n', _bin(kwargs[r'node'])) s = repo.set('%n', _bin(kwargs[r'node']))
match = repo.narrowmatch() match = repo._storenarrowmatch
for ctx in s: for ctx in s:
# TODO: is there a way to just walk the files in the commit? # TODO: is there a way to just walk the files in the commit?
if any(ctx[f].islfs() for f in ctx.files() if any(ctx[f].islfs() for f in ctx.files()
if f in ctx and match(f)): if f in ctx and match(f)):
repo.requirements.add('lfs') repo.requirements.add('lfs')
repo.features.add(repository.REPO_FEATURE_LFS) repo.features.add(repository.REPO_FEATURE_LFS)
repo._writerequirements() repo._writerequirements()
repo.prepushoutgoinghooks.add('lfs', wrapper.prepush) repo.prepushoutgoinghooks.add('lfs', wrapper.prepush)

mercurial/localrepo.py

@interfaceutil.implementer(repository.ilocalrepositoryfilestorage) @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
class revlognarrowfilestorage(object): class revlognarrowfilestorage(object):
"""File storage when using revlogs and narrow files.""" """File storage when using revlogs and narrow files."""
def file(self, path): def file(self, path):
if path[0] == b'/': if path[0] == b'/':
path = path[1:] path = path[1:]
return filelog.narrowfilelog(self.svfs, path, self.narrowmatch()) return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
def makefilestorage(requirements, features, **kwargs): def makefilestorage(requirements, features, **kwargs):
"""Produce a type conforming to ``ilocalrepositoryfilestorage``.""" """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE) features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
features.add(repository.REPO_FEATURE_STREAM_CLONE) features.add(repository.REPO_FEATURE_STREAM_CLONE)
if repository.NARROW_REQUIREMENT in requirements: if repository.NARROW_REQUIREMENT in requirements:
return revlognarrowfilestorage return revlognarrowfilestorage
def changelog(self): def changelog(self):
return changelog.changelog(self.svfs, return changelog.changelog(self.svfs,
trypending=txnutil.mayhavepending(self.root)) trypending=txnutil.mayhavepending(self.root))
@storecache('00manifest.i') @storecache('00manifest.i')
def manifestlog(self): def manifestlog(self):
rootstore = manifest.manifestrevlog(self.svfs) rootstore = manifest.manifestrevlog(self.svfs)
return manifest.manifestlog(self.svfs, self, rootstore, return manifest.manifestlog(self.svfs, self, rootstore,
self.narrowmatch()) self._storenarrowmatch)
@repofilecache('dirstate') @repofilecache('dirstate')
def dirstate(self): def dirstate(self):
return self._makedirstate() return self._makedirstate()
def _makedirstate(self): def _makedirstate(self):
"""Extension point for wrapping the dirstate per-repo.""" """Extension point for wrapping the dirstate per-repo."""
sparsematchfn = lambda: sparse.matcher(self) sparsematchfn = lambda: sparse.matcher(self)
def narrowpats(self): def narrowpats(self):
"""matcher patterns for this repository's narrowspec """matcher patterns for this repository's narrowspec
A tuple of (includes, excludes). A tuple of (includes, excludes).
""" """
return narrowspec.load(self) return narrowspec.load(self)
@storecache(narrowspec.FILENAME) @storecache(narrowspec.FILENAME)
def _storenarrowmatch(self):
pulkitUnsubmitted
Not Done

In future, we can add a boolean store argument to narrowmatch() function. That will be better than accessing private attributes of the localrepo class.

pulkit: In future, we can add a boolean `store` argument to `narrowmatch()` function. That will be…
if repository.NARROW_REQUIREMENT not in self.requirements:
return matchmod.always(self.root, '')
include, exclude = self.narrowpats
return narrowspec.match(self.root, include=include, exclude=exclude)
@storecache(narrowspec.FILENAME)
def _narrowmatch(self): def _narrowmatch(self):
if repository.NARROW_REQUIREMENT not in self.requirements: if repository.NARROW_REQUIREMENT not in self.requirements:
return matchmod.always(self.root, '') return matchmod.always(self.root, '')
narrowspec.checkworkingcopynarrowspec(self) narrowspec.checkworkingcopynarrowspec(self)
include, exclude = self.narrowpats include, exclude = self.narrowpats
return narrowspec.match(self.root, include=include, exclude=exclude) return narrowspec.match(self.root, include=include, exclude=exclude)
def narrowmatch(self, match=None, includeexact=False): def narrowmatch(self, match=None, includeexact=False):