tags: don't crash if unable to write tag cache

This happens with hgweb in real life, if the httpd user is unable to
write in the repository directory. Another case is doing 'hg incoming'
on a repository in the filesystem owned by someone else.

mercurial/tags.py

@@ -1,338 +1,341 b''
 # tags.py - read tag info from local repository
 #
 # Copyright 2009 Matt Mackall <[e-mail]>
 # Copyright 2009 Greg Ward <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 # Currently this module only deals with reading and caching tags.
 # Eventually, it could take care of updating (adding/removing/moving)
 # tags too.
 
 import os
 from node import nullid, bin, hex, short
 from i18n import _
 import encoding
 import error
 
 def _debugalways(ui, *msg):
     ui.write(*msg)
 
 def _debugconditional(ui, *msg):
     ui.debug(*msg)
 
 def _debugnever(ui, *msg):
     pass
 
 _debug = _debugalways
 _debug = _debugnever
 
 def findglobaltags1(ui, repo, alltags, tagtypes):
     '''Find global tags in repo by reading .hgtags from every head that
     has a distinct version of it.  Updates the dicts alltags, tagtypes
     in place: alltags maps tag name to (node, hist) pair (see _readtags()
     below), and tagtypes maps tag name to tag type ('global' in this
     case).'''
 
     seen = set()
     fctx = None
     ctxs = []                       # list of filectx
     for node in repo.heads():
         try:
             fnode = repo[node].filenode('.hgtags')
         except error.LookupError:
             continue
         if fnode not in seen:
             seen.add(fnode)
             if not fctx:
                 fctx = repo.filectx('.hgtags', fileid=fnode)
             else:
                 fctx = fctx.filectx(fnode)
             ctxs.append(fctx)
 
     # read the tags file from each head, ending with the tip
     for fctx in reversed(ctxs):
         filetags = _readtags(
             ui, repo, fctx.data().splitlines(), fctx)
         _updatetags(filetags, "global", alltags, tagtypes)
 
 def findglobaltags2(ui, repo, alltags, tagtypes):
     '''Same as findglobaltags1(), but with caching.'''
     # This is so we can be lazy and assume alltags contains only global
     # tags when we pass it to _writetagcache().
     assert len(alltags) == len(tagtypes) == 0, \
            "findglobaltags() should be called first"
 
     (heads, tagfnode, cachetags, shouldwrite) = _readtagcache(ui, repo)
     if cachetags is not None:
         assert not shouldwrite
         # XXX is this really 100% correct?  are there oddball special
         # cases where a global tag should outrank a local tag but won't,
         # because cachetags does not contain rank info?
         _updatetags(cachetags, 'global', alltags, tagtypes)
         return
 
     _debug(ui, "reading tags from %d head(s): %s\n"
            % (len(heads), map(short, reversed(heads))))
     seen = set()                    # set of fnode
     fctx = None
     for head in reversed(heads):        # oldest to newest
         assert head in repo.changelog.nodemap, \
                "tag cache returned bogus head %s" % short(head)
 
         fnode = tagfnode.get(head)
         if fnode and fnode not in seen:
             seen.add(fnode)
             if not fctx:
                 fctx = repo.filectx('.hgtags', fileid=fnode)
             else:
                 fctx = fctx.filectx(fnode)
 
             filetags = _readtags(ui, repo, fctx.data().splitlines(), fctx)
             _updatetags(filetags, 'global', alltags, tagtypes)
 
     # and update the cache (if necessary)
     if shouldwrite:
         _writetagcache(ui, repo, heads, tagfnode, alltags)
 
 # Set this to findglobaltags1 to disable tag caching.
 findglobaltags = findglobaltags2
 
 def readlocaltags(ui, repo, alltags, tagtypes):
     '''Read local tags in repo.  Update alltags and tagtypes.'''
     try:
         # localtags is in the local encoding; re-encode to UTF-8 on
         # input for consistency with the rest of this module.
         data = repo.opener("localtags").read()
         filetags = _readtags(
             ui, repo, data.splitlines(), "localtags",
             recode=encoding.fromlocal)
         _updatetags(filetags, "local", alltags, tagtypes)
     except IOError:
         pass
 
 def _readtags(ui, repo, lines, fn, recode=None):
     '''Read tag definitions from a file (or any source of lines).
     Return a mapping from tag name to (node, hist): node is the node id
     from the last line read for that name, and hist is the list of node
     ids previously associated with it (in file order).  All node ids are
     binary, not hex.'''
 
     filetags = {}               # map tag name to (node, hist)
     count = 0
 
     def warn(msg):
         ui.warn(_("%s, line %s: %s\n") % (fn, count, msg))
 
     for line in lines:
         count += 1
         if not line:
             continue
         try:
             (nodehex, name) = line.split(" ", 1)
         except ValueError:
             warn(_("cannot parse entry"))
             continue
         name = name.strip()
         if recode:
             name = recode(name)
         try:
             nodebin = bin(nodehex)
         except TypeError:
             warn(_("node '%s' is not well formed") % nodehex)
             continue
         if nodebin not in repo.changelog.nodemap:
             # silently ignore as pull -r might cause this
             continue
 
         # update filetags
         hist = []
         if name in filetags:
             n, hist = filetags[name]
             hist.append(n)
         filetags[name] = (nodebin, hist)
     return filetags
 
 def _updatetags(filetags, tagtype, alltags, tagtypes):
     '''Incorporate the tag info read from one file into the two
     dictionaries, alltags and tagtypes, that contain all tag
     info (global across all heads plus local).'''
 
     for name, nodehist in filetags.iteritems():
         if name not in alltags:
             alltags[name] = nodehist
             tagtypes[name] = tagtype
             continue
 
         # we prefer alltags[name] if:
         #  it supercedes us OR
         #  mutual supercedes and it has a higher rank
         # otherwise we win because we're tip-most
         anode, ahist = nodehist
         bnode, bhist = alltags[name]
         if (bnode != anode and anode in bhist and
             (bnode not in ahist or len(bhist) > len(ahist))):
             anode = bnode
         ahist.extend([n for n in bhist if n not in ahist])
         alltags[name] = anode, ahist
         tagtypes[name] = tagtype
 
 
 # The tag cache only stores info about heads, not the tag contents
 # from each head.  I.e. it doesn't try to squeeze out the maximum
 # performance, but is simpler has a better chance of actually
 # working correctly.  And this gives the biggest performance win: it
 # avoids looking up .hgtags in the manifest for every head, and it
 # can avoid calling heads() at all if there have been no changes to
 # the repo.
 
 def _readtagcache(ui, repo):
     '''Read the tag cache and return a tuple (heads, fnodes, cachetags,
     shouldwrite).  If the cache is completely up-to-date, cachetags is a
     dict of the form returned by _readtags(); otherwise, it is None and
     heads and fnodes are set.  In that case, heads is the list of all
     heads currently in the repository (ordered from tip to oldest) and
     fnodes is a mapping from head to .hgtags filenode.  If those two are
     set, caller is responsible for reading tag info from each head.'''
 
     try:
         cachefile = repo.opener('tags.cache', 'r')
         _debug(ui, 'reading tag cache from %s\n' % cachefile.name)
     except IOError:
         cachefile = None
 
     # The cache file consists of lines like
     #   <headrev> <headnode> [<tagnode>]
     # where <headrev> and <headnode> redundantly identify a repository
     # head from the time the cache was written, and <tagnode> is the
     # filenode of .hgtags on that head.  Heads with no .hgtags file will
     # have no <tagnode>.  The cache is ordered from tip to oldest (which
     # is part of why <headrev> is there: a quick visual check is all
     # that's required to ensure correct order).
     #
     # This information is enough to let us avoid the most expensive part
     # of finding global tags, which is looking up <tagnode> in the
     # manifest for each head.
     cacherevs = []                      # list of headrev
     cacheheads = []                     # list of headnode
     cachefnode = {}                     # map headnode to filenode
     if cachefile:
         for line in cachefile:
             if line == "\n":
                 break
             line = line.rstrip().split()
             cacherevs.append(int(line[0]))
             headnode = bin(line[1])
             cacheheads.append(headnode)
             if len(line) == 3:
                 fnode = bin(line[2])
                 cachefnode[headnode] = fnode
 
     tipnode = repo.changelog.tip()
     tiprev = len(repo.changelog) - 1
 
     # Case 1 (common): tip is the same, so nothing has changed.
     # (Unchanged tip trivially means no changesets have been added.
     # But, thanks to localrepository.destroyed(), it also means none
     # have been destroyed by strip or rollback.)
     if cacheheads and cacheheads[0] == tipnode and cacherevs[0] == tiprev:
         _debug(ui, "tag cache: tip unchanged\n")
         tags = _readtags(ui, repo, cachefile, cachefile.name)
         cachefile.close()
         return (None, None, tags, False)
     if cachefile:
         cachefile.close()               # ignore rest of file
 
     repoheads = repo.heads()
     # Case 2 (uncommon): empty repo; get out quickly and don't bother
     # writing an empty cache.
     if repoheads == [nullid]:
         return ([], {}, {}, False)
 
     # Case 3 (uncommon): cache file missing or empty.
     if not cacheheads:
         _debug(ui, 'tag cache: cache file missing or empty\n')
 
     # Case 4 (uncommon): tip rev decreased.  This should only happen
     # when we're called from localrepository.destroyed().  Refresh the
     # cache so future invocations will not see disappeared heads in the
     # cache.
     elif cacheheads and tiprev < cacherevs[0]:
         _debug(ui,
                'tag cache: tip rev decremented (from %d to %d), '
                'so we must be destroying nodes\n'
                % (cacherevs[0], tiprev))
 
     # Case 5 (common): tip has changed, so we've added/replaced heads.
     else:
         _debug(ui,
                'tag cache: tip has changed (%d:%s); must find new heads\n'
                % (tiprev, short(tipnode)))
 
     # Luckily, the code to handle cases 3, 4, 5 is the same.  So the
     # above if/elif/else can disappear once we're confident this thing
     # actually works and we don't need the debug output.
 
     # N.B. in case 4 (nodes destroyed), "new head" really means "newly
     # exposed".
     newheads = [head
                 for head in repoheads
                 if head not in set(cacheheads)]
     _debug(ui, 'tag cache: found %d head(s) not in cache: %s\n'
            % (len(newheads), map(short, newheads)))
 
     # Now we have to lookup the .hgtags filenode for every new head.
     # This is the most expensive part of finding tags, so performance
     # depends primarily on the size of newheads.  Worst case: no cache
     # file, so newheads == repoheads.
     for head in newheads:
         cctx = repo[head]
         try:
             fnode = cctx.filenode('.hgtags')
             cachefnode[head] = fnode
         except error.LookupError:
             # no .hgtags file on this head
             pass
 
     # Caller has to iterate over all heads, but can use the filenodes in
     # cachefnode to get to each .hgtags revision quickly.
     return (repoheads, cachefnode, None, True)
 
 def _writetagcache(ui, repo, heads, tagfnode, cachetags):
 
