merge with stable

mercurial/chgserver.py

@@ -1,714 +1,715 b''
 # chgserver.py - command server extension for cHg
 #
 # Copyright 2011 Yuya Nishihara <[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.
 
 """command server extension for cHg
 
 'S' channel (read/write)
     propagate ui.system() request to client
 
 'attachio' command
     attach client's stdio passed by sendmsg()
 
 'chdir' command
     change current directory
 
 'setenv' command
     replace os.environ completely
 
 'setumask' command (DEPRECATED)
 'setumask2' command
     set umask
 
 'validate' command
     reload the config and check if the server is up to date
 
 Config
 ------
 
 ::
 
   [chgserver]
   # how long (in seconds) should an idle chg server exit
   idletimeout = 3600
 
   # whether to skip config or env change checks
   skiphash = False
 """
 
 from __future__ import absolute_import
 
 import inspect
 import os
 import re
 import socket
 import stat
 import struct
 import time
 
 from .i18n import _
 from .pycompat import (
     getattr,
     setattr,
 )
 
 from . import (
     commandserver,
     encoding,
     error,
     extensions,
     node,
     pycompat,
     util,
 )
 
 from .utils import (
     hashutil,
     procutil,
     stringutil,
 )
 
 
 def _hashlist(items):
     """return sha1 hexdigest for a list"""
     return node.hex(hashutil.sha1(stringutil.pprint(items)).digest())
 
 
 # sensitive config sections affecting confighash
 _configsections = [
     b'alias',  # affects global state commands.table
     b'eol',  # uses setconfig('eol', ...)
     b'extdiff',  # uisetup will register new commands
     b'extensions',
+    b'schemes',  # extsetup will update global hg.schemes
 ]
 
 _configsectionitems = [
     (b'commands', b'show.aliasprefix'),  # show.py reads it in extsetup
 ]
 
 # sensitive environment variables affecting confighash
 _envre = re.compile(
     br'''\A(?:
                     CHGHG
                     |HG(?:DEMANDIMPORT|EMITWARNINGS|MODULEPOLICY|PROF|RCPATH)?
                     |HG(?:ENCODING|PLAIN).*
                     |LANG(?:UAGE)?
                     |LC_.*
                     |LD_.*
                     |PATH
                     |PYTHON.*
                     |TERM(?:INFO)?
                     |TZ
                     )\Z''',
     re.X,
 )
 
 
 def _confighash(ui):
     """return a quick hash for detecting config/env changes
 
     confighash is the hash of sensitive config items and environment variables.
 
     for chgserver, it is designed that once confighash changes, the server is
     not qualified to serve its client and should redirect the client to a new
     server. different from mtimehash, confighash change will not mark the
     server outdated and exit since the user can have different configs at the
     same time.
     """
     sectionitems = []
     for section in _configsections:
         sectionitems.append(ui.configitems(section))
     for section, item in _configsectionitems:
         sectionitems.append(ui.config(section, item))
     sectionhash = _hashlist(sectionitems)
     # If $CHGHG is set, the change to $HG should not trigger a new chg server
     if b'CHGHG' in encoding.environ:
         ignored = {b'HG'}
     else:
         ignored = set()
     envitems = [
         (k, v)
         for k, v in pycompat.iteritems(encoding.environ)
         if _envre.match(k) and k not in ignored
     ]
     envhash = _hashlist(sorted(envitems))
     return sectionhash[:6] + envhash[:6]
 
 
 def _getmtimepaths(ui):
     """get a list of paths that should be checked to detect change
 
     The list will include:
     - extensions (will not cover all files for complex extensions)
     - mercurial/__version__.py
     - python binary
     """
     modules = [m for n, m in extensions.extensions(ui)]
     try:
         from . import __version__
 
         modules.append(__version__)
     except ImportError:
         pass
     files = []
     if pycompat.sysexecutable:
         files.append(pycompat.sysexecutable)
     for m in modules:
         try:
             files.append(pycompat.fsencode(inspect.getabsfile(m)))
         except TypeError:
             pass
     return sorted(set(files))
 
 
 def _mtimehash(paths):
     """return a quick hash for detecting file changes
 
     mtimehash calls stat on given paths and calculate a hash based on size and
     mtime of each file. mtimehash does not read file content because reading is
     expensive. therefore it's not 100% reliable for detecting content changes.
     it's possible to return different hashes for same file contents.
     it's also possible to return a same hash for different file contents for
     some carefully crafted situation.
 
     for chgserver, it is designed that once mtimehash changes, the server is
     considered outdated immediately and should no longer provide service.
 
     mtimehash is not included in confighash because we only know the paths of
     extensions after importing them (there is imp.find_module but that faces
     race conditions). We need to calculate confighash without importing.
     """
 
     def trystat(path):
         try:
             st = os.stat(path)
             return (st[stat.ST_MTIME], st.st_size)
         except OSError:
             # could be ENOENT, EPERM etc. not fatal in any case
             pass
 
     return _hashlist(pycompat.maplist(trystat, paths))[:12]
 
 
 class hashstate(object):
     """a structure storing confighash, mtimehash, paths used for mtimehash"""
 
     def __init__(self, confighash, mtimehash, mtimepaths):
         self.confighash = confighash
         self.mtimehash = mtimehash
         self.mtimepaths = mtimepaths
 
     @staticmethod
     def fromui(ui, mtimepaths=None):
         if mtimepaths is None:
             mtimepaths = _getmtimepaths(ui)
         confighash = _confighash(ui)
         mtimehash = _mtimehash(mtimepaths)
         ui.log(
             b'cmdserver',
             b'confighash = %s mtimehash = %s\n',
             confighash,
             mtimehash,
         )
         return hashstate(confighash, mtimehash, mtimepaths)
 
 
 def _newchgui(srcui, csystem, attachio):
     class chgui(srcui.__class__):
         def __init__(self, src=None):
             super(chgui, self).__init__(src)
             if src:
                 self._csystem = getattr(src, '_csystem', csystem)
             else:
                 self._csystem = csystem
 
         def _runsystem(self, cmd, environ, cwd, out):
             # fallback to the original system method if
             #  a. the output stream is not stdout (e.g. stderr, cStringIO),
             #  b. or stdout is redirected by protectfinout(),
             # because the chg client is not aware of these situations and
             # will behave differently (i.e. write to stdout).
             if (
                 out is not self.fout
                 or not util.safehasattr(self.fout, b'fileno')
                 or self.fout.fileno() != procutil.stdout.fileno()
                 or self._finoutredirected
             ):
                 return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
             self.flush()
             return self._csystem(cmd, procutil.shellenviron(environ), cwd)
 
         def _runpager(self, cmd, env=None):
             self._csystem(
                 cmd,
                 procutil.shellenviron(env),
                 type=b'pager',
                 cmdtable={b'attachio': attachio},
             )
             return True
 
     return chgui(srcui)
 
 
 def _loadnewui(srcui, args, cdebug):
     from . import dispatch  # avoid cycle
 
     newui = srcui.__class__.load()
     for a in [b'fin', b'fout', b'ferr', b'environ']:
         setattr(newui, a, getattr(srcui, a))
     if util.safehasattr(srcui, b'_csystem'):
         newui._csystem = srcui._csystem
 
     # command line args
     options = dispatch._earlyparseopts(newui, args)
     dispatch._parseconfig(newui, options[b'config'])
 
     # stolen from tortoisehg.util.copydynamicconfig()
     for section, name, value in srcui.walkconfig():
         source = srcui.configsource(section, name)
         if b':' in source or source == b'--config' or source.startswith(b'$'):
             # path:line or command line, or environ
             continue
         newui.setconfig(section, name, value, source)
 
     # load wd and repo config, copied from dispatch.py
     cwd = options[b'cwd']
     cwd = cwd and os.path.realpath(cwd) or None
     rpath = options[b'repository']
     path, newlui = dispatch._getlocal(newui, rpath, wd=cwd)
 
     extensions.populateui(newui)
     commandserver.setuplogging(newui, fp=cdebug)
     if newui is not newlui:
         extensions.populateui(newlui)
         commandserver.setuplogging(newlui, fp=cdebug)
 
     return (newui, newlui)
 
 
 class channeledsystem(object):
     """Propagate ui.system() request in the following format:
 
     payload length (unsigned int),
     type, '\0',
     cmd, '\0',
     cwd, '\0',
     envkey, '=', val, '\0',
     ...
     envkey, '=', val
 
     if type == 'system', waits for:
 
     exitcode length (unsigned int),
     exitcode (int)
 
     if type == 'pager', repetitively waits for a command name ending with '\n'
     and executes it defined by cmdtable, or exits the loop if the command name
     is empty.
     """
 
     def __init__(self, in_, out, channel):
         self.in_ = in_
         self.out = out
         self.channel = channel
 
     def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None):
         args = [type, procutil.quotecommand(cmd), os.path.abspath(cwd or b'.')]
         args.extend(b'%s=%s' % (k, v) for k, v in pycompat.iteritems(environ))
         data = b'\0'.join(args)
         self.out.write(struct.pack(b'>cI', self.channel, len(data)))
         self.out.write(data)
         self.out.flush()
 
         if type == b'system':
             length = self.in_.read(4)
             (length,) = struct.unpack(b'>I', length)
             if length != 4:
                 raise error.Abort(_(b'invalid response'))
             (rc,) = struct.unpack(b'>i', self.in_.read(4))
             return rc
         elif type == b'pager':
             while True:
                 cmd = self.in_.readline()[:-1]
                 if not cmd:
                     break
                 if cmdtable and cmd in cmdtable:
                     cmdtable[cmd]()
                 else:
                     raise error.Abort(_(b'unexpected command: %s') % cmd)
         else:
             raise error.ProgrammingError(b'invalid S channel type: %s' % type)
 
 
 _iochannels = [
     # server.ch, ui.fp, mode
     (b'cin', b'fin', 'rb'),
     (b'cout', b'fout', 'wb'),
     (b'cerr', b'ferr', 'wb'),
 ]
 
 
 class chgcmdserver(commandserver.server):
     def __init__(
         self, ui, repo, fin, fout, sock, prereposetups, hashstate, baseaddress
     ):
         super(chgcmdserver, self).__init__(
             _newchgui(ui, channeledsystem(fin, fout, b'S'), self.attachio),
             repo,
             fin,
             fout,
             prereposetups,
         )
         self.clientsock = sock
         self._ioattached = False
         self._oldios = []  # original (self.ch, ui.fp, fd) before "attachio"
         self.hashstate = hashstate
         self.baseaddress = baseaddress
         if hashstate is not None:
             self.capabilities = self.capabilities.copy()
             self.capabilities[b'validate'] = chgcmdserver.validate
 
     def cleanup(self):
         super(chgcmdserver, self).cleanup()
         # dispatch._runcatch() does not flush outputs if exception is not
         # handled by dispatch._dispatch()
         self.ui.flush()
         self._restoreio()
         self._ioattached = False
 
     def attachio(self):
         """Attach to client's stdio passed via unix domain socket; all
         channels except cresult will no longer be used
         """
         # tell client to sendmsg() with 1-byte payload, which makes it
         # distinctive from "attachio\n" command consumed by client.read()
         self.clientsock.sendall(struct.pack(b'>cI', b'I', 1))
         clientfds = util.recvfds(self.clientsock.fileno())
         self.ui.log(b'chgserver', b'received fds: %r\n', clientfds)
 
         ui = self.ui
         ui.flush()
         self._saveio()
         for fd, (cn, fn, mode) in zip(clientfds, _iochannels):
             assert fd > 0
             fp = getattr(ui, fn)
             os.dup2(fd, fp.fileno())
             os.close(fd)
             if self._ioattached:
                 continue
             # reset buffering mode when client is first attached. as we want
             # to see output immediately on pager, the mode stays unchanged
             # when client re-attached. ferr is unchanged because it should
             # be unbuffered no matter if it is a tty or not.
             if fn == b'ferr':
                 newfp = fp
             else:
                 # make it line buffered explicitly because the default is
                 # decided on first write(), where fout could be a pager.
                 if fp.isatty():
                     bufsize = 1  # line buffered
                 else:
                     bufsize = -1  # system default
                 newfp = os.fdopen(fp.fileno(), mode, bufsize)
                 setattr(ui, fn, newfp)
             setattr(self, cn, newfp)
 
         self._ioattached = True
         self.cresult.write(struct.pack(b'>i', len(clientfds)))
 
     def _saveio(self):
         if self._oldios:
             return
         ui = self.ui
         for cn, fn, _mode in _iochannels:
             ch = getattr(self, cn)
             fp = getattr(ui, fn)
             fd = os.dup(fp.fileno())
             self._oldios.append((ch, fp, fd))
 
     def _restoreio(self):
         ui = self.ui
         for (ch, fp, fd), (cn, fn, _mode) in zip(self._oldios, _iochannels):
             newfp = getattr(ui, fn)
             # close newfp while it's associated with client; otherwise it
             # would be closed when newfp is deleted
             if newfp is not fp:
                 newfp.close()
             # restore original fd: fp is open again
             os.dup2(fd, fp.fileno())
             os.close(fd)
             setattr(self, cn, ch)
             setattr(ui, fn, fp)
         del self._oldios[:]
 
     def validate(self):
         """Reload the config and check if the server is up to date
 
         Read a list of '\0' separated arguments.
         Write a non-empty list of '\0' separated instruction strings or '\0'
         if the list is empty.
         An instruction string could be either:
             - "unlink $path", the client should unlink the path to stop the
               outdated server.
             - "redirect $path", the client should attempt to connect to $path
               first. If it does not work, start a new server. It implies
               "reconnect".
             - "exit $n", the client should exit directly with code n.
               This may happen if we cannot parse the config.
             - "reconnect", the client should close the connection and
               reconnect.
         If neither "reconnect" nor "redirect" is included in the instruction
         list, the client can continue with this server after completing all
         the instructions.
         """
         from . import dispatch  # avoid cycle
 
         args = self._readlist()
         try:
             self.ui, lui = _loadnewui(self.ui, args, self.cdebug)
         except error.ParseError as inst:
             dispatch._formatparse(self.ui.warn, inst)
             self.ui.flush()
             self.cresult.write(b'exit 255')
             return
         except error.Abort as inst:
             self.ui.error(_(b"abort: %s\n") % inst)
             if inst.hint:
                 self.ui.error(_(b"(%s)\n") % inst.hint)
             self.ui.flush()
             self.cresult.write(b'exit 255')
             return
         newhash = hashstate.fromui(lui, self.hashstate.mtimepaths)
         insts = []
         if newhash.mtimehash != self.hashstate.mtimehash:
             addr = _hashaddress(self.baseaddress, self.hashstate.confighash)
             insts.append(b'unlink %s' % addr)
             # mtimehash is empty if one or more extensions fail to load.
             # to be compatible with hg, still serve the client this time.
             if self.hashstate.mtimehash:
                 insts.append(b'reconnect')
         if newhash.confighash != self.hashstate.confighash:
             addr = _hashaddress(self.baseaddress, newhash.confighash)
             insts.append(b'redirect %s' % addr)
         self.ui.log(b'chgserver', b'validate: %s\n', stringutil.pprint(insts))
         self.cresult.write(b'\0'.join(insts) or b'\0')
 
     def chdir(self):
         """Change current directory
 
         Note that the behavior of --cwd option is bit different from this.
         It does not affect --config parameter.
         """
         path = self._readstr()
         if not path:
             return
         self.ui.log(b'chgserver', b"chdir to '%s'\n", path)
         os.chdir(path)
 
     def setumask(self):
         """Change umask (DEPRECATED)"""
         # BUG: this does not follow the message frame structure, but kept for
         # backward compatibility with old chg clients for some time
         self._setumask(self._read(4))
 
     def setumask2(self):
         """Change umask"""
         data = self._readstr()
         if len(data) != 4:
             raise ValueError(b'invalid mask length in setumask2 request')
         self._setumask(data)
 
     def _setumask(self, data):
         mask = struct.unpack(b'>I', data)[0]
         self.ui.log(b'chgserver', b'setumask %r\n', mask)
         os.umask(mask)
 
     def runcommand(self):
         # pager may be attached within the runcommand session, which should
         # be detached at the end of the session. otherwise the pager wouldn't
         # receive EOF.
         globaloldios = self._oldios
         self._oldios = []
         try:
             return super(chgcmdserver, self).runcommand()
         finally:
             self._restoreio()
             self._oldios = globaloldios
 
     def setenv(self):
         """Clear and update os.environ
 
         Note that not all variables can make an effect on the running process.
         """
         l = self._readlist()
         try:
             newenv = dict(s.split(b'=', 1) for s in l)
         except ValueError:
             raise ValueError(b'unexpected value in setenv request')
         self.ui.log(b'chgserver', b'setenv: %r\n', sorted(newenv.keys()))
 
         encoding.environ.clear()
         encoding.environ.update(newenv)
 
     capabilities = commandserver.server.capabilities.copy()
     capabilities.update(
         {
             b'attachio': attachio,
             b'chdir': chdir,
             b'runcommand': runcommand,
             b'setenv': setenv,
             b'setumask': setumask,
             b'setumask2': setumask2,
         }
     )
 
     if util.safehasattr(procutil, b'setprocname'):
 
         def setprocname(self):
             """Change process title"""
             name = self._readstr()
             self.ui.log(b'chgserver', b'setprocname: %r\n', name)
             procutil.setprocname(name)
 
         capabilities[b'setprocname'] = setprocname
 
 
 def _tempaddress(address):
     return b'%s.%d.tmp' % (address, os.getpid())
 
 
 def _hashaddress(address, hashstr):
     # if the basename of address contains '.', use only the left part. this
     # makes it possible for the client to pass 'server.tmp$PID' and follow by
     # an atomic rename to avoid locking when spawning new servers.
     dirname, basename = os.path.split(address)
     basename = basename.split(b'.', 1)[0]
     return b'%s-%s' % (os.path.join(dirname, basename), hashstr)
 
 
 class chgunixservicehandler(object):
     """Set of operations for chg services"""
 
     pollinterval = 1  # [sec]
 
     def __init__(self, ui):
         self.ui = ui
         self._idletimeout = ui.configint(b'chgserver', b'idletimeout')
         self._lastactive = time.time()
 
     def bindsocket(self, sock, address):
         self._inithashstate(address)
         self._checkextensions()
         self._bind(sock)
         self._createsymlink()
         # no "listening at" message should be printed to simulate hg behavior
 
     def _inithashstate(self, address):
         self._baseaddress = address
         if self.ui.configbool(b'chgserver', b'skiphash'):
             self._hashstate = None
             self._realaddress = address
             return
         self._hashstate = hashstate.fromui(self.ui)
         self._realaddress = _hashaddress(address, self._hashstate.confighash)
 
     def _checkextensions(self):
         if not self._hashstate:
             return
         if extensions.notloaded():
             # one or more extensions failed to load. mtimehash becomes
             # meaningless because we do not know the paths of those extensions.
             # set mtimehash to an illegal hash value to invalidate the server.
             self._hashstate.mtimehash = b''
 
     def _bind(self, sock):
         # use a unique temp address so we can stat the file and do ownership
         # check later
         tempaddress = _tempaddress(self._realaddress)
         util.bindunixsocket(sock, tempaddress)
         self._socketstat = os.stat(tempaddress)
         sock.listen(socket.SOMAXCONN)
         # rename will replace the old socket file if exists atomically. the
         # old server will detect ownership change and exit.
         util.rename(tempaddress, self._realaddress)
 
     def _createsymlink(self):
         if self._baseaddress == self._realaddress:
             return
         tempaddress = _tempaddress(self._baseaddress)
         os.symlink(os.path.basename(self._realaddress), tempaddress)
         util.rename(tempaddress, self._baseaddress)
 
     def _issocketowner(self):
         try:
             st = os.stat(self._realaddress)
             return (
                 st.st_ino == self._socketstat.st_ino
                 and st[stat.ST_MTIME] == self._socketstat[stat.ST_MTIME]
             )
         except OSError:
             return False
 
     def unlinksocket(self, address):
         if not self._issocketowner():
             return
         # it is possible to have a race condition here that we may
         # remove another server's socket file. but that's okay
         # since that server will detect and exit automatically and
         # the client will start a new server on demand.
         util.tryunlink(self._realaddress)
 
     def shouldexit(self):
         if not self._issocketowner():
             self.ui.log(
                 b'chgserver', b'%s is not owned, exiting.\n', self._realaddress
             )
             return True
         if time.time() - self._lastactive > self._idletimeout:
             self.ui.log(b'chgserver', b'being idle too long. exiting.\n')
             return True
         return False
 
     def newconnection(self):
         self._lastactive = time.time()
 
     def createcmdserver(self, repo, conn, fin, fout, prereposetups):
         return chgcmdserver(
             self.ui,
             repo,
             fin,
             fout,
             conn,
             prereposetups,
             self._hashstate,
             self._baseaddress,
         )
 
 
 def chgunixservice(ui, repo, opts):
     # CHGINTERNALMARK is set by chg client. It is an indication of things are
     # started by chg so other code can do things accordingly, like disabling
     # demandimport or detecting chg client started by chg client. When executed
     # here, CHGINTERNALMARK is no longer useful and hence dropped to make
     # environ cleaner.
     if b'CHGINTERNALMARK' in encoding.environ:
         del encoding.environ[b'CHGINTERNALMARK']
     # Python3.7+ "coerces" the LC_CTYPE environment variable to a UTF-8 one if
     # it thinks the current value is "C". This breaks the hash computation and
     # causes chg to restart loop.
     if b'CHGORIG_LC_CTYPE' in encoding.environ:
         encoding.environ[b'LC_CTYPE'] = encoding.environ[b'CHGORIG_LC_CTYPE']
         del encoding.environ[b'CHGORIG_LC_CTYPE']
     elif b'CHG_CLEAR_LC_CTYPE' in encoding.environ:
         if b'LC_CTYPE' in encoding.environ:
             del encoding.environ[b'LC_CTYPE']
         del encoding.environ[b'CHG_CLEAR_LC_CTYPE']
 
     if repo:
         # one chgserver can serve multiple repos. drop repo information
         ui.setconfig(b'bundle', b'mainreporoot', b'', b'repo')
     h = chgunixservicehandler(ui)
     return commandserver.unixforkingservice(ui, repo=None, opts=opts, handler=h)

