mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 16:31:02 +03:00
96a8ea56df
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.
252 lines
7.1 KiB
Python
252 lines
7.1 KiB
Python
# commandserver.py - communicate with Mercurial's API over a pipe
|
|
#
|
|
# Copyright Matt Mackall <mpm@selenic.com>
|
|
#
|
|
# 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
|