tags: do not abort if failed to write lock file to save cache

LockHeld wasn't enough to suppress error during acquiring lock. If .hg directory
is read-only, LockUnavailable will be raised.

  $ chmod ugo-w .hg
  $ hg identify
  abort: could not lock working directory of ...: Permission denied

mercurial/tags.py

@@ -1,534 +1,534
 # 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 or any later version.
 
 # Currently this module only deals with reading and caching tags.
 # Eventually, it could take care of updating (adding/removing/moving)
 # tags too.
 
 from node import nullid, bin, hex, short
 from i18n import _
 import util
 import encoding
 import error
 from array import array
 import errno
 import time
 
 # Tags computation can be expensive and caches exist to make it fast in
 # the common case.
 #
 # The "hgtagsfnodes1" cache file caches the .hgtags filenode values for
 # each revision in the repository. The file is effectively an array of
 # fixed length records. Read the docs for "hgtagsfnodescache" for technical
 # details.
 #
 # The .hgtags filenode cache grows in proportion to the length of the
 # changelog. The file is truncated when the # changelog is stripped.
 #
 # The purpose of the filenode cache is to avoid the most expensive part
 # of finding global tags, which is looking up the .hgtags filenode in the
 # manifest for each head. This can take dozens or over 100ms for
 # repositories with very large manifests. Multiplied by dozens or even
 # hundreds of heads and there is a significant performance concern.
 #
 # There also exist a separate cache file for each repository filter.
 # These "tags-*" files store information about the history of tags.
 #
 # The tags cache files consists of a cache validation line followed by
 # a history of tags.
 #
 # The cache validation line has the format:
 #
 #   <tiprev> <tipnode> [<filteredhash>]
 #
 # <tiprev> is an integer revision and <tipnode> is a 40 character hex
 # node for that changeset. These redundantly identify the repository
 # tip from the time the cache was written. In addition, <filteredhash>,
 # if present, is a 40 character hex hash of the contents of the filtered
 # revisions for this filter. If the set of filtered revs changes, the
 # hash will change and invalidate the cache.
 #
 # The history part of the tags cache consists of lines of the form:
 #
 #   <node> <tag>
 #
 # (This format is identical to that of .hgtags files.)
 #
 # <tag> is the tag name and <node> is the 40 character hex changeset
 # the tag is associated with.
 #
 # Tags are written sorted by tag name.
 #
 # Tags associated with multiple changesets have an entry for each changeset.
 # The most recent changeset (in terms of revlog ordering for the head
 # setting it) for each tag is last.
 
 def findglobaltags(ui, repo, alltags, tagtypes):
     '''Find global tags in a repo.
 
     "alltags" maps tag name to (node, hist) 2-tuples.
 
     "tagtypes" maps tag name to tag type. Global tags always have the
     "global" tag type.
 
     The "alltags" and "tagtypes" dicts are updated in place. Empty dicts
     should be passed in.
 
     The tags cache is read and updated as a side-effect of calling.
     '''
     # 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, valid, 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
 
     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, valid, alltags)
 
 def readlocaltags(ui, repo, alltags, tagtypes):
     '''Read local tags in repo. Update alltags and tagtypes.'''
     try:
         data = repo.vfs.read("localtags")
     except IOError, inst:
         if inst.errno != errno.ENOENT:
             raise
         return
 
     # localtags is in the local encoding; re-encode to UTF-8 on
     # input for consistency with the rest of this module.
     filetags = _readtags(
         ui, repo, data.splitlines(), "localtags",
         recode=encoding.fromlocal)
 
     # remove tags pointing to invalid nodes
     cl = repo.changelog
     for t in filetags.keys():
         try:
             cl.rev(filetags[t][0])
         except (LookupError, ValueError):
             del filetags[t]
 
     _updatetags(filetags, "local", alltags, tagtypes)
 
 def _readtaghist(ui, repo, lines, fn, recode=None, calcnodelines=False):
     '''Read tag definitions from a file (or any source of lines).
 
     This function returns two sortdicts with similar information:
 
     - the first dict, bintaghist, contains the tag information as expected by
       the _readtags function, i.e. a mapping from tag name to (node, hist):
         - node is the node id from the last line read for that name,
         - hist is the list of node ids previously associated with it (in file
           order). All node ids are binary, not hex.
 
     - the second dict, hextaglines, is a mapping from tag name to a list of
       [hexnode, line number] pairs, ordered from the oldest to the newest node.
 
     When calcnodelines is False the hextaglines dict is not calculated (an
     empty dict is returned). This is done to improve this function's
     performance in cases where the line numbers are not needed.
     '''
 
     bintaghist = util.sortdict()
     hextaglines = util.sortdict()
     count = 0
 
     def warn(msg):
         ui.warn(_("%s, line %s: %s\n") % (fn, count, msg))
 
     for nline, line in enumerate(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
 
         # update filetags
         if calcnodelines:
             # map tag name to a list of line numbers
             if name not in hextaglines:
                 hextaglines[name] = []
             hextaglines[name].append([nodehex, nline])
             continue
         # map tag name to (node, hist)
         if name not in bintaghist:
             bintaghist[name] = []
         bintaghist[name].append(nodebin)
     return bintaghist, hextaglines
 
 def _readtags(ui, repo, lines, fn, recode=None, calcnodelines=False):
     '''Read tag definitions from a file (or any source of lines).
 
     Returns a mapping from tag name to (node, hist).
 
     "node" is the node id from the last line read for that name. "hist"
     is the list of node ids previously associated with it (in file order).
     All node ids are binary, not hex.
     '''
     filetags, nodelines = _readtaghist(ui, repo, lines, fn, recode=recode,
                                        calcnodelines=calcnodelines)
     for tag, taghist in filetags.items():
         filetags[tag] = (taghist[-1], taghist[:-1])
     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 supersedes us OR
         #  mutual supersedes 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
         else:
             tagtypes[name] = tagtype
         ahist.extend([n for n in bhist if n not in ahist])
         alltags[name] = anode, ahist
 
 def _filename(repo):
     """name of a tagcache file for a given repo or repoview"""
     filename = 'cache/tags2'
     if repo.filtername:
         filename = '%s-%s' % (filename, repo.filtername)
     return filename
 
 def _readtagcache(ui, repo):
     '''Read the tag cache.
 
     Returns a tuple (heads, fnodes, validinfo, cachetags, shouldwrite).
 
     If the cache is completely up-to-date, "cachetags" is a dict of the
     form returned by _readtags() and "heads", "fnodes", and "validinfo" are
     None and "shouldwrite" is False.
 
     If the cache is not up to date, "cachetags" is None. "heads" is a list
     of all heads currently in the repository, ordered from tip to oldest.
     "validinfo" is a tuple describing cache validation info. This is used
     when writing the tags cache. "fnodes" is a mapping from head to .hgtags
     filenode. "shouldwrite" is True.
 
     If the cache is not up to date, the caller is responsible for reading tag
     info from each returned head. (See findglobaltags().)
     '''
     import scmutil  # avoid cycle
 
     try:
         cachefile = repo.vfs(_filename(repo), 'r')
         # force reading the file for static-http
         cachelines = iter(cachefile)
     except IOError:
         cachefile = None
 
     cacherev = None
     cachenode = None
     cachehash = None
     if cachefile:
         try:
             validline = cachelines.next()
             validline = validline.split()
             cacherev = int(validline[0])
             cachenode = bin(validline[1])
             if len(validline) > 2:
                 cachehash = bin(validline[2])
         except Exception:
             # corruption of the cache, just recompute it.
             pass
 
     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 (cacherev == tiprev
             and cachenode == tipnode
             and cachehash == scmutil.filteredhash(repo, tiprev)):
         tags = _readtags(ui, repo, cachelines, cachefile.name)
         cachefile.close()
         return (None, None, None, tags, False)
     if cachefile:
         cachefile.close()               # ignore rest of file
 
     valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev))
 
     repoheads = repo.heads()
     # Case 2 (uncommon): empty repo; get out quickly and don't bother
     # writing an empty cache.
     if repoheads == [nullid]:
         return ([], {}, valid, {}, False)
 
     # Case 3 (uncommon): cache file missing or empty.
 
     # 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.
 
     # Case 5 (common): tip has changed, so we've added/replaced heads.
 
     # As it happens, the code to handle cases 3, 4, 5 is the same.
 
     # N.B. in case 4 (nodes destroyed), "new head" really means "newly
     # exposed".
     if not len(repo.file('.hgtags')):
         # No tags have ever been committed, so we can avoid a
         # potentially expensive search.
         return ([], {}, valid, None, True)
 
     starttime = time.time()
 
     # 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.
     fnodescache = hgtagsfnodescache(repo.unfiltered())
     cachefnode = {}
     for head in reversed(repoheads):
         fnode = fnodescache.getfnode(head)
         if fnode != nullid:
             cachefnode[head] = fnode
 
     fnodescache.write()
 
     duration = time.time() - starttime
     ui.log('tagscache',
            '%d/%d cache hits/lookups in %0.4f '
            'seconds\n',
            fnodescache.hitcount, fnodescache.lookupcount, duration)
 
     # Caller has to iterate over all heads, but can use the filenodes in
     # cachefnode to get to each .hgtags revision quickly.
     return (repoheads, cachefnode, valid, None, True)
 
 def _writetagcache(ui, repo, valid, cachetags):
     filename = _filename(repo)
     try:
         cachefile = repo.vfs(filename, 'w', atomictemp=True)
     except (OSError, IOError):
         return
 
     ui.log('tagscache', 'writing .hg/%s with %d tags\n',
            filename, len(cachetags))
 
     if valid[2]:
         cachefile.write('%d %s %s\n' % (valid[0], hex(valid[1]), hex(valid[2])))
     else:
         cachefile.write('%d %s\n' % (valid[0], hex(valid[1])))
 
     # 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.
     for (name, (node, hist)) in sorted(cachetags.iteritems()):
         for n in hist:
             cachefile.write("%s %s\n" % (hex(n), name))
         cachefile.write("%s %s\n" % (hex(node), name))
 
     try:
         cachefile.close()
     except (OSError, IOError):
         pass
 
 _fnodescachefile = 'cache/hgtagsfnodes1'
 _fnodesrecsize = 4 + 20 # changeset fragment + filenode
 _fnodesmissingrec = '\xff' * 24
 
 class hgtagsfnodescache(object):
     """Persistent cache mapping revisions to .hgtags filenodes.
 
     The cache is an array of records. Each item in the array corresponds to
     a changelog revision. Values in the array contain the first 4 bytes of
     the node hash and the 20 bytes .hgtags filenode for that revision.
 
     The first 4 bytes are present as a form of verification. Repository
     stripping and rewriting may change the node at a numeric revision in the
     changelog. The changeset fragment serves as a verifier to detect
     rewriting. This logic is shared with the rev branch cache (see
     branchmap.py).
 
     The instance holds in memory the full cache content but entries are
     only parsed on read.
 
     Instances behave like lists. ``c[i]`` works where i is a rev or
     changeset node. Missing indexes are populated automatically on access.
     """
     def __init__(self, repo):
         assert repo.filtername is None
 
         self._repo = repo
 
         # Only for reporting purposes.
         self.lookupcount = 0
         self.hitcount = 0
 
         self._raw = array('c')
 
         data = repo.vfs.tryread(_fnodescachefile)
         self._raw.fromstring(data)
 
         # The end state of self._raw is an array that is of the exact length
         # required to hold a record for every revision in the repository.
         # We truncate or extend the array as necessary. self._dirtyoffset is
         # defined to be the start offset at which we need to write the output
         # file. This offset is also adjusted when new entries are calculated
         # for array members.
         cllen = len(repo.changelog)
         wantedlen = cllen * _fnodesrecsize
         rawlen = len(self._raw)
 
         self._dirtyoffset = None
 
         if rawlen < wantedlen:
             self._dirtyoffset = rawlen
             self._raw.extend('\xff' * (wantedlen - rawlen))
         elif rawlen > wantedlen:
             # There's no easy way to truncate array instances. This seems
             # slightly less evil than copying a potentially large array slice.
             for i in range(rawlen - wantedlen):
                 self._raw.pop()
             self._dirtyoffset = len(self._raw)
 
     def getfnode(self, node):
         """Obtain the filenode of the .hgtags file at a specified revision.
 
         If the value is in the cache, the entry will be validated and returned.
         Otherwise, the filenode will be computed and returned.
 
         If an .hgtags does not exist at the specified revision, nullid is
         returned.
         """
         ctx = self._repo[node]
         rev = ctx.rev()
 
         self.lookupcount += 1
 
         offset = rev * _fnodesrecsize
         record = self._raw[offset:offset + _fnodesrecsize].tostring()
         properprefix = node[0:4]
 
         # Validate and return existing entry.
         if record != _fnodesmissingrec:
             fileprefix = record[0:4]
 
             if fileprefix == properprefix:
                 self.hitcount += 1
                 return record[4:]
 
             # Fall through.
 
         # If we get here, the entry is either missing or invalid. Populate it.
         try:
             fnode = ctx.filenode('.hgtags')
         except error.LookupError:
             # No .hgtags file on this revision.
             fnode = nullid
 
         # Slices on array instances only accept other array.
         entry = array('c', properprefix + fnode)
         self._raw[offset:offset + _fnodesrecsize] = entry
         # self._dirtyoffset could be None.
         self._dirtyoffset = min(self._dirtyoffset, offset) or 0
 
         return fnode
 
     def write(self):
         """Perform all necessary writes to cache file.
 
         This may no-op if no writes are needed or if a write lock could
         not be obtained.
         """
         if self._dirtyoffset is None:
             return
 
         data = self._raw[self._dirtyoffset:]
         if not data:
             return
 
         repo = self._repo
 
         try:
             lock = repo.wlock(wait=False)
