cmdserver: forcibly use L channel to read password input (issue3161)

Command server is designed to use the channel protocol even if the server
process is accessible to tty, whereas vanilla hg should be able to read
password from tty in that case.  So it isn't enough to swap sys.stdin:

    # works only if the server process is detached from the console
    sys.stdin = self.fin
    getpass.getpass('')
    sys.stdin = oldin

or test isatty:

    # vanilla hg can't talk to tty if stdin is redirected
    if self._isatty(self.fin):
        return getpass.getpass('')
    else:
        ...

Since ui.nontty flag is undocumented and command-server channels don't provide
isatty(), this change won't affect the other uses of ui._isatty().

issue3161 also suggests to provide some context of messages.  I think it can
be implemented by using the generic templating function.

mercurial/commandserver.py

@@ -1,245 +1,251 b''
 # commandserver.py - communicate with Mercurial's API over a pipe
 #
 #  Copyright 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 _
 import struct
 import sys, os
 import dispatch, encoding, util
 
 logfile = None
 
 def log(*args):
     if not logfile:
         return
 
     for a in args:
         logfile.write(str(a))
 
     logfile.flush()
 
 class channeledoutput(object):
     """
     Write data from in_ to out in the following format:
 
     data length (unsigned int),
     data
     """
     def __init__(self, in_, out, channel):
         self.in_ = in_
         self.out = out
         self.channel = channel
 
     def write(self, data):
         if not data:
             return
         self.out.write(struct.pack('>cI', self.channel, len(data)))
         self.out.write(data)
         self.out.flush()
 
     def __getattr__(self, attr):
         if attr in ('isatty', 'fileno'):
             raise AttributeError(attr)
         return getattr(self.in_, attr)
 
 class channeledinput(object):
     """
     Read data from in_.
 
     Requests for input are written to out in the following format:
     channel identifier - 'I' for plain input, 'L' line based (1 byte)
     how many bytes to send at most (unsigned int),
 
     The client replies with:
     data length (unsigned int), 0 meaning EOF
     data
     """
 
     maxchunksize = 4 * 1024
 
     def __init__(self, in_, out, channel):
         self.in_ = in_
         self.out = out
         self.channel = channel
 
     def read(self, size=-1):
         if size < 0:
             # if we need to consume all the clients input, ask for 4k chunks
             # so the pipe doesn't fill up risking a deadlock
             size = self.maxchunksize
             s = self._read(size, self.channel)
             buf = s
             while s:
                 s = self._read(size, self.channel)
                 buf += s
 
             return buf
         else:
             return self._read(size, self.channel)
 
     def _read(self, size, channel):
         if not size:
             return ''
         assert size > 0
 
         # tell the client we need at most size bytes
         self.out.write(struct.pack('>cI', channel, size))
         self.out.flush()
 
         length = self.in_.read(4)
         length = struct.unpack('>I', length)[0]
         if not length:
             return ''
         else:
             return self.in_.read(length)
 
     def readline(self, size=-1):
         if size < 0:
             size = self.maxchunksize
             s = self._read(size, 'L')
             buf = s
             # keep asking for more until there's either no more or
             # we got a full line
             while s and s[-1] != '\n':
                 s = self._read(size, 'L')
                 buf += s
 
             return buf
         else:
             return self._read(size, 'L')
 
     def __iter__(self):
         return self
 
     def next(self):
         l = self.readline()
         if not l:
             raise StopIteration
         return l
 
     def __getattr__(self, attr):
         if attr in ('isatty', 'fileno'):
             raise AttributeError(attr)
         return getattr(self.in_, attr)
 
 class server(object):
     """
     Listens for commands on stdin, runs them and writes the output on a channel
     based stream to stdout.
     """
     def __init__(self, ui, repo, mode):
         self.cwd = os.getcwd()
 
         logpath = ui.config("cmdserver", "log", None)
         if logpath:
             global logfile
             if logpath == '-':
                 # write log on a special 'd' (debug) channel
                 logfile = channeledoutput(sys.stdout, sys.stdout, 'd')
             else:
                 logfile = open(logpath, 'a')
 
         if repo:
             # the ui here is really the repo ui so take its baseui so we don't
             # end up with its local configuration
             self.ui = repo.baseui
             self.repo = repo
             self.repoui = repo.ui
         else:
             self.ui = ui
             self.repo = self.repoui = None
 
         if mode == 'pipe':
             self.cerr = channeledoutput(sys.stderr, sys.stdout, 'e')
             self.cout = channeledoutput(sys.stdout, sys.stdout, 'o')
             self.cin = channeledinput(sys.stdin, sys.stdout, 'I')
             self.cresult = channeledoutput(sys.stdout, sys.stdout, 'r')
 
             self.client = sys.stdin
         else:
             raise util.Abort(_('unknown mode %s') % mode)
 
     def _read(self, size):
         if not size:
             return ''
 
         data = self.client.read(size)
 
         # is the other end closed?
         if not data:
             raise EOFError
 
         return data
 
     def runcommand(self):
         """ reads a list of \0 terminated arguments, executes
         and writes the return code to the result channel """
 
         length = struct.unpack('>I', self._read(4))[0]
         if not length:
             args = []
         else:
             args = self._read(length).split('\0')
 
         # copy the uis so changes (e.g. --config or --verbose) don't
         # persist between requests
         copiedui = self.ui.copy()
+        uis = [copiedui]
         if self.repo:
             self.repo.baseui = copiedui
             # clone ui without using ui.copy because this is protected
             repoui = self.repoui.__class__(self.repoui)
             repoui.copy = copiedui.copy # redo copy protection
+            uis.append(repoui)
             self.repo.ui = self.repo.dirstate._ui = repoui
             self.repo.invalidateall()
 
