This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4096

narrow: call narrowspec.{save,restore,clear}backup directly
ClosedPublic

Authored by martinvonz on Aug 3 2018, 5:23 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGad24b581e4d9: narrow: call narrowspec.{save,restore,clear}backup directly
Summary

I want to move .hg/narrowspec to .hg/store/narrowspec and we need to
decouple the narrowspec update from the dirstate update for that. This
patch lets the callers call the narrowspec backup functions directly,
in addition to the dirstate backup functions. The narrowspec methods
are made to check if narrowing is enabled. For that, a repo instance
was needed, which all the callers luckily already had available.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

martinvonz created this revision.Aug 3 2018, 5:23 PM
martinvonz updated this revision to Diff 9871.Aug 3 2018, 8:12 PM
Closed by commit rHGad24b581e4d9: narrow: call narrowspec.{save,restore,clear}backup directly (authored by martinvonz). · Explain WhyAug 5 2018, 9:04 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 9871

hgext/narrow/narrowdirstate.py

# narrowdirstate.py - extensions to mercurial dirstate to support narrow clones # narrowdirstate.py - extensions to mercurial dirstate to support narrow clones
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
error, error,
match as matchmod, match as matchmod,
narrowspec,
) )
def wrapdirstate(repo, dirstate): def wrapdirstate(repo, dirstate):
"""Add narrow spec dirstate ignore, block changes outside narrow spec.""" """Add narrow spec dirstate ignore, block changes outside narrow spec."""
def _editfunc(fn): def _editfunc(fn):
def _wrapper(self, *args): def _wrapper(self, *args):
dirstate = repo.dirstate dirstate = repo.dirstate
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
for f in args: for f in args:
if f is not None and not narrowmatch(f) and f not in dirstate: if f is not None and not narrowmatch(f) and f not in dirstate:
raise error.Abort(_("cannot track '%s' - it is outside " + raise error.Abort(_("cannot track '%s' - it is outside " +
"the narrow clone") % f) "the narrow clone") % f)
return fn(self, *args) return fn(self, *args)
return _wrapper return _wrapper
def _narrowbackupname(backupname):
assert 'dirstate' in backupname
return backupname.replace('dirstate', narrowspec.FILENAME)
class narrowdirstate(dirstate.__class__): class narrowdirstate(dirstate.__class__):
def walk(self, match, subrepos, unknown, ignored, full=True, def walk(self, match, subrepos, unknown, ignored, full=True,
narrowonly=True): narrowonly=True):
if narrowonly: if narrowonly:
# hack to not exclude explicitly-specified paths so that they # hack to not exclude explicitly-specified paths so that they
# can be warned later on e.g. dirstate.add() # can be warned later on e.g. dirstate.add()
em = matchmod.exact(match._root, match._cwd, match.files()) em = matchmod.exact(match._root, match._cwd, match.files())
nm = matchmod.unionmatcher([repo.narrowmatch(), em]) nm = matchmod.unionmatcher([repo.narrowmatch(), em])
def rebuild(self, parent, allfiles, changedfiles=None): def rebuild(self, parent, allfiles, changedfiles=None):
if changedfiles is None: if changedfiles is None:
# Rebuilding entire dirstate, let's filter allfiles to match the # Rebuilding entire dirstate, let's filter allfiles to match the
# narrowspec. # narrowspec.
allfiles = [f for f in allfiles if repo.narrowmatch()(f)] allfiles = [f for f in allfiles if repo.narrowmatch()(f)]
super(narrowdirstate, self).rebuild(parent, allfiles, changedfiles) super(narrowdirstate, self).rebuild(parent, allfiles, changedfiles)
def restorebackup(self, tr, backupname):
narrowspec.restorebackup(self._opener,
_narrowbackupname(backupname))
super(narrowdirstate, self).restorebackup(tr, backupname)
def savebackup(self, tr, backupname):
super(narrowdirstate, self).savebackup(tr, backupname)
narrowspec.savebackup(self._opener, _narrowbackupname(backupname))
def clearbackup(self, tr, backupname):
super(narrowdirstate, self).clearbackup(tr, backupname)
narrowspec.clearbackup(self._opener, _narrowbackupname(backupname))
dirstate.__class__ = narrowdirstate dirstate.__class__ = narrowdirstate
return dirstate return dirstate

hgext/shelve.py

