localrepo: store branchheads sorted

mercurial/branchmap.py

@@ -1,223 +1,223
 # branchmap.py - logic to computes, maintain and stores branchmap for local repo
 #
 # Copyright 2005-2007 Matt Mackall <[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.
 
 from node import bin, hex, nullid, nullrev
 import encoding
 import util, repoview
 
 def _filename(repo):
     """name of a branchcache file for a given repo or repoview"""
     filename = "cache/branchheads"
     if repo.filtername:
         filename = '%s-%s' % (filename, repo.filtername)
     return filename
 
 def read(repo):
     try:
         f = repo.opener(_filename(repo))
         lines = f.read().split('\n')
         f.close()
     except (IOError, OSError):
         return None
 
     try:
         cachekey = lines.pop(0).split(" ", 2)
         last, lrev = cachekey[:2]
         last, lrev = bin(last), int(lrev)
         filteredhash = None
         if len(cachekey) > 2:
             filteredhash = bin(cachekey[2])
         partial = branchcache(tipnode=last, tiprev=lrev,
                               filteredhash=filteredhash)
         if not partial.validfor(repo):
             # invalidate the cache
             raise ValueError('tip differs')
         for l in lines:
             if not l:
                 continue
             node, label = l.split(" ", 1)
             label = encoding.tolocal(label.strip())
             if not node in repo:
                 raise ValueError('node %s does not exist' % node)
             partial.setdefault(label, []).append(bin(node))
     except KeyboardInterrupt:
         raise
     except Exception, inst:
         if repo.ui.debugflag:
             msg = 'invalid branchheads cache'
             if repo.filtername is not None:
                 msg += ' (%s)' % repo.filtername
             msg += ': %s\n'
             repo.ui.warn(msg % inst)
         partial = None
     return partial
 
 
 
 def updatecache(repo):
     cl = repo.changelog
     filtername = repo.filtername
     partial = repo._branchcaches.get(filtername)
 
     revs = []
     if partial is None or not partial.validfor(repo):
         partial = read(repo)
         if partial is None:
             subsetname = repoview.subsettable.get(filtername)
             if subsetname is None:
                 partial = branchcache()
             else:
                 subset = repo.filtered(subsetname)
                 partial = subset.branchmap().copy()
                 extrarevs = subset.changelog.filteredrevs - cl.filteredrevs
                 revs.extend(r for  r in extrarevs if r <= partial.tiprev)
     revs.extend(cl.revs(start=partial.tiprev + 1))
     if revs:
         partial.update(repo, revs)
         partial.write(repo)
     assert partial.validfor(repo)
     repo._branchcaches[repo.filtername] = partial
 
 class branchcache(dict):
     """A dict like object that hold branches heads cache"""
 
     def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev,
                  filteredhash=None):
         super(branchcache, self).__init__(entries)
         self.tipnode = tipnode
         self.tiprev = tiprev
         self.filteredhash = filteredhash
 
     def _hashfiltered(self, repo):
         """build hash of revision filtered in the current cache
 
         Tracking tipnode and tiprev is not enough to ensure validaty of the
         cache as they do not help to distinct cache that ignored various
         revision bellow tiprev.
 
         To detect such difference, we build a cache of all ignored revisions.
         """
         cl = repo.changelog
         if not cl.filteredrevs:
             return None
         key = None
         revs = sorted(r for r in cl.filteredrevs if r <= self.tiprev)
         if revs:
             s = util.sha1()
             for rev in revs:
                 s.update('%s;' % rev)
             key = s.digest()
         return key
 
     def validfor(self, repo):
         """Is the cache content valide regarding a repo
 
         - False when cached tipnode are unknown or if we detect a strip.
         - True when cache is up to date or a subset of current repo."""
         try:
             return ((self.tipnode == repo.changelog.node(self.tiprev))
                     and (self.filteredhash == self._hashfiltered(repo)))
         except IndexError:
             return False
 
     def copy(self):
         """return an deep copy of the branchcache object"""
         return branchcache(self, self.tipnode, self.tiprev, self.filteredhash)
 
     def write(self, repo):
         try:
             f = repo.opener(_filename(repo), "w", atomictemp=True)
             cachekey = [hex(self.tipnode), str(self.tiprev)]
             if self.filteredhash is not None:
                 cachekey.append(hex(self.filteredhash))
             f.write(" ".join(cachekey) + '\n')