tests/test-chg.t

@@ -1,368 +1,418 b''
 #require chg
 
   $ mkdir log
   $ cp $HGRCPATH $HGRCPATH.unconfigured
   $ cat <<'EOF' >> $HGRCPATH
   > [cmdserver]
   > log = $TESTTMP/log/server.log
   > max-log-files = 1
   > max-log-size = 10 kB
   > EOF
   $ cp $HGRCPATH $HGRCPATH.orig
 
   $ filterlog () {
   >   sed -e 's!^[0-9/]* [0-9:]* ([0-9]*)>!YYYY/MM/DD HH:MM:SS (PID)>!' \
   >       -e 's!\(setprocname\|received fds\|setenv\): .*!\1: ...!' \
   >       -e 's!\(confighash\|mtimehash\) = [0-9a-f]*!\1 = ...!g' \
   >       -e 's!\(in \)[0-9.]*s\b!\1 ...s!g' \
   >       -e 's!\(pid\)=[0-9]*!\1=...!g' \
   >       -e 's!\(/server-\)[0-9a-f]*!\1...!g'
   > }
 
 init repo
 
   $ chg init foo
   $ cd foo
 
 ill-formed config
 
   $ chg status
   $ echo '=brokenconfig' >> $HGRCPATH
   $ chg status
   hg: parse error at * (glob)
   [255]
 
   $ cp $HGRCPATH.orig $HGRCPATH
 
 long socket path
 
   $ sockpath=$TESTTMP/this/path/should/be/longer/than/one-hundred-and-seven/characters/where/107/is/the/typical/size/limit/of/unix-domain-socket
   $ mkdir -p $sockpath
   $ bakchgsockname=$CHGSOCKNAME
   $ CHGSOCKNAME=$sockpath/server
   $ export CHGSOCKNAME
   $ chg root
   $TESTTMP/foo
   $ rm -rf $sockpath
   $ CHGSOCKNAME=$bakchgsockname
   $ export CHGSOCKNAME
 
   $ cd ..
 
 editor
 ------
 
   $ cat >> pushbuffer.py <<EOF
   > def reposetup(ui, repo):
   >     repo.ui.pushbuffer(subproc=True)
   > EOF
 
   $ chg init editor
   $ cd editor
 
 by default, system() should be redirected to the client:
 
   $ touch foo
   $ CHGDEBUG= HGEDITOR=cat chg ci -Am channeled --edit 2>&1 \
   > | egrep "HG:|run 'cat"
   chg: debug: * run 'cat "*"' at '$TESTTMP/editor' (glob)
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added foo
 
 but no redirection should be made if output is captured:
 
   $ touch bar
   $ CHGDEBUG= HGEDITOR=cat chg ci -Am bufferred --edit \
   > --config extensions.pushbuffer="$TESTTMP/pushbuffer.py" 2>&1 \
   > | egrep "HG:|run 'cat"
   [1]
 
 check that commit commands succeeded:
 
   $ hg log -T '{rev}:{desc}\n'
   1:bufferred
   0:channeled
 
   $ cd ..
 
 pager
 -----
 
   $ cat >> fakepager.py <<EOF
   > import sys
   > for line in sys.stdin:
   >     sys.stdout.write('paged! %r\n' % line)
   > EOF
 
 enable pager extension globally, but spawns the master server with no tty:
 
   $ chg init pager
   $ cd pager
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > pager =
   > [pager]
   > pager = "$PYTHON" $TESTTMP/fakepager.py
   > EOF
   $ chg version > /dev/null
   $ touch foo
   $ chg ci -qAm foo
 
 pager should be enabled if the attached client has a tty:
 
   $ chg log -l1 -q --config ui.formatted=True
   paged! '0:1f7b0de80e11\n'
   $ chg log -l1 -q --config ui.formatted=False
   0:1f7b0de80e11
 
 chg waits for pager if runcommand raises
 
   $ cat > $TESTTMP/crash.py <<EOF
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'crash')
   > def pagercrash(ui, repo, *pats, **opts):
   >     ui.write(b'going to crash\n')
   >     raise Exception('.')
   > EOF
 
   $ cat > $TESTTMP/fakepager.py <<EOF
   > from __future__ import absolute_import
   > import sys
   > import time
   > for line in iter(sys.stdin.readline, ''):
   >     if 'crash' in line: # only interested in lines containing 'crash'
   >         # if chg exits when pager is sleeping (incorrectly), the output
   >         # will be captured by the next test case
   >         time.sleep(1)
   >         sys.stdout.write('crash-pager: %s' % line)
   > EOF
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > crash = $TESTTMP/crash.py
   > EOF
 
   $ chg crash --pager=on --config ui.formatted=True 2>/dev/null
   crash-pager: going to crash
   [255]
 
   $ cd ..
 
 server lifecycle
 ----------------
 
 chg server should be restarted on code change, and old server will shut down
 automatically. In this test, we use the following time parameters:
 
  - "sleep 1" to make mtime different
  - "sleep 2" to notice mtime change (polling interval is 1 sec)
 
 set up repository with an extension:
 
   $ chg init extreload
   $ cd extreload
   $ touch dummyext.py
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > dummyext = dummyext.py
   > EOF
 
 isolate socket directory for stable result:
 
   $ OLDCHGSOCKNAME=$CHGSOCKNAME
   $ mkdir chgsock
   $ CHGSOCKNAME=`pwd`/chgsock/server
 
 warm up server:
 
   $ CHGDEBUG= chg log 2>&1 | egrep 'instruction|start'
   chg: debug: * start cmdserver at $TESTTMP/extreload/chgsock/server.* (glob)
 
 new server should be started if extension modified:
 
   $ sleep 1
   $ touch dummyext.py
   $ CHGDEBUG= chg log 2>&1 | egrep 'instruction|start'
   chg: debug: * instruction: unlink $TESTTMP/extreload/chgsock/server-* (glob)
   chg: debug: * instruction: reconnect (glob)
   chg: debug: * start cmdserver at $TESTTMP/extreload/chgsock/server.* (glob)
 
 old server will shut down, while new server should still be reachable:
 
   $ sleep 2
   $ CHGDEBUG= chg log 2>&1 | (egrep 'instruction|start' || true)
 
 socket file should never be unlinked by old server:
 (simulates unowned socket by updating mtime, which makes sure server exits
 at polling cycle)
 
   $ ls chgsock/server-*
   chgsock/server-* (glob)
   $ touch chgsock/server-*
   $ sleep 2
   $ ls chgsock/server-*
   chgsock/server-* (glob)
 
 since no server is reachable from socket file, new server should be started:
 (this test makes sure that old server shut down automatically)
 
   $ CHGDEBUG= chg log 2>&1 | egrep 'instruction|start'
   chg: debug: * start cmdserver at $TESTTMP/extreload/chgsock/server.* (glob)
 
 shut down servers and restore environment:
 
   $ rm -R chgsock
   $ sleep 2
   $ CHGSOCKNAME=$OLDCHGSOCKNAME
   $ cd ..
 
 check that server events are recorded:
 
   $ ls log
   server.log
   server.log.1
 
 print only the last 10 lines, since we aren't sure how many records are
 preserved (since setprocname isn't available on py3, the 10th-most-recent line
 is different when using py3):
 
   $ cat log/server.log.1 log/server.log | tail -10 | filterlog
   YYYY/MM/DD HH:MM:SS (PID)> confighash = ... mtimehash = ... (py3 !)
   YYYY/MM/DD HH:MM:SS (PID)> forked worker process (pid=...)
   YYYY/MM/DD HH:MM:SS (PID)> setprocname: ... (no-py3 !)
   YYYY/MM/DD HH:MM:SS (PID)> received fds: ...
   YYYY/MM/DD HH:MM:SS (PID)> chdir to '$TESTTMP/extreload'
   YYYY/MM/DD HH:MM:SS (PID)> setumask 18
   YYYY/MM/DD HH:MM:SS (PID)> setenv: ...
   YYYY/MM/DD HH:MM:SS (PID)> confighash = ... mtimehash = ...
   YYYY/MM/DD HH:MM:SS (PID)> validate: []
   YYYY/MM/DD HH:MM:SS (PID)> worker process exited (pid=...)
   YYYY/MM/DD HH:MM:SS (PID)> $TESTTMP/extreload/chgsock/server-... is not owned, exiting.
 