cmdutil, cmdutil,
discovery, discovery,
error, error,
exchange, exchange,
hg, hg,
lock as lockmod, lock as lockmod,
mdiff, mdiff,
merge, merge,
narrowspec,
node as nodemod, node as nodemod,
patch, patch,
phases, phases,
pycompat, pycompat,
registrar, registrar,
repair, repair,
scmutil, scmutil,
templatefilters, templatefilters,
def _restoreactivebookmark(repo, mark): def _restoreactivebookmark(repo, mark):
if mark: if mark:
bookmarks.activate(repo, mark) bookmarks.activate(repo, mark)
def _aborttransaction(repo): def _aborttransaction(repo):
'''Abort current transaction for shelve/unshelve, but keep dirstate '''Abort current transaction for shelve/unshelve, but keep dirstate
''' '''
tr = repo.currenttransaction() tr = repo.currenttransaction()
backupname = 'dirstate.shelve' dirstatebackupname = 'dirstate.shelve'
repo.dirstate.savebackup(tr, backupname) narrowspecbackupname = 'narrowspec.shelve'
repo.dirstate.savebackup(tr, dirstatebackupname)
narrowspec.savebackup(repo, narrowspecbackupname)
tr.abort() tr.abort()
repo.dirstate.restorebackup(None, backupname) narrowspec.restorebackup(repo, narrowspecbackupname)
repo.dirstate.restorebackup(None, dirstatebackupname)
def createcmd(ui, repo, pats, opts): def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve""" """subcommand that creates a new shelve"""
with repo.wlock(): with repo.wlock():
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
return _docreatecmd(ui, repo, pats, opts) return _docreatecmd(ui, repo, pats, opts)
def getshelvename(repo, parent, opts): def getshelvename(repo, parent, opts):

mercurial/dirstateguard.py

# dirstateguard.py - class to allow restoring dirstate after failure # dirstateguard.py - class to allow restoring dirstate after failure
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
narrowspec,
util, util,
) )
class dirstateguard(util.transactional): class dirstateguard(util.transactional):
'''Restore dirstate at unexpected failure. '''Restore dirstate at unexpected failure.
At the construction, this class does: At the construction, this class does:
- write current ``repo.dirstate`` out, and - write current ``repo.dirstate`` out, and
- save ``.hg/dirstate`` into the backup file - save ``.hg/dirstate`` into the backup file
This restores ``.hg/dirstate`` from backup file, if ``release()`` This restores ``.hg/dirstate`` from backup file, if ``release()``
is invoked before ``close()``. is invoked before ``close()``.
This just removes the backup file at ``close()`` before ``release()``. This just removes the backup file at ``close()`` before ``release()``.
''' '''
def __init__(self, repo, name): def __init__(self, repo, name):
self._repo = repo self._repo = repo
self._active = False self._active = False
self._closed = False self._closed = False
self._backupname = 'dirstate.backup.%s.%d' % (name, id(self)) self._backupname = 'dirstate.backup.%s.%d' % (name, id(self))
self._narrowspecbackupname = ('narrowspec.backup.%s.%d' %
(name, id(self)))
repo.dirstate.savebackup(repo.currenttransaction(), self._backupname) repo.dirstate.savebackup(repo.currenttransaction(), self._backupname)
narrowspec.savebackup(repo, self._narrowspecbackupname)
self._active = True self._active = True
def __del__(self): def __del__(self):
if self._active: # still active if self._active: # still active
# this may occur, even if this class is used correctly: # this may occur, even if this class is used correctly:
# for example, releasing other resources like transaction # for example, releasing other resources like transaction
# may raise exception before ``dirstateguard.release`` in # may raise exception before ``dirstateguard.release`` in
# ``release(tr, ....)``. # ``release(tr, ....)``.
self._abort() self._abort()
def close(self): def close(self):
if not self._active: # already inactivated if not self._active: # already inactivated
msg = (_("can't close already inactivated backup: %s") msg = (_("can't close already inactivated backup: %s")
% self._backupname) % self._backupname)
raise error.Abort(msg) raise error.Abort(msg)
self._repo.dirstate.clearbackup(self._repo.currenttransaction(), self._repo.dirstate.clearbackup(self._repo.currenttransaction(),
self._backupname) self._backupname)
narrowspec.clearbackup(self._repo, self._narrowspecbackupname)
self._active = False self._active = False
self._closed = True self._closed = True
def _abort(self): def _abort(self):
narrowspec.restorebackup(self._repo, self._narrowspecbackupname)
self._repo.dirstate.restorebackup(self._repo.currenttransaction(), self._repo.dirstate.restorebackup(self._repo.currenttransaction(),
self._backupname) self._backupname)
self._active = False self._active = False
def release(self): def release(self):
if not self._closed: if not self._closed:
if not self._active: # already inactivated if not self._active: # already inactivated
msg = (_("can't release already inactivated backup: %s") msg = (_("can't release already inactivated backup: %s")
% self._backupname) % self._backupname)
raise error.Abort(msg) raise error.Abort(msg)
self._abort() self._abort()

mercurial/localrepo.py

# in-memory changes aren't written out at closing # in-memory changes aren't written out at closing
# transaction, if tr.addfilegenerator (via # transaction, if tr.addfilegenerator (via
# dirstate.write or so) isn't invoked while # dirstate.write or so) isn't invoked while
# transaction running # transaction running
repo.dirstate.write(None) repo.dirstate.write(None)
else: else:
# discard all changes (including ones already written # discard all changes (including ones already written
# out) in this transaction # out) in this transaction
narrowspec.restorebackup(self, 'journal.narrowspec')
repo.dirstate.restorebackup(None, 'journal.dirstate') repo.dirstate.restorebackup(None, 'journal.dirstate')
repo.invalidate(clearfilecache=True) repo.invalidate(clearfilecache=True)
tr = transaction.transaction(rp, self.svfs, vfsmap, tr = transaction.transaction(rp, self.svfs, vfsmap,
"journal", "journal",
"undo", "undo",
aftertrans(renames), aftertrans(renames),
(self.svfs, 'journal.phaseroots')) (self.svfs, 'journal.phaseroots'))
def undofiles(self): def undofiles(self):
return [(vfs, undoname(x)) for vfs, x in self._journalfiles()] return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
@unfilteredmethod @unfilteredmethod
def _writejournal(self, desc): def _writejournal(self, desc):
self.dirstate.savebackup(None, 'journal.dirstate') self.dirstate.savebackup(None, 'journal.dirstate')
narrowspec.savebackup(self, 'journal.narrowspec')
self.vfs.write("journal.branch", self.vfs.write("journal.branch",
encoding.fromlocal(self.dirstate.branch())) encoding.fromlocal(self.dirstate.branch()))
self.vfs.write("journal.desc", self.vfs.write("journal.desc",
"%d\n%s\n" % (len(self), desc)) "%d\n%s\n" % (len(self), desc))
self.vfs.write("journal.bookmarks", self.vfs.write("journal.bookmarks",
self.vfs.tryread("bookmarks")) self.vfs.tryread("bookmarks"))
self.svfs.write("journal.phaseroots", self.svfs.write("journal.phaseroots",
self.svfs.tryread("phaseroots")) self.svfs.tryread("phaseroots"))
self.invalidate() self.invalidate()
parentgone = (parents[0] not in self.changelog.nodemap or parentgone = (parents[0] not in self.changelog.nodemap or
parents[1] not in self.changelog.nodemap) parents[1] not in self.changelog.nodemap)
if parentgone: if parentgone:
# prevent dirstateguard from overwriting already restored one # prevent dirstateguard from overwriting already restored one
dsguard.close() dsguard.close()
narrowspec.restorebackup(self, 'undo.narrowspec')
self.dirstate.restorebackup(None, 'undo.dirstate') self.dirstate.restorebackup(None, 'undo.dirstate')
try: try:
branch = self.vfs.read('undo.branch') branch = self.vfs.read('undo.branch')
self.dirstate.setbranch(encoding.tolocal(branch)) self.dirstate.setbranch(encoding.tolocal(branch))
except IOError: except IOError:
ui.warn(_('named branch could not be reset: ' ui.warn(_('named branch could not be reset: '
'current branch is still \'%s\'\n') 'current branch is still \'%s\'\n')
% self.dirstate.branch()) % self.dirstate.branch())

mercurial/narrowspec.py

# narrowspec.py - methods for working with a narrow view of a repository # narrowspec.py - methods for working with a narrow view of a repository
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
repository,
sparse, sparse,
util, util,
) )
FILENAME = 'narrowspec' FILENAME = 'narrowspec'
def parseserverpatterns(text): def parseserverpatterns(text):
"""Parses the narrowspec format that's returned by the server.""" """Parses the narrowspec format that's returned by the server."""
raise error.Abort(_("including other spec files using '%include' is not" raise error.Abort(_("including other spec files using '%include' is not"
" suported in narrowspec")) " suported in narrowspec"))
return includepats, excludepats return includepats, excludepats
def save(repo, includepats, excludepats): def save(repo, includepats, excludepats):
spec = format(includepats, excludepats) spec = format(includepats, excludepats)
repo.vfs.write(FILENAME, spec) repo.vfs.write(FILENAME, spec)
def savebackup(vfs, backupname): def savebackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements:
return
vfs = repo.vfs
vfs.tryunlink(backupname) vfs.tryunlink(backupname)
util.copyfile(vfs.join(FILENAME), vfs.join(backupname), hardlink=True) util.copyfile(vfs.join(FILENAME), vfs.join(backupname), hardlink=True)
def restorebackup(vfs, backupname): def restorebackup(repo, backupname):
vfs.rename(backupname, FILENAME, checkambig=True) if repository.NARROW_REQUIREMENT not in repo.requirements:
return
def clearbackup(vfs, backupname): repo.vfs.rename(backupname, FILENAME, checkambig=True)
vfs.unlink(backupname)
def clearbackup(repo, backupname):
if repository.NARROW_REQUIREMENT not in repo.requirements:
return
repo.vfs.unlink(backupname)
def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes): def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes):
r""" Restricts the patterns according to repo settings, r""" Restricts the patterns according to repo settings,
results in a logical AND operation results in a logical AND operation
:param req_includes: requested includes :param req_includes: requested includes
:param req_excludes: requested excludes :param req_excludes: requested excludes
:param repo_includes: repo includes :param repo_includes: repo includes