+        for ui in uis:
+            # any kind of interaction must use server channels
+            ui.setconfig('ui', 'nontty', 'true', 'commandserver')
+
         req = dispatch.request(args[:], copiedui, self.repo, self.cin,
                                self.cout, self.cerr)
 
         ret = (dispatch.dispatch(req) or 0) & 255 # might return None
 
         # restore old cwd
         if '--cwd' in args:
             os.chdir(self.cwd)
 
         self.cresult.write(struct.pack('>i', int(ret)))
 
     def getencoding(self):
         """ writes the current encoding to the result channel """
         self.cresult.write(encoding.encoding)
 
     def serveone(self):
         cmd = self.client.readline()[:-1]
         if cmd:
             handler = self.capabilities.get(cmd)
             if handler:
                 handler(self)
             else:
                 # clients are expected to check what commands are supported by
                 # looking at the servers capabilities
                 raise util.Abort(_('unknown command %s') % cmd)
 
         return cmd != ''
 
     capabilities = {'runcommand'  : runcommand,
                     'getencoding' : getencoding}
 
     def serve(self):
         hellomsg = 'capabilities: ' + ' '.join(sorted(self.capabilities))
         hellomsg += '\n'
         hellomsg += 'encoding: ' + encoding.encoding
 
         # write the hello msg in -one- chunk
         self.cout.write(hellomsg)
 
         try:
             while self.serveone():
                 pass
         except EOFError:
             # we'll get here if the client disconnected while we were reading
             # its request
             return 1
 
         return 0

mercurial/ui.py

