push: perform phases discovery before the push

This will allow including phase information in the same bundle2 as the
changesets.

mercurial/exchange.py

@@ -1,881 +1,921 b''
 # exchange.py - utility to exchange data between repos.
 #
 # 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 i18n import _
 from node import hex, nullid
 import errno, urllib
 import util, scmutil, changegroup, base85, error
 import discovery, phases, obsolete, bookmarks, bundle2, pushkey
 
 def readbundle(ui, fh, fname, vfs=None):
     header = changegroup.readexactly(fh, 4)
 
     alg = None
     if not fname:
         fname = "stream"
         if not header.startswith('HG') and header.startswith('\0'):
             fh = changegroup.headerlessfixup(fh, header)
             header = "HG10"
             alg = 'UN'
     elif vfs:
         fname = vfs.join(fname)
 
     magic, version = header[0:2], header[2:4]
 
     if magic != 'HG':
         raise util.Abort(_('%s: not a Mercurial bundle') % fname)
     if version == '10':
         if alg is None:
             alg = changegroup.readexactly(fh, 2)
         return changegroup.unbundle10(fh, alg)
     elif version == '2X':
         return bundle2.unbundle20(ui, fh, header=magic + version)
     else:
         raise util.Abort(_('%s: unknown bundle version %s') % (fname, version))
 
 
 class pushoperation(object):
     """A object that represent a single push operation
 
     It purpose is to carry push related state and very common operation.
 
     A new should be created at the beginning of each push and discarded
     afterward.
     """
 
     def __init__(self, repo, remote, force=False, revs=None, newbranch=False):
         # repo we push from
         self.repo = repo
         self.ui = repo.ui
         # repo we push to
         self.remote = remote
         # force option provided
         self.force = force
         # revs to be pushed (None is "all")
         self.revs = revs
         # allow push of new branch
         self.newbranch = newbranch
         # did a local lock get acquired?
         self.locallocked = None
         # step already performed
         # (used to check what steps have been already performed through bundle2)
         self.stepsdone = set()
         # Integer version of the push result
         # - None means nothing to push
         # - 0 means HTTP error
         # - 1 means we pushed and remote head count is unchanged *or*
         #   we have outgoing changesets but refused to push
         # - other values as described by addchangegroup()
         self.ret = None
         # discover.outgoing object (contains common and outgoing data)
         self.outgoing = None
         # all remote heads before the push
         self.remoteheads = None
         # testable as a boolean indicating if any nodes are missing locally.
         self.incoming = None
+        # phases changes that must be pushed along side the changesets
+        self.outdatedphases = None
+        # phases changes that must be pushed if changeset push fails
+        self.fallbackoutdatedphases = None
 
     @util.propertycache
     def futureheads(self):
         """future remote heads if the changeset push succeeds"""
         return self.outgoing.missingheads
 
     @util.propertycache
     def fallbackheads(self):
         """future remote heads if the changeset push fails"""
         if self.revs is None:
             # not target to push, all common are relevant
             return self.outgoing.commonheads
         unfi = self.repo.unfiltered()
         # I want cheads = heads(::missingheads and ::commonheads)
         # (missingheads is revs with secret changeset filtered out)
         #
         # This can be expressed as:
         #     cheads = ( (missingheads and ::commonheads)
         #              + (commonheads and ::missingheads))"
         #              )
         #
         # while trying to push we already computed the following:
         #     common = (::commonheads)
         #     missing = ((commonheads::missingheads) - commonheads)
         #
         # We can pick:
         # * missingheads part of common (::commonheads)
         common = set(self.outgoing.common)
         nm = self.repo.changelog.nodemap
         cheads = [node for node in self.revs if nm[node] in common]
         # and
         # * commonheads parents on missing
         revset = unfi.set('%ln and parents(roots(%ln))',
                          self.outgoing.commonheads,
                          self.outgoing.missing)
         cheads.extend(c.node() for c in revset)
         return cheads
 
     @property
     def commonheads(self):
         """set of all common heads after changeset bundle push"""
         if self.ret:
             return self.futureheads
         else:
             return self.fallbackheads
 
 def push(repo, remote, force=False, revs=None, newbranch=False):
     '''Push outgoing changesets (limited by revs) from a local
     repository to remote. Return an integer:
       - None means nothing to push
       - 0 means HTTP error
       - 1 means we pushed and remote head count is unchanged *or*
         we have outgoing changesets but refused to push
       - other values as described by addchangegroup()
     '''
     pushop = pushoperation(repo, remote, force, revs, newbranch)
     if pushop.remote.local():
         missing = (set(pushop.repo.requirements)
                    - pushop.remote.local().supported)
         if missing:
             msg = _("required features are not"
                     " supported in the destination:"
                     " %s") % (', '.join(sorted(missing)))
             raise util.Abort(msg)
 
     # there are two ways to push to remote repo:
     #
     # addchangegroup assumes local user can lock remote
     # repo (local filesystem, old ssh servers).
     #
     # unbundle assumes local user cannot lock remote repo (new ssh
     # servers, http servers).
 
     if not pushop.remote.canpush():
         raise util.Abort(_("destination does not support push"))
     # get local lock as we might write phase data
     locallock = None
     try:
         locallock = pushop.repo.lock()
         pushop.locallocked = True
     except IOError, err:
         pushop.locallocked = False
         if err.errno != errno.EACCES:
             raise
         # source repo cannot be locked.
         # We do not abort the push, but just disable the local phase
         # synchronisation.
         msg = 'cannot lock source repository: %s\n' % err
         pushop.ui.debug(msg)
     try:
         pushop.repo.checkpush(pushop)
         lock = None
         unbundle = pushop.remote.capable('unbundle')
         if not unbundle:
             lock = pushop.remote.lock()
         try:
             _pushdiscovery(pushop)
             if (pushop.repo.ui.configbool('experimental', 'bundle2-exp',
                                           False)
                 and pushop.remote.capable('bundle2-exp')):
                 _pushbundle2(pushop)
             _pushchangeset(pushop)
             _pushsyncphase(pushop)
             _pushobsolete(pushop)
         finally:
             if lock is not None:
                 lock.release()
     finally:
         if locallock is not None:
             locallock.release()
 
     _pushbookmark(pushop)
     return pushop.ret
 
 # list of steps to perform discovery before push
 pushdiscoveryorder = []
 
 # Mapping between step name and function
 #
 # This exists to help extensions wrap steps if necessary
 pushdiscoverymapping = {}
 
 def pushdiscovery(stepname):
     """decorator for function performing discovery before push
 
     The function is added to the step -> function mapping and appended to the
     list of steps.  Beware that decorated function will be added in order (this
     may matter).
 
     You can only use this decorator for a new step, if you want to wrap a step
     from an extension, change the pushdiscovery dictionary directly."""
     def dec(func):
         assert stepname not in pushdiscoverymapping
         pushdiscoverymapping[stepname] = func
         pushdiscoveryorder.append(stepname)
         return func
     return dec
 
 
 
 def _pushdiscovery(pushop):
     """Run all discovery steps"""
     for stepname in pushdiscoveryorder:
         step = pushdiscoverymapping[stepname]
         step(pushop)
 
 @pushdiscovery('changeset')
 def _pushdiscoverychangeset(pushop):
     """discover the changeset that need to be pushed"""
     unfi = pushop.repo.unfiltered()
     fci = discovery.findcommonincoming
     commoninc = fci(unfi, pushop.remote, force=pushop.force)
     common, inc, remoteheads = commoninc
     fco = discovery.findcommonoutgoing
     outgoing = fco(unfi, pushop.remote, onlyheads=pushop.revs,
                    commoninc=commoninc, force=pushop.force)
     pushop.outgoing = outgoing
     pushop.remoteheads = remoteheads
     pushop.incoming = inc
 
+@pushdiscovery('phase')
+def _pushdiscoveryphase(pushop):
+    """discover the phase that needs to be pushed
+
+    (computed for both success and failure case for changesets push)"""
+    outgoing = pushop.outgoing
+    unfi = pushop.repo.unfiltered()
+    remotephases = pushop.remote.listkeys('phases')
+    publishing = remotephases.get('publishing', False)
+    ana = phases.analyzeremotephases(pushop.repo,
+                                     pushop.fallbackheads,
+                                     remotephases)
+    pheads, droots = ana
+    extracond = ''
+    if not publishing:
+        extracond = ' and public()'
+    revset = 'heads((%%ln::%%ln) %s)' % extracond
+    # Get the list of all revs draft on remote by public here.
+    # XXX Beware that revset break if droots is not strictly
+    # XXX root we may want to ensure it is but it is costly
+    fallback = list(unfi.set(revset, droots, pushop.fallbackheads))
+    if not outgoing.missing:
+        future = fallback
+    else:
+        # adds changeset we are going to push as draft
+        #
+        # should not be necessary for pushblishing server, but because of an
+        # issue fixed in xxxxx we have to do it anyway.
+        fdroots = list(unfi.set('roots(%ln  + %ln::)',
+                       outgoing.missing, droots))
+        fdroots = [f.node() for f in fdroots]
+        future = list(unfi.set(revset, fdroots, pushop.futureheads))
+    pushop.outdatedphases = future
+    pushop.fallbackoutdatedphases = fallback
+
 def _pushcheckoutgoing(pushop):
     outgoing = pushop.outgoing
     unfi = pushop.repo.unfiltered()
     if not outgoing.missing:
         # nothing to push
         scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)
         return False
     # something to push
     if not pushop.force:
         # if repo.obsstore == False --> no obsolete
         # then, save the iteration
         if unfi.obsstore:
             # this message are here for 80 char limit reason
             mso = _("push includes obsolete changeset: %s!")
             mst = "push includes %s changeset: %s!"
             # plain versions for i18n tool to detect them
             _("push includes unstable changeset: %s!")
             _("push includes bumped changeset: %s!")
             _("push includes divergent changeset: %s!")
             # If we are to push if there is at least one
             # obsolete or unstable changeset in missing, at
             # least one of the missinghead will be obsolete or
             # unstable. So checking heads only is ok
             for node in outgoing.missingheads:
                 ctx = unfi[node]
                 if ctx.obsolete():
                     raise util.Abort(mso % ctx)
                 elif ctx.troubled():
                     raise util.Abort(_(mst)
                                      % (ctx.troubles()[0],
                                         ctx))
         newbm = pushop.ui.configlist('bookmarks', 'pushing')
         discovery.checkheads(unfi, pushop.remote, outgoing,
                              pushop.remoteheads,
                              pushop.newbranch,
                              bool(pushop.incoming),
                              newbm)
     return True
 
 # List of names of steps to perform for an outgoing bundle2, order matters.
 b2partsgenorder = []
 
 # Mapping between step name and function
 #
 # This exists to help extensions wrap steps if necessary
 b2partsgenmapping = {}
 
 def b2partsgenerator(stepname):
     """decorator for function generating bundle2 part
 
     The function is added to the step -> function mapping and appended to the
     list of steps.  Beware that decorated functions will be added in order
     (this may matter).
 
     You can only use this decorator for new steps, if you want to wrap a step
     from an extension, attack the b2partsgenmapping dictionary directly."""
     def dec(func):
         assert stepname not in b2partsgenmapping
         b2partsgenmapping[stepname] = func
         b2partsgenorder.append(stepname)
         return func
     return dec
 
 @b2partsgenerator('changeset')
 def _pushb2ctx(pushop, bundler):
     """handle changegroup push through bundle2
 
     addchangegroup result is stored in the ``pushop.ret`` attribute.
     """
     if 'changesets' in pushop.stepsdone:
         return
     pushop.stepsdone.add('changesets')
     # Send known heads to the server for race detection.
     pushop.stepsdone.add('changesets')
     if not _pushcheckoutgoing(pushop):
         return
     pushop.repo.prepushoutgoinghooks(pushop.repo,
                                      pushop.remote,
                                      pushop.outgoing)
     if not pushop.force:
         bundler.newpart('B2X:CHECK:HEADS', data=iter(pushop.remoteheads))
     cg = changegroup.getlocalbundle(pushop.repo, 'push', pushop.outgoing)
     cgpart = bundler.newpart('B2X:CHANGEGROUP', data=cg.getchunks())
     def handlereply(op):
         """extract addchangroup returns from server reply"""
         cgreplies = op.records.getreplies(cgpart.id)
         assert len(cgreplies['changegroup']) == 1
         pushop.ret = cgreplies['changegroup'][0]['return']
     return handlereply
 
 
 def _pushbundle2(pushop):
     """push data to the remote using bundle2
 
     The only currently supported type of data is changegroup but this will
     evolve in the future."""
     bundler = bundle2.bundle20(pushop.ui, bundle2.bundle2caps(pushop.remote))
     # create reply capability
     capsblob = bundle2.encodecaps(pushop.repo.bundle2caps)
     bundler.newpart('b2x:replycaps', data=capsblob)
     replyhandlers = []
     for partgenname in b2partsgenorder:
         partgen = b2partsgenmapping[partgenname]
         ret = partgen(pushop, bundler)
         if callable(ret):
             replyhandlers.append(ret)
     # do not push if nothing to push
     if bundler.nbparts <= 1:
         return
     stream = util.chunkbuffer(bundler.getchunks())
     try:
         reply = pushop.remote.unbundle(stream, ['force'], 'push')
     except error.BundleValueError, exc:
         raise util.Abort('missing support for %s' % exc)
     try:
         op = bundle2.processbundle(pushop.repo, reply)
     except error.BundleValueError, exc:
         raise util.Abort('missing support for %s' % exc)
     for rephand in replyhandlers:
         rephand(op)
 
 def _pushchangeset(pushop):
     """Make the actual push of changeset bundle to remote repo"""
     if 'changesets' in pushop.stepsdone:
         return
     pushop.stepsdone.add('changesets')
     if not _pushcheckoutgoing(pushop):
         return
     pushop.repo.prepushoutgoinghooks(pushop.repo,
                                      pushop.remote,
                                      pushop.outgoing)
     outgoing = pushop.outgoing
     unbundle = pushop.remote.capable('unbundle')
     # TODO: get bundlecaps from remote
     bundlecaps = None
     # create a changegroup from local
     if pushop.revs is None and not (outgoing.excluded
                             or pushop.repo.changelog.filteredrevs):
         # push everything,
         # use the fast path, no race possible on push
         bundler = changegroup.bundle10(pushop.repo, bundlecaps)
         cg = changegroup.getsubset(pushop.repo,
                                    outgoing,
                                    bundler,
                                    'push',
                                    fastpath=True)
     else:
         cg = changegroup.getlocalbundle(pushop.repo, 'push', outgoing,
                                         bundlecaps)
 
     # apply changegroup to remote
     if unbundle:
         # local repo finds heads on server, finds out what
         # revs it must push. once revs transferred, if server
         # finds it has different heads (someone else won
         # commit/push race), server aborts.
         if pushop.force:
             remoteheads = ['force']
         else:
             remoteheads = pushop.remoteheads
         # ssh: return remote's addchangegroup()
         # http: return remote's addchangegroup() or 0 for error
         pushop.ret = pushop.remote.unbundle(cg, remoteheads,
                                             pushop.repo.url())
     else:
         # we return an integer indicating remote head count
         # change
         pushop.ret = pushop.remote.addchangegroup(cg, 'push', pushop.repo.url())
 
 def _pushsyncphase(pushop):
     """synchronise phase information locally and remotely"""