-            for label, nodes in self.iteritems():
+            for label, nodes in sorted(self.iteritems()):
                 for node in nodes:
                     f.write("%s %s\n" % (hex(node), encoding.fromlocal(label)))
             f.close()
         except (IOError, OSError, util.Abort):
             # Abort may be raise by read only opener
             pass
 
     def update(self, repo, revgen):
         """Given a branchhead cache, self, that may have extra nodes or be
         missing heads, and a generator of nodes that are at least a superset of
         heads missing, this function updates self to be correct.
         """
         cl = repo.changelog
         # collect new branch entries
         newbranches = {}
         getbranch = cl.branch
         for r in revgen:
             newbranches.setdefault(getbranch(r), []).append(cl.node(r))
         # if older branchheads are reachable from new ones, they aren't
         # really branchheads. Note checking parents is insufficient:
         # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
         for branch, newnodes in newbranches.iteritems():
             bheads = self.setdefault(branch, [])
             # Remove candidate heads that no longer are in the repo (e.g., as
             # the result of a strip that just happened).  Avoid using 'node in
             # self' here because that dives down into branchcache code somewhat
             # recursively.
             bheadrevs = [cl.rev(node) for node in bheads
                          if cl.hasnode(node)]
             newheadrevs = [cl.rev(node) for node in newnodes
                            if cl.hasnode(node)]
             ctxisnew = bheadrevs and min(newheadrevs) > max(bheadrevs)
             # Remove duplicates - nodes that are in newheadrevs and are already
             # in bheadrevs.  This can happen if you strip a node whose parent
             # was already a head (because they're on different branches).
             bheadrevs = sorted(set(bheadrevs).union(newheadrevs))
 
             # Starting from tip means fewer passes over reachable.  If we know
             # the new candidates are not ancestors of existing heads, we don't
             # have to examine ancestors of existing heads
             if ctxisnew:
                 iterrevs = sorted(newheadrevs)
             else:
                 iterrevs = list(bheadrevs)
 
             # This loop prunes out two kinds of heads - heads that are
             # superseded by a head in newheadrevs, and newheadrevs that are not
             # heads because an existing head is their descendant.
             while iterrevs:
                 latest = iterrevs.pop()
                 if latest not in bheadrevs:
                     continue
                 ancestors = set(cl.ancestors([latest],
                                                          bheadrevs[0]))
                 if ancestors:
                     bheadrevs = [b for b in bheadrevs if b not in ancestors]
             self[branch] = [cl.node(rev) for rev in bheadrevs]
             tiprev = max(bheadrevs)
             if tiprev > self.tiprev:
                 self.tipnode = cl.node(tiprev)
                 self.tiprev = tiprev
 
         # There may be branches that cease to exist when the last commit in the
         # branch was stripped.  This code filters them out.  Note that the
         # branch that ceased to exist may not be in newbranches because
         # newbranches is the set of candidate heads, which when you strip the
         # last commit in a branch will be the parent branch.
         droppednodes = []
         for branch in self.keys():
             nodes = [head for head in self[branch]
                      if cl.hasnode(head)]
             if not nodes:
                 droppednodes.extend(nodes)
                 del self[branch]
         if ((not self.validfor(repo)) or (self.tipnode in droppednodes)):
 
             # cache key are not valid anymore
             self.tipnode = nullid
             self.tiprev = nullrev
             for heads in self.values():
                 tiprev = max(cl.rev(node) for node in heads)
                 if tiprev > self.tiprev:
                     self.tipnode = cl.node(tiprev)
                     self.tiprev = tiprev
         self.filteredhash = self._hashfiltered(repo)

tests/test-newbranch.t