@@ -1,846 +1,851 b''
 # ui.py - user interface bits for mercurial
 #
 # 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 _
 import errno, getpass, os, socket, sys, tempfile, traceback
 import config, scmutil, util, error, formatter
 from node import hex
 
 class ui(object):
     def __init__(self, src=None):
         # _buffers: used for temporary capture of output
         self._buffers = []
         # _bufferstates: Should the temporary capture includes stderr
         self._bufferstates = []
         self.quiet = self.verbose = self.debugflag = self.tracebackflag = False
         self._reportuntrusted = True
         self._ocfg = config.config() # overlay
         self._tcfg = config.config() # trusted
         self._ucfg = config.config() # untrusted
         self._trustusers = set()
         self._trustgroups = set()
         self.callhooks = True
 
         if src:
             self.fout = src.fout
             self.ferr = src.ferr
             self.fin = src.fin
 
             self._tcfg = src._tcfg.copy()
             self._ucfg = src._ucfg.copy()
             self._ocfg = src._ocfg.copy()
             self._trustusers = src._trustusers.copy()
             self._trustgroups = src._trustgroups.copy()
             self.environ = src.environ
             self.callhooks = src.callhooks
             self.fixconfig()
         else:
             self.fout = sys.stdout
             self.ferr = sys.stderr
             self.fin = sys.stdin
 
             # shared read-only environment
             self.environ = os.environ
             # we always trust global config files
             for f in scmutil.rcpath():
                 self.readconfig(f, trust=True)
 
     def copy(self):
         return self.__class__(self)
 
     def formatter(self, topic, opts):
         return formatter.formatter(self, topic, opts)
 
     def _trusted(self, fp, f):
         st = util.fstat(fp)
         if util.isowner(st):
             return True
 
         tusers, tgroups = self._trustusers, self._trustgroups
         if '*' in tusers or '*' in tgroups:
             return True
 
         user = util.username(st.st_uid)
         group = util.groupname(st.st_gid)
         if user in tusers or group in tgroups or user == util.username():
             return True
 
         if self._reportuntrusted:
             self.warn(_('not trusting file %s from untrusted '
                         'user %s, group %s\n') % (f, user, group))
         return False
 
     def readconfig(self, filename, root=None, trust=False,
                    sections=None, remap=None):
         try:
             fp = open(filename)
         except IOError:
             if not sections: # ignore unless we were looking for something
                 return
             raise
 
         cfg = config.config()
         trusted = sections or trust or self._trusted(fp, filename)
 
         try:
             cfg.read(filename, fp, sections=sections, remap=remap)
             fp.close()
         except error.ConfigError, inst:
             if trusted:
                 raise
             self.warn(_("ignored: %s\n") % str(inst))
 
         if self.plain():
             for k in ('debug', 'fallbackencoding', 'quiet', 'slash',
                       'logtemplate', 'style',
                       'traceback', 'verbose'):
                 if k in cfg['ui']:
                     del cfg['ui'][k]
             for k, v in cfg.items('defaults'):
                 del cfg['defaults'][k]
         # Don't remove aliases from the configuration if in the exceptionlist
         if self.plain('alias'):
             for k, v in cfg.items('alias'):
                 del cfg['alias'][k]
 
         if trusted:
             self._tcfg.update(cfg)
             self._tcfg.update(self._ocfg)
         self._ucfg.update(cfg)
         self._ucfg.update(self._ocfg)
 
         if root is None:
             root = os.path.expanduser('~')
         self.fixconfig(root=root)
 
     def fixconfig(self, root=None, section=None):
         if section in (None, 'paths'):
             # expand vars and ~
             # translate paths relative to root (or home) into absolute paths
             root = root or os.getcwd()
             for c in self._tcfg, self._ucfg, self._ocfg:
                 for n, p in c.items('paths'):
                     if not p:
                         continue
                     if '%%' in p:
                         self.warn(_("(deprecated '%%' in path %s=%s from %s)\n")
                                   % (n, p, self.configsource('paths', n)))
                         p = p.replace('%%', '%')
                     p = util.expandpath(p)
                     if not util.hasscheme(p) and not os.path.isabs(p):
                         p = os.path.normpath(os.path.join(root, p))
                     c.set("paths", n, p)
 
         if section in (None, 'ui'):
             # update ui options
             self.debugflag = self.configbool('ui', 'debug')
             self.verbose = self.debugflag or self.configbool('ui', 'verbose')
             self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
             if self.verbose and self.quiet:
                 self.quiet = self.verbose = False
             self._reportuntrusted = self.debugflag or self.configbool("ui",
                 "report_untrusted", True)
             self.tracebackflag = self.configbool('ui', 'traceback', False)
 
         if section in (None, 'trusted'):
             # update trust information
             self._trustusers.update(self.configlist('trusted', 'users'))
             self._trustgroups.update(self.configlist('trusted', 'groups'))
 
     def backupconfig(self, section, item):
         return (self._ocfg.backup(section, item),
                 self._tcfg.backup(section, item),
                 self._ucfg.backup(section, item),)
     def restoreconfig(self, data):
         self._ocfg.restore(data[0])
         self._tcfg.restore(data[1])
         self._ucfg.restore(data[2])
 
     def setconfig(self, section, name, value, source=''):
         for cfg in (self._ocfg, self._tcfg, self._ucfg):
             cfg.set(section, name, value, source)
         self.fixconfig(section=section)
 
     def _data(self, untrusted):
         return untrusted and self._ucfg or self._tcfg
 
     def configsource(self, section, name, untrusted=False):
         return self._data(untrusted).source(section, name) or 'none'
 
     def config(self, section, name, default=None, untrusted=False):
         if isinstance(name, list):
             alternates = name
         else:
             alternates = [name]
 
         for n in alternates:
             value = self._data(untrusted).get(section, n, None)
             if value is not None:
                 name = n
                 break
         else:
             value = default
 
         if self.debugflag and not untrusted and self._reportuntrusted:
             for n in alternates:
                 uvalue = self._ucfg.get(section, n)
                 if uvalue is not None and uvalue != value:
                     self.debug("ignoring untrusted configuration option "
                                "%s.%s = %s\n" % (section, n, uvalue))
         return value
 
     def configpath(self, section, name, default=None, untrusted=False):
         'get a path config item, expanded relative to repo root or config file'
         v = self.config(section, name, default, untrusted)
         if v is None:
             return None
         if not os.path.isabs(v) or "://" not in v:
             src = self.configsource(section, name, untrusted)
             if ':' in src:
                 base = os.path.dirname(src.rsplit(':')[0])
                 v = os.path.join(base, os.path.expanduser(v))
         return v
 
     def configbool(self, section, name, default=False, untrusted=False):
         """parse a configuration element as a boolean
 
         >>> u = ui(); s = 'foo'
         >>> u.setconfig(s, 'true', 'yes')
         >>> u.configbool(s, 'true')
         True
         >>> u.setconfig(s, 'false', 'no')
         >>> u.configbool(s, 'false')
         False
         >>> u.configbool(s, 'unknown')
         False
         >>> u.configbool(s, 'unknown', True)
         True
         >>> u.setconfig(s, 'invalid', 'somevalue')
         >>> u.configbool(s, 'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a boolean ('somevalue')
         """
 
         v = self.config(section, name, None, untrusted)
         if v is None:
             return default
         if isinstance(v, bool):
             return v
         b = util.parsebool(v)
         if b is None:
             raise error.ConfigError(_("%s.%s is not a boolean ('%s')")
                                     % (section, name, v))
         return b
 
     def configint(self, section, name, default=None, untrusted=False):
         """parse a configuration element as an integer
 
         >>> u = ui(); s = 'foo'
         >>> u.setconfig(s, 'int1', '42')
         >>> u.configint(s, 'int1')
         42
         >>> u.setconfig(s, 'int2', '-42')
         >>> u.configint(s, 'int2')
         -42
         >>> u.configint(s, 'unknown', 7)
         7
         >>> u.setconfig(s, 'invalid', 'somevalue')
         >>> u.configint(s, 'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not an integer ('somevalue')
         """
 
         v = self.config(section, name, None, untrusted)
         if v is None:
             return default
         try:
             return int(v)
         except ValueError:
             raise error.ConfigError(_("%s.%s is not an integer ('%s')")
                                     % (section, name, v))
 
     def configbytes(self, section, name, default=0, untrusted=False):
         """parse a configuration element as a quantity in bytes
 
         Units can be specified as b (bytes), k or kb (kilobytes), m or
         mb (megabytes), g or gb (gigabytes).
 
         >>> u = ui(); s = 'foo'
         >>> u.setconfig(s, 'val1', '42')
         >>> u.configbytes(s, 'val1')
         42
         >>> u.setconfig(s, 'val2', '42.5 kb')
         >>> u.configbytes(s, 'val2')
         43520
         >>> u.configbytes(s, 'unknown', '7 MB')
         7340032
         >>> u.setconfig(s, 'invalid', 'somevalue')
         >>> u.configbytes(s, 'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a byte quantity ('somevalue')
         """
 
         value = self.config(section, name)
         if value is None:
             if not isinstance(default, str):
                 return default
             value = default
         try:
             return util.sizetoint(value)
         except error.ParseError:
             raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')")
                                     % (section, name, value))
 
     def configlist(self, section, name, default=None, untrusted=False):
         """parse a configuration element as a list of comma/space separated
         strings
 
         >>> u = ui(); s = 'foo'
         >>> u.setconfig(s, 'list1', 'this,is "a small" ,test')
         >>> u.configlist(s, 'list1')
         ['this', 'is', 'a small', 'test']
         """
 
         def _parse_plain(parts, s, offset):
             whitespace = False
             while offset < len(s) and (s[offset].isspace() or s[offset] == ','):
                 whitespace = True
                 offset += 1
             if offset >= len(s):
                 return None, parts, offset
             if whitespace:
                 parts.append('')
             if s[offset] == '"' and not parts[-1]:
                 return _parse_quote, parts, offset + 1
             elif s[offset] == '"' and parts[-1][-1] == '\\':
                 parts[-1] = parts[-1][:-1] + s[offset]
                 return _parse_plain, parts, offset + 1
             parts[-1] += s[offset]
             return _parse_plain, parts, offset + 1
 
         def _parse_quote(parts, s, offset):
             if offset < len(s) and s[offset] == '"': # ""
                 parts.append('')
                 offset += 1
                 while offset < len(s) and (s[offset].isspace() or
                         s[offset] == ','):
                     offset += 1
                 return _parse_plain, parts, offset
 
             while offset < len(s) and s[offset] != '"':
                 if (s[offset] == '\\' and offset + 1 < len(s)
                         and s[offset + 1] == '"'):
                     offset += 1
                     parts[-1] += '"'
                 else:
                     parts[-1] += s[offset]
                 offset += 1
 
             if offset >= len(s):
                 real_parts = _configlist(parts[-1])
                 if not real_parts:
                     parts[-1] = '"'
                 else:
                     real_parts[0] = '"' + real_parts[0]
                     parts = parts[:-1]
                     parts.extend(real_parts)
                 return None, parts, offset
 
             offset += 1
             while offset < len(s) and s[offset] in [' ', ',']:
                 offset += 1
 
             if offset < len(s):
                 if offset + 1 == len(s) and s[offset] == '"':
                     parts[-1] += '"'
                     offset += 1
                 else:
                     parts.append('')
             else:
                 return None, parts, offset
 
             return _parse_plain, parts, offset
 
         def _configlist(s):
             s = s.rstrip(' ,')
             if not s:
                 return []
             parser, parts, offset = _parse_plain, [''], 0
             while parser:
                 parser, parts, offset = parser(parts, s, offset)
             return parts
 
         result = self.config(section, name, untrusted=untrusted)
         if result is None:
             result = default or []
         if isinstance(result, basestring):
             result = _configlist(result.lstrip(' ,\n'))
             if result is None:
                 result = default or []
         return result
 
     def has_section(self, section, untrusted=False):
         '''tell whether section exists in config.'''
         return section in self._data(untrusted)
 
     def configitems(self, section, untrusted=False):
         items = self._data(untrusted).items(section)
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in self._ucfg.items(section):
                 if self._tcfg.get(section, k) != v:
                     self.debug("ignoring untrusted configuration option "
                                "%s.%s = %s\n" % (section, k, v))
         return items
 
     def walkconfig(self, untrusted=False):
         cfg = self._data(untrusted)
         for section in cfg.sections():
             for name, value in self.configitems(section, untrusted):
                 yield section, name, value
 
     def plain(self, feature=None):
         '''is plain mode active?
 
         Plain mode means that all configuration variables which affect
         the behavior and output of Mercurial should be
         ignored. Additionally, the output should be stable,
         reproducible and suitable for use in scripts or applications.
 
         The only way to trigger plain mode is by setting either the
         `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
 
         The return value can either be
         - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
         - True otherwise
         '''
         if 'HGPLAIN' not in os.environ and 'HGPLAINEXCEPT' not in os.environ:
             return False
         exceptions = os.environ.get('HGPLAINEXCEPT', '').strip().split(',')
         if feature and exceptions:
             return feature not in exceptions
         return True
 
     def username(self):
         """Return default username to be used in commits.
 
         Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
         and stop searching if one of these is set.
         If not found and ui.askusername is True, ask the user, else use
         ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
         """
         user = os.environ.get("HGUSER")
         if user is None:
             user = self.config("ui", "username")
             if user is not None:
                 user = os.path.expandvars(user)
         if user is None:
             user = os.environ.get("EMAIL")
         if user is None and self.configbool("ui", "askusername"):
             user = self.prompt(_("enter a commit username:"), default=None)
         if user is None and not self.interactive():
             try:
                 user = '%s@%s' % (util.getuser(), socket.getfqdn())
                 self.warn(_("no username found, using '%s' instead\n") % user)
             except KeyError:
                 pass
         if not user:
             raise util.Abort(_('no username supplied'),
                              hint=_('use "hg config --edit" '
                                     'to set your username'))
         if "\n" in user:
             raise util.Abort(_("username %s contains a newline\n") % repr(user))
         return user
 
     def shortuser(self, user):
         """Return a short representation of a user name or email address."""
         if not self.verbose:
             user = util.shortuser(user)
         return user
 
     def expandpath(self, loc, default=None):
         """Return repository location relative to cwd or from [paths]"""
         if util.hasscheme(loc) or os.path.isdir(os.path.join(loc, '.hg')):
             return loc
 
         path = self.config('paths', loc)
         if not path and default is not None:
             path = self.config('paths', default)
         return path or loc
 
     def pushbuffer(self, error=False):
         """install a buffer to capture standar output of the ui object
 
         If error is True, the error output will be captured too."""
         self._buffers.append([])
         self._bufferstates.append(error)
 
     def popbuffer(self, labeled=False):
         '''pop the last buffer and return the buffered output
 
         If labeled is True, any labels associated with buffered
         output will be handled. By default, this has no effect
         on the output returned, but extensions and GUI tools may
         handle this argument and returned styled output. If output
         is being buffered so it can be captured and parsed or
         processed, labeled should not be set to True.
         '''
         self._bufferstates.pop()
         return "".join(self._buffers.pop())
 
     def write(self, *args, **opts):
         '''write args to output
 
         By default, this method simply writes to the buffer or stdout,
         but extensions or GUI tools may override this method,
         write_err(), popbuffer(), and label() to style output from
         various parts of hg.
 
         An optional keyword argument, "label", can be passed in.
         This should be a string containing label names separated by
         space. Label names take the form of "topic.type". For example,
         ui.debug() issues a label of "ui.debug".
 
         When labeling output for a specific command, a label of
         "cmdname.type" is recommended. For example, status issues
         a label of "status.modified" for modified files.
         '''
         if self._buffers:
             self._buffers[-1].extend([str(a) for a in args])
         else:
             for a in args:
                 self.fout.write(str(a))
 
     def write_err(self, *args, **opts):
         try:
             if self._bufferstates and self._bufferstates[-1]:
                 return self.write(*args, **opts)
             if not getattr(self.fout, 'closed', False):
                 self.fout.flush()
             for a in args:
                 self.ferr.write(str(a))
             # stderr may be buffered under win32 when redirected to files,
             # including stdout.
             if not getattr(self.ferr, 'closed', False):
                 self.ferr.flush()
         except IOError, inst:
             if inst.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                 raise
 
     def flush(self):
         try: self.fout.flush()
         except (IOError, ValueError): pass
         try: self.ferr.flush()
         except (IOError, ValueError): pass
 
     def _isatty(self, fh):
         if self.configbool('ui', 'nontty', False):
             return False
         return util.isatty(fh)
 
     def interactive(self):
         '''is interactive input allowed?
 
         An interactive session is a session where input can be reasonably read
         from `sys.stdin'. If this function returns false, any attempt to read
         from stdin should fail with an error, unless a sensible default has been
         specified.
 
         Interactiveness is triggered by the value of the `ui.interactive'
         configuration variable or - if it is unset - when `sys.stdin' points
         to a terminal device.
 
         This function refers to input only; for output, see `ui.formatted()'.
         '''
         i = self.configbool("ui", "interactive", None)
         if i is None:
             # some environments replace stdin without implementing isatty
             # usually those are non-interactive
             return self._isatty(self.fin)
 
         return i
 
     def termwidth(self):
         '''how wide is the terminal in columns?
         '''
         if 'COLUMNS' in os.environ:
             try:
                 return int(os.environ['COLUMNS'])
             except ValueError:
                 pass
         return util.termwidth()
 
     def formatted(self):
         '''should formatted output be used?
 
         It is often desirable to format the output to suite the output medium.
         Examples of this are truncating long lines or colorizing messages.
         However, this is not often not desirable when piping output into other
         utilities, e.g. `grep'.
 
         Formatted output is triggered by the value of the `ui.formatted'
         configuration variable or - if it is unset - when `sys.stdout' points
         to a terminal device. Please note that `ui.formatted' should be
         considered an implementation detail; it is not intended for use outside
         Mercurial or its extensions.
 
         This function refers to output only; for input, see `ui.interactive()'.
         This function always returns false when in plain mode, see `ui.plain()'.
         '''
         if self.plain():
             return False
 
         i = self.configbool("ui", "formatted", None)
         if i is None:
             # some environments replace stdout without implementing isatty
             # usually those are non-interactive
             return self._isatty(self.fout)
 
         return i
 
     def _readline(self, prompt=''):
         if self._isatty(self.fin):
             try:
                 # magically add command line editing support, where
                 # available
                 import readline
                 # force demandimport to really load the module
                 readline.read_history_file
                 # windows sometimes raises something other than ImportError
             except Exception:
                 pass
 
         # call write() so output goes through subclassed implementation
         # e.g. color extension on Windows
         self.write(prompt)
 
         # instead of trying to emulate raw_input, swap (self.fin,
         # self.fout) with (sys.stdin, sys.stdout)
         oldin = sys.stdin
         oldout = sys.stdout
         sys.stdin = self.fin
         sys.stdout = self.fout
         line = raw_input(' ')
         sys.stdin = oldin
         sys.stdout = oldout
 
         # When stdin is in binary mode on Windows, it can cause
         # raw_input() to emit an extra trailing carriage return
         if os.linesep == '\r\n' and line and line[-1] == '\r':
             line = line[:-1]
         return line
 
     def prompt(self, msg, default="y"):
         """Prompt user with msg, read response.
         If ui is not interactive, the default is returned.
         """
         if not self.interactive():
             self.write(msg, ' ', default, "\n")
             return default
         try:
             r = self._readline(self.label(msg, 'ui.prompt'))
             if not r:
                 return default
             return r
         except EOFError:
             raise util.Abort(_('response expected'))
 
     @staticmethod
     def extractchoices(prompt):
         """Extract prompt message and list of choices from specified prompt.
 
         This returns tuple "(message, choices)", and "choices" is the
         list of tuple "(response character, text without &)".
         """
         parts = prompt.split('$$')
         msg = parts[0].rstrip(' ')
         choices = [p.strip(' ') for p in parts[1:]]
         return (msg,
                 [(s[s.index('&') + 1].lower(), s.replace('&', '', 1))
                  for s in choices])
 
     def promptchoice(self, prompt, default=0):
         """Prompt user with a message, read response, and ensure it matches
         one of the provided choices. The prompt is formatted as follows:
 
            "would you like fries with that (Yn)? $$ &Yes $$ &No"
 
         The index of the choice is returned. Responses are case
         insensitive. If ui is not interactive, the default is
         returned.
         """
 
         msg, choices = self.extractchoices(prompt)
         resps = [r for r, t in choices]
         while True:
             r = self.prompt(msg, resps[default])
             if r.lower() in resps:
                 return resps.index(r.lower())
             self.write(_("unrecognized response\n"))
 
     def getpass(self, prompt=None, default=None):
         if not self.interactive():
             return default
         try:
             self.write_err(self.label(prompt or _('password: '), 'ui.prompt'))