+    try:
     cachefile = repo.opener('tags.cache', 'w', atomictemp=True)
+    except (OSError, IOError):
+        return
     _debug(ui, 'writing cache file %s\n' % cachefile.name)
 
     realheads = repo.heads()            # for sanity checks below
     for head in heads:
         # temporary sanity checks; these can probably be removed
         # once this code has been in crew for a few weeks
         assert head in repo.changelog.nodemap, \
                'trying to write non-existent node %s to tag cache' % short(head)
         assert head in realheads, \
                'trying to write non-head %s to tag cache' % short(head)
         assert head != nullid, \
                'trying to write nullid to tag cache'
 
         # This can't fail because of the first assert above.  When/if we
         # remove that assert, we might want to catch LookupError here
         # and downgrade it to a warning.
         rev = repo.changelog.rev(head)
 
         fnode = tagfnode.get(head)
         if fnode:
             cachefile.write('%d %s %s\n' % (rev, hex(head), hex(fnode)))
         else:
             cachefile.write('%d %s\n' % (rev, hex(head)))
 
     # Tag names in the cache are in UTF-8 -- which is the whole reason
     # we keep them in UTF-8 throughout this module.  If we converted
     # them local encoding on input, we would lose info writing them to
     # the cache.
     cachefile.write('\n')
     for (name, (node, hist)) in cachetags.iteritems():
         cachefile.write("%s %s\n" % (hex(node), name))
 
     cachefile.rename()
     cachefile.close()