-    unfi = pushop.repo.unfiltered()
     cheads = pushop.commonheads
     # even when we don't push, exchanging phase data is useful
     remotephases = pushop.remote.listkeys('phases')
     if (pushop.ui.configbool('ui', '_usedassubrepo', False)
         and remotephases    # server supports phases
         and pushop.ret is None # nothing was pushed
         and remotephases.get('publishing', False)):
         # When:
         # - this is a subrepo push
         # - and remote support phase
         # - and no changeset was pushed
         # - and remote is publishing
         # We may be in issue 3871 case!
         # We drop the possible phase synchronisation done by
         # courtesy to publish changesets possibly locally draft
         # on the remote.
         remotephases = {'publishing': 'True'}
     if not remotephases: # old server or public only reply from non-publishing
         _localphasemove(pushop, cheads)
         # don't push any phase data as there is nothing to push
     else:
         ana = phases.analyzeremotephases(pushop.repo, cheads,
                                          remotephases)
         pheads, droots = ana
         ### Apply remote phase on local
         if remotephases.get('publishing', False):
             _localphasemove(pushop, cheads)
         else: # publish = False
             _localphasemove(pushop, pheads)
             _localphasemove(pushop, cheads, phases.draft)
         ### Apply local phase on remote
 
-        # Get the list of all revs draft on remote by public here.
-        # XXX Beware that revset break if droots is not strictly
-        # XXX root we may want to ensure it is but it is costly
-        outdated = unfi.set('heads((%ln::%ln) and public())',
-                            droots, cheads)
+        if pushop.ret:
+            outdated = pushop.outdatedphases
+        else:
+            outdated = pushop.fallbackoutdatedphases
+
+        # filter heads already turned public by the push
+        outdated = [c for c in outdated if c.node() not in pheads]
 
         b2caps = bundle2.bundle2caps(pushop.remote)
         if 'b2x:pushkey' in b2caps:
             # server supports bundle2, let's do a batched push through it
             #
             # This will eventually be unified with the changesets bundle2 push
             bundler = bundle2.bundle20(pushop.ui, b2caps)
             capsblob = bundle2.encodecaps(pushop.repo.bundle2caps)
             bundler.newpart('b2x:replycaps', data=capsblob)
             part2node = []
             enc = pushkey.encode
             for newremotehead in outdated:
                 part = bundler.newpart('b2x:pushkey')
                 part.addparam('namespace', enc('phases'))
                 part.addparam('key', enc(newremotehead.hex()))
                 part.addparam('old', enc(str(phases.draft)))
                 part.addparam('new', enc(str(phases.public)))
                 part2node.append((part.id, newremotehead))
             stream = util.chunkbuffer(bundler.getchunks())
             try:
                 reply = pushop.remote.unbundle(stream, ['force'], 'push')
                 op = bundle2.processbundle(pushop.repo, reply)
             except error.BundleValueError, exc:
                 raise util.Abort('missing support for %s' % exc)
             for partid, node in part2node:
                 partrep = op.records.getreplies(partid)
                 results = partrep['pushkey']
                 assert len(results) <= 1
                 msg = None
                 if not results:
                     msg = _('server ignored update of %s to public!\n') % node
                 elif not int(results[0]['return']):
                     msg = _('updating %s to public failed!\n') % node
                 if msg is not None:
                     pushop.ui.warn(msg)
 
         else:
             # fallback to independant pushkey command
             for newremotehead in outdated:
                 r = pushop.remote.pushkey('phases',
                                           newremotehead.hex(),
                                           str(phases.draft),
                                           str(phases.public))
                 if not r:
                     pushop.ui.warn(_('updating %s to public failed!\n')
                                    % newremotehead)
 
 def _localphasemove(pushop, nodes, phase=phases.public):
     """move <nodes> to <phase> in the local source repo"""
     if pushop.locallocked:
         phases.advanceboundary(pushop.repo, phase, nodes)
     else:
         # repo is not locked, do not change any phases!
         # Informs the user that phases should have been moved when
         # applicable.
         actualmoves = [n for n in nodes if phase < pushop.repo[n].phase()]
         phasestr = phases.phasenames[phase]
         if actualmoves:
             pushop.ui.status(_('cannot lock source repo, skipping '
                                'local %s phase update\n') % phasestr)
 
 def _pushobsolete(pushop):
     """utility function to push obsolete markers to a remote"""
     pushop.ui.debug('try to push obsolete markers to remote\n')
     repo = pushop.repo
     remote = pushop.remote
     if (obsolete._enabled and repo.obsstore and
         'obsolete' in remote.listkeys('namespaces')):
         rslts = []
         remotedata = repo.listkeys('obsolete')
         for key in sorted(remotedata, reverse=True):
             # reverse sort to ensure we end with dump0
             data = remotedata[key]
             rslts.append(remote.pushkey('obsolete', key, '', data))
         if [r for r in rslts if not r]:
             msg = _('failed to push some obsolete markers!\n')
             repo.ui.warn(msg)
 
 def _pushbookmark(pushop):
     """Update bookmark position on remote"""
     ui = pushop.ui
     repo = pushop.repo.unfiltered()
     remote = pushop.remote
     ui.debug("checking for updated bookmarks\n")
     revnums = map(repo.changelog.rev, pushop.revs or [])
     ancestors = [a for a in repo.changelog.ancestors(revnums, inclusive=True)]
     (addsrc, adddst, advsrc, advdst, diverge, differ, invalid
      ) = bookmarks.compare(repo, repo._bookmarks, remote.listkeys('bookmarks'),
                            srchex=hex)
 
     for b, scid, dcid in advsrc:
         if ancestors and repo[scid].rev() not in ancestors:
             continue
         if remote.pushkey('bookmarks', b, dcid, scid):
             ui.status(_("updating bookmark %s\n") % b)
         else:
             ui.warn(_('updating bookmark %s failed!\n') % b)
 
 class pulloperation(object):
     """A object that represent a single pull operation
 
     It purpose is to carry push related state and very common operation.
 
     A new should be created at the beginning of each pull and discarded
     afterward.
     """
 
     def __init__(self, repo, remote, heads=None, force=False):
         # repo we pull into
         self.repo = repo
         # repo we pull from
         self.remote = remote
         # revision we try to pull (None is "all")
         self.heads = heads
         # do we force pull?
         self.force = force
         # the name the pull transaction
         self._trname = 'pull\n' + util.hidepassword(remote.url())
         # hold the transaction once created
         self._tr = None
         # set of common changeset between local and remote before pull
         self.common = None
         # set of pulled head
         self.rheads = None
         # list of missing changeset to fetch remotely
         self.fetch = None
         # result of changegroup pulling (used as return code by pull)
         self.cgresult = None
         # list of step remaining todo (related to future bundle2 usage)
         self.todosteps = set(['changegroup', 'phases', 'obsmarkers'])
 
     @util.propertycache
     def pulledsubset(self):
         """heads of the set of changeset target by the pull"""
         # compute target subset
         if self.heads is None:
             # We pulled every thing possible
             # sync on everything common
             c = set(self.common)
             ret = list(self.common)
             for n in self.rheads:
                 if n not in c:
                     ret.append(n)
             return ret
         else:
             # We pulled a specific subset
             # sync on this subset
             return self.heads
 
     def gettransaction(self):
         """get appropriate pull transaction, creating it if needed"""
         if self._tr is None:
             self._tr = self.repo.transaction(self._trname)
         return self._tr
 
     def closetransaction(self):
         """close transaction if created"""
         if self._tr is not None:
             self._tr.close()
 
     def releasetransaction(self):
         """release transaction if created"""
         if self._tr is not None:
             self._tr.release()
 
 def pull(repo, remote, heads=None, force=False):
     pullop = pulloperation(repo, remote, heads, force)
     if pullop.remote.local():
         missing = set(pullop.remote.requirements) - pullop.repo.supported
         if missing:
             msg = _("required features are not"
                     " supported in the destination:"
                     " %s") % (', '.join(sorted(missing)))
             raise util.Abort(msg)
 
     lock = pullop.repo.lock()
     try:
         _pulldiscovery(pullop)
         if (pullop.repo.ui.configbool('experimental', 'bundle2-exp', False)
             and pullop.remote.capable('bundle2-exp')):
             _pullbundle2(pullop)
         if 'changegroup' in pullop.todosteps:
             _pullchangeset(pullop)
         if 'phases' in pullop.todosteps:
             _pullphase(pullop)
         if 'obsmarkers' in pullop.todosteps:
             _pullobsolete(pullop)
         pullop.closetransaction()
     finally:
         pullop.releasetransaction()
         lock.release()
 
     return pullop.cgresult
 
 def _pulldiscovery(pullop):
     """discovery phase for the pull
 
     Current handle changeset discovery only, will change handle all discovery
     at some point."""
     tmp = discovery.findcommonincoming(pullop.repo.unfiltered(),
                                        pullop.remote,
                                        heads=pullop.heads,
                                        force=pullop.force)
     pullop.common, pullop.fetch, pullop.rheads = tmp
 
 def _pullbundle2(pullop):
     """pull data using bundle2
 
     For now, the only supported data are changegroup."""
     remotecaps = bundle2.bundle2caps(pullop.remote)
     kwargs = {'bundlecaps': caps20to10(pullop.repo)}
     # pulling changegroup
     pullop.todosteps.remove('changegroup')
 
     kwargs['common'] = pullop.common
     kwargs['heads'] = pullop.heads or pullop.rheads
     if 'b2x:listkeys' in remotecaps:
         kwargs['listkeys'] = ['phase']
     if not pullop.fetch:
         pullop.repo.ui.status(_("no changes found\n"))
         pullop.cgresult = 0
     else:
         if pullop.heads is None and list(pullop.common) == [nullid]:
             pullop.repo.ui.status(_("requesting all changes\n"))
     _pullbundle2extraprepare(pullop, kwargs)
     if kwargs.keys() == ['format']:
         return # nothing to pull
     bundle = pullop.remote.getbundle('pull', **kwargs)
     try:
         op = bundle2.processbundle(pullop.repo, bundle, pullop.gettransaction)
     except error.BundleValueError, exc:
         raise util.Abort('missing support for %s' % exc)
 
     if pullop.fetch:
         assert len(op.records['changegroup']) == 1
         pullop.cgresult = op.records['changegroup'][0]['return']
 
     # processing phases change
     for namespace, value in op.records['listkeys']:
         if namespace == 'phases':
             _pullapplyphases(pullop, value)
 
 def _pullbundle2extraprepare(pullop, kwargs):
     """hook function so that extensions can extend the getbundle call"""
     pass
 
 def _pullchangeset(pullop):
     """pull changeset from unbundle into the local repo"""
     # We delay the open of the transaction as late as possible so we
     # don't open transaction for nothing or you break future useful
     # rollback call
     pullop.todosteps.remove('changegroup')
     if not pullop.fetch:
             pullop.repo.ui.status(_("no changes found\n"))
             pullop.cgresult = 0
             return
     pullop.gettransaction()
     if pullop.heads is None and list(pullop.common) == [nullid]:
         pullop.repo.ui.status(_("requesting all changes\n"))
     elif pullop.heads is None and pullop.remote.capable('changegroupsubset'):
         # issue1320, avoid a race if remote changed after discovery
         pullop.heads = pullop.rheads
 
     if pullop.remote.capable('getbundle'):
         # TODO: get bundlecaps from remote
         cg = pullop.remote.getbundle('pull', common=pullop.common,
                                      heads=pullop.heads or pullop.rheads)
     elif pullop.heads is None:
         cg = pullop.remote.changegroup(pullop.fetch, 'pull')
     elif not pullop.remote.capable('changegroupsubset'):
         raise util.Abort(_("partial pull cannot be done because "
                            "other repository doesn't support "
                            "changegroupsubset."))
     else:
         cg = pullop.remote.changegroupsubset(pullop.fetch, pullop.heads, 'pull')
     pullop.cgresult = changegroup.addchangegroup(pullop.repo, cg, 'pull',
                                                  pullop.remote.url())
 
 def _pullphase(pullop):
     # Get remote phases data from remote
     remotephases = pullop.remote.listkeys('phases')
     _pullapplyphases(pullop, remotephases)
 
 def _pullapplyphases(pullop, remotephases):
     """apply phase movement from observed remote state"""
     pullop.todosteps.remove('phases')
     publishing = bool(remotephases.get('publishing', False))
     if remotephases and not publishing:
         # remote is new and unpublishing
         pheads, _dr = phases.analyzeremotephases(pullop.repo,
                                                  pullop.pulledsubset,
                                                  remotephases)
         phases.advanceboundary(pullop.repo, phases.public, pheads)
         phases.advanceboundary(pullop.repo, phases.draft,
                                pullop.pulledsubset)
     else:
         # Remote is old or publishing all common changesets
         # should be seen as public
         phases.advanceboundary(pullop.repo, phases.public,
                                pullop.pulledsubset)
 
 def _pullobsolete(pullop):
     """utility function to pull obsolete markers from a remote
 
     The `gettransaction` is function that return the pull transaction, creating
     one if necessary. We return the transaction to inform the calling code that
     a new transaction have been created (when applicable).
 
     Exists mostly to allow overriding for experimentation purpose"""
     pullop.todosteps.remove('obsmarkers')
     tr = None
     if obsolete._enabled:
         pullop.repo.ui.debug('fetching remote obsolete markers\n')
         remoteobs = pullop.remote.listkeys('obsolete')
         if 'dump0' in remoteobs:
             tr = pullop.gettransaction()
             for key in sorted(remoteobs, reverse=True):
                 if key.startswith('dump'):
                     data = base85.b85decode(remoteobs[key])
                     pullop.repo.obsstore.mergemarkers(tr, data)
             pullop.repo.invalidatevolatilesets()
     return tr
 
 def caps20to10(repo):
     """return a set with appropriate options to use bundle20 during getbundle"""
     caps = set(['HG2X'])
     capsblob = bundle2.encodecaps(repo.bundle2caps)
     caps.add('bundle2=' + urllib.quote(capsblob))
     return caps
 
 def getbundle(repo, source, heads=None, common=None, bundlecaps=None,
               **kwargs):
     """return a full bundle (with potentially multiple kind of parts)
 
     Could be a bundle HG10 or a bundle HG2X depending on bundlecaps
     passed. For now, the bundle can contain only changegroup, but this will
     changes when more part type will be available for bundle2.
 
     This is different from changegroup.getbundle that only returns an HG10
     changegroup bundle. They may eventually get reunited in the future when we
     have a clearer idea of the API we what to query different data.
 
     The implementation is at a very early stage and will get massive rework
     when the API of bundle is refined.
     """
     cg = None
     if kwargs.get('cg', True):
         # build changegroup bundle here.
         cg = changegroup.getbundle(repo, source, heads=heads,
                                    common=common, bundlecaps=bundlecaps)
     elif 'HG2X' not in bundlecaps:
         raise ValueError(_('request for bundle10 must include changegroup'))
     if bundlecaps is None or 'HG2X' not in bundlecaps:
         if kwargs:
             raise ValueError(_('unsupported getbundle arguments: %s')
                              % ', '.join(sorted(kwargs.keys())))
         return cg
     # very crude first implementation,
     # the bundle API will change and the generation will be done lazily.
     b2caps = {}
     for bcaps in bundlecaps:
         if bcaps.startswith('bundle2='):
             blob = urllib.unquote(bcaps[len('bundle2='):])
             b2caps.update(bundle2.decodecaps(blob))
     bundler = bundle2.bundle20(repo.ui, b2caps)
     if cg:
         bundler.newpart('b2x:changegroup', data=cg.getchunks())
     listkeys = kwargs.get('listkeys', ())
     for namespace in listkeys:
         part = bundler.newpart('b2x:listkeys')
         part.addparam('namespace', namespace)
         keys = repo.listkeys(namespace).items()
         part.data = pushkey.encodekeys(keys)
     _getbundleextrapart(bundler, repo, source, heads=heads, common=common,
                         bundlecaps=bundlecaps, **kwargs)
     return util.chunkbuffer(bundler.getchunks())
 
 def _getbundleextrapart(bundler, repo, source, heads=None, common=None,
                         bundlecaps=None, **kwargs):
     """hook function to let extensions add parts to the requested bundle"""
     pass
 
 def check_heads(repo, their_heads, context):
     """check if the heads of a repo have been modified
 
     Used by peer for unbundling.
     """
     heads = repo.heads()
     heads_hash = util.sha1(''.join(sorted(heads))).digest()
     if not (their_heads == ['force'] or their_heads == heads or
             their_heads == ['hashed', heads_hash]):
         # someone else committed/pushed/unbundled while we
         # were transferring data
         raise error.PushRaced('repository changed while %s - '
                               'please try again' % context)
 
 def unbundle(repo, cg, heads, source, url):
     """Apply a bundle to a repo.
 
     this function makes sure the repo is locked during the application and have
     mechanism to check that no push race occurred between the creation of the
     bundle and its application.
 
     If the push was raced as PushRaced exception is raised."""
     r = 0
     # need a transaction when processing a bundle2 stream
     tr = None
     lock = repo.lock()
     try:
         check_heads(repo, heads, 'uploading changes')
         # push can proceed
         if util.safehasattr(cg, 'params'):
             try:
                 tr = repo.transaction('unbundle')
                 tr.hookargs['bundle2-exp'] = '1'
                 r = bundle2.processbundle(repo, cg, lambda: tr).reply
                 cl = repo.unfiltered().changelog
                 p = cl.writepending() and repo.root or ""
                 repo.hook('b2x-pretransactionclose', throw=True, source=source,
                           url=url, pending=p, **tr.hookargs)
                 tr.close()
                 repo.hook('b2x-transactionclose', source=source, url=url,
                           **tr.hookargs)
             except Exception, exc:
                 exc.duringunbundle2 = True
                 raise
         else:
             r = changegroup.addchangegroup(repo, cg, source, url)
     finally:
         if tr is not None:
             tr.release()
         lock.release()
     return r