-            return getpass.getpass('')
+            # disable getpass() only if explicitly specified. it's still valid
+            # to interact with tty even if fin is not a tty.
+            if self.configbool('ui', 'nontty'):
+                return self.fin.readline().rstrip('\n')
+            else:
+                return getpass.getpass('')
         except EOFError:
             raise util.Abort(_('response expected'))
     def status(self, *msg, **opts):
         '''write status message to output (if ui.quiet is False)
 
         This adds an output label of "ui.status".
         '''
         if not self.quiet:
             opts['label'] = opts.get('label', '') + ' ui.status'
             self.write(*msg, **opts)
     def warn(self, *msg, **opts):
         '''write warning message to output (stderr)
 
         This adds an output label of "ui.warning".
         '''
         opts['label'] = opts.get('label', '') + ' ui.warning'
         self.write_err(*msg, **opts)
     def note(self, *msg, **opts):
         '''write note to output (if ui.verbose is True)
 
         This adds an output label of "ui.note".
         '''
         if self.verbose:
             opts['label'] = opts.get('label', '') + ' ui.note'
             self.write(*msg, **opts)
     def debug(self, *msg, **opts):
         '''write debug message to output (if ui.debugflag is True)
 
         This adds an output label of "ui.debug".
         '''
         if self.debugflag:
             opts['label'] = opts.get('label', '') + ' ui.debug'
             self.write(*msg, **opts)
     def edit(self, text, user, extra={}):
         (fd, name) = tempfile.mkstemp(prefix="hg-editor-", suffix=".txt",
                                       text=True)
         try:
             f = os.fdopen(fd, "w")
             f.write(text)
             f.close()
 
             environ = {'HGUSER': user}
             if 'transplant_source' in extra:
                 environ.update({'HGREVISION': hex(extra['transplant_source'])})
             for label in ('source', 'rebase_source'):
                 if label in extra:
                     environ.update({'HGREVISION': extra[label]})
                     break
 
             editor = self.geteditor()
 
             util.system("%s \"%s\"" % (editor, name),
                         environ=environ,
                         onerr=util.Abort, errprefix=_("edit failed"),
                         out=self.fout)
 
             f = open(name)
             t = f.read()
             f.close()
         finally:
             os.unlink(name)
 
         return t
 
     def traceback(self, exc=None, force=False):
         '''print exception traceback if traceback printing enabled or forced.
         only to call in exception handler. returns true if traceback
         printed.'''
         if self.tracebackflag or force:
             if exc is None:
                 exc = sys.exc_info()
             cause = getattr(exc[1], 'cause', None)
 
             if cause is not None:
                 causetb = traceback.format_tb(cause[2])
                 exctb = traceback.format_tb(exc[2])
                 exconly = traceback.format_exception_only(cause[0], cause[1])
 
                 # exclude frame where 'exc' was chained and rethrown from exctb
                 self.write_err('Traceback (most recent call last):\n',
                                ''.join(exctb[:-1]),
                                ''.join(causetb),
                                ''.join(exconly))
             else:
                 traceback.print_exception(exc[0], exc[1], exc[2],
                                           file=self.ferr)
         return self.tracebackflag or force
 
     def geteditor(self):
         '''return editor to use'''
         if sys.platform == 'plan9':
             # vi is the MIPS instruction simulator on Plan 9. We
             # instead default to E to plumb commit messages to
             # avoid confusion.
             editor = 'E'
         else:
             editor = 'vi'
         return (os.environ.get("HGEDITOR") or
                 self.config("ui", "editor") or
                 os.environ.get("VISUAL") or
                 os.environ.get("EDITOR", editor))
 
     def progress(self, topic, pos, item="", unit="", total=None):
         '''show a progress message
 
         With stock hg, this is simply a debug message that is hidden
         by default, but with extensions or GUI tools it may be
         visible. 'topic' is the current operation, 'item' is a
         non-numeric marker of the current position (i.e. the currently
         in-process file), 'pos' is the current numeric position (i.e.
         revision, bytes, etc.), unit is a corresponding unit label,
         and total is the highest expected pos.
 
         Multiple nested topics may be active at a time.
 
         All topics should be marked closed by setting pos to None at
         termination.
         '''
 
         if pos is None or not self.debugflag:
             return
 
         if unit:
             unit = ' ' + unit
         if item:
             item = ' ' + item
 
         if total:
             pct = 100.0 * pos / total
             self.debug('%s:%s %s/%s%s (%4.2f%%)\n'
                      % (topic, item, pos, total, unit, pct))
         else:
             self.debug('%s:%s %s%s\n' % (topic, item, pos, unit))
 
     def log(self, service, *msg, **opts):
         '''hook for logging facility extensions
 
         service should be a readily-identifiable subsystem, which will
         allow filtering.
         message should be a newline-terminated string to log.
         '''
         pass
 
     def label(self, msg, label):
         '''style msg based on supplied label
 
         Like ui.write(), this just returns msg unchanged, but extensions
         and GUI tools can override it to allow styling output without
         writing it.
 
         ui.write(s, 'label') is equivalent to
         ui.write(ui.label(s, 'label')).
         '''
         return msg

