clfilter: add impactable filter

The `mutable` filter still have some chance to get invalidated. This will happen
when:

- you garbage collect hidden changeset,
- public phase is moved backward,
- something is changed in the filtering (this could be fixed)

So we introduce an even more stable filtering set: everything with a revision
number egal or higher than the first mutable changeset is filtered.

The only official use of this filter is for branchcache.

mercurial/repoview.py

@@ -1,140 +1,165
 # repoview.py - Filtered view of a localrepo object
 #
 # Copyright 2012 Pierre-Yves David <[e-mail]>
 #                Logilab SA        <[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.
 
 import copy
 import phases
 import util
 
 
 def computehidden(repo):
     """compute the set of hidden revision to filter
 
     During most operation hidden should be filtered."""
     assert not repo.changelog.filteredrevs
     if repo.obsstore:
         return frozenset(repo.revs('hidden()'))
     return frozenset()
 
 def computeunserved(repo):
     """compute the set of revision that should be filtered when used a server
 
     Secret and hidden changeset should not pretend to be here."""
     assert not repo.changelog.filteredrevs
     # fast path in simple case to avoid impact of non optimised code
     if phases.hassecret(repo) or repo.obsstore:
         return frozenset(repo.revs('hidden() + secret()'))
     return frozenset()
 
 def computemutable(repo):
     """compute the set of revision that should be filtered when used a server
 
     Secret and hidden changeset should not pretend to be here."""
     assert not repo.changelog.filteredrevs
     # fast check to avoid revset call on huge repo
     if util.any(repo._phasecache.phaseroots[1:]):
         return frozenset(repo.revs('draft() + secret()'))
     return frozenset()
 