+global data mutated by schems
+-----------------------------
+
+  $ hg init schemes
+  $ cd schemes
+
+initial state
+
+  $ cat > .hg/hgrc <<'EOF'
+  > [extensions]
+  > schemes =
+  > [schemes]
+  > foo = https://foo.example.org/
+  > EOF
+  $ hg debugexpandscheme foo://expanded
+  https://foo.example.org/expanded
+  $ hg debugexpandscheme bar://unexpanded
+  bar://unexpanded
+
+add bar
+
+  $ cat > .hg/hgrc <<'EOF'
+  > [extensions]
+  > schemes =
+  > [schemes]
+  > foo = https://foo.example.org/
+  > bar = https://bar.example.org/
+  > EOF
+  $ hg debugexpandscheme foo://expanded
+  https://foo.example.org/expanded
+  $ hg debugexpandscheme bar://expanded
+  https://bar.example.org/expanded
+
+remove foo
+
+  $ cat > .hg/hgrc <<'EOF'
+  > [extensions]
+  > schemes =
+  > [schemes]
+  > bar = https://bar.example.org/
+  > EOF
+  $ hg debugexpandscheme foo://unexpanded
+  foo://unexpanded
+  $ hg debugexpandscheme bar://expanded
+  https://bar.example.org/expanded
+
+  $ cd ..
+
 repository cache
 ----------------
 
   $ rm log/server.log*
   $ cp $HGRCPATH.unconfigured $HGRCPATH
   $ cat <<'EOF' >> $HGRCPATH
   > [cmdserver]
   > log = $TESTTMP/log/server.log
   > max-repo-cache = 1
   > track-log = command, repocache
   > EOF
 
 isolate socket directory for stable result:
 
   $ OLDCHGSOCKNAME=$CHGSOCKNAME
   $ mkdir chgsock
   $ CHGSOCKNAME=`pwd`/chgsock/server
 
 create empty repo and cache it:
 
   $ hg init cached
   $ hg id -R cached
   000000000000 tip
   $ sleep 1
 
 modify repo (and cache will be invalidated):
 
   $ touch cached/a
   $ hg ci -R cached -Am 'add a'
   adding a
   $ sleep 1
 
 read cached repo:
 
   $ hg log -R cached
   changeset:   0:ac82d8b1f7c4
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a
   
   $ sleep 1
 
 discard cached from LRU cache:
 
   $ hg clone cached cached2
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -R cached2
   ac82d8b1f7c4 tip
   $ sleep 1
 
 read uncached repo:
 
   $ hg log -R cached
   changeset:   0:ac82d8b1f7c4
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a
   
   $ sleep 1
 
 shut down servers and restore environment:
 
   $ rm -R chgsock
   $ sleep 2
   $ CHGSOCKNAME=$OLDCHGSOCKNAME
 
 check server log:
 
   $ cat log/server.log | filterlog