tests/test-commandserver.py

@@ -1,340 +1,358 b''
 import sys, os, struct, subprocess, cStringIO, re, shutil
 
 def connect(path=None):
     cmdline = ['hg', 'serve', '--cmdserver', 'pipe']
     if path:
         cmdline += ['-R', path]
 
     server = subprocess.Popen(cmdline, stdin=subprocess.PIPE,
                               stdout=subprocess.PIPE)
 
     return server
 
 def writeblock(server, data):
     server.stdin.write(struct.pack('>I', len(data)))
     server.stdin.write(data)
     server.stdin.flush()
 
 def readchannel(server):
     data = server.stdout.read(5)
     if not data:
         raise EOFError
     channel, length = struct.unpack('>cI', data)
     if channel in 'IL':
         return channel, length
     else:
         return channel, server.stdout.read(length)
 
 def sep(text):
     return text.replace('\\', '/')
 
 def runcommand(server, args, output=sys.stdout, error=sys.stderr, input=None,
                outfilter=lambda x: x):
     print ' runcommand', ' '.join(args)
     sys.stdout.flush()
     server.stdin.write('runcommand\n')
     writeblock(server, '\0'.join(args))
 
     if not input:
         input = cStringIO.StringIO()
 
     while True:
         ch, data = readchannel(server)
         if ch == 'o':
             output.write(outfilter(data))
             output.flush()
         elif ch == 'e':
             error.write(data)
             error.flush()
         elif ch == 'I':
             writeblock(server, input.read(data))
         elif ch == 'L':
             writeblock(server, input.readline(data))
         elif ch == 'r':
             ret, = struct.unpack('>i', data)
             if ret != 0:
                 print ' [%d]' % ret
             return ret
         else:
             print "unexpected channel %c: %r" % (ch, data)
             if ch.isupper():
                 return
 
 def check(func, repopath=None):
     print
     print 'testing %s:' % func.__name__
     print
     sys.stdout.flush()
     server = connect(repopath)
     try:
         return func(server)
     finally:
         server.stdin.close()
         server.wait()
 
 def unknowncommand(server):
     server.stdin.write('unknowncommand\n')
 
 def hellomessage(server):
     ch, data = readchannel(server)
     # escaping python tests output not supported
     print '%c, %r' % (ch, re.sub('encoding: [a-zA-Z0-9-]+', 'encoding: ***',
                                  data))
 
     # run an arbitrary command to make sure the next thing the server sends
     # isn't part of the hello message
     runcommand(server, ['id'])
 
 def checkruncommand(server):
     # hello block
     readchannel(server)
 
     # no args
     runcommand(server, [])
 
     # global options
     runcommand(server, ['id', '--quiet'])
 
     # make sure global options don't stick through requests
     runcommand(server, ['id'])
 
     # --config
     runcommand(server, ['id', '--config', 'ui.quiet=True'])
 
     # make sure --config doesn't stick
     runcommand(server, ['id'])
 
     # negative return code should be masked
     runcommand(server, ['id', '-runknown'])
 
 def inputeof(server):
     readchannel(server)
     server.stdin.write('runcommand\n')
     # close stdin while server is waiting for input
     server.stdin.close()
 
     # server exits with 1 if the pipe closed while reading the command
     print 'server exit code =', server.wait()
 
 def serverinput(server):
     readchannel(server)
 
     patch = """
 # HG changeset patch
 # User test
 # Date 0 0
 # Node ID c103a3dec114d882c98382d684d8af798d09d857
 # Parent  0000000000000000000000000000000000000000
 1
 
 diff -r 000000000000 -r c103a3dec114 a
 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
 +++ b/a	Thu Jan 01 00:00:00 1970 +0000
 @@ -0,0 +1,1 @@
 +1
 """
 
     runcommand(server, ['import', '-'], input=cStringIO.StringIO(patch))
     runcommand(server, ['log'])
 
 def cwd(server):
     """ check that --cwd doesn't persist between requests """
     readchannel(server)
     os.mkdir('foo')
     f = open('foo/bar', 'wb')
     f.write('a')
     f.close()
     runcommand(server, ['--cwd', 'foo', 'st', 'bar'])
     runcommand(server, ['st', 'foo/bar'])
     os.remove('foo/bar')
 
 def localhgrc(server):
     """ check that local configs for the cached repo aren't inherited when -R
     is used """
     readchannel(server)
 
     # the cached repo local hgrc contains ui.foo=bar, so showconfig should
     # show it
     runcommand(server, ['showconfig'])
 
     # but not for this repo
     runcommand(server, ['init', 'foo'])
     runcommand(server, ['-R', 'foo', 'showconfig', 'ui', 'defaults'])
     shutil.rmtree('foo')
 
 def hook(**args):
     print 'hook talking'
     print 'now try to read something: %r' % sys.stdin.read()
 
 def hookoutput(server):
     readchannel(server)
     runcommand(server, ['--config',
                         'hooks.pre-identify=python:test-commandserver.hook',
                         'id'],
                input=cStringIO.StringIO('some input'))
 
 def outsidechanges(server):
     readchannel(server)
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['status'])
     os.system('hg ci -Am2')
     runcommand(server, ['tip'])
     runcommand(server, ['status'])
 
 def bookmarks(server):
     readchannel(server)
     runcommand(server, ['bookmarks'])
 
     # changes .hg/bookmarks
     os.system('hg bookmark -i bm1')
     os.system('hg bookmark -i bm2')
     runcommand(server, ['bookmarks'])
 
     # changes .hg/bookmarks.current
     os.system('hg upd bm1 -q')
     runcommand(server, ['bookmarks'])
 
     runcommand(server, ['bookmarks', 'bm3'])
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['commit', '-Amm'])
     runcommand(server, ['bookmarks'])
 
 def tagscache(server):
     readchannel(server)
     runcommand(server, ['id', '-t', '-r', '0'])
     os.system('hg tag -r 0 foo')
     runcommand(server, ['id', '-t', '-r', '0'])
 
 def setphase(server):
     readchannel(server)
     runcommand(server, ['phase', '-r', '.'])
     os.system('hg phase -r . -p')
     runcommand(server, ['phase', '-r', '.'])
 
 def rollback(server):
     readchannel(server)
     runcommand(server, ['phase', '-r', '.', '-p'])
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['commit', '-Am.'])
     runcommand(server, ['rollback'])
     runcommand(server, ['phase', '-r', '.'])
 
 def branch(server):
     readchannel(server)
     runcommand(server, ['branch'])
     os.system('hg branch foo')
     runcommand(server, ['branch'])
     os.system('hg branch default')
 
 def hgignore(server):
     readchannel(server)
     f = open('.hgignore', 'ab')
     f.write('')
     f.close()
     runcommand(server, ['commit', '-Am.'])
     f = open('ignored-file', 'ab')
     f.write('')
     f.close()
     f = open('.hgignore', 'ab')
     f.write('ignored-file')
     f.close()
     runcommand(server, ['status', '-i', '-u'])
 
 def phasecacheafterstrip(server):
     readchannel(server)
 
     # create new head, 5:731265503d86
     runcommand(server, ['update', '-C', '0'])
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['commit', '-Am.', 'a'])
     runcommand(server, ['log', '-Gq'])
 
     # make it public; draft marker moves to 4:7966c8e3734d
     runcommand(server, ['phase', '-p', '.'])
     # load _phasecache.phaseroots
     runcommand(server, ['phase', '.'], outfilter=sep)
 
     # strip 1::4 outside server
     os.system('hg -q --config extensions.mq= strip 1')
 
     # shouldn't raise "7966c8e3734d: no node!"
     runcommand(server, ['branches'])
 
 def obsolete(server):
     readchannel(server)
 
     runcommand(server, ['up', 'null'])
     runcommand(server, ['phase', '-df', 'tip'])
     cmd = 'hg debugobsolete `hg log -r tip --template {node}`'
     if os.name == 'nt':
         cmd = 'sh -c "%s"' % cmd # run in sh, not cmd.exe
     os.system(cmd)
     runcommand(server, ['log', '--hidden'])
     runcommand(server, ['log'])
 
 def mqoutsidechanges(server):
     readchannel(server)
 
     # load repo.mq
     runcommand(server, ['qapplied'])
     os.system('hg qnew 0.diff')
     # repo.mq should be invalidated
     runcommand(server, ['qapplied'])
 
     runcommand(server, ['qpop', '--all'])
     os.system('hg qqueue --create foo')
     # repo.mq should be recreated to point to new queue
     runcommand(server, ['qqueue', '--active'])
 