tests/test-tags

@@ -1,206 +1,214 b''
 #!/bin/sh
 
 cacheexists() {
     [ -f .hg/tags.cache ] && echo "tag cache exists" || echo "no tag cache"
 }
 
 # XXX need to test that the tag cache works when we strip an old head
 # and add a new one rooted off non-tip: i.e. node and rev of tip are the
 # same, but stuff has changed behind tip.
 
 echo "% setup"
 mkdir t
 cd t
 hg init
 cacheexists
 hg id
 cacheexists
 echo a > a
 hg add a
 hg commit -m "test"
 hg co
 hg identify
 cacheexists
 
 echo "% create local tag with long name"
 T=`hg identify --debug --id`
 hg tag -l "This is a local tag with a really long name!"
 hg tags
 rm .hg/localtags
 
 echo "% create a tag behind hg's back"
 echo "$T first" > .hgtags
 cat .hgtags
 hg add .hgtags
 hg commit -m "add tags"
 hg tags
 hg identify
 
 # repeat with cold tag cache
+echo "% identify with cold cache"
 rm -f .hg/tags.cache
 hg identify
 
+# and again, but now unable to write tag cache
+echo "% identify with unwritable cache"
+rm -f .hg/tags.cache
+chmod 555 .hg
+hg identify
+chmod 755 .hg
+
 echo "% create a branch"
 echo bb > a
 hg status
 hg identify
 hg co first
 hg id
 hg -v id
 hg status
 echo 1 > b
 hg add b
 hg commit -m "branch"
 hg id
 
 echo "% merge the two heads"
 hg merge 1
 hg id
 hg status
 
 hg commit -m "merge"
 
 echo "% create fake head, make sure tag not visible afterwards"
 cp .hgtags tags
 hg tag last
 hg rm .hgtags
 hg commit -m "remove"
 
 mv tags .hgtags
 hg add .hgtags
 hg commit -m "readd"
 
 hg tags
 
 echo "% add invalid tags"
 echo "spam" >> .hgtags
 echo >> .hgtags
 echo "foo bar" >> .hgtags
 echo "$T invalid" | sed "s/..../a5a5/" >> .hg/localtags
 echo "committing .hgtags:"
 cat .hgtags 
 hg commit -m "tags"
 
 echo "% report tag parse error on other head"
 hg up 3
 echo 'x y' >> .hgtags
 hg commit -m "head"
 
 hg tags
 hg tip
 
 echo "% test tag precedence rules"
 cd ..
 hg init t2
 cd t2
 echo foo > foo
 hg add foo
 hg ci -m 'add foo'      # rev 0
 hg tag bar              # rev 1
 echo >> foo
 hg ci -m 'change foo 1' # rev 2
 hg up -C 1
 hg tag -r 1 -f bar      # rev 3
 hg up -C 1
 echo >> foo
 hg ci -m 'change foo 2' # rev 4
 hg tags
 hg tags         # repeat in case of cache effects
 
 dumptags() {
     rev=$1
     echo "rev $rev: .hgtags:"
     hg cat -r$rev .hgtags
 }
 
 echo "% detailed dump of tag info"
 echo "heads:"
 hg heads -q             # expect 4, 3, 2
 dumptags 2
 dumptags 3
 dumptags 4
 echo ".hg/tags.cache:"
 [ -f .hg/tags.cache ] && cat .hg/tags.cache || echo "no such file"
 
 echo "% test tag removal"
 hg tag --remove bar     # rev 5
 hg tip -vp
 hg tags
 hg tags                 # again, try to expose cache bugs
 
 echo '% remove nonexistent tag'
 hg tag --remove foobar
 hg tip
 
 echo "% rollback undoes tag operation"
 hg rollback             # destroy rev 5 (restore bar)
 hg tags
 hg tags
 
 echo "% test tag rank"
 cd ..
 hg init t3
 cd t3
 echo foo > foo
 hg add foo
 hg ci -m 'add foo'       # rev 0
 hg tag -f bar            # rev 1 bar -> 0
 hg tag -f bar            # rev 2 bar -> 1
 hg tag -fr 0 bar         # rev 3 bar -> 0
 hg tag -fr 1 bar         # rev 4 bar -> 1
 hg tag -fr 0 bar         # rev 5 bar -> 0
 hg tags
 hg co 3
 echo barbar > foo
 hg ci -m 'change foo'    # rev 6
 hg tags
 
 echo "% don't allow moving tag without -f"
 hg tag -r 3 bar
 hg tags
 
 echo "% strip 1: expose an old head"
 hg --config extensions.mq= strip 5 > /dev/null 2>&1
 hg tags                  # partly stale cache
 hg tags                  # up-to-date cache
 echo "% strip 2: destroy whole branch, no old head exposed"
 hg --config extensions.mq= strip 4 > /dev/null 2>&1 
 hg tags                  # partly stale
 rm -f .hg/tags.cache
 hg tags                  # cold cache
 
 echo "% test tag rank with 3 heads"
 cd ..
 hg init t4
 cd t4
 echo foo > foo
 hg add
 hg ci -m 'add foo'                 # rev 0
 hg tag bar                         # rev 1 bar -> 0
 hg tag -f bar                      # rev 2 bar -> 1
 hg up -qC 0
 hg tag -fr 2 bar                   # rev 3 bar -> 2
 hg tags
 hg up -qC 0
 hg tag -m 'retag rev 0' -fr 0 bar  # rev 4 bar -> 0, but bar stays at 2
 echo "% bar should still point to rev 2"
 hg tags
 
 
 echo "% remove local as global and global as local"
 # test that removing global/local tags does not get confused when trying
 # to remove a tag of type X which actually only exists as a type Y
 cd ..
 hg init t5
 cd t5
 echo foo > foo
 hg add
 hg ci -m 'add foo'                 # rev 0
 
 hg tag -r 0 -l localtag
 hg tag --remove localtag
 
 hg tag -r 0 globaltag
 hg tag --remove -l globaltag
 hg tags -v
 exit 0