+  YYYY/MM/DD HH:MM:SS (PID)> worker process exited (pid=...)
+  YYYY/MM/DD HH:MM:SS (PID)> worker process exited (pid=...)
   YYYY/MM/DD HH:MM:SS (PID)> init cached
   YYYY/MM/DD HH:MM:SS (PID)> id -R cached
   YYYY/MM/DD HH:MM:SS (PID)> loaded repo into cache: $TESTTMP/cached (in  ...s)
   YYYY/MM/DD HH:MM:SS (PID)> repo from cache: $TESTTMP/cached
   YYYY/MM/DD HH:MM:SS (PID)> ci -R cached -Am 'add a'
   YYYY/MM/DD HH:MM:SS (PID)> loaded repo into cache: $TESTTMP/cached (in  ...s)
   YYYY/MM/DD HH:MM:SS (PID)> repo from cache: $TESTTMP/cached
   YYYY/MM/DD HH:MM:SS (PID)> log -R cached
   YYYY/MM/DD HH:MM:SS (PID)> loaded repo into cache: $TESTTMP/cached (in  ...s)
   YYYY/MM/DD HH:MM:SS (PID)> clone cached cached2
   YYYY/MM/DD HH:MM:SS (PID)> id -R cached2
   YYYY/MM/DD HH:MM:SS (PID)> loaded repo into cache: $TESTTMP/cached2 (in  ...s)
   YYYY/MM/DD HH:MM:SS (PID)> log -R cached
   YYYY/MM/DD HH:MM:SS (PID)> loaded repo into cache: $TESTTMP/cached (in  ...s)
 
 Test that chg works (sets to the user's actual LC_CTYPE) even when python
 "coerces" the locale (py3.7+)
 
   $ cat > $TESTTMP/debugenv.py <<EOF
   > from mercurial import encoding
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'debugenv', [], b'', norepo=True)
   > def debugenv(ui):
   >     for k in [b'LC_ALL', b'LC_CTYPE', b'LANG']:
   >         v = encoding.environ.get(k)
   >         if v is not None:
   >             ui.write(b'%s=%s\n' % (k, encoding.environ[k]))
   > EOF
 (hg keeps python's modified LC_CTYPE, chg doesn't)
   $ (unset LC_ALL; unset LANG; LC_CTYPE= "$CHGHG" \
   >    --config extensions.debugenv=$TESTTMP/debugenv.py debugenv)
   LC_CTYPE=C.UTF-8 (py37 !)
   LC_CTYPE= (no-py37 !)
   $ (unset LC_ALL; unset LANG; LC_CTYPE= chg \
   >    --config extensions.debugenv=$TESTTMP/debugenv.py debugenv)
   LC_CTYPE=
   $ (unset LC_ALL; unset LANG; LC_CTYPE=unsupported_value chg \
   >    --config extensions.debugenv=$TESTTMP/debugenv.py debugenv)
   LC_CTYPE=unsupported_value
   $ (unset LC_ALL; unset LANG; LC_CTYPE= chg \
   >    --config extensions.debugenv=$TESTTMP/debugenv.py debugenv)
   LC_CTYPE=
   $ LANG= LC_ALL= LC_CTYPE= chg \
   >    --config extensions.debugenv=$TESTTMP/debugenv.py debugenv
   LC_ALL=
   LC_CTYPE=
   LANG=