+def getpass(server):
+    readchannel(server)
+    runcommand(server, ['debuggetpass', '--config', 'ui.interactive=True'],
+               input=cStringIO.StringIO('1234\n'))
+
 def startwithoutrepo(server):
     readchannel(server)
     runcommand(server, ['init', 'repo2'])
     runcommand(server, ['id', '-R', 'repo2'])
 
 if __name__ == '__main__':
     os.system('hg init repo')
     os.chdir('repo')
 
     check(hellomessage)
     check(unknowncommand)
     check(checkruncommand)
     check(inputeof)
     check(serverinput)
     check(cwd)
 
     hgrc = open('.hg/hgrc', 'a')
     hgrc.write('[ui]\nfoo=bar\n')
     hgrc.close()
     check(localhgrc)
     check(hookoutput)
     check(outsidechanges)
     check(bookmarks)
     check(tagscache)
     check(setphase)
     check(rollback)
     check(branch)
     check(hgignore)
     check(phasecacheafterstrip)
     obs = open('obs.py', 'w')
     obs.write('import mercurial.obsolete\nmercurial.obsolete._enabled = True\n')
     obs.close()
     hgrc = open('.hg/hgrc', 'a')
     hgrc.write('[extensions]\nobs=obs.py\n')
     hgrc.close()
     check(obsolete)
     hgrc = open('.hg/hgrc', 'a')
     hgrc.write('[extensions]\nmq=\n')
     hgrc.close()
     check(mqoutsidechanges)