@@ -1,344 +1,344
   $ branchcache=.hg/cache/branchheads
 
   $ listbranchcaches() {
   >    for f in .hg/cache/branchheads*;
   >       do echo === $f ===;
   >       cat $f;
   >     done;
   > }
   $ purgebranchcaches() {
   >     rm .hg/cache/branchheads*
   > }
 
   $ hg init t
   $ cd t
 
   $ hg branches
   $ echo foo > a
   $ hg add a
   $ hg ci -m "initial"
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ hg branch
   foo
   $ hg ci -m "add branch name"
   $ hg branch bar
   marked working directory as branch bar
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m "change branch name"
 
 Branch shadowing:
 
   $ hg branch default
   abort: a branch of the same name already exists
   (use 'hg update' to switch to it)
   [255]
 
   $ hg branch -f default
   marked working directory as branch default
   (branches are permanent and global, did you want a bookmark?)
 
   $ hg ci -m "clear branch name"
   created new head
 
 There should be only one default branch head
 
   $ hg heads .
   changeset:   3:1c28f494dae6
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     clear branch name
   
 
   $ hg co foo
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   foo
   $ echo bleah > a
   $ hg ci -m "modify a branch"
 
   $ hg merge default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg branch
   foo
   $ hg ci -m "merge"
 
   $ hg log
   changeset:   5:530046499edf
   branch:      foo
   tag:         tip
   parent:      4:adf1a74a7f7b
   parent:      3:1c28f494dae6
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge
   
   changeset:   4:adf1a74a7f7b
   branch:      foo
   parent:      1:6c0e42da283a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify a branch
   
   changeset:   3:1c28f494dae6
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     clear branch name
   
   changeset:   2:c21617b13b22
   branch:      bar
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change branch name
   
   changeset:   1:6c0e42da283a
   branch:      foo
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add branch name
   
   changeset:   0:db01e8ea3388
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     initial
   
   $ hg branches
   foo                            5:530046499edf
   default                        3:1c28f494dae6 (inactive)
   bar                            2:c21617b13b22 (inactive)
 
   $ hg branches -q
   foo
   default
   bar
 
 Test for invalid branch cache:
 
   $ hg rollback
   repository tip rolled back to revision 4 (undo commit)
   working directory now based on revisions 4 and 3
 
   $ cp ${branchcache}-unserved .hg/bc-invalid
 
   $ hg log -r foo
   changeset:   4:adf1a74a7f7b
   branch:      foo
   tag:         tip
   parent:      1:6c0e42da283a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify a branch
   
   $ cp .hg/bc-invalid $branchcache
 
   $ hg --debug log -r foo
   changeset:   4:adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6
   branch:      foo
   tag:         tip
   phase:       draft
   parent:      1:6c0e42da283a56b5edc5b4fadb491365ec7f5fa8
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:8c342a37dfba0b3d3ce073562a00d8a813c54ffe
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   extra:       branch=foo
   description:
   modify a branch
   
   
   $ purgebranchcaches
   $ echo corrupted > $branchcache
 
   $ hg log -qr foo
   4:adf1a74a7f7b
 
   $ listbranchcaches
   === .hg/cache/branchheads ===
   corrupted
   === .hg/cache/branchheads-unserved ===
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 4
+  c21617b13b220988e7a2e26290fbe4325ffa7139 bar
   1c28f494dae69a2f8fc815059d257eccf3fcfe75 default
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 foo
-  c21617b13b220988e7a2e26290fbe4325ffa7139 bar
 
 Push should update the branch cache:
 
   $ hg init ../target
 
 Pushing just rev 0:
 
   $ hg push -qr 0 ../target
 
   $ (cd ../target/; listbranchcaches)
   === .hg/cache/branchheads-impactable ===
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 0
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 default
 
 Pushing everything:
 
   $ hg push -qf ../target
 
   $ (cd ../target/; listbranchcaches)
   === .hg/cache/branchheads-impactable ===
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 4
+  c21617b13b220988e7a2e26290fbe4325ffa7139 bar
   1c28f494dae69a2f8fc815059d257eccf3fcfe75 default
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 foo
-  c21617b13b220988e7a2e26290fbe4325ffa7139 bar
 
 Update with no arguments: tipmost revision of the current branch:
 
   $ hg up -q -C 0
   $ hg up -q
   $ hg id
   1c28f494dae6
 
   $ hg up -q 1
   $ hg up -q
   $ hg id
   adf1a74a7f7b (foo) tip
 
   $ hg branch foobar
   marked working directory as branch foobar
   (branches are permanent and global, did you want a bookmark?)
 
   $ hg up
   abort: branch foobar not found
   [255]
 
 Fastforward merge:
 
   $ hg branch ff
   marked working directory as branch ff
   (branches are permanent and global, did you want a bookmark?)
 
   $ echo ff > ff
   $ hg ci -Am'fast forward'
   adding ff
 
   $ hg up foo
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge ff
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg branch
   foo
   $ hg commit -m'Merge ff into foo'
   $ hg parents
   changeset:   6:185ffbfefa30
   branch:      foo
   tag:         tip
   parent:      4:adf1a74a7f7b
   parent:      5:1a3c27dc5e11
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Merge ff into foo
   
   $ hg manifest
   a
   ff
 
 
 Test merging, add 3 default heads and one test head:
 
   $ cd ..
   $ hg init merges
   $ cd merges
   $ echo a > a
   $ hg ci -Ama
   adding a
 
   $ echo b > b
   $ hg ci -Amb
   adding b
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Amc
   adding c
   created new head
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Amd
   adding d
   created new head
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo e >> e
   $ hg ci -Ame
   adding e
 
   $ hg log
   changeset:   4:3a1e01ed1df4
   branch:      test
   tag:         tip
   parent:      0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   3:980f7dc84c29
   parent:      0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   2:d36c0562f908
   parent:      0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   1:d2ae7f538514
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 Implicit merge with test branch as parent:
 
   $ hg merge
   abort: branch 'test' has one head - please merge with an explicit rev
   (run 'hg heads' to see all heads)
   [255]
   $ hg up -C default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Implicit merge with default branch as parent:
 
   $ hg merge
   abort: branch 'default' has 3 heads - please merge with an explicit rev
   (run 'hg heads .' to see heads)
   [255]
 
 3 branch heads, explicit merge required:
 
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
 
 2 branch heads, implicit merge works:
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cd ..