-        except error.LockHeld:
+        except error.LockError:
             repo.ui.log('tagscache',
-                        'not writing .hg/%s because lock held\n' %
+                        'not writing .hg/%s because lock cannot be acquired\n' %
                         (_fnodescachefile))
             return
 
         try:
             try:
                 f = repo.vfs.open(_fnodescachefile, 'ab')
                 try:
                     # if the file has been truncated
                     actualoffset = f.tell()
                     if actualoffset < self._dirtyoffset:
                         self._dirtyoffset = actualoffset
                         data = self._raw[self._dirtyoffset:]
                     f.seek(self._dirtyoffset)
                     f.truncate()
                     repo.ui.log('tagscache',
                                 'writing %d bytes to %s\n' % (
                                 len(data), _fnodescachefile))
                     f.write(data)
                     self._dirtyoffset = None
                 finally:
                     f.close()
             except (IOError, OSError), inst:
                 repo.ui.log('tagscache',
                             "couldn't write %s: %s\n" % (
                             _fnodescachefile, inst))
         finally:
             lock.release()

tests/test-tags.t

@@ -1,622 +1,627
 setup
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > blackbox=
   > mock=$TESTDIR/mockblackbox.py
   > EOF
 
 Helper functions:
 
   $ cacheexists() {
   >   [ -f .hg/cache/tags2-visible ] && echo "tag cache exists" || echo "no tag cache"
   > }
 
   $ fnodescacheexists() {
   >   [ -f .hg/cache/hgtagsfnodes1 ] && echo "fnodes cache exists" || echo "no fnodes cache"
   > }
 
   $ dumptags() {
   >     rev=$1
   >     echo "rev $rev: .hgtags:"
   >     hg cat -r$rev .hgtags
   > }
 
 # 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.
 
 Setup:
 
   $ hg init t
   $ cd t
   $ cacheexists
   no tag cache
   $ fnodescacheexists
   no fnodes cache
   $ hg id
   000000000000 tip
   $ cacheexists
   no tag cache
   $ fnodescacheexists
   no fnodes cache
   $ echo a > a
   $ hg add a
   $ hg commit -m "test"
   $ hg co
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg identify
   acb14030fe0a tip
   $ cacheexists
   tag cache exists
 No fnodes cache because .hgtags file doesn't exist
 (this is an implementation detail)
   $ fnodescacheexists
   no fnodes cache
 
 Try corrupting the cache
 
   $ printf 'a b' > .hg/cache/tags2-visible
   $ hg identify
   acb14030fe0a tip
   $ cacheexists
   tag cache exists
   $ fnodescacheexists
   no fnodes cache
   $ hg identify
   acb14030fe0a tip
 
 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
   tip                                0:acb14030fe0a
   This is a local tag with a really long name!     0:acb14030fe0a
   $ rm .hg/localtags
 
 Create a tag behind hg's back:
 
   $ echo "$T first" > .hgtags
   $ cat .hgtags
   acb14030fe0a21b60322c440ad2d20cf7685a376 first
   $ hg add .hgtags
   $ hg commit -m "add tags"
   $ hg tags
   tip                                1:b9154636be93
   first                              0:acb14030fe0a
   $ hg identify
   b9154636be93 tip
 
 We should have a fnodes cache now that we have a real tag
 The cache should have an empty entry for rev 0 and a valid entry for rev 1.
 
 
   $ fnodescacheexists
   fnodes cache exists
   $ f --size --hexdump .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=48
   0000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0010: ff ff ff ff ff ff ff ff b9 15 46 36 26 b7 b4 a7 |..........F6&...|
   0020: 73 e0 9e e3 c5 2f 51 0e 19 e0 5e 1f f9 66 d8 59 |s..../Q...^..f.Y|
 
 Repeat with cold tag cache:
 
   $ rm -f .hg/cache/tags2-visible .hg/cache/hgtagsfnodes1
   $ hg identify
   b9154636be93 tip
 
   $ fnodescacheexists
   fnodes cache exists
   $ f --size --hexdump .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=48
   0000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0010: ff ff ff ff ff ff ff ff b9 15 46 36 26 b7 b4 a7 |..........F6&...|
   0020: 73 e0 9e e3 c5 2f 51 0e 19 e0 5e 1f f9 66 d8 59 |s..../Q...^..f.Y|
 