+    dbg = open('dbgui.py', 'w')
+    dbg.write('from mercurial import cmdutil, commands\n'
+              'commands.norepo += " debuggetpass"\n'
+              'cmdtable = {}\n'
+              'command = cmdutil.command(cmdtable)\n'
+              '@command("debuggetpass")\n'
+              'def debuggetpass(ui):\n'
+              '    ui.write("%s\\n" % ui.getpass())\n')
+    dbg.close()
+    hgrc = open('.hg/hgrc', 'a')
+    hgrc.write('[extensions]\ndbgui=dbgui.py\n')
+    hgrc.close()
+    check(getpass)
 
     os.chdir('..')
     check(hellomessage)
     check(startwithoutrepo)

tests/test-commandserver.py.out

@@ -1,252 +1,259 b''
 
 testing hellomessage:
 
 o, 'capabilities: getencoding runcommand\nencoding: ***'
  runcommand id
 000000000000 tip
 
 testing unknowncommand:
 
 abort: unknown command unknowncommand
 
 testing checkruncommand:
 
  runcommand 
 Mercurial Distributed SCM
 
 basic commands:
 
  add           add the specified files on the next commit
  annotate      show changeset information by line for each file
  clone         make a copy of an existing repository
  commit        commit the specified files or all outstanding changes
  diff          diff repository (or selected files)
  export        dump the header and diffs for one or more changesets
  forget        forget the specified files on the next commit
  init          create a new repository in the given directory
  log           show revision history of entire repository or files
  merge         merge working directory with another revision
  pull          pull changes from the specified source
  push          push changes to the specified destination
  remove        remove the specified files on the next commit
  serve         start stand-alone webserver
  status        show changed files in the working directory
  summary       summarize working directory state
  update        update working directory (or switch revisions)
 
 use "hg help" for the full list of commands or "hg -v" for details
  runcommand id --quiet
 000000000000
  runcommand id
 000000000000 tip
  runcommand id --config ui.quiet=True
 000000000000
  runcommand id
 000000000000 tip
  runcommand id -runknown
 abort: unknown revision 'unknown'!
  [255]
 
 testing inputeof:
 
 server exit code = 1
 
 testing serverinput:
 
  runcommand import -
 applying patch from stdin
  runcommand log
 changeset:   0:eff892de26ec
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     1
 
 
 testing cwd:
 
  runcommand --cwd foo st bar
 ? bar
  runcommand st foo/bar
 ? foo/bar
 
 testing localhgrc:
 
  runcommand showconfig
 bundle.mainreporoot=$TESTTMP/repo
 defaults.backout=-d "0 0"
 defaults.commit=-d "0 0"
 defaults.shelve=--date "0 0"
 defaults.tag=-d "0 0"
 ui.slash=True
 ui.interactive=False
 ui.foo=bar