tests/test-convert-bzr-directories.t

@@ -1,194 +1,197 b''
 #require bzr
 
   $ . "$TESTDIR/bzr-definitions"
 
+Work around https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=944379
+  $ mkdir -p "${HOME}/.config/breezy"
+
 empty directory
 
   $ mkdir test-empty
   $ cd test-empty
   $ bzr init -q source
   $ cd source
   $ echo content > a
   $ bzr add -q a
   $ bzr commit -q -m 'Initial add'
   $ mkdir empty
   $ bzr add -q empty
   $ bzr commit -q -m 'Empty directory added'
   $ echo content > empty/something
   $ bzr add -q empty/something
   $ bzr commit -q -m 'Added file into directory'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   2 Initial add
   1 Empty directory added
   0 Added file into directory
   $ manifest source-hg 1
   % manifest of 1
   644   a
   $ manifest source-hg tip
   % manifest of tip
   644   a
   644   empty/something
   $ cd ..
 
 directory renames
 
   $ mkdir test-dir-rename
   $ cd test-dir-rename
   $ bzr init -q source
   $ cd source
   $ mkdir tpyo
   $ echo content > tpyo/something
   $ bzr add -q tpyo
   $ bzr commit -q -m 'Added directory'
   $ bzr mv tpyo typo
   tpyo => typo
   $ bzr commit -q -m 'Oops, typo'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Added directory
   0 Oops, typo
   $ manifest source-hg 0
   % manifest of 0
   644   tpyo/something
   $ manifest source-hg tip
   % manifest of tip
   644   typo/something
   $ cd ..
 
 nested directory renames
 
   $ mkdir test-nested-dir-rename
   $ cd test-nested-dir-rename
   $ bzr init -q source
   $ cd source
   $ mkdir -p firstlevel/secondlevel/thirdlevel
   $ echo content > firstlevel/secondlevel/file
   $ echo this_needs_to_be_there_too > firstlevel/secondlevel/thirdlevel/stuff
   $ bzr add -q firstlevel
   $ bzr commit -q -m 'Added nested directories'
   $ bzr mv firstlevel/secondlevel secondlevel
   firstlevel/secondlevel => secondlevel
   $ bzr commit -q -m 'Moved secondlevel one level up'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Added nested directories
   0 Moved secondlevel one level up
   $ manifest source-hg tip
   % manifest of tip
   644   secondlevel/file
   644   secondlevel/thirdlevel/stuff
   $ cd ..
 
 directory remove
 
   $ mkdir test-dir-remove
   $ cd test-dir-remove
   $ bzr init -q source
   $ cd source
   $ mkdir src
   $ echo content > src/sourcecode
   $ bzr add -q src
   $ bzr commit -q -m 'Added directory'
   $ bzr rm -q src
   $ bzr commit -q -m 'Removed directory'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Added directory
   0 Removed directory
   $ manifest source-hg 0
   % manifest of 0
   644   src/sourcecode
   $ manifest source-hg tip
   % manifest of tip
   $ cd ..
 
 directory replace
 
   $ mkdir test-dir-replace
   $ cd test-dir-replace
   $ bzr init -q source
   $ cd source
   $ mkdir first second
   $ echo content > first/file
   $ echo morecontent > first/dummy
   $ echo othercontent > second/something
   $ bzr add -q first second
   $ bzr commit -q -m 'Initial layout'
   $ bzr mv first/file second/file
   first/file => second/file
   $ bzr mv first third
   first => third
   $ bzr commit -q -m 'Some conflicting moves'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial layout
   0 Some conflicting moves
   $ manifest source-hg tip
   % manifest of tip
   644   second/file
   644   second/something
   644   third/dummy
   $ cd ..
 
 divergent nested renames (issue3089)
 
   $ mkdir test-divergent-renames
   $ cd test-divergent-renames
   $ bzr init -q source
   $ cd source
   $ mkdir -p a/c
   $ echo a > a/fa
   $ echo c > a/c/fc
   $ bzr add -q a
   $ bzr commit -q -m 'Initial layout'
   $ bzr mv a b
   a => b
   $ mkdir a
   $ bzr add a
   add(ed|ing) a (re)
   $ bzr mv b/c a/c
   b/c => a/c
   $ bzr status
   added:
     a/
   renamed:
     a/? => b/? (re)
     a/c/? => a/c/? (re)
   $ bzr commit -q -m 'Divergent renames'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial layout
   0 Divergent renames
   $ hg -R source-hg st -C --change 1
   A b/fa
     a/fa
   R a/fa
   $ hg -R source-hg manifest -r 1
   a/c/fc
   b/fa
   $ cd ..