tests/test-acl.t

@@ -1,2139 +1,2166 b''
   > do_push()
   > {
   >     user=$1
   >     shift
   >     echo "Pushing as user $user"
   >     echo 'hgrc = """'
   >     sed -e 1,2d b/.hg/hgrc | grep -v fakegroups.py
   >     echo '"""'
   >     if test -f acl.config; then
   >         echo 'acl.config = """'
   >         cat acl.config
   >         echo '"""'
   >     fi
   >     # On AIX /etc/profile sets LOGNAME read-only. So
   >     #  LOGNAME=$user hg --cws a --debug push ../b
   >     # fails with "This variable is read only."
   >     # Use env to work around this.
   >     env LOGNAME=$user hg --cwd a --debug push ../b
   >     hg --cwd b rollback
   >     hg --cwd b --quiet tip
   >     echo
   > }
 
   > init_config()
   > {
   >     cat > fakegroups.py <<EOF
   > from hgext import acl
   > def fakegetusers(ui, group):
   >     try:
   >         return acl._getusersorig(ui, group)
   >     except:
   >         return ["fred", "betty"]
   > acl._getusersorig = acl._getusers
   > acl._getusers = fakegetusers
   > EOF
   >     rm -f acl.config
   >     cat > $config <<EOF
   > [hooks]
   > pretxnchangegroup.acl = python:hgext.acl.hook
   > [acl]
   > sources = push
   > [extensions]
   > f=`pwd`/fakegroups.py
   > EOF
   > }
 
   $ hg init a
   $ cd a
   $ mkdir foo foo/Bar quux
   $ echo 'in foo' > foo/file.txt
   $ echo 'in foo/Bar' > foo/Bar/file.txt
   $ echo 'in quux' > quux/file.py
   $ hg add -q
   $ hg ci -m 'add files' -d '1000000 0'
   $ echo >> foo/file.txt
   $ hg ci -m 'change foo/file' -d '1000001 0'
   $ echo >> foo/Bar/file.txt
   $ hg ci -m 'change foo/Bar/file' -d '1000002 0'
   $ echo >> quux/file.py
   $ hg ci -m 'change quux/file' -d '1000003 0'
   $ hg tip --quiet
   3:911600dab2ae
 
   $ cd ..
   $ hg clone -r 0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 3 changes to 3 files
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ config=b/.hg/hgrc
 
 Extension disabled for lack of a hook
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
   $ echo '[hooks]' >> $config
   $ echo 'pretxnchangegroup.acl = python:hgext.acl.hook' >> $config
 
 Extension disabled for lack of acl.sources
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: changes have source "push" - skipping
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 No [acl.allow]/[acl.deny]
 
   $ echo '[acl]' >> $config
   $ echo 'sources = push' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 Empty [acl.allow]
 
   $ echo '[acl.allow]' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 0 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "fred" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   no rollback information available
   0:6675d58eff77
   
 
 fred is allowed inside foo/
 
   $ echo 'foo/** = fred' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   transaction abort!
   rollback completed
   abort: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 Empty [acl.deny]
 
   $ echo '[acl.deny]' >> $config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 0 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   no rollback information available
   0:6675d58eff77
   
 
 fred is allowed inside foo/, but not foo/bar/ (case matters)
 
   $ echo 'foo/bar/** = fred' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 1 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   transaction abort!
   rollback completed
   abort: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 fred is allowed inside foo/, but not foo/Bar/
 
   $ echo 'foo/Bar/** = fred' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 2 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   no rollback information available
   0:6675d58eff77
   
 
   $ echo 'barney is not mentioned => not allowed anywhere'
   barney is not mentioned => not allowed anywhere
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 0 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   no rollback information available
   0:6675d58eff77
   
 
 barney is allowed everywhere
 
   $ echo '[acl.allow]' >> $config
   $ echo '** = barney' >> $config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 wilma can change files with a .txt extension
 
   $ echo '**/*.txt = wilma' >> $config
   $ do_push wilma
   Pushing as user wilma
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "wilma"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user wilma
   acl: acl.deny enabled, 0 entries for user wilma
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "wilma" not allowed on "quux/file.py" (changeset "911600dab2ae")
   transaction abort!
   rollback completed
   abort: acl: user "wilma" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 file specified by acl.config does not exist
 
   $ echo '[acl]' >> $config
   $ echo 'config = ../acl.config' >> $config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   [acl]
   config = ../acl.config
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   error: pretxnchangegroup.acl hook raised an exception: [Errno *] *: '../acl.config' (glob)
   transaction abort!
   rollback completed
   abort: *: ../acl.config (glob)
   no rollback information available
   0:6675d58eff77
   
 
 betty is allowed inside foo/ by a acl.config file
 
   $ echo '[acl.allow]' >> acl.config
   $ echo 'foo/** = betty' >> acl.config
   $ do_push betty
   Pushing as user betty
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   [acl]
   config = ../acl.config
   """
   acl.config = """
   [acl.allow]
   foo/** = betty
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "betty"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user betty
   acl: acl.deny enabled, 0 entries for user betty
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "betty" not allowed on "quux/file.py" (changeset "911600dab2ae")
   transaction abort!
   rollback completed
   abort: acl: user "betty" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 acl.config can set only [acl.allow]/[acl.deny]
 
   $ echo '[hooks]' >> acl.config
   $ echo 'changegroup.acl = false' >> acl.config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   [acl]
   config = ../acl.config
   """
   acl.config = """
   [acl.allow]
   foo/** = betty
   [hooks]
   changegroup.acl = false
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 asterisk
 
   $ init_config
 
 asterisk test
 
   $ echo '[acl.allow]' >> $config
   $ echo "** = fred" >> $config
 
 fred is always allowed
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow]
   ** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
   $ echo '[acl.deny]' >> $config
   $ echo "foo/Bar/** = *" >> $config
 
 no one is allowed inside foo/Bar/
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow]
   ** = fred
   [acl.deny]
   foo/Bar/** = *
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 1 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   no rollback information available
   0:6675d58eff77
   
 
 Groups
 
   $ init_config
 
 OS-level groups
 
   $ echo '[acl.allow]' >> $config
   $ echo "** = @group1" >> $config
 
 @group1 is always allowed
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow]
   ** = @group1
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: "group1" not defined in [acl.groups]
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
   $ echo '[acl.deny]' >> $config
   $ echo "foo/Bar/** = @group1" >> $config
 
 @group is allowed inside anything but foo/Bar/
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow]
   ** = @group1
   [acl.deny]
   foo/Bar/** = @group1
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   invalid branchheads cache (served): tip differs
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundling: 1/3 changesets (33.33%)
   bundling: 2/3 changesets (66.67%)
   bundling: 3/3 changesets (100.00%)
   bundling: 1/3 manifests (33.33%)
   bundling: 2/3 manifests (66.67%)
   bundling: 3/3 manifests (100.00%)
   bundling: foo/Bar/file.txt 1/3 files (33.33%)
   bundling: foo/file.txt 2/3 files (66.67%)
   bundling: quux/file.py 3/3 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   adding manifests
   manifests: 1/3 chunks (33.33%)
   manifests: 2/3 chunks (66.67%)
   manifests: 3/3 chunks (100.00%)
   adding file changes
   adding foo/Bar/file.txt revisions
   files: 1/3 chunks (33.33%)
   adding foo/file.txt revisions
   files: 2/3 chunks (66.67%)
   adding quux/file.py revisions
   files: 3/3 chunks (100.00%)
   added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: "group1" not defined in [acl.groups]
   acl: acl.allow enabled, 1 entries for user fred
   acl: "group1" not defined in [acl.groups]
   acl: acl.deny enabled, 1 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   no rollback information available
   0:6675d58eff77
   
 
 Invalid group
 
 Disable the fakegroups trick to get real failures
 
   $ grep -v fakegroups $config > config.tmp
   $ mv config.tmp $config
   $ echo '[acl.allow]' >> $config
   $ echo "** = @unlikelytoexist" >> $config
   $ do_push fred 2>&1 | grep unlikelytoexist
   ** = @unlikelytoexist
   acl: "unlikelytoexist" not defined in [acl.groups]
   error: pretxnchangegroup.acl hook failed: group 'unlikelytoexist' is undefined
   abort: group 'unlikelytoexist' is undefined
 
 
 Branch acl tests setup
 
   $ init_config
   $ cd b
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch foobar
   marked working directory as branch foobar
   (branches are permanent and global, did you want a bookmark?)
   $ hg commit -m 'create foobar'
   $ echo 'foo contents' > abc.txt
   $ hg add abc.txt
   $ hg commit -m 'foobar contents'
   $ cd ..
   $ hg --cwd a pull ../b
   pulling from ../b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files (+1 heads)
   (run 'hg heads' to see heads)
 
 Create additional changeset on foobar branch
 
   $ cd a
   $ hg up -C foobar
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'foo contents2' > abc.txt
   $ hg commit -m 'foobar contents2'
   $ cd ..
 
 
 No branch acls specified
 
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [acl]
   sources = push
   [extensions]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 
 Branch acl deny test
 
   $ echo "[acl.deny.branches]" >> $config
   $ echo "foobar = *" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.deny.branches]
   foobar = *
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 1 entries for user astro
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   error: pretxnchangegroup.acl hook failed: acl: user "astro" denied on branch "foobar" (changeset "e8fc755d4d82")
   transaction abort!
   rollback completed
   abort: acl: user "astro" denied on branch "foobar" (changeset "e8fc755d4d82")
   no rollback information available
   2:fb35475503ef
   
 
 Branch acl empty allow test
 
   $ init_config
   $ echo "[acl.allow.branches]" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow.branches]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches enabled, 0 entries for user astro
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
 
 Branch acl allow other
 
   $ init_config
   $ echo "[acl.allow.branches]" >> $config
   $ echo "* = george" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow.branches]
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches enabled, 0 entries for user astro
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
   $ do_push george
   Pushing as user george
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow.branches]
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches enabled, 1 entries for user george
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 
 Branch acl conflicting allow
 asterisk ends up applying to all branches and allowing george to
 push foobar into the remote
 
   $ init_config
   $ echo "[acl.allow.branches]" >> $config
   $ echo "foobar = astro" >> $config
   $ echo "* = george" >> $config
   $ do_push george
   Pushing as user george
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.allow.branches]
   foobar = astro
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches enabled, 1 entries for user george
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 Branch acl conflicting deny
 
   $ init_config
   $ echo "[acl.deny.branches]" >> $config
   $ echo "foobar = astro" >> $config
   $ echo "default = astro" >> $config
   $ echo "* = george" >> $config
   $ do_push george
   Pushing as user george
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.deny.branches]
   foobar = astro
   default = astro
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 1 entries for user george
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
 User 'astro' must not be denied
 
   $ init_config
   $ echo "[acl.deny.branches]" >> $config
   $ echo "default = !astro" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.deny.branches]
   default = !astro
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 0 entries for user astro
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   updating the branch cache
   listing keys for "phases"
   try to push obsolete markers to remote
   checking for updated bookmarks
   listing keys for "bookmarks"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 
 Non-astro users must be denied
 
   $ do_push george
   Pushing as user george
   hgrc = """
   [acl]
   sources = push
   [extensions]
   [acl.deny.branches]
   default = !astro
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
+  listing keys for "phases"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundling: 1/4 changesets (25.00%)
   bundling: 2/4 changesets (50.00%)
   bundling: 3/4 changesets (75.00%)
   bundling: 4/4 changesets (100.00%)
   bundling: 1/4 manifests (25.00%)
   bundling: 2/4 manifests (50.00%)
   bundling: 3/4 manifests (75.00%)
   bundling: 4/4 manifests (100.00%)
   bundling: abc.txt 1/4 files (25.00%)
   bundling: foo/Bar/file.txt 2/4 files (50.00%)
   bundling: foo/file.txt 3/4 files (75.00%)
   bundling: quux/file.py 4/4 files (100.00%)
   adding changesets
   changesets: 1 chunks
   add changeset ef1ea85a6374
   changesets: 2 chunks
   add changeset f9cafe1212c8
   changesets: 3 chunks
   add changeset 911600dab2ae
   changesets: 4 chunks
   add changeset e8fc755d4d82
   adding manifests
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   adding file changes
   adding abc.txt revisions
   files: 1/4 chunks (25.00%)
   adding foo/Bar/file.txt revisions
   files: 2/4 chunks (50.00%)
   adding foo/file.txt revisions
   files: 3/4 chunks (75.00%)
   adding quux/file.py revisions
   files: 4/4 chunks (100.00%)
   added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 1 entries for user george
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   transaction abort!
   rollback completed
   abort: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
 

tests/test-hook.t

@@ -1,644 +1,645 b''
 commit hooks can see env vars
 
   $ hg init a
   $ cd a
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > commit = sh -c "HG_LOCAL= HG_TAG= python \"$TESTDIR/printenv.py\" commit"
   > commit.b = sh -c "HG_LOCAL= HG_TAG= python \"$TESTDIR/printenv.py\" commit.b"
   > precommit = sh -c  "HG_LOCAL= HG_NODE= HG_TAG= python \"$TESTDIR/printenv.py\" precommit"
   > pretxncommit = sh -c "HG_LOCAL= HG_TAG= python \"$TESTDIR/printenv.py\" pretxncommit"
   > pretxncommit.tip = hg -q tip
   > pre-identify = python "$TESTDIR/printenv.py" pre-identify 1
   > pre-cat = python "$TESTDIR/printenv.py" pre-cat
   > post-cat = python "$TESTDIR/printenv.py" post-cat
   > EOF
   $ echo a > a
   $ hg add a
   $ hg commit -m a
   precommit hook: HG_PARENT1=0000000000000000000000000000000000000000
   pretxncommit hook: HG_NODE=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PARENT1=0000000000000000000000000000000000000000 HG_PENDING=$TESTTMP/a
   0:cb9a9f314b8b
   commit hook: HG_NODE=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PARENT1=0000000000000000000000000000000000000000
   commit.b hook: HG_NODE=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PARENT1=0000000000000000000000000000000000000000
 
   $ hg clone . ../b
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../b
 
 changegroup hooks can see env vars
 
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > prechangegroup = python "$TESTDIR/printenv.py" prechangegroup
   > changegroup = python "$TESTDIR/printenv.py" changegroup
   > incoming = python "$TESTDIR/printenv.py" incoming
   > EOF
 
 pretxncommit and commit hooks can see both parents of merge
 
   $ cd ../a
   $ echo b >> a
   $ hg commit -m a1 -d "1 0"
   precommit hook: HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   pretxncommit hook: HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PENDING=$TESTTMP/a
   1:ab228980c14d
   commit hook: HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   commit.b hook: HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   $ hg update -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg add b
   $ hg commit -m b -d '1 0'
   precommit hook: HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   pretxncommit hook: HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PENDING=$TESTTMP/a
   2:ee9deb46ab31
   commit hook: HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   commit.b hook: HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   created new head
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m merge -d '2 0'
   precommit hook: HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd
   pretxncommit hook: HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd HG_PENDING=$TESTTMP/a
   3:07f3376c1e65
   commit hook: HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd
   commit.b hook: HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd
 
 test generic hooks
 
   $ hg id
   pre-identify hook: HG_ARGS=id HG_OPTS={'bookmarks': None, 'branch': None, 'id': None, 'insecure': None, 'num': None, 'remotecmd': '', 'rev': '', 'ssh': '', 'tags': None} HG_PATS=[]
   abort: pre-identify hook exited with status 1
   [255]
   $ hg cat b
   pre-cat hook: HG_ARGS=cat b HG_OPTS={'decode': None, 'exclude': [], 'include': [], 'output': '', 'rev': ''} HG_PATS=['b']
   b
   post-cat hook: HG_ARGS=cat b HG_OPTS={'decode': None, 'exclude': [], 'include': [], 'output': '', 'rev': ''} HG_PATS=['b'] HG_RESULT=0
 
   $ cd ../b
   $ hg pull ../a
   pulling from ../a
   searching for changes
   prechangegroup hook: HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 2 changes to 2 files
   changegroup hook: HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   incoming hook: HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   incoming hook: HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   incoming hook: HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   (run 'hg update' to get a working copy)
 
 tag hooks can see env vars
 
   $ cd ../a
   $ cat >> .hg/hgrc <<EOF
   > pretag = python "$TESTDIR/printenv.py" pretag
   > tag = sh -c "HG_PARENT1= HG_PARENT2= python \"$TESTDIR/printenv.py\" tag"
   > EOF
   $ hg tag -d '3 0' a
   pretag hook: HG_LOCAL=0 HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_TAG=a
   precommit hook: HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2
   pretxncommit hook: HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PENDING=$TESTTMP/a
   4:539e4b31b6dc
   tag hook: HG_LOCAL=0 HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_TAG=a
   commit hook: HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2
   commit.b hook: HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2
   $ hg tag -l la
   pretag hook: HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=la
   tag hook: HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=la
 
 pretag hook can forbid tagging
 
   $ echo "pretag.forbid = python \"$TESTDIR/printenv.py\" pretag.forbid 1" >> .hg/hgrc
   $ hg tag -d '4 0' fa
   pretag hook: HG_LOCAL=0 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fa
   pretag.forbid hook: HG_LOCAL=0 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fa
   abort: pretag.forbid hook exited with status 1
   [255]
   $ hg tag -l fla
   pretag hook: HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fla
   pretag.forbid hook: HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fla
   abort: pretag.forbid hook exited with status 1
   [255]
 
 pretxncommit hook can see changeset, can roll back txn, changeset no
 more there after
 
   $ echo "pretxncommit.forbid0 = hg tip -q" >> .hg/hgrc
   $ echo "pretxncommit.forbid1 = python \"$TESTDIR/printenv.py\" pretxncommit.forbid 1" >> .hg/hgrc
   $ echo z > z
   $ hg add z
   $ hg -q tip
   4:539e4b31b6dc
   $ hg commit -m 'fail' -d '4 0'
   precommit hook: HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10
   pretxncommit hook: HG_NODE=6f611f8018c10e827fee6bd2bc807f937e761567 HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PENDING=$TESTTMP/a
   5:6f611f8018c1
   5:6f611f8018c1
   pretxncommit.forbid hook: HG_NODE=6f611f8018c10e827fee6bd2bc807f937e761567 HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PENDING=$TESTTMP/a
   transaction abort!
   rollback completed
   abort: pretxncommit.forbid1 hook exited with status 1
   [255]
   $ hg -q tip
   4:539e4b31b6dc
 
 precommit hook can prevent commit
 
   $ echo "precommit.forbid = python \"$TESTDIR/printenv.py\" precommit.forbid 1" >> .hg/hgrc
   $ hg commit -m 'fail' -d '4 0'
   precommit hook: HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10
   precommit.forbid hook: HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10
   abort: precommit.forbid hook exited with status 1
   [255]
   $ hg -q tip
   4:539e4b31b6dc
 
 preupdate hook can prevent update
 
   $ echo "preupdate = python \"$TESTDIR/printenv.py\" preupdate" >> .hg/hgrc
   $ hg update 1
   preupdate hook: HG_PARENT1=ab228980c14d
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
 update hook
 
   $ echo "update = python \"$TESTDIR/printenv.py\" update" >> .hg/hgrc
   $ hg update
   preupdate hook: HG_PARENT1=539e4b31b6dc
   update hook: HG_ERROR=0 HG_PARENT1=539e4b31b6dc
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 pushkey hook
 
   $ echo "pushkey = python \"$TESTDIR/printenv.py\" pushkey" >> .hg/hgrc
   $ cd ../b
   $ hg bookmark -r null foo
   $ hg push -B foo ../a
   pushing to ../a
   searching for changes
   no changes found
   exporting bookmark foo
   pushkey hook: HG_KEY=foo HG_NAMESPACE=bookmarks HG_NEW=0000000000000000000000000000000000000000 HG_RET=1
   [1]
   $ cd ../a
 
 listkeys hook
 
   $ echo "listkeys = python \"$TESTDIR/printenv.py\" listkeys" >> .hg/hgrc
   $ hg bookmark -r null bar
   $ cd ../b
   $ hg pull -B bar ../a
   pulling from ../a
   listkeys hook: HG_NAMESPACE=bookmarks HG_VALUES={'bar': '0000000000000000000000000000000000000000', 'foo': '0000000000000000000000000000000000000000'}
   no changes found
   listkeys hook: HG_NAMESPACE=phases HG_VALUES={'cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b': '1', 'publishing': 'True'}
   adding remote bookmark bar
   importing bookmark bar
   $ cd ../a
 
 test that prepushkey can prevent incoming keys
 
   $ echo "prepushkey = python \"$TESTDIR/printenv.py\" prepushkey.forbid 1" >> .hg/hgrc
   $ cd ../b
   $ hg bookmark -r null baz
   $ hg push -B baz ../a
   pushing to ../a
   searching for changes
+  listkeys hook: HG_NAMESPACE=phases HG_VALUES={'cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b': '1', 'publishing': 'True'}
   no changes found
   listkeys hook: HG_NAMESPACE=phases HG_VALUES={'cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b': '1', 'publishing': 'True'}
   listkeys hook: HG_NAMESPACE=bookmarks HG_VALUES={'bar': '0000000000000000000000000000000000000000', 'foo': '0000000000000000000000000000000000000000'}
   listkeys hook: HG_NAMESPACE=bookmarks HG_VALUES={'bar': '0000000000000000000000000000000000000000', 'foo': '0000000000000000000000000000000000000000'}
   exporting bookmark baz
   prepushkey.forbid hook: HG_KEY=baz HG_NAMESPACE=bookmarks HG_NEW=0000000000000000000000000000000000000000
   abort: prepushkey hook exited with status 1
   [255]
   $ cd ../a
 
 test that prelistkeys can prevent listing keys
 
   $ echo "prelistkeys = python \"$TESTDIR/printenv.py\" prelistkeys.forbid 1" >> .hg/hgrc
   $ hg bookmark -r null quux
   $ cd ../b
   $ hg pull -B quux ../a
   pulling from ../a
   prelistkeys.forbid hook: HG_NAMESPACE=bookmarks
   abort: prelistkeys hook exited with status 1
   [255]
   $ cd ../a
   $ rm .hg/hgrc
 
 prechangegroup hook can prevent incoming changes
 
   $ cd ../b
   $ hg -q tip
   3:07f3376c1e65
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > prechangegroup.forbid = python "$TESTDIR/printenv.py" prechangegroup.forbid 1
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   prechangegroup.forbid hook: HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   abort: prechangegroup.forbid hook exited with status 1
   [255]
 
 pretxnchangegroup hook can see incoming changes, can roll back txn,
 incoming changes no longer there after
 
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > pretxnchangegroup.forbid0 = hg tip -q
   > pretxnchangegroup.forbid1 = python "$TESTDIR/printenv.py" pretxnchangegroup.forbid 1
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   4:539e4b31b6dc
   pretxnchangegroup.forbid hook: HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PENDING=$TESTTMP/b HG_SOURCE=pull HG_URL=file:$TESTTMP/a
   transaction abort!
   rollback completed
   abort: pretxnchangegroup.forbid1 hook exited with status 1
   [255]
   $ hg -q tip
   3:07f3376c1e65
 
 outgoing hooks can see env vars
 
   $ rm .hg/hgrc
   $ cat > ../a/.hg/hgrc <<EOF
   > [hooks]
   > preoutgoing = python "$TESTDIR/printenv.py" preoutgoing
   > outgoing = python "$TESTDIR/printenv.py" outgoing
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   preoutgoing hook: HG_SOURCE=pull
   adding changesets
   outgoing hook: HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_SOURCE=pull
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   adding remote bookmark quux
   (run 'hg update' to get a working copy)
   $ hg rollback
   repository tip rolled back to revision 3 (undo pull)
 
 preoutgoing hook can prevent outgoing changes
 
   $ echo "preoutgoing.forbid = python \"$TESTDIR/printenv.py\" preoutgoing.forbid 1" >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   preoutgoing hook: HG_SOURCE=pull
   preoutgoing.forbid hook: HG_SOURCE=pull
   abort: preoutgoing.forbid hook exited with status 1
   [255]
 
 outgoing hooks work for local clones
 
   $ cd ..
   $ cat > a/.hg/hgrc <<EOF
   > [hooks]
   > preoutgoing = python "$TESTDIR/printenv.py" preoutgoing
   > outgoing = python "$TESTDIR/printenv.py" outgoing
   > EOF
   $ hg clone a c
   preoutgoing hook: HG_SOURCE=clone
   outgoing hook: HG_NODE=0000000000000000000000000000000000000000 HG_SOURCE=clone
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -rf c
 
 preoutgoing hook can prevent outgoing changes for local clones
 
   $ echo "preoutgoing.forbid = python \"$TESTDIR/printenv.py\" preoutgoing.forbid 1" >> a/.hg/hgrc
   $ hg clone a zzz
   preoutgoing hook: HG_SOURCE=clone
   preoutgoing.forbid hook: HG_SOURCE=clone
   abort: preoutgoing.forbid hook exited with status 1
   [255]
 
   $ cd "$TESTTMP/b"
 
   $ cat > hooktests.py <<EOF
   > from mercurial import util
   > 
   > uncallable = 0
   > 
   > def printargs(args):
   >     args.pop('ui', None)
   >     args.pop('repo', None)
   >     a = list(args.items())
   >     a.sort()
   >     print 'hook args:'
   >     for k, v in a:
   >        print ' ', k, v
   > 
   > def passhook(**args):
   >     printargs(args)
   > 
   > def failhook(**args):
   >     printargs(args)
   >     return True
   > 
   > class LocalException(Exception):
   >     pass
   > 
   > def raisehook(**args):
   >     raise LocalException('exception from hook')
   > 
   > def aborthook(**args):
   >     raise util.Abort('raise abort from hook')
   > 
   > def brokenhook(**args):
   >     return 1 + {}
   > 
   > def verbosehook(ui, **args):
   >     ui.note('verbose output from hook\n')
   > 
   > def printtags(ui, repo, **args):
   >     print sorted(repo.tags())
   > 
   > class container:
   >     unreachable = 1
   > EOF
 
 test python hooks
 
 #if windows
   $ PYTHONPATH="$TESTTMP/b;$PYTHONPATH"
 #else
   $ PYTHONPATH="$TESTTMP/b:$PYTHONPATH"
 #endif
   $ export PYTHONPATH
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.broken = python:hooktests.brokenhook' >> ../a/.hg/hgrc
   $ hg pull ../a 2>&1 | grep 'raised an exception'
   error: preoutgoing.broken hook raised an exception: unsupported operand type(s) for +: 'int' and 'dict'
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.raise = python:hooktests.raisehook' >> ../a/.hg/hgrc
   $ hg pull ../a 2>&1 | grep 'raised an exception'
   error: preoutgoing.raise hook raised an exception: exception from hook
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.abort = python:hooktests.aborthook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   error: preoutgoing.abort hook failed: raise abort from hook
   abort: raise abort from hook
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.fail = python:hooktests.failhook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   hook args:
     hooktype preoutgoing
     source pull
   abort: preoutgoing.fail hook failed
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.uncallable = python:hooktests.uncallable' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.uncallable hook is invalid ("hooktests.uncallable" is not callable)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.nohook = python:hooktests.nohook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.nohook hook is invalid ("hooktests.nohook" is not defined)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.nomodule = python:nomodule' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.nomodule hook is invalid ("nomodule" not in a module)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.badmodule = python:nomodule.nowhere' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.badmodule hook is invalid (import of "nomodule" failed)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.unreachable = python:hooktests.container.unreachable' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.unreachable hook is invalid (import of "hooktests.container" failed)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.pass = python:hooktests.passhook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   hook args:
     hooktype preoutgoing
     source pull
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   adding remote bookmark quux
   (run 'hg update' to get a working copy)
 
 make sure --traceback works
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'commit.abort = python:hooktests.aborthook' >> .hg/hgrc
 
   $ echo aa > a
   $ hg --traceback commit -d '0 0' -ma 2>&1 | grep '^Traceback'
   Traceback (most recent call last):
 
   $ cd ..
   $ hg init c
   $ cd c
 
   $ cat > hookext.py <<EOF
   > def autohook(**args):
   >     print "Automatically installed hook"
   > 
   > def reposetup(ui, repo):
   >     repo.ui.setconfig("hooks", "commit.auto", autohook)
   > EOF
   $ echo '[extensions]' >> .hg/hgrc
   $ echo 'hookext = hookext.py' >> .hg/hgrc
 
   $ touch foo
   $ hg add foo
   $ hg ci -d '0 0' -m 'add foo'
   Automatically installed hook
   $ echo >> foo
   $ hg ci --debug -d '0 0' -m 'change foo'
   foo
   calling hook commit.auto: hgext_hookext.autohook
   Automatically installed hook
   committed changeset 1:52998019f6252a2b893452765fcb0a47351a5708
 
   $ hg showconfig hooks
   hooks.commit.auto=<function autohook at *> (glob)
 
 test python hook configured with python:[file]:[hook] syntax
 
   $ cd ..
   $ mkdir d
   $ cd d
   $ hg init repo
   $ mkdir hooks
 
   $ cd hooks
   $ cat > testhooks.py <<EOF
   > def testhook(**args):
   >     print 'hook works'
   > EOF
   $ echo '[hooks]' > ../repo/.hg/hgrc
   $ echo "pre-commit.test = python:`pwd`/testhooks.py:testhook" >> ../repo/.hg/hgrc
 
   $ cd ../repo
   $ hg commit -d '0 0'
   hook works
   nothing changed
   [1]
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo "update.ne = python:`pwd`/nonexistent.py:testhook" >> .hg/hgrc
   $ echo "pre-identify.npmd = python:`pwd`/:no_python_module_dir" >> .hg/hgrc
 
   $ hg up null
   loading update.ne hook failed:
   abort: No such file or directory: $TESTTMP/d/repo/nonexistent.py
   [255]
 
   $ hg id
   loading pre-identify.npmd hook failed:
   abort: No module named repo!
   [255]
 
   $ cd ../../b
 
 make sure --traceback works on hook import failure
 
   $ cat > importfail.py <<EOF
   > import somebogusmodule
   > # dereference something in the module to force demandimport to load it
   > somebogusmodule.whatever
   > EOF
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'precommit.importfail = python:importfail.whatever' >> .hg/hgrc
 
   $ echo a >> a
   $ hg --traceback commit -ma 2>&1 | egrep -v '^( +File|    [a-zA-Z(])'
   exception from first failed import attempt:
   Traceback (most recent call last):
   ImportError: No module named somebogusmodule
   exception from second failed import attempt:
   Traceback (most recent call last):
   ImportError: No module named hgext_importfail
   Traceback (most recent call last):
   Abort: precommit.importfail hook is invalid (import of "importfail" failed)
   abort: precommit.importfail hook is invalid (import of "importfail" failed)
 
 Issue1827: Hooks Update & Commit not completely post operation
 
 commit and update hooks should run after command completion
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'commit = hg id' >> .hg/hgrc
   $ echo 'update = hg id' >> .hg/hgrc
   $ echo bb > a
   $ hg ci -ma
   223eafe2750c tip
   $ hg up 0
   cb9a9f314b8b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 make sure --verbose (and --quiet/--debug etc.) are propagated to the local ui
 that is passed to pre/post hooks
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'pre-identify = python:hooktests.verbosehook' >> .hg/hgrc
   $ hg id
   cb9a9f314b8b
   $ hg id --verbose
   calling hook pre-identify: hooktests.verbosehook
   verbose output from hook
   cb9a9f314b8b
 
 Ensure hooks can be prioritized
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'pre-identify.a = python:hooktests.verbosehook' >> .hg/hgrc
   $ echo 'pre-identify.b = python:hooktests.verbosehook' >> .hg/hgrc
   $ echo 'priority.pre-identify.b = 1' >> .hg/hgrc
   $ echo 'pre-identify.c = python:hooktests.verbosehook' >> .hg/hgrc
   $ hg id --verbose
   calling hook pre-identify.b: hooktests.verbosehook
   verbose output from hook
   calling hook pre-identify.a: hooktests.verbosehook
   verbose output from hook
   calling hook pre-identify.c: hooktests.verbosehook
   verbose output from hook
   cb9a9f314b8b
 
 new tags must be visible in pretxncommit (issue3210)
 
   $ echo 'pretxncommit.printtags = python:hooktests.printtags' >> .hg/hgrc
   $ hg tag -f foo
   ['a', 'foo', 'tip']
 
 new commits must be visible in pretxnchangegroup (issue3428)
 
   $ cd ..
   $ hg init to
   $ echo '[hooks]' >> to/.hg/hgrc
   $ echo 'pretxnchangegroup = hg --traceback tip' >> to/.hg/hgrc
   $ echo a >> to/a
   $ hg --cwd to ci -Ama
   adding a
   $ hg clone to from
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo aa >> from/a
   $ hg --cwd from ci -mb
   $ hg --cwd from push
   pushing to $TESTTMP/to (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   changeset:   1:9836a07b9b9d
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   

tests/test-http.t

@@ -1,306 +1,307 b''
   $ "$TESTDIR/hghave" serve || exit 80
 
   $ hg init test
   $ cd test
   $ echo foo>foo
   $ mkdir foo.d foo.d/bAr.hg.d foo.d/baR.d.hg
   $ echo foo>foo.d/foo
   $ echo bar>foo.d/bAr.hg.d/BaR
   $ echo bar>foo.d/baR.d.hg/bAR
   $ hg commit -A -m 1
   adding foo
   adding foo.d/bAr.hg.d/BaR
   adding foo.d/baR.d.hg/bAR
   adding foo.d/foo
   $ hg serve -p $HGPORT -d --pid-file=../hg1.pid -E ../error.log
   $ hg --config server.uncompressed=False serve -p $HGPORT1 -d --pid-file=../hg2.pid
 
 Test server address cannot be reused
 
 #if windows
   $ hg serve -p $HGPORT1 2>&1
   abort: cannot start server at ':$HGPORT1': * (glob)
   [255]
 #else
   $ hg serve -p $HGPORT1 2>&1
   abort: cannot start server at ':$HGPORT1': Address already in use
   [255]
 #endif
   $ cd ..
   $ cat hg1.pid hg2.pid >> $DAEMON_PIDS
 
 clone via stream
 
   $ hg clone --uncompressed http://localhost:$HGPORT/ copy 2>&1
   streaming all changes
   6 files to transfer, 606 bytes of data
   transferred * bytes in * seconds (*/sec) (glob)
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg verify -R copy
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 1 changesets, 4 total revisions
 
 try to clone via stream, should use pull instead
 
   $ hg clone --uncompressed http://localhost:$HGPORT1/ copy2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 clone via pull
 
   $ hg clone http://localhost:$HGPORT1/ copy-pull
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg verify -R copy-pull
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 1 changesets, 4 total revisions
   $ cd test
   $ echo bar > bar
   $ hg commit -A -d '1 0' -m 2
   adding bar
   $ cd ..
 
 clone over http with --update
 
   $ hg clone http://localhost:$HGPORT1/ updated --update 0
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 5 changes to 5 files
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -r . -R updated
   changeset:   0:8b6053c928fe
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ rm -rf updated
 
 incoming via HTTP
 
   $ hg clone http://localhost:$HGPORT1/ --rev 0 partial
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd partial
   $ touch LOCAL
   $ hg ci -qAm LOCAL
   $ hg incoming http://localhost:$HGPORT1/ --template '{desc}\n'
   comparing with http://localhost:$HGPORT1/
   searching for changes
   2
   $ cd ..
 
 pull
 
   $ cd copy-pull
   $ echo '[hooks]' >> .hg/hgrc
   $ echo "changegroup = python \"$TESTDIR/printenv.py\" changegroup" >> .hg/hgrc
   $ hg pull
   pulling from http://localhost:$HGPORT1/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   changegroup hook: HG_NODE=5fed3813f7f5e1824344fdc9cf8f63bb662c292d HG_SOURCE=pull HG_URL=http://localhost:$HGPORT1/
   (run 'hg update' to get a working copy)
   $ cd ..
 
 clone from invalid URL
 
   $ hg clone http://localhost:$HGPORT/bad
   abort: HTTP Error 404: Not Found
   [255]
 
 test http authentication
 + use the same server to test server side streaming preference
 
   $ cd test
   $ cat << EOT > userpass.py
   > import base64
   > from mercurial.hgweb import common
   > def perform_authentication(hgweb, req, op):
   >     auth = req.env.get('HTTP_AUTHORIZATION')
   >     if not auth:
   >         raise common.ErrorResponse(common.HTTP_UNAUTHORIZED, 'who',
   >                 [('WWW-Authenticate', 'Basic Realm="mercurial"')])
   >     if base64.b64decode(auth.split()[1]).split(':', 1) != ['user', 'pass']:
   >         raise common.ErrorResponse(common.HTTP_FORBIDDEN, 'no')
   > def extsetup():
   >     common.permhooks.insert(0, perform_authentication)
   > EOT
   $ hg --config extensions.x=userpass.py serve -p $HGPORT2 -d --pid-file=pid \
   >    --config server.preferuncompressed=True \
   >    --config web.push_ssl=False --config web.allow_push=* -A ../access.log
   $ cat pid >> $DAEMON_PIDS
 
   $ cat << EOF > get_pass.py
   > import getpass
   > def newgetpass(arg):
   >   return "pass"
   > getpass.getpass = newgetpass
   > EOF
 
 #if python243
   $ hg id http://localhost:$HGPORT2/
   abort: http authorization required for http://localhost:$HGPORT2/
   [255]
   $ hg id http://localhost:$HGPORT2/
   abort: http authorization required for http://localhost:$HGPORT2/
   [255]
   $ hg id --config ui.interactive=true --config extensions.getpass=get_pass.py http://user@localhost:$HGPORT2/
   http authorization required for http://localhost:$HGPORT2/
   realm: mercurial
   user: user
   password: 5fed3813f7f5
   $ hg id http://user:pass@localhost:$HGPORT2/
   5fed3813f7f5
 #endif
   $ echo '[auth]' >> .hg/hgrc
   $ echo 'l.schemes=http' >> .hg/hgrc
   $ echo 'l.prefix=lo' >> .hg/hgrc
   $ echo 'l.username=user' >> .hg/hgrc
   $ echo 'l.password=pass' >> .hg/hgrc
   $ hg id http://localhost:$HGPORT2/
   5fed3813f7f5
   $ hg id http://localhost:$HGPORT2/
   5fed3813f7f5
   $ hg id http://user@localhost:$HGPORT2/
   5fed3813f7f5
 #if python243
   $ hg clone http://user:pass@localhost:$HGPORT2/ dest 2>&1
   streaming all changes
   7 files to transfer, 916 bytes of data
   transferred * bytes in * seconds (*/sec) (glob)
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg id http://user2@localhost:$HGPORT2/
   abort: http authorization required for http://localhost:$HGPORT2/
   [255]
   $ hg id http://user:pass2@localhost:$HGPORT2/
   abort: HTTP Error 403: no
   [255]
 
   $ hg -R dest tag -r tip top
   $ hg -R dest push http://user:pass@localhost:$HGPORT2/
   pushing to http://user:***@localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   $ hg rollback -q
 
   $ cut -c38- ../access.log
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=branchmap HTTP/1.1" 200 -
   "GET /?cmd=stream_out HTTP/1.1" 401 -
   "GET /?cmd=stream_out HTTP/1.1" 200 -
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=listkeys HTTP/1.1" 403 - x-hgarg-1:namespace=namespaces
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D7f4e523d01f2cc3765ac8934da3d14db775ff872
+  "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=phases
+  "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=phases
   "GET /?cmd=branchmap HTTP/1.1" 200 -
   "GET /?cmd=branchmap HTTP/1.1" 200 -