tests/test-tags.out

@@ -1,150 +1,153 b''
 % setup
 no tag cache
 000000000000 tip
 no tag cache
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 acb14030fe0a tip
 tag cache exists
 % create local tag with long name
 tip                                0:acb14030fe0a
 This is a local tag with a really long name!     0:acb14030fe0a
 % create a tag behind hg's back
 acb14030fe0a21b60322c440ad2d20cf7685a376 first
 tip                                1:b9154636be93
 first                              0:acb14030fe0a
 b9154636be93 tip
+% identify with cold cache
+b9154636be93 tip
+% identify with unwritable cache
 b9154636be93 tip
 % create a branch
 M a
 b9154636be93+ tip
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 acb14030fe0a+ first
 acb14030fe0a+ first
 M a
 created new head
 c8edf04160c7 tip
 % merge the two heads
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 c8edf04160c7+b9154636be93+ tip
 M .hgtags
 % create fake head, make sure tag not visible afterwards
 tip                                6:35ff301afafe
 first                              0:acb14030fe0a
 % add invalid tags
 committing .hgtags:
 acb14030fe0a21b60322c440ad2d20cf7685a376 first
 spam
 
 foo bar
 % report tag parse error on other head
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 .hgtags@75d9f02dfe28, line 2: cannot parse entry
 .hgtags@75d9f02dfe28, line 4: node 'foo' is not well formed
 .hgtags@c4be69a18c11, line 2: node 'x' is not well formed
 tip                                8:c4be69a18c11
 first                              0:acb14030fe0a
 changeset:   8:c4be69a18c11
 tag:         tip
 parent:      3:ac5e980c4dc0
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     head
 
 % test tag precedence rules
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 tip                                4:0c192d7d5e6b
 bar                                1:78391a272241
 tip                                4:0c192d7d5e6b
 bar                                1:78391a272241
 % detailed dump of tag info
 heads:
 4:0c192d7d5e6b
 3:6fa450212aeb
 2:7a94127795a3
 rev 2: .hgtags:
 bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
 rev 3: .hgtags:
 bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
 bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
 78391a272241d70354aa14c874552cad6b51bb42 bar
 rev 4: .hgtags:
 bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
 .hg/tags.cache:
 4 0c192d7d5e6b78a714de54a2e9627952a877e25a 0c04f2a8af31de17fab7422878ee5a2dadbc943d
 3 6fa450212aeb2a21ed616a54aea39a4a27894cd7 7d3b718c964ef37b89e550ebdafd5789e76ce1b0
 2 7a94127795a33c10a370c93f731fd9fea0b79af6 0c04f2a8af31de17fab7422878ee5a2dadbc943d
 
 78391a272241d70354aa14c874552cad6b51bb42 bar
 % test tag removal
 changeset:   5:5f6e8655b1c7
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 files:       .hgtags
 description:
 Removed tag bar
 
 
 diff -r 0c192d7d5e6b -r 5f6e8655b1c7 .hgtags
 --- a/.hgtags	Thu Jan 01 00:00:00 1970 +0000
 +++ b/.hgtags	Thu Jan 01 00:00:00 1970 +0000
 @@ -1,1 +1,3 @@
  bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
 +78391a272241d70354aa14c874552cad6b51bb42 bar
 +0000000000000000000000000000000000000000 bar
 
 tip                                5:5f6e8655b1c7
 tip                                5:5f6e8655b1c7
 % remove nonexistent tag
 abort: tag 'foobar' does not exist
 changeset:   5:5f6e8655b1c7
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     Removed tag bar
 
 % rollback undoes tag operation
 rolling back last transaction
 tip                                4:0c192d7d5e6b
 bar                                1:78391a272241
 tip                                4:0c192d7d5e6b
 bar                                1:78391a272241
 % test tag rank
 tip                                5:85f05169d91d
 bar                                0:bbd179dfa0a7
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 tip                                6:735c3ca72986
 bar                                0:bbd179dfa0a7
 % don't allow moving tag without -f
 abort: tag 'bar' already exists (use -f to force)
 tip                                6:735c3ca72986
 bar                                0:bbd179dfa0a7
 % strip 1: expose an old head
 tip                                5:735c3ca72986
 bar                                1:78391a272241
 tip                                5:735c3ca72986
 bar                                1:78391a272241
 % strip 2: destroy whole branch, no old head exposed
 tip                                4:735c3ca72986
 bar                                0:bbd179dfa0a7
 tip                                4:735c3ca72986
 bar                                0:bbd179dfa0a7
 % test tag rank with 3 heads
 adding foo
 tip                                3:197c21bbbf2c
 bar                                2:6fa450212aeb
 % bar should still point to rev 2
 tip                                4:3b4b14ed0202
 bar                                2:6fa450212aeb
 % remove local as global and global as local
 adding foo
 abort: tag 'localtag' is not a global tag
 abort: tag 'globaltag' is not a local tag
 tip                                1:a0b6fe111088
 localtag                           0:bbd179dfa0a7 local
 globaltag                          0:bbd179dfa0a7