tests/test-convert-bzr.t

@@ -1,288 +1,288 b''
 #require bzr
 
   $ . "$TESTDIR/bzr-definitions"
 
 create and rename on the same file in the same step
 
   $ mkdir test-createandrename
   $ cd test-createandrename
   $ bzr init -q source
 
 test empty repo conversion (issue3233)
 
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
 
 back to the rename stuff
 
   $ cd source
   $ echo a > a
   $ echo c > c
   $ echo e > e
   $ bzr add -q a c e
   $ bzr commit -q -m 'Initial add: a, c, e'
   $ bzr mv a b
   a => b
   $ bzr mv c d
   c => d
   $ bzr mv e f
   e => f
   $ echo a2 >> a
   $ mkdir e
   $ bzr add -q a e
   $ bzr commit -q -m 'rename a into b, create a, rename c into d'
   $ cd ..
   $ hg convert source source-hg
   scanning source...
   sorting...
   converting...
   1 Initial add: a, c, e
   0 rename a into b, create a, rename c into d
   $ glog -R source-hg
   o  1@source "rename a into b, create a, rename c into d" files+: [b d f], files-: [c e], files: [a]
   |
   o  0@source "Initial add: a, c, e" files+: [a c e], files-: [], files: []
   
 
 manifest
 
   $ hg manifest -R source-hg -r tip
   a
   b
   d
   f
 
 test --rev option
 
   $ hg convert -r 1 source source-1-hg
   initializing destination source-1-hg repository
   scanning source...
   sorting...
   converting...
   0 Initial add: a, c, e
   $ glog -R source-1-hg
   o  0@source "Initial add: a, c, e" files+: [a c e], files-: [], files: []
   
 
 test with filemap
 
   $ cat > filemap <<EOF
   > exclude a
   > EOF
   $ hg convert --filemap filemap source source-filemap-hg
   initializing destination source-filemap-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial add: a, c, e
   0 rename a into b, create a, rename c into d
   $ hg -R source-filemap-hg manifest -r tip
   b
   d
   f
 
 convert from lightweight checkout
 
   $ bzr checkout --lightweight source source-light
   $ hg convert -s bzr source-light source-light-hg
   initializing destination source-light-hg repository
   warning: lightweight checkouts may cause conversion failures, try with a regular branch instead.
   $TESTTMP/test-createandrename/source-light does not look like a Bazaar repository
   abort: source-light: missing or unsupported repository
   [255]
 
 extract timestamps that look just like hg's {date|isodate}:
 yyyy-mm-dd HH:MM zzzz (no seconds!)
 compare timestamps
 
   $ cd source
   $ bzr log | \
   >   sed '/timestamp/!d;s/.\{15\}\([0-9: -]\{16\}\):.. \(.[0-9]\{4\}\)/\1 \2/' \
   >   > ../bzr-timestamps
   $ cd ..
   $ hg -R source-hg log --template "{date|isodate}\n" > hg-timestamps
   $ cmp bzr-timestamps hg-timestamps || diff -u bzr-timestamps hg-timestamps
   $ cd ..
 
 merge
 
   $ mkdir test-merge
   $ cd test-merge
   $ cat > helper.py <<EOF
   > import sys
   > from bzrlib import workingtree
   > wt = workingtree.WorkingTree.open('.')
   > 
   > message, stamp = sys.argv[1:]
   > wt.commit(message, timestamp=int(stamp))
   > EOF
   $ bzr init -q source
   $ cd source
   $ echo content > a
   $ echo content2 > b
   $ bzr add -q a b
   $ bzr commit -q -m 'Initial add'
   $ cd ..
   $ bzr branch -q source source-improve
   $ cd source
   $ echo more >> a
   $ "$PYTHON" ../helper.py 'Editing a' 100
   $ cd ../source-improve
   $ echo content3 >> b
   $ "$PYTHON" ../helper.py 'Editing b' 200
   $ cd ../source
   $ bzr merge -q ../source-improve
   $ bzr commit -q -m 'Merged improve branch'
   $ cd ..
   $ hg convert --datesort source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   3 Initial add
   2 Editing a
   1 Editing b
   0 Merged improve branch
   $ glog -R source-hg
   o    3@source "Merged improve branch" files+: [], files-: [], files: []
   |\
   | o  2@source-improve "Editing b" files+: [], files-: [], files: [b]
   | |
   o |  1@source "Editing a" files+: [], files-: [], files: [a]
   |/
   o  0@source "Initial add" files+: [a b], files-: [], files: []
   
   $ cd ..
 
 #if symlink execbit
 
 symlinks and executable files
 
   $ mkdir test-symlinks
   $ cd test-symlinks
   $ bzr init -q source
   $ cd source
   $ touch program
   $ chmod +x program
   $ ln -s program altname
   $ mkdir d
   $ echo a > d/a
   $ ln -s a syma
   $ bzr add -q altname program syma d/a
   $ bzr commit -q -m 'Initial setup'
   $ touch newprog
   $ chmod +x newprog
   $ rm altname
   $ ln -s newprog altname
   $ chmod -x program
   $ bzr add -q newprog
   $ bzr commit -q -m 'Symlink changed, x bits changed'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial setup
   0 Symlink changed, x bits changed
   $ manifest source-hg 0
   % manifest of 0
   644 @ altname
   644   d/a
   755 * program
   644 @ syma
   $ manifest source-hg tip
   % manifest of tip
   644 @ altname
   644   d/a
   755 * newprog
   644   program
   644 @ syma
 
 test the symlinks can be recreated
 
   $ cd source-hg
   $ hg up
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg cat syma; echo
   a
   $ cd ../..
 
 #endif
 
 Multiple branches
 
   $ bzr init-repo -q --no-trees repo
   $ bzr init -q repo/trunk
   $ bzr co repo/trunk repo-trunk
   $ cd repo-trunk
   $ echo a > a
   $ bzr add -q a
   $ bzr ci -qm adda
   $ bzr tag trunk-tag
   Created tag trunk-tag.
   $ bzr switch -b branch
   Tree is up to date at revision 1.
