narrow: fix crash when restoring backup in legacy repo

Using --addremove when committing in an old repo (before we started
keeping .hg/narrowspec.dirstate) results in a crash. The test
case modified in this patch would crash like this:

  abort: $ENOENT$

The issue is that when the dirstateguard is aborted, it tries to
restore the backup of .hg/narrowspec.dirstate. However, since we were
in an old repo, that file did not get created when the dirstateguard
was created. Note that the dirstateguard is not used unless
--addremove is passed.

This patch fixes the bug by making restorewcbackup() not fail if the
backup doesn't exist. I also made clearwcbackup() safe, just in case.

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

mercurial/narrowspec.py

@@ -1,314 +1,316 b''
 # narrowspec.py - methods for working with a narrow view of a repository
 #
 # Copyright 2017 Google, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 
 from .i18n import _
 from . import (
     error,
     match as matchmod,
     merge,
     repository,
     sparse,
     util,
 )
 
 # The file in .hg/store/ that indicates which paths exit in the store
 FILENAME = 'narrowspec'
 # The file in .hg/ that indicates which paths exit in the dirstate
 DIRSTATE_FILENAME = 'narrowspec.dirstate'
 
 # Pattern prefixes that are allowed in narrow patterns. This list MUST
 # only contain patterns that are fast and safe to evaluate. Keep in mind
 # that patterns are supplied by clients and executed on remote servers
 # as part of wire protocol commands. That means that changes to this
 # data structure influence the wire protocol and should not be taken
 # lightly - especially removals.
 VALID_PREFIXES = (
     b'path:',
     b'rootfilesin:',
 )
 
 def normalizesplitpattern(kind, pat):
     """Returns the normalized version of a pattern and kind.
 
     Returns a tuple with the normalized kind and normalized pattern.
     """
     pat = pat.rstrip('/')
     _validatepattern(pat)
     return kind, pat
 
 def _numlines(s):
     """Returns the number of lines in s, including ending empty lines."""
     # We use splitlines because it is Unicode-friendly and thus Python 3
     # compatible. However, it does not count empty lines at the end, so trick
     # it by adding a character at the end.
     return len((s + 'x').splitlines())
 
 def _validatepattern(pat):
     """Validates the pattern and aborts if it is invalid.
 
     Patterns are stored in the narrowspec as newline-separated
     POSIX-style bytestring paths. There's no escaping.
     """
 
     # We use newlines as separators in the narrowspec file, so don't allow them
     # in patterns.
     if _numlines(pat) > 1:
         raise error.Abort(_('newlines are not allowed in narrowspec paths'))
 
     components = pat.split('/')
     if '.' in components or '..' in components:
         raise error.Abort(_('"." and ".." are not allowed in narrowspec paths'))
 
 def normalizepattern(pattern, defaultkind='path'):
     """Returns the normalized version of a text-format pattern.
 
     If the pattern has no kind, the default will be added.
     """
     kind, pat = matchmod._patsplit(pattern, defaultkind)
     return '%s:%s' % normalizesplitpattern(kind, pat)
 
 def parsepatterns(pats):
     """Parses an iterable of patterns into a typed pattern set.
 
     Patterns are assumed to be ``path:`` if no prefix is present.
     For safety and performance reasons, only some prefixes are allowed.
     See ``validatepatterns()``.
 
     This function should be used on patterns that come from the user to
     normalize and validate them to the internal data structure used for
     representing patterns.
     """
     res = {normalizepattern(orig) for orig in pats}
     validatepatterns(res)
     return res
 
 def validatepatterns(pats):
     """Validate that patterns are in the expected data structure and format.
 
     And that is a set of normalized patterns beginning with ``path:`` or
     ``rootfilesin:``.
 
     This function should be used to validate internal data structures
     and patterns that are loaded from sources that use the internal,
     prefixed pattern representation (but can't necessarily be fully trusted).
     """
     if not isinstance(pats, set):
         raise error.ProgrammingError('narrow patterns should be a set; '
                                      'got %r' % pats)
 
     for pat in pats:
         if not pat.startswith(VALID_PREFIXES):
             # Use a Mercurial exception because this can happen due to user
             # bugs (e.g. manually updating spec file).
             raise error.Abort(_('invalid prefix on narrow pattern: %s') % pat,
                               hint=_('narrow patterns must begin with one of '
                                      'the following: %s') %
                                    ', '.join(VALID_PREFIXES))
 
 def format(includes, excludes):
     output = '[include]\n'
     for i in sorted(includes - excludes):
         output += i + '\n'
     output += '[exclude]\n'
     for e in sorted(excludes):
         output += e + '\n'
     return output
 
 def match(root, include=None, exclude=None):
     if not include:
         # Passing empty include and empty exclude to matchmod.match()
         # gives a matcher that matches everything, so explicitly use
         # the nevermatcher.
         return matchmod.never(root, '')
     return matchmod.match(root, '', [], include=include or [],
                           exclude=exclude or [])
 
 def parseconfig(ui, spec):
     # maybe we should care about the profiles returned too
     includepats, excludepats, profiles = sparse.parseconfig(ui, spec, 'narrow')
     if profiles:
         raise error.Abort(_("including other spec files using '%include' is not"
                             " supported in narrowspec"))
 
     validatepatterns(includepats)
     validatepatterns(excludepats)
 
     return includepats, excludepats
 
 def load(repo):
     try:
         spec = repo.svfs.read(FILENAME)
     except IOError as e:
         # Treat "narrowspec does not exist" the same as "narrowspec file exists
         # and is empty".
         if e.errno == errno.ENOENT:
             return set(), set()
         raise
 
     return parseconfig(repo.ui, spec)
 
 def save(repo, includepats, excludepats):
     validatepatterns(includepats)
     validatepatterns(excludepats)
     spec = format(includepats, excludepats)
     repo.svfs.write(FILENAME, spec)
 
 def copytoworkingcopy(repo):
     spec = repo.svfs.read(FILENAME)
     repo.vfs.write(DIRSTATE_FILENAME, spec)
 
 def savebackup(repo, backupname):
     if repository.NARROW_REQUIREMENT not in repo.requirements:
         return
     svfs = repo.svfs
     svfs.tryunlink(backupname)
     util.copyfile(svfs.join(FILENAME), svfs.join(backupname), hardlink=True)
 
 def restorebackup(repo, backupname):
     if repository.NARROW_REQUIREMENT not in repo.requirements:
         return
     util.rename(repo.svfs.join(backupname), repo.svfs.join(FILENAME))
 
 def savewcbackup(repo, backupname):
     if repository.NARROW_REQUIREMENT not in repo.requirements:
         return
     vfs = repo.vfs
     vfs.tryunlink(backupname)
     # It may not exist in old repos
     if vfs.exists(DIRSTATE_FILENAME):
         util.copyfile(vfs.join(DIRSTATE_FILENAME), vfs.join(backupname),
                       hardlink=True)
 
 def restorewcbackup(repo, backupname):
     if repository.NARROW_REQUIREMENT not in repo.requirements:
         return