-And again, but now unable to write tag cache:
+And again, but now unable to write tag cache or lock file:
 
 #if unix-permissions
   $ rm -f .hg/cache/tags2-visible .hg/cache/hgtagsfnodes1
   $ chmod 555 .hg/cache
   $ hg identify
   b9154636be93 tip
   $ chmod 755 .hg/cache
+
+  $ chmod 555 .hg
+  $ hg identify
+  b9154636be93 tip
+  $ chmod 755 .hg
 #endif
 
 Tag cache debug info written to blackbox log
 
   $ rm -f .hg/cache/tags2-visible .hg/cache/hgtagsfnodes1
   $ hg identify
   b9154636be93 tip
   $ hg blackbox -l 5
   1970/01/01 00:00:00 bob> identify
   1970/01/01 00:00:00 bob> writing 48 bytes to cache/hgtagsfnodes1
   1970/01/01 00:00:00 bob> 0/1 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> identify exited 0 after ?.?? seconds (glob)
 
 Failure to acquire lock results in no write
 
   $ rm -f .hg/cache/tags2-visible .hg/cache/hgtagsfnodes1
   $ echo 'foo:1' > .hg/wlock
   $ hg identify
   b9154636be93 tip
   $ hg blackbox -l 5
   1970/01/01 00:00:00 bob> identify