-  Switched to branch: *repo/branch/ (glob)
+  Switched to branch*repo/branch/ (glob)
   $ sleep 1
   $ echo b > b
   $ bzr add -q b
   $ bzr ci -qm addb
   $ bzr tag branch-tag
   Created tag branch-tag.
   $ bzr switch --force ../repo/trunk
   Updated to revision 1.
-  Switched to branch: */repo/trunk/ (glob)
+  Switched to branch*/repo/trunk/ (glob)
   $ sleep 1
   $ echo a >> a
   $ bzr ci -qm changea
   $ cd ..
   $ hg convert --datesort repo repo-bzr
   initializing destination repo-bzr repository
   scanning source...
   sorting...
   converting...
   2 adda
   1 addb
   0 changea
   updating tags
   $ (cd repo-bzr; glog)
   o  3@default "update tags" files+: [.hgtags], files-: [], files: []
   |
   o  2@default "changea" files+: [], files-: [], files: [a]
   |
   | o  1@branch "addb" files+: [b], files-: [], files: []
   |/
   o  0@default "adda" files+: [a], files-: [], files: []
   
 
 Test tags (converted identifiers are not stable because bzr ones are
 not and get incorporated in extra fields).
 
   $ hg -R repo-bzr tags
   tip                                3:* (glob)
   branch-tag                         1:* (glob)
   trunk-tag                          0:* (glob)
 
 Nested repositories (issue3254)
 
   $ bzr init-repo -q --no-trees repo/inner
   $ bzr init -q repo/inner/trunk
   $ bzr co repo/inner/trunk inner-trunk
   $ cd inner-trunk
   $ echo b > b
   $ bzr add -q b
   $ bzr ci -qm addb
   $ cd ..
   $ hg convert --datesort repo noinner-bzr
   initializing destination noinner-bzr repository
   scanning source...
   sorting...
   converting...
   2 adda
   1 addb
   0 changea
   updating tags

tests/test-issue4074.t

@@ -1,29 +1,29 b''
 #require no-pure
 
 A script to generate nasty diff worst-case scenarios:
 
   $ cat > s.py <<EOF
   > import random
   > for x in range(100000):
   >     print
   >     if random.randint(0, 100) >= 50:
   >         x += 1
   >     print(hex(x))
   > EOF
 
   $ hg init a
   $ cd a
 
 Check in a big file:
 
   $ "$PYTHON" ../s.py > a
   $ hg ci -qAm0
 
 Modify it:
 
   $ "$PYTHON" ../s.py > a
 
 Time a check-in, should never take more than 10 seconds user time:
 
-  $ hg ci --time -m1
+  $ hg ci --time -m1 --config worker.enabled=no
   time: real .* secs .user [0-9][.].* sys .* (re)

tests/test-remotefilelog-bgprefetch.t

@@ -1,345 +1,357 b''
 #require no-windows
 
   $ . "$TESTDIR/remotefilelog-library.sh"
   $ cat >> $HGRCPATH <<EOF
   > [devel]
   > remotefilelog.bg-wait=True
   > EOF
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > server=True
   > EOF
   $ echo x > x
   $ echo z > z
   $ hg commit -qAm x
   $ echo x2 > x
   $ echo y > y
   $ hg commit -qAm y
   $ echo w > w
   $ rm z
   $ hg commit -qAm w
   $ hg bookmark foo
 
   $ cd ..
 
 # clone the repo
 
   $ hgcloneshallow ssh://user@dummy/master shallow --noupdate
   streaming all changes
   2 files to transfer, 776 bytes of data
   transferred 776 bytes in * seconds (*/sec) (glob)
   searching for changes
   no changes found
 
 # Set the prefetchdays config to zero so that all commits are prefetched
 # no matter what their creation date is. Also set prefetchdelay config
 # to zero so that there is no delay between prefetches.
   $ cd shallow
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > prefetchdays=0
   > prefetchdelay=0
   > EOF
   $ cd ..
 
 # prefetch a revision
   $ cd shallow
 
   $ hg prefetch -r 0
   2 files fetched over 1 fetches - (2 misses, 0.00% hit ratio) over *s (glob)
 
   $ hg cat -r 0 x
   x
 
 # background prefetch on pull when configured
 
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > pullprefetch=bookmark()
   > backgroundprefetch=True
   > EOF
   $ hg strip tip
   saved backup bundle to $TESTTMP/shallow/.hg/strip-backup/6b4b6f66ef8c-b4b8bdaf-backup.hg (glob)
 
   $ clearcache
   $ hg pull
   pulling from ssh://user@dummy/master
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark foo
   added 1 changesets with 0 changes to 0 files
   new changesets 6b4b6f66ef8c
   (run 'hg update' to get a working copy)
   prefetching file contents
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/ef95c5376f34698742fe34f315fd82136f8f68c0
   $TESTTMP/hgcache/master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca
   $TESTTMP/hgcache/master/af/f024fe4ab0fece4091de044c58c9ae4233383a/bb6ccd5dceaa5e9dc220e0dad65e051b94f69a2c
   $TESTTMP/hgcache/repos
 
 # background prefetch with repack on pull when configured
 
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > backgroundrepack=True
   > EOF
   $ hg strip tip
   saved backup bundle to $TESTTMP/shallow/.hg/strip-backup/6b4b6f66ef8c-b4b8bdaf-backup.hg (glob)
 
   $ clearcache
   $ hg pull
   pulling from ssh://user@dummy/master
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark foo
   added 1 changesets with 0 changes to 0 files
   new changesets 6b4b6f66ef8c
   (run 'hg update' to get a working copy)
   prefetching file contents
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/packs/6e8633deba6e544e5f8edbd7b996d6e31a2c42ae.histidx
   $TESTTMP/hgcache/master/packs/6e8633deba6e544e5f8edbd7b996d6e31a2c42ae.histpack
   $TESTTMP/hgcache/master/packs/8ce5ab3745465ab83bba30a7b9c295e0c8404652.dataidx
   $TESTTMP/hgcache/master/packs/8ce5ab3745465ab83bba30a7b9c295e0c8404652.datapack
   $TESTTMP/hgcache/repos
 
 # background prefetch with repack on update when wcprevset configured
 
   $ clearcache
   $ hg up -r 0
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   2 files fetched over 1 fetches - (2 misses, 0.00% hit ratio) over *s (glob)
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0
   $TESTTMP/hgcache/master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a
   $TESTTMP/hgcache/repos
 
   $ hg up -r 1
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   2 files fetched over 2 fetches - (2 misses, 0.00% hit ratio) over *s (glob)
 
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > bgprefetchrevs=.::
   > EOF
 
   $ clearcache
   $ hg up -r 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   * files fetched over * fetches - (* misses, 0.00% hit ratio) over *s (glob)
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histidx
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histpack
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.dataidx
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.datapack
   $TESTTMP/hgcache/repos
 
 # Ensure that file 'w' was prefetched - it was not part of the update operation and therefore
 # could only be downloaded by the background prefetch
 
   $ hg debugdatapack `ls -ct $TESTTMP/hgcache/master/packs/*.datapack | head -n 1`
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407:
   w:
   Node          Delta Base    Delta Length  Blob Size
   bb6ccd5dceaa  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   x:
   Node          Delta Base    Delta Length  Blob Size
   ef95c5376f34  000000000000  3             3
   1406e7411862  ef95c5376f34  14            2
   
   Total:                      17            5         (240.0% bigger)
   y:
   Node          Delta Base    Delta Length  Blob Size
   076f5e2225b3  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   z:
   Node          Delta Base    Delta Length  Blob Size
   69a1b6752270  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
 
 # background prefetch with repack on commit when wcprevset configured
 
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > bgprefetchrevs=0::
   > EOF
 
   $ clearcache
   $ find $CACHEDIR -type f | sort
   $ echo b > b