+def computeimpactable(repo):
+    """Everything impactable by mutable revision
+
+    The mutable filter still have some chance to get invalidated. This will
+    happen when:
+
+    - you garbage collect hidden changeset,
+    - public phase is moved backward,
+    - something is changed in the filtering (this could be fixed)
+
+    This filter out any mutable changeset and any public changeset that may be
+    impacted by something happening to a mutable revision.
+
+    This is achieved by filtered everything with a revision number egal or
+    higher than the first mutable changeset is filtered."""
+    assert not repo.changelog.filteredrevs
+    cl = repo.changelog
+    firstmutable = len(cl)
+    for roots in repo._phasecache.phaseroots[1:]:
+        if roots:
+            firstmutable = min(firstmutable, min(cl.rev(r) for r in roots))
+    return frozenset(xrange(firstmutable, len(cl)))
+
 # function to compute filtered set
 filtertable = {'hidden': computehidden,
                'unserved': computeunserved,
-               'mutable':  computemutable}
+               'mutable':  computemutable,
+               'impactable':  computeimpactable}
 ### Nearest subset relation
 # Nearest subset of filter X is a filter Y so that:
 # * Y is included in X,
 # * X - Y is as small as possible.
 # This create and ordering used for branchmap purpose.
 # the ordering may be partial
 subsettable = {None: 'hidden',
                'hidden': 'unserved',
-               'unserved': 'mutable'}
+               'unserved': 'mutable',
+               'mutable': 'impactable'}
 
 def filteredrevs(repo, filtername):
     """returns set of filtered revision for this filter name"""
     if filtername not in repo.filteredrevcache:
         func = filtertable[filtername]
         repo.filteredrevcache[filtername] = func(repo.unfiltered())
     return repo.filteredrevcache[filtername]
 
 class repoview(object):
     """Provide a read/write view of a repo through a filtered changelog
 
     This object is used to access a filtered version of a repository without
     altering the original repository object itself. We can not alter the
     original object for two main reasons:
     - It prevents the use of a repo with multiple filters at the same time. In
       particular when multiple threads are involved.
     - It makes scope of the filtering harder to control.
 
     This object behaves very closely to the original repository. All attribute
     operations are done on the original repository:
     - An access to `repoview.someattr` actually returns `repo.someattr`,
     - A write to `repoview.someattr` actually sets value of `repo.someattr`,
     - A deletion of `repoview.someattr` actually drops `someattr`
       from `repo.__dict__`.
 
     The only exception is the `changelog` property. It is overridden to return
     a (surface) copy of `repo.changelog` with some revisions filtered. The
     `filtername` attribute of the view control the revisions that need to be
     filtered.  (the fact the changelog is copied is an implementation detail).
 
     Unlike attributes, this object intercepts all method calls. This means that
     all methods are run on the `repoview` object with the filtered `changelog`
     property. For this purpose the simple `repoview` class must be mixed with
     the actual class of the repository. This ensures that the resulting
     `repoview` object have the very same methods than the repo object. This
     leads to the property below.
 
         repoview.method() --> repo.__class__.method(repoview)
 
     The inheritance has to be done dynamically because `repo` can be of any
     subclasses of `localrepo`. Eg: `bundlerepo` or `httprepo`.
     """
 
     def __init__(self, repo, filtername):
         object.__setattr__(self, '_unfilteredrepo', repo)
         object.__setattr__(self, 'filtername', filtername)
 
     # not a cacheproperty on purpose we shall implement a proper cache later
     @property
     def changelog(self):
         """return a filtered version of the changeset
 
         this changelog must not be used for writing"""
         # some cache may be implemented later
         cl = copy.copy(self._unfilteredrepo.changelog)
         cl.filteredrevs = filteredrevs(self._unfilteredrepo, self.filtername)
         return cl
 
     def unfiltered(self):
         """Return an unfiltered version of a repo"""
         return self._unfilteredrepo
 
     def filtered(self, name):
         """Return a filtered version of a repository"""
         if name == self.filtername:
             return self
         return self.unfiltered().filtered(name)
 
     # everything access are forwarded to the proxied repo
     def __getattr__(self, attr):
         return getattr(self._unfilteredrepo, attr)
 
     def __setattr__(self, attr, value):
         return setattr(self._unfilteredrepo, attr, value)
 
     def __delattr__(self, attr):
         return delattr(self._unfilteredrepo, attr)
 
     # The `requirement` attribut is initialiazed during __init__. But
     # __getattr__ won't be called as it also exists on the class. We need
     # explicit forwarding to main repo here
     @property
     def requirements(self):
         return self._unfilteredrepo.requirements
 

tests/test-inherit-mode.t