-  1970/01/01 00:00:00 bob> not writing .hg/cache/hgtagsfnodes1 because lock held
+  1970/01/01 00:00:00 bob> not writing .hg/cache/hgtagsfnodes1 because lock cannot be acquired
   1970/01/01 00:00:00 bob> 0/1 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> identify exited 0 after * seconds (glob)
 
   $ fnodescacheexists
   no fnodes cache
 
   $ rm .hg/wlock
 
   $ rm -f .hg/cache/tags2-visible .hg/cache/hgtagsfnodes1
   $ hg identify
   b9154636be93 tip
 
 Create a branch:
 
   $ echo bb > a
   $ hg status
   M a
   $ hg identify
   b9154636be93+ tip
   $ hg co first
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg id
   acb14030fe0a+ first
   $ hg -v id
   acb14030fe0a+ first
   $ hg status
   M a
   $ echo 1 > b
   $ hg add b
   $ hg commit -m "branch"
   created new head
 
 Creating a new commit shouldn't append the .hgtags fnodes cache until
 tags info is accessed
 
   $ f --size --hexdump .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=48
   0000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0010: ff ff ff ff ff ff ff ff b9 15 46 36 26 b7 b4 a7 |..........F6&...|
   0020: 73 e0 9e e3 c5 2f 51 0e 19 e0 5e 1f f9 66 d8 59 |s..../Q...^..f.Y|
 
   $ hg id
   c8edf04160c7 tip
 
 First 4 bytes of record 3 are changeset fragment
 
   $ f --size --hexdump .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=72
   0000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0010: ff ff ff ff ff ff ff ff b9 15 46 36 26 b7 b4 a7 |..........F6&...|
   0020: 73 e0 9e e3 c5 2f 51 0e 19 e0 5e 1f f9 66 d8 59 |s..../Q...^..f.Y|
   0030: c8 ed f0 41 00 00 00 00 00 00 00 00 00 00 00 00 |...A............|
   0040: 00 00 00 00 00 00 00 00                         |........|
 
 Merge the two heads:
 
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg id
   c8edf04160c7+b9154636be93+ tip
   $ hg status
   M .hgtags
   $ hg commit -m "merge"
 
 Create a 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
   tip                                6:35ff301afafe
   first                              0:acb14030fe0a
 
 Add invalid tags:
 
   $ echo "spam" >> .hgtags
   $ echo >> .hgtags
   $ echo "foo bar" >> .hgtags
   $ echo "a5a5 invalid" >> .hg/localtags
   $ cat .hgtags
   acb14030fe0a21b60322c440ad2d20cf7685a376 first
   spam
   
   foo bar
   $ hg commit -m "tags"
 
 Report tag parse error on other head:
 
   $ hg up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'x y' >> .hgtags
   $ hg commit -m "head"
   created new head
 
   $ hg tags
   .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
   $ hg tip
   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:
 
   $ 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
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg tag -r 1 -f bar      # rev 3
   $ hg up -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo >> foo
   $ hg ci -m 'change foo 2' # rev 4
   created new head
   $ hg tags
   tip                                4:0c192d7d5e6b
   bar                                1:78391a272241
 
 Repeat in case of cache effects:
 
   $ hg tags
   tip                                4:0c192d7d5e6b
   bar                                1:78391a272241
 
 Detailed dump of tag info:
 
   $ hg heads -q             # expect 4, 3, 2
   4:0c192d7d5e6b
   3:6fa450212aeb
   2:7a94127795a3
   $ dumptags 2
   rev 2: .hgtags:
   bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
   $ dumptags 3
   rev 3: .hgtags:
   bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
   bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
   78391a272241d70354aa14c874552cad6b51bb42 bar
   $ dumptags 4
   rev 4: .hgtags:
   bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
 
 Dump cache:
 
   $ cat .hg/cache/tags2-visible
   4 0c192d7d5e6b78a714de54a2e9627952a877e25a
   bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
   bbd179dfa0a71671c253b3ae0aa1513b60d199fa bar
   78391a272241d70354aa14c874552cad6b51bb42 bar
 
   $ f --size --hexdump .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=120
   0000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0010: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0020: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0030: 7a 94 12 77 0c 04 f2 a8 af 31 de 17 fa b7 42 28 |z..w.....1....B(|
   0040: 78 ee 5a 2d ad bc 94 3d 6f a4 50 21 7d 3b 71 8c |x.Z-...=o.P!};q.|
   0050: 96 4e f3 7b 89 e5 50 eb da fd 57 89 e7 6c e1 b0 |.N.{..P...W..l..|
   0060: 0c 19 2d 7d 0c 04 f2 a8 af 31 de 17 fa b7 42 28 |..-}.....1....B(|
   0070: 78 ee 5a 2d ad bc 94 3d                         |x.Z-...=|
 
 Corrupt the .hgtags fnodes cache
 Extra junk data at the end should get overwritten on next cache update
 
   $ echo extra >> .hg/cache/hgtagsfnodes1
   $ echo dummy1 > foo
   $ hg commit -m throwaway1
 
   $ hg tags
   tip                                5:8dbfe60eff30
   bar                                1:78391a272241
 
   $ hg blackbox -l 5
   1970/01/01 00:00:00 bob> tags
   1970/01/01 00:00:00 bob> writing 24 bytes to cache/hgtagsfnodes1
   1970/01/01 00:00:00 bob> 2/3 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> tags exited 0 after * seconds (glob)
 
 #if unix-permissions no-root
 Errors writing to .hgtags fnodes cache are silently ignored
 
   $ echo dummy2 > foo
   $ hg commit -m throwaway2
 
   $ chmod a-w .hg/cache/hgtagsfnodes1
   $ rm -f .hg/cache/tags2-visible
 
   $ hg tags
   tip                                6:b968051b5cf3
   bar                                1:78391a272241
 
   $ hg blackbox -l 5
   1970/01/01 00:00:00 bob> tags
   1970/01/01 00:00:00 bob> couldn't write cache/hgtagsfnodes1: [Errno 13] Permission denied: '$TESTTMP/t2/.hg/cache/hgtagsfnodes1'
   1970/01/01 00:00:00 bob> 2/3 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> tags exited 0 after * seconds (glob)
 
   $ chmod a+w .hg/cache/hgtagsfnodes1
 
   $ rm -f .hg/cache/tags2-visible
   $ hg tags
   tip                                6:b968051b5cf3
   bar                                1:78391a272241
 
   $ hg blackbox -l 5
   1970/01/01 00:00:00 bob> tags
   1970/01/01 00:00:00 bob> writing 24 bytes to cache/hgtagsfnodes1
   1970/01/01 00:00:00 bob> 2/3 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> tags exited 0 after * seconds (glob)
 
   $ f --size .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=168
 
   $ hg -q --config extensions.strip= strip -r 6 --no-backup
 #endif
 
 Stripping doesn't truncate the tags cache until new data is available
 
   $ rm -f .hg/cache/hgtagsfnodes1 .hg/cache/tags2-visible
   $ hg tags
   tip                                5:8dbfe60eff30
   bar                                1:78391a272241
 
   $ f --size .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=144
 
   $ hg -q --config extensions.strip= strip -r 5 --no-backup
   $ hg tags
   tip                                4:0c192d7d5e6b
   bar                                1:78391a272241
 
   $ hg blackbox -l 4
   1970/01/01 00:00:00 bob> writing 24 bytes to cache/hgtagsfnodes1
   1970/01/01 00:00:00 bob> 2/3 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> tags exited 0 after * seconds (glob)
 
   $ f --size .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=120
 
   $ echo dummy > foo
   $ hg commit -m throwaway3
 
   $ hg tags
   tip                                5:035f65efb448
   bar                                1:78391a272241
 
   $ hg blackbox -l 5
   1970/01/01 00:00:00 bob> tags
   1970/01/01 00:00:00 bob> writing 24 bytes to cache/hgtagsfnodes1
   1970/01/01 00:00:00 bob> 2/3 cache hits/lookups in * seconds (glob)
   1970/01/01 00:00:00 bob> writing .hg/cache/tags2-visible with 1 tags
   1970/01/01 00:00:00 bob> tags exited 0 after * seconds (glob)
   $ f --size .hg/cache/hgtagsfnodes1
   .hg/cache/hgtagsfnodes1: size=144
 
   $ hg -q --config extensions.strip= strip -r 5 --no-backup
 
 Test tag removal:
 
   $ hg tag --remove bar     # rev 5
   $ hg tip -vp
   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
   
   $ hg tags
   tip                                5:5f6e8655b1c7
   $ hg tags                 # again, try to expose cache bugs
   tip                                5:5f6e8655b1c7
 
 Remove nonexistent tag:
 
   $ hg tag --remove foobar
   abort: tag 'foobar' does not exist
   [255]
   $ hg tip
   changeset:   5:5f6e8655b1c7
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Removed tag bar
   
 
 Undo a tag with rollback:
 
   $ hg rollback             # destroy rev 5 (restore bar)
   repository tip rolled back to revision 4 (undo commit)
   working directory now based on revision 4
   $ hg tags
   tip                                4:0c192d7d5e6b
   bar                                1:78391a272241
   $ hg tags
   tip                                4:0c192d7d5e6b
   bar                                1:78391a272241
 
 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
   tip                                5:85f05169d91d
   bar                                0:bbd179dfa0a7
   $ hg co 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo barbar > foo
   $ hg ci -m 'change foo'    # rev 6
   created new head
   $ hg tags
   tip                                6:735c3ca72986
   bar                                0:bbd179dfa0a7
 
 Don't allow moving tag without -f:
 
   $ hg tag -r 3 bar
   abort: tag 'bar' already exists (use -f to force)
   [255]
   $ hg tags
   tip                                6:735c3ca72986
   bar                                0:bbd179dfa0a7
 
 Strip 1: expose an old head:
 
   $ hg --config extensions.mq= strip 5
   saved backup bundle to $TESTTMP/t3/.hg/strip-backup/*-backup.hg (glob)
   $ hg tags                  # partly stale cache
   tip                                5:735c3ca72986
   bar                                1:78391a272241
   $ hg tags                  # up-to-date cache
   tip                                5:735c3ca72986
   bar                                1:78391a272241
 
 Strip 2: destroy whole branch, no old head exposed
 
   $ hg --config extensions.mq= strip 4
   saved backup bundle to $TESTTMP/t3/.hg/strip-backup/*-backup.hg (glob)
   $ hg tags                  # partly stale
   tip                                4:735c3ca72986
   bar                                0:bbd179dfa0a7
   $ rm -f .hg/cache/tags2-visible
   $ hg tags                  # cold cache
   tip                                4:735c3ca72986
   bar                                0:bbd179dfa0a7
 
 Test tag rank with 3 heads:
 
   $ cd ..
   $ hg init t4
   $ cd t4
   $ echo foo > foo
   $ hg add
   adding foo
   $ 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
   tip                                3:197c21bbbf2c
   bar                                2:6fa450212aeb
   $ hg up -qC 0
   $ hg tag -m 'retag rev 0' -fr 0 bar  # rev 4 bar -> 0, but bar stays at 2
 
 Bar should still point to rev 2:
 
   $ hg tags
   tip                                4:3b4b14ed0202
   bar                                2:6fa450212aeb
 
 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
   adding foo
   $ hg ci -m 'add foo'                 # rev 0
 
   $ hg tag -r 0 -l localtag
   $ hg tag --remove localtag
   abort: tag 'localtag' is not a global tag
   [255]
   $ 
   $ hg tag -r 0 globaltag
   $ hg tag --remove -l globaltag
   abort: tag 'globaltag' is not a local tag
   [255]
   $ hg tags -v
   tip                                1:a0b6fe111088
   localtag                           0:bbd179dfa0a7 local
   globaltag                          0:bbd179dfa0a7
 
 Test for issue3911
 
   $ hg tag -r 0 -l localtag2
   $ hg tag -l --remove localtag2
   $ hg tags -v
   tip                                1:a0b6fe111088
   localtag                           0:bbd179dfa0a7 local
   globaltag                          0:bbd179dfa0a7
 
   $ hg tag -r 1 -f localtag
   $ hg tags -v
   tip                                2:5c70a037bb37
   localtag                           1:a0b6fe111088
   globaltag                          0:bbd179dfa0a7
 
   $ hg tags -v
   tip                                2:5c70a037bb37
   localtag                           1:a0b6fe111088
   globaltag                          0:bbd179dfa0a7
 
   $ hg tag -r 1 localtag2
   $ hg tags -v
   tip                                3:bbfb8cd42be2
   localtag2                          1:a0b6fe111088
   localtag                           1:a0b6fe111088
   globaltag                          0:bbd179dfa0a7
 
   $ hg tags -v
   tip                                3:bbfb8cd42be2
   localtag2                          1:a0b6fe111088
   localtag                           1:a0b6fe111088
   globaltag                          0:bbd179dfa0a7
 
   $ cd ..