-  "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=bookmarks
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
   "POST /?cmd=unbundle HTTP/1.1" 200 - x-hgarg-1:heads=686173686564+5eb5abfefeea63c80dd7553bcc3783f37e0c5524
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=phases
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks
 
 #endif
   $ cd ..
 
 clone of serve with repo in root and unserved subrepo (issue2970)
 
   $ hg --cwd test init sub
   $ echo empty > test/sub/empty
   $ hg --cwd test/sub add empty
   $ hg --cwd test/sub commit -qm 'add empty'
   $ hg --cwd test/sub tag -r 0 something
   $ echo sub = sub > test/.hgsub
   $ hg --cwd test add .hgsub
   $ hg --cwd test commit -qm 'add subrepo'
   $ hg clone http://localhost:$HGPORT noslash-clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 7 changes to 7 files
   updating to branch default
   abort: HTTP Error 404: Not Found
   [255]
   $ hg clone http://localhost:$HGPORT/ slash-clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 7 changes to 7 files
   updating to branch default
   abort: HTTP Error 404: Not Found
   [255]
 
 check error log
 
   $ cat error.log

tests/test-obsolete.t

@@ -1,669 +1,670 b''
   $ cat >> $HGRCPATH << EOF
   > [phases]
   > # public changeset are not obsolete
   > publish=false
   > [ui]
   > logtemplate="{rev}:{node|short} ({phase}) [{tags} {bookmarks}] {desc|firstline}\n"
   > EOF
   $ mkcommit() {
   >    echo "$1" > "$1"
   >    hg add "$1"
   >    hg ci -m "add $1"
   > }
   $ getid() {
   >    hg id --debug --hidden -ir "desc('$1')"
   > }
 
   $ cat > debugkeys.py <<EOF
   > def reposetup(ui, repo):
   >     class debugkeysrepo(repo.__class__):
   >         def listkeys(self, namespace):
   >             ui.write('listkeys %s\n' % (namespace,))
   >             return super(debugkeysrepo, self).listkeys(namespace)
   > 
   >     if repo.local():
   >         repo.__class__ = debugkeysrepo
   > EOF
 
   $ hg init tmpa
   $ cd tmpa
   $ mkcommit kill_me
 
 Checking that the feature is properly disabled
 
   $ hg debugobsolete -d '0 0' `getid kill_me` -u babar
   abort: obsolete feature is not enabled on this repo
   [255]
 
 Enabling it
 
   $ cat > ../obs.py << EOF
   > import mercurial.obsolete
   > mercurial.obsolete._enabled = True
   > EOF
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=${TESTTMP}/obs.py" >> $HGRCPATH
 
 Killing a single changeset without replacement
 
   $ hg debugobsolete 0
   abort: changeset references must be full hexadecimal node identifiers
   [255]
   $ hg debugobsolete '00'
   abort: changeset references must be full hexadecimal node identifiers
   [255]
   $ hg debugobsolete -d '0 0' `getid kill_me` -u babar
   $ hg debugobsolete
   97b7c2d76b1845ed3eb988cd612611e72406cef0 0 {'date': '0 0', 'user': 'babar'}
 
 (test that mercurial is not confused)
 
   $ hg up null --quiet # having 0 as parent prevents it to be hidden
   $ hg tip
   -1:000000000000 (public) [tip ] 
   $ hg up --hidden tip --quiet
   $ cd ..
 
 Killing a single changeset with replacement
 
   $ hg init tmpb
   $ cd tmpb
   $ mkcommit a
   $ mkcommit b
   $ mkcommit original_c
   $ hg up "desc('b')"
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mkcommit new_c
   created new head
   $ hg log -r 'hidden()' --template '{rev}:{node|short} {desc}\n' --hidden
   $ hg debugobsolete --flag 12 `getid original_c`  `getid new_c` -d '56 12'
   $ hg log -r 'hidden()' --template '{rev}:{node|short} {desc}\n' --hidden
   2:245bde4270cd add original_c
   $ hg debugrevlog -cd
   # rev p1rev p2rev start   end deltastart base   p1   p2 rawsize totalsize compression heads
       0    -1    -1     0    59          0    0    0    0      58        58           0     1
       1     0    -1    59   118         59   59    0    0      58       116           0     1
       2     1    -1   118   204         59   59   59    0      76       192           0     1
       3     1    -1   204   271        204  204   59    0      66       258           0     2
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
 
 do it again (it read the obsstore before adding new changeset)
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mkcommit new_2_c
   created new head
   $ hg debugobsolete -d '1337 0' `getid new_c` `getid new_2_c`
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
 
 Register two markers with a missing node
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mkcommit new_3_c
   created new head
   $ hg debugobsolete -d '1338 0' `getid new_2_c` 1337133713371337133713371337133713371337
   $ hg debugobsolete -d '1339 0' 1337133713371337133713371337133713371337 `getid new_3_c`
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
 
 Refuse pathological nullid successors
   $ hg debugobsolete -d '9001 0' 1337133713371337133713371337133713371337 0000000000000000000000000000000000000000
   transaction abort!
   rollback completed
   abort: bad obsolescence marker detected: invalid successors nullid
   [255]
 
 Check that graphlog detect that a changeset is obsolete:
 
   $ hg log -G
   @  5:5601fb93a350 (draft) [tip ] add new_3_c
   |
   o  1:7c3bad9141dc (draft) [ ] add b
   |
   o  0:1f0dee641bb7 (draft) [ ] add a
   
 
 check that heads does not report them
 
   $ hg heads
   5:5601fb93a350 (draft) [tip ] add new_3_c
   $ hg heads --hidden
   5:5601fb93a350 (draft) [tip ] add new_3_c
   4:ca819180edb9 (draft) [ ] add new_2_c
   3:cdbce2fbb163 (draft) [ ] add new_c
   2:245bde4270cd (draft) [ ] add original_c
 
 
 check that summary does not report them
 
   $ hg init ../sink
   $ echo '[paths]' >> .hg/hgrc
   $ echo 'default=../sink' >> .hg/hgrc
   $ hg summary --remote
   parent: 5:5601fb93a350 tip
    add new_3_c
   branch: default
   commit: (clean)
   update: (current)
   remote: 3 outgoing
 
   $ hg summary --remote --hidden
   parent: 5:5601fb93a350 tip
    add new_3_c
   branch: default
   commit: (clean)
   update: 3 new changesets, 4 branch heads (merge)
   remote: 3 outgoing
 
 check that various commands work well with filtering
 
   $ hg tip
   5:5601fb93a350 (draft) [tip ] add new_3_c
   $ hg log -r 6
   abort: unknown revision '6'!
   [255]
   $ hg log -r 4
   abort: unknown revision '4'!
   [255]
 
 Check that public changeset are not accounted as obsolete:
 
   $ hg --hidden phase --public 2
   $ hg log -G
   @  5:5601fb93a350 (draft) [tip ] add new_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 And that bumped changeset are detected
 --------------------------------------
 
 If we didn't filtered obsolete changesets out, 3 and 4 would show up too. Also
 note that the bumped changeset (5:5601fb93a350) is not a direct successor of
 the public changeset
 
   $ hg log --hidden -r 'bumped()'
   5:5601fb93a350 (draft) [tip ] add new_3_c
 
 And that we can't push bumped changeset
 
   $ hg push ../tmpa -r 0 --force #(make repo related)
   pushing to ../tmpa
   searching for changes
   warning: repository is unrelated
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   $ hg push ../tmpa
   pushing to ../tmpa
   searching for changes
   abort: push includes bumped changeset: 5601fb93a350!
   [255]
 
 Fixing "bumped" situation
 We need to create a clone of 5 and add a special marker with a flag
 
   $ hg up '5^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg revert -ar 5
   adding new_3_c
   $ hg ci -m 'add n3w_3_c'
   created new head
   $ hg debugobsolete -d '1338 0' --flags 1 `getid new_3_c` `getid n3w_3_c`
   $ hg log -r 'bumped()'
   $ hg log -G
   @  6:6f9641995072 (draft) [tip ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 
 
   $ cd ..
 
 Exchange Test
 ============================
 
 Destination repo does not have any data
 ---------------------------------------
 
 Simple incoming test
 
   $ hg init tmpc
   $ cd tmpc
   $ hg incoming ../tmpb
   comparing with ../tmpb
   0:1f0dee641bb7 (public) [ ] add a
   1:7c3bad9141dc (public) [ ] add b
   2:245bde4270cd (public) [ ] add original_c
   6:6f9641995072 (draft) [tip ] add n3w_3_c
 
 Try to pull markers
 (extinct changeset are excluded but marker are pushed)
 
   $ hg pull ../tmpb
   pulling from ../tmpb
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
 
 Rollback//Transaction support
 
   $ hg debugobsolete -d '1340 0' aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb 0 {'date': '1340 0', 'user': 'test'}
   $ hg rollback -n
   repository tip rolled back to revision 3 (undo debugobsolete)
   $ hg rollback
   repository tip rolled back to revision 3 (undo debugobsolete)
   $ hg debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
 
   $ cd ..
 
 Try to push markers
 
   $ hg init tmpd
   $ hg -R tmpb push tmpd
   pushing to tmpd
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files (+1 heads)
   $ hg -R tmpd debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
 
 Check obsolete keys are exchanged only if source has an obsolete store
 
   $ hg init empty
   $ hg --config extensions.debugkeys=debugkeys.py -R empty push tmpd
   pushing to tmpd
+  listkeys phases
   no changes found
   listkeys phases
   listkeys bookmarks
   [1]
 
 clone support
 (markers are copied and extinct changesets are included to allow hardlinks)
 
   $ hg clone tmpb clone-dest
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R clone-dest log -G --hidden
   @  6:6f9641995072 (draft) [tip ] add n3w_3_c
   |
   | x  5:5601fb93a350 (draft) [ ] add new_3_c
   |/
   | x  4:ca819180edb9 (draft) [ ] add new_2_c
   |/
   | x  3:cdbce2fbb163 (draft) [ ] add new_c
   |/
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
   $ hg -R clone-dest debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
 
 
 Destination repo have existing data
 ---------------------------------------
 
 On pull
 
   $ hg init tmpe
   $ cd tmpe
   $ hg debugobsolete -d '1339 0' 2448244824482448244824482448244824482448 1339133913391339133913391339133913391339
   $ hg pull ../tmpb
   pulling from ../tmpb
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg debugobsolete
   2448244824482448244824482448244824482448 1339133913391339133913391339133913391339 0 {'date': '1339 0', 'user': 'test'}
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
 
 
 On push
 
   $ hg push ../tmpc
   pushing to ../tmpc
   searching for changes
   no changes found
   [1]
   $ hg -R ../tmpc debugobsolete
   245bde4270cd1072a27757984f9cda8ba26f08ca cdbce2fbb16313928851e97e0d85413f3f7eb77f C {'date': '56 12', 'user': 'test'}
   cdbce2fbb16313928851e97e0d85413f3f7eb77f ca819180edb99ed25ceafb3e9584ac287e240b00 0 {'date': '1337 0', 'user': 'test'}
   ca819180edb99ed25ceafb3e9584ac287e240b00 1337133713371337133713371337133713371337 0 {'date': '1338 0', 'user': 'test'}
   1337133713371337133713371337133713371337 5601fb93a350734d935195fee37f4054c529ff39 0 {'date': '1339 0', 'user': 'test'}
   5601fb93a350734d935195fee37f4054c529ff39 6f96419950729f3671185b847352890f074f7557 1 {'date': '1338 0', 'user': 'test'}
   2448244824482448244824482448244824482448 1339133913391339133913391339133913391339 0 {'date': '1339 0', 'user': 'test'}
 
 detect outgoing obsolete and unstable
 ---------------------------------------
 
 
   $ hg log -G
   o  3:6f9641995072 (draft) [tip ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
   $ hg up 'desc("n3w_3_c")'
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mkcommit original_d
   $ mkcommit original_e
   $ hg debugobsolete `getid original_d` -d '0 0'
   $ hg log -r 'obsolete()'
   4:94b33453f93b (draft) [ ] add original_d
   $ hg log -G -r '::unstable()'
   @  5:cda648ca50f5 (draft) [tip ] add original_e
   |
   x  4:94b33453f93b (draft) [ ] add original_d
   |
   o  3:6f9641995072 (draft) [ ] add n3w_3_c
   |
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
 
 refuse to push obsolete changeset
 
   $ hg push ../tmpc/ -r 'desc("original_d")'
   pushing to ../tmpc/
   searching for changes
   abort: push includes obsolete changeset: 94b33453f93b!
   [255]
 
 refuse to push unstable changeset
 
   $ hg push ../tmpc/
   pushing to ../tmpc/
   searching for changes
   abort: push includes unstable changeset: cda648ca50f5!
   [255]
 
 Test that extinct changeset are properly detected
 
   $ hg log -r 'extinct()'
 
 Don't try to push extinct changeset
 
   $ hg init ../tmpf
   $ hg out  ../tmpf
   comparing with ../tmpf
   searching for changes
   0:1f0dee641bb7 (public) [ ] add a
   1:7c3bad9141dc (public) [ ] add b
   2:245bde4270cd (public) [ ] add original_c
   3:6f9641995072 (draft) [ ] add n3w_3_c
   4:94b33453f93b (draft) [ ] add original_d
   5:cda648ca50f5 (draft) [tip ] add original_e
   $ hg push ../tmpf -f # -f because be push unstable too
   pushing to ../tmpf
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 6 changes to 6 files (+1 heads)
 
 no warning displayed
 
   $ hg push ../tmpf
   pushing to ../tmpf
   searching for changes
   no changes found
   [1]
 
 Do not warn about new head when the new head is a successors of a remote one
 
   $ hg log -G
   @  5:cda648ca50f5 (draft) [tip ] add original_e
   |
   x  4:94b33453f93b (draft) [ ] add original_d
   |
   o  3:6f9641995072 (draft) [ ] add n3w_3_c
   |
   | o  2:245bde4270cd (public) [ ] add original_c
   |/
   o  1:7c3bad9141dc (public) [ ] add b
   |
   o  0:1f0dee641bb7 (public) [ ] add a
   
   $ hg up -q 'desc(n3w_3_c)'
   $ mkcommit obsolete_e
   created new head
   $ hg debugobsolete `getid 'original_e'` `getid 'obsolete_e'`
   $ hg outgoing ../tmpf # parasite hg outgoing testin
   comparing with ../tmpf
   searching for changes
   6:3de5eca88c00 (draft) [tip ] add obsolete_e
   $ hg push ../tmpf
   pushing to ../tmpf
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
 
 #if serve
 
 check hgweb does not explode
 ====================================
 
   $ hg unbundle $TESTDIR/bundles/hgweb+obs.hg
   adding changesets
   adding manifests
   adding file changes
   added 62 changesets with 63 changes to 9 files (+60 heads)
   (run 'hg heads .' to see heads, 'hg merge' to merge)
   $ for node in `hg log -r 'desc(babar_)' --template '{node}\n'`;
   > do
   >    hg debugobsolete $node
   > done
   $ hg up tip
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg serve -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 check changelog view
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'shortlog/'
   200 Script output follows
 
 check graph view
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'graph'
   200 Script output follows
 
 check filelog view
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'log/'`hg id --debug --id`/'babar'
   200 Script output follows
 
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'rev/68'
   200 Script output follows
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'rev/67'
   404 Not Found
   [1]
 
 check that web.view config option:
 
   $ "$TESTDIR/killdaemons.py" hg.pid
   $ cat >> .hg/hgrc << EOF
   > [web]
   > view=all
   > EOF
   $ wait
   $ hg serve -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
   $ "$TESTDIR/get-with-headers.py" --headeronly localhost:$HGPORT 'rev/67'
   200 Script output follows
   $ "$TESTDIR/killdaemons.py" hg.pid
 
 Checking _enable=False warning if obsolete marker exists
 
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=!" >> $HGRCPATH
   $ hg log -r tip
   obsolete feature not enabled but 68 markers found!
   68:c15e9edfca13 (draft) [tip ] add celestine
 
 reenable for later test
 
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=${TESTTMP}/obs.py" >> $HGRCPATH
 
 #endif
 
 Test incoming/outcoming with changesets obsoleted remotely, known locally
 ===============================================================================
 
 This test issue 3805
 
   $ hg init repo-issue3805
   $ cd repo-issue3805
   $ echo "foo" > foo
   $ hg ci -Am "A"
   adding foo
   $ hg clone . ../other-issue3805
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "bar" >> foo
   $ hg ci --amend
   $ cd ../other-issue3805
   $ hg log -G
   @  0:193e9254ce7e (draft) [tip ] A
   
   $ hg log -G -R ../repo-issue3805
   @  2:3816541e5485 (draft) [tip ] A
   
   $ hg incoming
   comparing with $TESTTMP/tmpe/repo-issue3805 (glob)
   searching for changes
   2:3816541e5485 (draft) [tip ] A
   $ hg incoming --bundle ../issue3805.hg
   comparing with $TESTTMP/tmpe/repo-issue3805 (glob)
   searching for changes
   2:3816541e5485 (draft) [tip ] A
   $ hg outgoing
   comparing with $TESTTMP/tmpe/repo-issue3805 (glob)
   searching for changes
   no changes found
   [1]
 
 #if serve
 
   $ hg serve -R ../repo-issue3805 -n test -p $HGPORT -d --pid-file=hg.pid -A access.log -E errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg incoming http://localhost:$HGPORT
   comparing with http://localhost:$HGPORT/
   searching for changes
   1:3816541e5485 (public) [tip ] A
   $ hg outgoing http://localhost:$HGPORT
   comparing with http://localhost:$HGPORT/
   searching for changes
   no changes found
   [1]
 
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 
 #endif
 
 This test issue 3814
 
 (nothing to push but locally hidden changeset)
 
   $ cd ..
   $ hg init repo-issue3814
   $ cd repo-issue3805
   $ hg push -r 3816541e5485 ../repo-issue3814
   pushing to ../repo-issue3814
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   $ hg out ../repo-issue3814
   comparing with ../repo-issue3814
   searching for changes
   no changes found
   [1]
 
 Test that a local tag blocks a changeset from being hidden
 
   $ hg tag -l visible -r 0 --hidden
   $ hg log -G
   @  2:3816541e5485 (draft) [tip ] A
   
   x  0:193e9254ce7e (draft) [visible ] A
   
 Test that removing a local tag does not cause some commands to fail
 
   $ hg tag -l -r tip tiptag
   $ hg tags
   tiptag                             2:3816541e5485
   tip                                2:3816541e5485
   visible                            0:193e9254ce7e
   $ hg --config extensions.strip= strip -r tip --no-backup
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg tags
   visible                            0:193e9254ce7e
   tip                                0:193e9254ce7e

tests/test-push-warn.t

@@ -1,774 +1,775 b''
   $ hg init a
   $ cd a
   $ echo foo > t1
   $ hg add t1
   $ hg commit -m "1"
 
   $ cd ..
   $ hg clone a b
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd a
   $ echo foo > t2
   $ hg add t2
   $ hg commit -m "2"
 
   $ cd ../b
   $ echo foo > t3
   $ hg add t3
   $ hg commit -m "3"
 
   $ hg push ../a
   pushing to ../a
   searching for changes
   remote has heads on branch 'default' that are not known locally: 1c9246a22a0a
   abort: push creates new remote head 1e108cc5548c!
   (pull and merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg push --debug ../a
   pushing to ../a
   query 1; heads
   searching for changes
   taking quick initial sample
   searching: 2 queries
   query 2; still undecided: 1, sample size is: 1
   2 total queries
+  listing keys for "phases"
   listing keys for "bookmarks"
   remote has heads on branch 'default' that are not known locally: 1c9246a22a0a
   new remote heads on branch 'default':
    1e108cc5548c
   abort: push creates new remote head 1e108cc5548c!
   (pull and merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg pull ../a
   pulling from ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg push ../a
   pushing to ../a
   searching for changes
   abort: push creates new remote head 1e108cc5548c!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg commit -m "4"
   $ hg push ../a
   pushing to ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files
 
   $ cd ..
 
   $ hg init c
   $ cd c
   $ for i in 0 1 2; do
   >     echo $i >> foo
   >     hg ci -Am $i
   > done
   adding foo
   $ cd ..
 
   $ hg clone c d
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd d
   $ for i in 0 1; do
   >    hg co -C $i
   >    echo d-$i >> foo
   >    hg ci -m d-$i
   > done
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   created new head
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   created new head
 
   $ HGMERGE=true hg merge 3
   merging foo
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m c-d
 
   $ hg push ../c
   pushing to ../c
   searching for changes
   abort: push creates new remote head 6346d66eb9f5!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg push -r 2 ../c
   pushing to ../c
   searching for changes
   no changes found
   [1]
 
   $ hg push -r 3 ../c
   pushing to ../c
   searching for changes
   abort: push creates new remote head a5dda829a167!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg push -v -r 3 -r 4 ../c
   pushing to ../c
   searching for changes
   new remote heads on branch 'default':
    a5dda829a167
    ee8fbc7a0295
   abort: push creates new remote head a5dda829a167!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg push -v -f -r 3 -r 4 ../c
   pushing to ../c
   searching for changes
   2 changesets found
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files (+2 heads)
 
   $ hg push -r 5 ../c
   pushing to ../c
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (-1 heads)
 
   $ hg in ../c
   comparing with ../c
   searching for changes
   no changes found
   [1]
 
 
 Issue450: push -r warns about remote head creation even if no heads
 will be created
 
   $ hg init ../e
   $ hg push -r 0 ../e
   pushing to ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ hg push -r 1 ../e
   pushing to ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ cd ..
 
 
 Issue736: named branches are not considered for detection of
 unmerged heads in "hg push"
 
   $ hg init f
   $ cd f
   $ hg -q branch a
   $ echo 0 > foo
   $ hg -q ci -Am 0
   $ echo 1 > foo
   $ hg -q ci -m 1
   $ hg -q up 0
   $ echo 2 > foo
   $ hg -q ci -m 2
   $ hg -q up 0
   $ hg -q branch b
   $ echo 3 > foo
   $ hg -q ci -m 3
   $ cd ..
 
   $ hg -q clone f g
   $ cd g
 
 Push on existing branch and new branch:
 
   $ hg -q up 1
   $ echo 4 > foo
   $ hg -q ci -m 4
   $ hg -q up 0
   $ echo 5 > foo
   $ hg -q branch c
   $ hg -q ci -m 5
 
   $ hg push ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
   $ hg push -r 4 -r 5 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
 
 Multiple new branches:
 
   $ hg -q branch d
   $ echo 6 > foo
   $ hg -q ci -m 6
 
   $ hg push ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c, d!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
   $ hg push -r 4 -r 6 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c, d!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
   $ cd ../g
 
 
 Fail on multiple head push:
 
   $ hg -q up 1
   $ echo 7 > foo
   $ hg -q ci -m 7
 
   $ hg push -r 4 -r 7 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote head 0b715ef6ff8f on branch 'a'!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
 Push replacement head on existing branches:
 
   $ hg -q up 3
   $ echo 8 > foo
   $ hg -q ci -m 8
 
   $ hg push -r 7 -r 8 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
 
 Merge of branch a to other branch b followed by unrelated push
 on branch a:
 
   $ hg -q up 7
   $ HGMERGE=true hg -q merge 8
   $ hg -q ci -m 9
   $ hg -q up 8
   $ echo 10 > foo
   $ hg -q ci -m 10
 
   $ hg push -r 9 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (-1 heads)
 
   $ hg push -r 10 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
 
 
 Cheating the counting algorithm:
 
   $ hg -q up 9
   $ HGMERGE=true hg -q merge 2
   $ hg -q ci -m 11
   $ hg -q up 1
   $ echo 12 > foo
   $ hg -q ci -m 12
 
   $ hg push -r 11 -r 12 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
 
 Failed push of new named branch:
 
   $ echo 12 > foo
   $ hg -q ci -m 12a
   [1]
   $ hg -q up 11
   $ echo 13 > foo
   $ hg -q branch e
   $ hg -q ci -m 13d
 
   $ hg push -r 12 -r 13 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: e!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
 
 Using --new-branch to push new named branch:
 
   $ hg push --new-branch -r 12 -r 13 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Pushing multi headed new branch:
 
   $ echo 14 > foo
   $ hg -q branch f
   $ hg -q ci -m 14
   $ echo 15 > foo
   $ hg -q ci -m 15
   $ hg -q up 14
   $ echo 16 > foo
   $ hg -q ci -m 16
   $ hg push --branch f --new-branch ../f
   pushing to ../f
   searching for changes
   abort: push creates new branch 'f' with multiple heads
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg push --branch f --new-branch --force ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files (+1 heads)
 
 Checking prepush logic does not allow silently pushing
 multiple new heads but also doesn't report too many heads:
 
   $ cd ..
   $ hg init h
   $ echo init > h/init
   $ hg -R h ci -Am init
   adding init
   $ echo a > h/a
   $ hg -R h ci -Am a
   adding a
   $ hg clone h i
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R h up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b > h/b
   $ hg -R h ci -Am b
   adding b
   created new head
   $ hg -R i up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > i/c
   $ hg -R i ci -Am c
   adding c
   created new head
 
   $ for i in `seq 3`; do hg -R h up -q 0; echo $i > h/b; hg -R h ci -qAm$i; done
 
   $ hg -R i push h
   pushing to h
   searching for changes
   remote has heads on branch 'default' that are not known locally: 534543e22c29 764f8ec07b96 afe7cc7679f5 ce4212fc8847
   abort: push creates new remote head 97bd0c84d346!
   (pull and merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg -R h up -q 0; echo x > h/b; hg -R h ci -qAmx
   $ hg -R i push h
   pushing to h
   searching for changes
   remote has heads on branch 'default' that are not known locally: 18ddb72c4590 534543e22c29 764f8ec07b96 afe7cc7679f5 and 1 others
   abort: push creates new remote head 97bd0c84d346!
   (pull and merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg -R i push h -v
   pushing to h
   searching for changes
   remote has heads on branch 'default' that are not known locally: 18ddb72c4590 534543e22c29 764f8ec07b96 afe7cc7679f5 ce4212fc8847
   new remote heads on branch 'default':
    97bd0c84d346
   abort: push creates new remote head 97bd0c84d346!
   (pull and merge or see "hg help push" for details about pushing new heads)
   [255]
 
 
 Check prepush logic with merged branches:
 
   $ hg init j
   $ hg -R j branch a
   marked working directory as branch a
   (branches are permanent and global, did you want a bookmark?)
   $ echo init > j/foo
   $ hg -R j ci -Am init
   adding foo
   $ hg clone j k
   updating to branch a
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo a1 > j/foo
   $ hg -R j ci -m a1
   $ hg -R k branch b
   marked working directory as branch b
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > k/foo
   $ hg -R k ci -m b
   $ hg -R k up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R k merge b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg -R k ci -m merge
 
   $ hg -R k push -r a j
   pushing to j
   searching for changes
   abort: push creates new remote branches: b!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
 
 Prepush -r should not allow you to sneak in new heads:
 
   $ hg init l
   $ cd l
   $ echo a >> foo
   $ hg -q add foo
   $ hg -q branch a
   $ hg -q ci -ma
   $ hg -q up null
   $ echo a >> foo
   $ hg -q add foo
   $ hg -q branch b
   $ hg -q ci -mb
   $ cd ..
   $ hg -q clone l m -u a
   $ cd m
   $ hg -q merge b
   $ hg -q ci -mmb
   $ hg -q up 0
   $ echo a >> foo
   $ hg -q ci -ma2
   $ hg -q up 2
   $ echo a >> foo
   $ hg -q branch -f b
   $ hg -q ci -mb2
   $ hg -q merge 3
   $ hg -q ci -mma
 
   $ hg push ../l -b b
   pushing to ../l
   searching for changes
   abort: push creates new remote head 451211cc22b0 on branch 'a'!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ cd ..
 
 
 Check prepush with new branch head on former topo non-head:
 
   $ hg init n
   $ cd n
   $ hg branch A
   marked working directory as branch A
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >a
   $ hg ci -Ama
   adding a
   $ hg branch B
   marked working directory as branch B
   (branches are permanent and global, did you want a bookmark?)
   $ echo b >b
   $ hg ci -Amb
   adding b
 
 b is now branch head of B, and a topological head
 a is now branch head of A, but not a topological head
 
   $ hg clone . inner
   updating to branch B
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd inner
   $ hg up B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b1 >b1
   $ hg ci -Amb1
   adding b1
 
 in the clone b1 is now the head of B
 
   $ cd ..
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo a2 >a2
   $ hg ci -Ama2
   adding a2
 
 a2 is now the new branch head of A, and a new topological head
 it replaces a former inner branch head, so it should at most warn about
 A, not B
 
 glog of local:
 
   $ hg log -G --template "{rev}: {branches} {desc}\n"
   @  2: A a2
   |
   | o  1: B b
   |/
   o  0: A a
   
 glog of remote:
 
   $ hg log -G -R inner --template "{rev}: {branches} {desc}\n"
   @  2: B b1
   |
   o  1: B b
   |
   o  0: A a
   
 outgoing:
 
   $ hg out inner --template "{rev}: {branches} {desc}\n"
   comparing with inner
   searching for changes
   2: A a2
 
   $ hg push inner
   pushing to inner
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
 
   $ cd ..
 
 
 Check prepush with new branch head on former topo head:
 
   $ hg init o
   $ cd o
   $ hg branch A
   marked working directory as branch A
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >a
   $ hg ci -Ama
   adding a
   $ hg branch B
   marked working directory as branch B
   (branches are permanent and global, did you want a bookmark?)
   $ echo b >b
   $ hg ci -Amb
   adding b
 
 b is now branch head of B, and a topological head
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo a1 >a1
   $ hg ci -Ama1
   adding a1
 
 a1 is now branch head of A, and a topological head
 
   $ hg clone . inner
   updating to branch A
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd inner
   $ hg up B
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b1 >b1
   $ hg ci -Amb1
   adding b1
 
 in the clone b1 is now the head of B
 
   $ cd ..
   $ echo a2 >a2
   $ hg ci -Ama2
   adding a2
 
 a2 is now the new branch head of A, and a topological head
 it replaces a former topological and branch head, so this should not warn
 
 glog of local:
 
   $ hg log -G --template "{rev}: {branches} {desc}\n"
   @  3: A a2
   |
   o  2: A a1
   |
   | o  1: B b
   |/
   o  0: A a
   
 glog of remote:
 
   $ hg log -G -R inner --template "{rev}: {branches} {desc}\n"
   @  3: B b1
   |
   | o  2: A a1
   | |
   o |  1: B b
   |/
   o  0: A a
   
 outgoing:
 
   $ hg out inner --template "{rev}: {branches} {desc}\n"
   comparing with inner
   searching for changes
   3: A a2
 
   $ hg push inner
   pushing to inner
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ cd ..
 
 
 Check prepush with new branch head and new child of former branch head
 but child is on different branch:
 
   $ hg init p
   $ cd p
   $ hg branch A
   marked working directory as branch A
   (branches are permanent and global, did you want a bookmark?)
   $ echo a0 >a
   $ hg ci -Ama0
   adding a
   $ echo a1 >a
   $ hg ci -ma1
   $ hg up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch B
   marked working directory as branch B
   (branches are permanent and global, did you want a bookmark?)
   $ echo b0 >b
   $ hg ci -Amb0
   adding b
   $ echo b1 >b
   $ hg ci -mb1
 
   $ hg clone . inner
   updating to branch B
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg up A
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch -f B
   marked working directory as branch B
   (branches are permanent and global, did you want a bookmark?)
   $ echo a3 >a
   $ hg ci -ma3
   created new head
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch -f A
   marked working directory as branch A
   (branches are permanent and global, did you want a bookmark?)
   $ echo b3 >b
   $ hg ci -mb3
   created new head
 
 glog of local:
 
   $ hg log -G --template "{rev}: {branches} {desc}\n"
   @  5: A b3
   |
   | o  4: B a3
   | |
   o |  3: B b1
   | |
   o |  2: B b0
    /
   o  1: A a1
   |
   o  0: A a0
   
 glog of remote:
 
   $ hg log -G -R inner --template "{rev}: {branches} {desc}\n"
   @  3: B b1
   |
   o  2: B b0
   
   o  1: A a1
   |
   o  0: A a0
   
 outgoing:
 
   $ hg out inner --template "{rev}: {branches} {desc}\n"
   comparing with inner
   searching for changes
   4: B a3
   5: A b3
 
   $ hg push inner
   pushing to inner
   searching for changes
   abort: push creates new remote head 7d0f4fb6cf04 on branch 'A'!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg push inner -r4 -r5
   pushing to inner
   searching for changes
   abort: push creates new remote head 7d0f4fb6cf04 on branch 'A'!
   (merge or see "hg help push" for details about pushing new heads)
   [255]
 
   $ hg in inner
   comparing with inner
   searching for changes
   no changes found
   [1]
 
   $ cd ..