@@ -1,152 +1,152
 test that new files created in .hg inherit the permissions from .hg/store
 
 
   $ "$TESTDIR/hghave" unix-permissions || exit 80
 
   $ mkdir dir
 
 just in case somebody has a strange $TMPDIR
 
   $ chmod g-s dir
   $ cd dir
 
   $ cat >printmodes.py <<EOF
   > import os, sys
   > 
   > allnames = []
   > isdir = {}
   > for root, dirs, files in os.walk(sys.argv[1]):
   >     for d in dirs:
   >         name = os.path.join(root, d)
   >         isdir[name] = 1
   >         allnames.append(name)
   >     for f in files:
   >         name = os.path.join(root, f)
   >         allnames.append(name)
   > allnames.sort()
   > for name in allnames:
   >     suffix = name in isdir and '/' or ''
   >     print '%05o %s%s' % (os.lstat(name).st_mode & 07777, name, suffix)
   > EOF
 
   $ cat >mode.py <<EOF
   > import sys
   > import os
   > print '%05o' % os.lstat(sys.argv[1]).st_mode
   > EOF
 
   $ umask 077
 
   $ hg init repo
   $ cd repo
 
   $ chmod 0770 .hg/store
 
 before commit
 store can be written by the group, other files cannot
 store is setgid
 
   $ python ../printmodes.py .
   00700 ./.hg/
   00600 ./.hg/00changelog.i
   00600 ./.hg/requires
   00770 ./.hg/store/
 
   $ mkdir dir
   $ touch foo dir/bar
   $ hg ci -qAm 'add files'
 
 after commit
 working dir files can only be written by the owner
 files created in .hg can be written by the group
 (in particular, store/**, dirstate, branch cache file, undo files)
 new directories are setgid
 
   $ python ../printmodes.py .
   00700 ./.hg/
   00600 ./.hg/00changelog.i
   00770 ./.hg/cache/
   00660 ./.hg/cache/branchheads-unserved
   00660 ./.hg/dirstate
   00660 ./.hg/last-message.txt
   00600 ./.hg/requires
   00770 ./.hg/store/
   00660 ./.hg/store/00changelog.i
   00660 ./.hg/store/00manifest.i
   00770 ./.hg/store/data/
   00770 ./.hg/store/data/dir/
   00660 ./.hg/store/data/dir/bar.i
   00660 ./.hg/store/data/foo.i
   00660 ./.hg/store/fncache
   00660 ./.hg/store/phaseroots
   00660 ./.hg/store/undo
   00660 ./.hg/store/undo.phaseroots
   00660 ./.hg/undo.bookmarks
   00660 ./.hg/undo.branch
   00660 ./.hg/undo.desc
   00660 ./.hg/undo.dirstate
   00700 ./dir/
   00600 ./dir/bar
   00600 ./foo
 
   $ umask 007
   $ hg init ../push
 
 before push
 group can write everything
 
   $ python ../printmodes.py ../push
   00770 ../push/.hg/
   00660 ../push/.hg/00changelog.i
   00660 ../push/.hg/requires
   00770 ../push/.hg/store/
 
   $ umask 077
   $ hg -q push ../push
 
 after push
 group can still write everything
 
   $ python ../printmodes.py ../push
   00770 ../push/.hg/
   00660 ../push/.hg/00changelog.i
   00770 ../push/.hg/cache/
-  00660 ../push/.hg/cache/branchheads-mutable
+  00660 ../push/.hg/cache/branchheads-impactable
   00660 ../push/.hg/requires
   00770 ../push/.hg/store/
   00660 ../push/.hg/store/00changelog.i
   00660 ../push/.hg/store/00manifest.i
   00770 ../push/.hg/store/data/
   00770 ../push/.hg/store/data/dir/
   00660 ../push/.hg/store/data/dir/bar.i
   00660 ../push/.hg/store/data/foo.i
   00660 ../push/.hg/store/fncache
   00660 ../push/.hg/store/phaseroots
   00660 ../push/.hg/store/undo
   00660 ../push/.hg/store/undo.phaseroots
   00660 ../push/.hg/undo.bookmarks
   00660 ../push/.hg/undo.branch
   00660 ../push/.hg/undo.desc
   00660 ../push/.hg/undo.dirstate
 
 
 Test that we don't lose the setgid bit when we call chmod.
 Not all systems support setgid directories (e.g. HFS+), so
 just check that directories have the same mode.
 
   $ cd ..
   $ hg init setgid
   $ cd setgid
   $ chmod g+rwx .hg/store
   $ chmod g+s .hg/store 2> /dev/null || true
   $ mkdir dir
   $ touch dir/file
   $ hg ci -qAm 'add dir/file'
   $ storemode=`python ../mode.py .hg/store`
   $ dirmode=`python ../mode.py .hg/store/data/dir`
   $ if [ "$storemode" != "$dirmode" ]; then
   >  echo "$storemode != $dirmode"
   > fi
   $ cd ..
 
   $ cd .. # g-s dir

tests/test-newbranch.t

@@ -1,345 +1,345
   $ 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
   invalid branchheads cache: tip differs
   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
   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-mutable ===
+  === .hg/cache/branchheads-impactable ===
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 0
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 default
 
 Pushing everything:
 
   $ hg push -qf ../target
 
   $ (cd ../target/; listbranchcaches)
-  === .hg/cache/branchheads-mutable ===
+  === .hg/cache/branchheads-impactable ===
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 4
   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 ..