-    util.rename(repo.vfs.join(backupname), repo.vfs.join(DIRSTATE_FILENAME))
+    # It may not exist in old repos
+    if repo.vfs.exists(backupname):
+        util.rename(repo.vfs.join(backupname), repo.vfs.join(DIRSTATE_FILENAME))
 
 def clearwcbackup(repo, backupname):
     if repository.NARROW_REQUIREMENT not in repo.requirements:
         return
-    repo.vfs.unlink(backupname)
+    repo.vfs.tryunlink(backupname)
 
 def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes):
     r""" Restricts the patterns according to repo settings,
     results in a logical AND operation
 
     :param req_includes: requested includes
     :param req_excludes: requested excludes
     :param repo_includes: repo includes
     :param repo_excludes: repo excludes
     :return: include patterns, exclude patterns, and invalid include patterns.
 
     >>> restrictpatterns({'f1','f2'}, {}, ['f1'], [])
     (set(['f1']), {}, [])
     >>> restrictpatterns({'f1'}, {}, ['f1','f2'], [])
     (set(['f1']), {}, [])
     >>> restrictpatterns({'f1/fc1', 'f3/fc3'}, {}, ['f1','f2'], [])
     (set(['f1/fc1']), {}, [])
     >>> restrictpatterns({'f1_fc1'}, {}, ['f1','f2'], [])
     ([], set(['path:.']), [])
     >>> restrictpatterns({'f1/../f2/fc2'}, {}, ['f1','f2'], [])
     (set(['f2/fc2']), {}, [])
     >>> restrictpatterns({'f1/../f3/fc3'}, {}, ['f1','f2'], [])
     ([], set(['path:.']), [])
     >>> restrictpatterns({'f1/$non_exitent_var'}, {}, ['f1','f2'], [])
     (set(['f1/$non_exitent_var']), {}, [])
     """
     res_excludes = set(req_excludes)
     res_excludes.update(repo_excludes)
     invalid_includes = []
     if not req_includes:
         res_includes = set(repo_includes)
     elif 'path:.' not in repo_includes:
         res_includes = []
         for req_include in req_includes:
             req_include = util.expandpath(util.normpath(req_include))
             if req_include in repo_includes:
                 res_includes.append(req_include)
                 continue
             valid = False
             for repo_include in repo_includes:
                 if req_include.startswith(repo_include + '/'):
                     valid = True
                     res_includes.append(req_include)
                     break
             if not valid:
                 invalid_includes.append(req_include)
         if len(res_includes) == 0:
             res_excludes = {'path:.'}
         else:
             res_includes = set(res_includes)
     else:
         res_includes = set(req_includes)
     return res_includes, res_excludes, invalid_includes
 
 # These two are extracted for extensions (specifically for Google's CitC file
 # system)
 def _deletecleanfiles(repo, files):
     for f in files:
         repo.wvfs.unlinkpath(f)
 
 def _writeaddedfiles(repo, pctx, files):
     actions = merge.emptyactions()
     addgaction = actions[merge.ACTION_GET].append
     mf = repo['.'].manifest()
     for f in files:
         if not repo.wvfs.exists(f):
             addgaction((f, (mf.flags(f), False), "narrowspec updated"))
     merge.applyupdates(repo, actions, wctx=repo[None],
                        mctx=repo['.'], overwrite=False)
 
 def checkworkingcopynarrowspec(repo):
     storespec = repo.svfs.tryread(FILENAME)
     wcspec = repo.vfs.tryread(DIRSTATE_FILENAME)
     if wcspec != storespec:
         raise error.Abort(_("working copy's narrowspec is stale"),
                           hint=_("run 'hg tracked --update-working-copy'"))
 
 def updateworkingcopy(repo, assumeclean=False):
     """updates the working copy and dirstate from the store narrowspec
 
     When assumeclean=True, files that are not known to be clean will also
     be deleted. It is then up to the caller to make sure they are clean.
     """
     oldspec = repo.vfs.tryread(DIRSTATE_FILENAME)
     newspec = repo.svfs.tryread(FILENAME)
 
     oldincludes, oldexcludes = parseconfig(repo.ui, oldspec)
     newincludes, newexcludes = parseconfig(repo.ui, newspec)
     oldmatch = match(repo.root, include=oldincludes, exclude=oldexcludes)
     newmatch = match(repo.root, include=newincludes, exclude=newexcludes)
     addedmatch = matchmod.differencematcher(newmatch, oldmatch)
     removedmatch = matchmod.differencematcher(oldmatch, newmatch)
 
     ds = repo.dirstate
     lookup, status = ds.status(removedmatch, subrepos=[], ignored=False,
                                clean=True, unknown=False)
     trackeddirty = status.modified + status.added
     clean = status.clean
     if assumeclean:
         assert not trackeddirty
         clean.extend(lookup)
     else:
         trackeddirty.extend(lookup)
     _deletecleanfiles(repo, clean)
     for f in sorted(trackeddirty):
         repo.ui.status(_('not deleting possibly dirty file %s\n') % f)
     for f in clean + trackeddirty:
         ds.drop(f)
 
     repo.narrowpats = newincludes, newexcludes
     repo._narrowmatch = newmatch
     pctx = repo['.']
     newfiles = [f for f in pctx.manifest().walk(addedmatch) if f not in ds]
     for f in newfiles:
         ds.normallookup(f)
     _writeaddedfiles(repo, pctx, newfiles)