+ui.nontty=true
  runcommand init foo
  runcommand -R foo showconfig ui defaults
 defaults.backout=-d "0 0"
 defaults.commit=-d "0 0"
 defaults.shelve=--date "0 0"
 defaults.tag=-d "0 0"
 ui.slash=True
 ui.interactive=False
+ui.nontty=true
 
 testing hookoutput:
 
  runcommand --config hooks.pre-identify=python:test-commandserver.hook id
 hook talking
 now try to read something: 'some input'
 eff892de26ec tip
 
 testing outsidechanges:
 
  runcommand status
 M a
  runcommand tip
 changeset:   1:d3a0a68be6de
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     2
 
  runcommand status
 
 testing bookmarks:
 
  runcommand bookmarks
 no bookmarks set
  runcommand bookmarks
    bm1                       1:d3a0a68be6de
    bm2                       1:d3a0a68be6de
  runcommand bookmarks
  * bm1                       1:d3a0a68be6de
    bm2                       1:d3a0a68be6de
  runcommand bookmarks bm3
  runcommand commit -Amm
  runcommand bookmarks
    bm1                       1:d3a0a68be6de
    bm2                       1:d3a0a68be6de
  * bm3                       2:aef17e88f5f0
 
 testing tagscache:
 
  runcommand id -t -r 0
 
  runcommand id -t -r 0
 foo
 
 testing setphase:
 
  runcommand phase -r .
 3: draft
  runcommand phase -r .
 3: public
 
 testing rollback:
 
  runcommand phase -r . -p
 no phases changed
  [1]
  runcommand commit -Am.
  runcommand rollback
 repository tip rolled back to revision 3 (undo commit)
 working directory now based on revision 3
  runcommand phase -r .
 3: public
 
 testing branch:
 
  runcommand branch
 default
 marked working directory as branch foo
 (branches are permanent and global, did you want a bookmark?)
  runcommand branch
 foo
 marked working directory as branch default
 (branches are permanent and global, did you want a bookmark?)
 
 testing hgignore:
 
  runcommand commit -Am.
 adding .hgignore
  runcommand status -i -u
 I ignored-file
 
 testing phasecacheafterstrip:
 
  runcommand update -C 0
 1 files updated, 0 files merged, 2 files removed, 0 files unresolved
  runcommand commit -Am. a
 created new head
  runcommand log -Gq
 @  5:731265503d86
 |
 | o  4:7966c8e3734d
 | |
 | o  3:b9b85890c400
 | |
 | o  2:aef17e88f5f0
 | |
 | o  1:d3a0a68be6de
 |/
 o  0:eff892de26ec
 
  runcommand phase -p .
  runcommand phase .
 5: public
  runcommand branches
 default                        1:731265503d86
 
 testing obsolete:
 
  runcommand up null
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
  runcommand phase -df tip
  runcommand log --hidden
 changeset:   1:731265503d86
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     .
 
 changeset:   0:eff892de26ec
 bookmark:    bm1
 bookmark:    bm2
 bookmark:    bm3
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     1
 
  runcommand log
 changeset:   0:eff892de26ec
 bookmark:    bm1
 bookmark:    bm2
 bookmark:    bm3
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     1
 
 
 testing mqoutsidechanges:
 
  runcommand qapplied
  runcommand qapplied
 0.diff
  runcommand qpop --all
 popping 0.diff
 patch queue now empty
  runcommand qqueue --active
 foo
 
+testing getpass:
+
+ runcommand debuggetpass --config ui.interactive=True
+password: 1234
+
 testing hellomessage:
 
 o, 'capabilities: getencoding runcommand\nencoding: ***'
  runcommand id
 abort: there is no Mercurial repository here (.hg not found)
  [255]
 
 testing startwithoutrepo:
 
  runcommand init repo2
  runcommand id -R repo2
 000000000000 tip