+.. The following output line about files fetches is globed because it is
+.. flaky, the core the test is checked when checking the cache dir, so
+.. hopefully this flakyness is not hiding any actual bug.
   $ hg commit -qAm b
-  * files fetched over 1 fetches - (* misses, 0.00% hit ratio) over *s (glob)
+  * files fetched over 1 fetches - (* misses, 0.00% hit ratio) over *s (glob) (?)
   $ hg bookmark temporary
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histidx
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histpack
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.dataidx
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.datapack
   $TESTTMP/hgcache/repos
 
 # Ensure that file 'w' was prefetched - it was not part of the commit operation and therefore
 # could only be downloaded by the background prefetch
 
   $ hg debugdatapack `ls -ct $TESTTMP/hgcache/master/packs/*.datapack | head -n 1`
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407:
   w:
   Node          Delta Base    Delta Length  Blob Size
   bb6ccd5dceaa  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   x:
   Node          Delta Base    Delta Length  Blob Size
   ef95c5376f34  000000000000  3             3
   1406e7411862  ef95c5376f34  14            2
   
   Total:                      17            5         (240.0% bigger)
   y:
   Node          Delta Base    Delta Length  Blob Size
   076f5e2225b3  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   z:
   Node          Delta Base    Delta Length  Blob Size
   69a1b6752270  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
 
 # background prefetch with repack on rebase when wcprevset configured
 
   $ hg up -r 2
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (leaving bookmark temporary)
   $ clearcache
   $ find $CACHEDIR -type f | sort
+.. The following output line about files fetches is globed because it is
+.. flaky, the core the test is checked when checking the cache dir, so
+.. hopefully this flakyness is not hiding any actual bug.
   $ hg rebase -s temporary -d foo
   rebasing 3:d9cf06e3b5b6 "b" (temporary tip)
   saved backup bundle to $TESTTMP/shallow/.hg/strip-backup/d9cf06e3b5b6-e5c3dc63-rebase.hg
-  3 files fetched over 1 fetches - (3 misses, 0.00% hit ratio) over *s (glob)
+  ? files fetched over ? fetches - (? misses, 0.00% hit ratio) over *s (glob)
+  $ find $CACHEDIR -type f | sort
+  $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histidx
+  $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histpack
+  $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.dataidx
+  $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.datapack
+  $TESTTMP/hgcache/repos
 
 # Ensure that file 'y' was prefetched - it was not part of the rebase operation and therefore
 # could only be downloaded by the background prefetch
 
   $ hg debugdatapack `ls -ct $TESTTMP/hgcache/master/packs/*.datapack | head -n 1`
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407:
   w:
   Node          Delta Base    Delta Length  Blob Size
   bb6ccd5dceaa  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   x:
   Node          Delta Base    Delta Length  Blob Size
   ef95c5376f34  000000000000  3             3
   1406e7411862  ef95c5376f34  14            2
   
   Total:                      17            5         (240.0% bigger)
   y:
   Node          Delta Base    Delta Length  Blob Size
   076f5e2225b3  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   z:
   Node          Delta Base    Delta Length  Blob Size
   69a1b6752270  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
 
 # Check that foregound prefetch with no arguments blocks until background prefetches finish
 
   $ hg up -r 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ clearcache
   $ hg prefetch --repack
   waiting for lock on prefetching in $TESTTMP/shallow held by process * on host * (glob) (?)
   got lock after * seconds (glob) (?)
   (running background incremental repack)
   * files fetched over 1 fetches - (* misses, 0.00% hit ratio) over *s (glob) (?)
 
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histidx
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histpack
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.dataidx
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.datapack
   $TESTTMP/hgcache/repos
 
 # Ensure that files were prefetched
   $ hg debugdatapack `ls -ct $TESTTMP/hgcache/master/packs/*.datapack | head -n 1`
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407:
   w:
   Node          Delta Base    Delta Length  Blob Size
   bb6ccd5dceaa  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   x:
   Node          Delta Base    Delta Length  Blob Size
   ef95c5376f34  000000000000  3             3
   1406e7411862  ef95c5376f34  14            2
   
   Total:                      17            5         (240.0% bigger)
   y:
   Node          Delta Base    Delta Length  Blob Size
   076f5e2225b3  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   z:
   Node          Delta Base    Delta Length  Blob Size
   69a1b6752270  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
 
 # Check that foreground prefetch fetches revs specified by '. + draft() + bgprefetchrevs + pullprefetch'
 
   $ clearcache
   $ hg prefetch --repack
   waiting for lock on prefetching in $TESTTMP/shallow held by process * on host * (glob) (?)
   got lock after * seconds (glob) (?)
   (running background incremental repack)
   * files fetched over 1 fetches - (* misses, 0.00% hit ratio) over *s (glob) (?)
 
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histidx
   $TESTTMP/hgcache/master/packs/8f1443d44e57fec96f72fb2412e01d2818767ef2.histpack
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.dataidx
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407.datapack
   $TESTTMP/hgcache/repos
 
 # Ensure that files were prefetched
   $ hg debugdatapack `ls -ct $TESTTMP/hgcache/master/packs/*.datapack | head -n 1`
   $TESTTMP/hgcache/master/packs/f4d50848e0b465e9bfd2875f213044c06cfd7407:
   w:
   Node          Delta Base    Delta Length  Blob Size
   bb6ccd5dceaa  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   x:
   Node          Delta Base    Delta Length  Blob Size
   ef95c5376f34  000000000000  3             3
   1406e7411862  ef95c5376f34  14            2
   
   Total:                      17            5         (240.0% bigger)
   y:
   Node          Delta Base    Delta Length  Blob Size
   076f5e2225b3  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
   z:
   Node          Delta Base    Delta Length  Blob Size
   69a1b6752270  000000000000  2             2
   
   Total:                      2             2         (0.0% bigger)
 
 # Test that if data was prefetched and repacked we dont need to prefetch it again
 # It ensures that Mercurial looks not only in loose files but in packs as well
 
   $ hg prefetch --repack
   (running background incremental repack)