tests/test-narrow-share.t

@@ -1,178 +1,178 b''
 #testcases flat tree
 
   $ . "$TESTDIR/narrow-library.sh"
 
 #if tree
   $ cat << EOF >> $HGRCPATH
   > [experimental]
   > treemanifest = 1
   > EOF
 #endif
 
   $ cat << EOF >> $HGRCPATH
   > [extensions]
   > share =
   > EOF
 
   $ hg init remote
   $ cd remote
   $ for x in `$TESTDIR/seq.py 0 10`
   > do
   >   mkdir d$x
   >   echo $x > d$x/f
   >   hg add d$x/f
   >   hg commit -m "add d$x/f"
   > done
   $ cd ..
 
   $ hg clone --narrow ssh://user@dummy/remote main -q \
   > --include d1 --include d3 --include d5 --include d7
 
   $ hg share main share
   updating working directory
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R share tracked
   I path:d1
   I path:d3
   I path:d5
   I path:d7
   $ hg -R share files
   share/d1/f
   share/d3/f
   share/d5/f
   share/d7/f
 
 Narrow the share and check that the main repo's working copy gets updated
 
 # Make sure the files that are supposed to be known-clean get their timestamps set in the dirstate
   $ sleep 2
   $ hg -R main st
   $ hg -R main debugdirstate --no-dates
   n 644          2 set                 d1/f
   n 644          2 set                 d3/f
   n 644          2 set                 d5/f
   n 644          2 set                 d7/f
 # Make d3/f dirty
   $ echo x >> main/d3/f
   $ echo y >> main/d3/g
   $ hg add main/d3/g
   $ hg -R main st
   M d3/f
   A d3/g
 # Make d5/f not match the dirstate timestamp even though it's clean
   $ sleep 2
   $ hg -R main st
   M d3/f
   A d3/g
   $ hg -R main debugdirstate --no-dates
   n 644          2 set                 d1/f
   n 644          2 set                 d3/f
   a   0         -1 unset               d3/g
   n 644          2 set                 d5/f
   n 644          2 set                 d7/f
   $ touch main/d5/f
   $ hg -R share tracked --removeinclude d1 --removeinclude d3 --removeinclude d5
   comparing with ssh://user@dummy/remote
   searching for changes
   looking for local changes to affected paths
   deleting data/d1/f.i
   deleting data/d3/f.i
   deleting data/d5/f.i
   deleting meta/d1/00manifest.i (tree !)
   deleting meta/d3/00manifest.i (tree !)
   deleting meta/d5/00manifest.i (tree !)
   $ hg -R main tracked
   I path:d7
   $ hg -R main files
   abort: working copy's narrowspec is stale
   (run 'hg tracked --update-working-copy')
   [255]
   $ hg -R main tracked --update-working-copy
   not deleting possibly dirty file d3/f
   not deleting possibly dirty file d3/g
   not deleting possibly dirty file d5/f
 # d1/f, d3/f, d3/g and d5/f should no longer be reported
   $ hg -R main files
   main/d7/f
 # d1/f should no longer be there, d3/f should be since it was dirty, d3/g should be there since
 # it was added, and d5/f should be since we couldn't be sure it was clean
   $ find main/d* -type f | sort
   main/d3/f
   main/d3/g
   main/d5/f
   main/d7/f
 
 Widen the share and check that the main repo's working copy gets updated
 
   $ hg -R share tracked --addinclude d1 --addinclude d3 -q
   $ hg -R share tracked
   I path:d1
   I path:d3
   I path:d7
   $ hg -R share files
   share/d1/f
   share/d3/f
   share/d7/f
   $ hg -R main tracked
   I path:d1
   I path:d3
   I path:d7
   $ hg -R main files
   abort: working copy's narrowspec is stale
   (run 'hg tracked --update-working-copy')
   [255]
   $ hg -R main tracked --update-working-copy
 # d1/f, d3/f should be back
   $ hg -R main files
   main/d1/f
   main/d3/f
   main/d7/f
 # d3/f should be modified (not clobbered by the widening), and d3/g should be untracked
   $ hg -R main st --all
   M d3/f
   ? d3/g
   C d1/f
   C d7/f
 
 We should also be able to unshare without breaking everything:
 
   $ hg share main share-unshare
   updating working directory
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd share-unshare
   $ hg unshare
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests (tree !)
   crosschecking files in changesets and manifests
   checking files
   checked 11 changesets with 3 changes to 3 files
   $ cd ..
 
 Dirstate should be left alone when upgrading from version of hg that didn't support narrow+share
 
   $ hg share main share-upgrade
   updating working directory
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd share-upgrade
   $ echo x >> d1/f
   $ echo y >> d3/g
   $ hg add d3/g
   $ hg rm d7/f
   $ hg st
   M d1/f
   A d3/g
   R d7/f
 Make it look like a repo from before narrow+share was supported
   $ rm .hg/narrowspec.dirstate
-  $ hg st
+  $ hg ci -Am test
   abort: working copy's narrowspec is stale
   (run 'hg tracked --update-working-copy')
   [255]
   $ hg tracked --update-working-copy
   $ hg st
   M d1/f
   A d3/g
   R d7/f
   $ cd ..