sshpeer.py
635 lines
| 21.5 KiB
| text/x-python
|
PythonLexer
/ mercurial / sshpeer.py
|
r17192 | # sshpeer.py - ssh repository proxy class for mercurial | ||
# | ||||
# Copyright 2005, 2006 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. | ||||
|
r25975 | from __future__ import absolute_import | ||
|
r17192 | import re | ||
|
r35994 | import uuid | ||
|
r25975 | |||
from .i18n import _ | ||||
from . import ( | ||||
error, | ||||
|
r33100 | pycompat, | ||
|
r25975 | util, | ||
wireproto, | ||||
|
r35994 | wireprotoserver, | ||
|
r36553 | wireprototypes, | ||
|
r25975 | ) | ||
|
r37138 | from .utils import ( | ||
procutil, | ||||
) | ||||
|
r17192 | |||
def _serverquote(s): | ||||
|
r35475 | """quote a string for the remote shell ... which we assume is sh""" | ||
|
r23671 | if not s: | ||
return s | ||||
|
r17192 | if re.match('[a-zA-Z0-9@%_+=:,./-]*$', s): | ||
return s | ||||
return "'%s'" % s.replace("'", "'\\''") | ||||
|
r25244 | def _forwardoutput(ui, pipe): | ||
"""display all data currently available on pipe as remote output. | ||||
This is non blocking.""" | ||||
|
r36851 | if pipe: | ||
|
r37138 | s = procutil.readpipe(pipe) | ||
|
r36851 | if s: | ||
for l in s.splitlines(): | ||||
ui.status(_("remote: "), l, '\n') | ||||
|
r25244 | |||
|
r25421 | class doublepipe(object): | ||
"""Operate a side-channel pipe in addition of a main one | ||||
The side-channel pipe contains server output to be forwarded to the user | ||||
input. The double pipe will behave as the "main" pipe, but will ensure the | ||||
content of the "side" pipe is properly processed while we wait for blocking | ||||
call on the "main" pipe. | ||||
If large amounts of data are read from "main", the forward will cease after | ||||
the first bytes start to appear. This simplifies the implementation | ||||
without affecting actual output of sshpeer too much as we rarely issue | ||||
large read for data not yet emitted by the server. | ||||
The main pipe is expected to be a 'bufferedinputpipe' from the util module | ||||
|
r31953 | that handle all the os specific bits. This class lives in this module | ||
|
r26781 | because it focus on behavior specific to the ssh protocol.""" | ||
|
r25421 | |||
def __init__(self, ui, main, side): | ||||
self._ui = ui | ||||
self._main = main | ||||
self._side = side | ||||
def _wait(self): | ||||
"""wait until some data are available on main or side | ||||
return a pair of boolean (ismainready, issideready) | ||||
(This will only wait for data if the setup is supported by `util.poll`) | ||||
""" | ||||
|
r36387 | if (isinstance(self._main, util.bufferedinputpipe) and | ||
self._main.hasbuffer): | ||||
# Main has data. Assume side is worth poking at. | ||||
return True, True | ||||
|
r25421 | fds = [self._main.fileno(), self._side.fileno()] | ||
try: | ||||
act = util.poll(fds) | ||||
except NotImplementedError: | ||||
# non supported yet case, assume all have data. | ||||
act = fds | ||||
return (self._main.fileno() in act, self._side.fileno() in act) | ||||
|
r25456 | def write(self, data): | ||
return self._call('write', data) | ||||
|
r25421 | def read(self, size): | ||
|
r32062 | r = self._call('read', size) | ||
if size != 0 and not r: | ||||
# We've observed a condition that indicates the | ||||
# stdout closed unexpectedly. Check stderr one | ||||
# more time and snag anything that's there before | ||||
# letting anyone know the main part of the pipe | ||||
# closed prematurely. | ||||
_forwardoutput(self._ui, self._side) | ||||
return r | ||||
|
r25421 | |||
def readline(self): | ||||
return self._call('readline') | ||||
|
r25455 | def _call(self, methname, data=None): | ||
|
r25421 | """call <methname> on "main", forward output of "side" while blocking | ||
""" | ||||
|
r25455 | # data can be '' or 0 | ||
if (data is not None and not data) or self._main.closed: | ||||
|
r25421 | _forwardoutput(self._ui, self._side) | ||
return '' | ||||
while True: | ||||
mainready, sideready = self._wait() | ||||
if sideready: | ||||
_forwardoutput(self._ui, self._side) | ||||
if mainready: | ||||
meth = getattr(self._main, methname) | ||||
|
r25455 | if data is None: | ||
|
r25421 | return meth() | ||
else: | ||||
|
r25455 | return meth(data) | ||
|
r25421 | |||
def close(self): | ||||
return self._main.close() | ||||
|
r25456 | def flush(self): | ||
return self._main.flush() | ||||
|
r35951 | def _cleanuppipes(ui, pipei, pipeo, pipee): | ||
"""Clean up pipes used by an SSH connection.""" | ||||
if pipeo: | ||||
pipeo.close() | ||||
if pipei: | ||||
pipei.close() | ||||
if pipee: | ||||
# Try to read from the err descriptor until EOF. | ||||
try: | ||||
for l in pipee: | ||||
ui.status(_('remote: '), l) | ||||
except (IOError, ValueError): | ||||
pass | ||||
pipee.close() | ||||
|
r35953 | def _makeconnection(ui, sshcmd, args, remotecmd, path, sshenv=None): | ||
"""Create an SSH connection to a server. | ||||
Returns a tuple of (process, stdin, stdout, stderr) for the | ||||
spawned process. | ||||
""" | ||||
cmd = '%s %s %s' % ( | ||||
sshcmd, | ||||
args, | ||||
|
r37138 | procutil.shellquote('%s -R %s serve --stdio' % ( | ||
|
r35953 | _serverquote(remotecmd), _serverquote(path)))) | ||
ui.debug('running %s\n' % cmd) | ||||
|
r37138 | cmd = procutil.quotecommand(cmd) | ||
|
r35953 | |||
# no buffer allow the use of 'select' | ||||
# feel free to remove buffering and select usage when we ultimately | ||||
# move to threading. | ||||
|
r37138 | stdin, stdout, stderr, proc = procutil.popen4(cmd, bufsize=0, env=sshenv) | ||
|
r35953 | |||
return proc, stdin, stdout, stderr | ||||
|
r37411 | def _clientcapabilities(): | ||
"""Return list of capabilities of this client. | ||||
Returns a list of capabilities that are supported by this client. | ||||
""" | ||||
|
r37516 | protoparams = {'partial-pull'} | ||
|
r37411 | comps = [e.wireprotosupport().name for e in | ||
util.compengines.supportedwireengines(util.CLIENTROLE)] | ||||
|
r37429 | protoparams.add('comp=%s' % ','.join(comps)) | ||
|
r37411 | return protoparams | ||
|
r35956 | def _performhandshake(ui, stdin, stdout, stderr): | ||
def badresponse(): | ||||
|
r36388 | # Flush any output on stderr. | ||
_forwardoutput(ui, stderr) | ||||
|
r35956 | msg = _('no suitable response from remote hg') | ||
hint = ui.config('ui', 'ssherrorhint') | ||||
raise error.RepoError(msg, hint=hint) | ||||
|
r35994 | # The handshake consists of sending wire protocol commands in reverse | ||
# order of protocol implementation and then sniffing for a response | ||||
# to one of them. | ||||
# | ||||
# Those commands (from oldest to newest) are: | ||||
|
r35957 | # | ||
|
r35994 | # ``between`` | ||
# Asks for the set of revisions between a pair of revisions. Command | ||||
# present in all Mercurial server implementations. | ||||
|
r35957 | # | ||
|
r35994 | # ``hello`` | ||
# Instructs the server to advertise its capabilities. Introduced in | ||||
# Mercurial 0.9.1. | ||||
# | ||||
# ``upgrade`` | ||||
# Requests upgrade from default transport protocol version 1 to | ||||
# a newer version. Introduced in Mercurial 4.6 as an experimental | ||||
# feature. | ||||
|
r35957 | # | ||
# The ``between`` command is issued with a request for the null | ||||
# range. If the remote is a Mercurial server, this request will | ||||
# generate a specific response: ``1\n\n``. This represents the | ||||
# wire protocol encoded value for ``\n``. We look for ``1\n\n`` | ||||
# in the output stream and know this is the response to ``between`` | ||||
# and we're at the end of our handshake reply. | ||||
# | ||||
# The response to the ``hello`` command will be a line with the | ||||
# length of the value returned by that command followed by that | ||||
# value. If the server doesn't support ``hello`` (which should be | ||||
# rare), that line will be ``0\n``. Otherwise, the value will contain | ||||
# RFC 822 like lines. Of these, the ``capabilities:`` line contains | ||||
# the capabilities of the server. | ||||
# | ||||
|
r35994 | # The ``upgrade`` command isn't really a command in the traditional | ||
# sense of version 1 of the transport because it isn't using the | ||||
# proper mechanism for formatting insteads: instead, it just encodes | ||||
# arguments on the line, delimited by spaces. | ||||
# | ||||
# The ``upgrade`` line looks like ``upgrade <token> <capabilities>``. | ||||
# If the server doesn't support protocol upgrades, it will reply to | ||||
# this line with ``0\n``. Otherwise, it emits an | ||||
# ``upgraded <token> <protocol>`` line to both stdout and stderr. | ||||
# Content immediately following this line describes additional | ||||
# protocol and server state. | ||||
# | ||||
|
r35957 | # In addition to the responses to our command requests, the server | ||
# may emit "banner" output on stdout. SSH servers are allowed to | ||||
# print messages to stdout on login. Issuing commands on connection | ||||
# allows us to flush this banner output from the server by scanning | ||||
# for output to our well-known ``between`` command. Of course, if | ||||
# the banner contains ``1\n\n``, this will throw off our detection. | ||||
|
r35956 | requestlog = ui.configbool('devel', 'debug.peer-request') | ||
|
r35994 | # Generate a random token to help identify responses to version 2 | ||
# upgrade request. | ||||
|
r36060 | token = pycompat.sysbytes(str(uuid.uuid4())) | ||
|
r35994 | upgradecaps = [ | ||
('proto', wireprotoserver.SSHV2), | ||||
] | ||||
upgradecaps = util.urlreq.urlencode(upgradecaps) | ||||
|
r35956 | try: | ||
pairsarg = '%s-%s' % ('0' * 40, '0' * 40) | ||||
handshake = [ | ||||
'hello\n', | ||||
'between\n', | ||||
'pairs %d\n' % len(pairsarg), | ||||
pairsarg, | ||||
] | ||||
|
r35994 | # Request upgrade to version 2 if configured. | ||
if ui.configbool('experimental', 'sshpeer.advertise-v2'): | ||||
ui.debug('sending upgrade request: %s %s\n' % (token, upgradecaps)) | ||||
handshake.insert(0, 'upgrade %s %s\n' % (token, upgradecaps)) | ||||
|
r35956 | if requestlog: | ||
ui.debug('devel-peer-request: hello\n') | ||||
ui.debug('sending hello command\n') | ||||
if requestlog: | ||||
ui.debug('devel-peer-request: between\n') | ||||
ui.debug('devel-peer-request: pairs: %d bytes\n' % len(pairsarg)) | ||||
ui.debug('sending between command\n') | ||||
stdin.write(''.join(handshake)) | ||||
stdin.flush() | ||||
except IOError: | ||||
badresponse() | ||||
|
r35994 | # Assume version 1 of wire protocol by default. | ||
|
r36553 | protoname = wireprototypes.SSHV1 | ||
|
r35994 | reupgraded = re.compile(b'^upgraded %s (.*)$' % re.escape(token)) | ||
|
r35956 | lines = ['', 'dummy'] | ||
max_noise = 500 | ||||
while lines[-1] and max_noise: | ||||
try: | ||||
l = stdout.readline() | ||||
_forwardoutput(ui, stderr) | ||||
|
r35994 | |||
# Look for reply to protocol upgrade request. It has a token | ||||
# in it, so there should be no false positives. | ||||
m = reupgraded.match(l) | ||||
if m: | ||||
protoname = m.group(1) | ||||
ui.debug('protocol upgraded to %s\n' % protoname) | ||||
# If an upgrade was handled, the ``hello`` and ``between`` | ||||
# requests are ignored. The next output belongs to the | ||||
# protocol, so stop scanning lines. | ||||
break | ||||
# Otherwise it could be a banner, ``0\n`` response if server | ||||
# doesn't support upgrade. | ||||
|
r35956 | if lines[-1] == '1\n' and l == '\n': | ||
break | ||||
if l: | ||||
ui.debug('remote: ', l) | ||||
lines.append(l) | ||||
max_noise -= 1 | ||||
except IOError: | ||||
badresponse() | ||||
else: | ||||
badresponse() | ||||
caps = set() | ||||
|
r35994 | # For version 1, we should see a ``capabilities`` line in response to the | ||
# ``hello`` command. | ||||
|
r36553 | if protoname == wireprototypes.SSHV1: | ||
|
r35994 | for l in reversed(lines): | ||
# Look for response to ``hello`` command. Scan from the back so | ||||
# we don't misinterpret banner output as the command reply. | ||||
if l.startswith('capabilities:'): | ||||
caps.update(l[:-1].split(':')[1].split()) | ||||
break | ||||
elif protoname == wireprotoserver.SSHV2: | ||||
# We see a line with number of bytes to follow and then a value | ||||
# looking like ``capabilities: *``. | ||||
line = stdout.readline() | ||||
try: | ||||
valuelen = int(line) | ||||
except ValueError: | ||||
badresponse() | ||||
capsline = stdout.read(valuelen) | ||||
if not capsline.startswith('capabilities: '): | ||||
badresponse() | ||||
|
r36234 | ui.debug('remote: %s\n' % capsline) | ||
|
r35994 | caps.update(capsline.split(':')[1].split()) | ||
# Trailing newline. | ||||
stdout.read(1) | ||||
# Error if we couldn't find capabilities, this means: | ||||
|
r35958 | # | ||
# 1. Remote isn't a Mercurial server | ||||
# 2. Remote is a <0.9.1 Mercurial server | ||||
# 3. Remote is a future Mercurial server that dropped ``hello`` | ||||
|
r35994 | # and other attempted handshake mechanisms. | ||
|
r35958 | if not caps: | ||
badresponse() | ||||
|
r36388 | # Flush any output on stderr before proceeding. | ||
_forwardoutput(ui, stderr) | ||||
|
r35996 | return protoname, caps | ||
|
r35956 | |||
|
r35995 | class sshv1peer(wireproto.wirepeer): | ||
|
r36550 | def __init__(self, ui, url, proc, stdin, stdout, stderr, caps, | ||
autoreadstderr=True): | ||||
|
r35954 | """Create a peer from an existing SSH connection. | ||
``proc`` is a handle on the underlying SSH process. | ||||
``stdin``, ``stdout``, and ``stderr`` are handles on the stdio | ||||
pipes for that process. | ||||
|
r35956 | ``caps`` is a set of capabilities supported by the remote. | ||
|
r36550 | ``autoreadstderr`` denotes whether to automatically read from | ||
stderr and to forward its output. | ||||
|
r35954 | """ | ||
self._url = url | ||||
|
r37337 | self.ui = ui | ||
|
r35953 | # self._subprocess is unused. Keeping a handle on the process | ||
# holds a reference and prevents it from being garbage collected. | ||||
|
r35954 | self._subprocess = proc | ||
|
r36388 | |||
# And we hook up our "doublepipe" wrapper to allow querying | ||||
# stderr any time we perform I/O. | ||||
|
r36550 | if autoreadstderr: | ||
stdout = doublepipe(ui, util.bufferedinputpipe(stdout), stderr) | ||||
stdin = doublepipe(ui, stdin, stderr) | ||||
|
r36388 | |||
|
r35954 | self._pipeo = stdin | ||
self._pipei = stdout | ||||
self._pipee = stderr | ||||
|
r35956 | self._caps = caps | ||
|
r36626 | self._autoreadstderr = autoreadstderr | ||
|
r17192 | |||
|
r36385 | # Commands that have a "framed" response where the first line of the | ||
# response contains the length of that response. | ||||
_FRAMED_COMMANDS = { | ||||
'batch', | ||||
} | ||||
|
r37336 | # Begin of ipeerconnection interface. | ||
|
r33803 | |||
|
r17192 | def url(self): | ||
return self._url | ||||
|
r33803 | def local(self): | ||
return None | ||||
def peer(self): | ||||
return self | ||||
def canpush(self): | ||||
return True | ||||
def close(self): | ||||
pass | ||||
|
r37336 | # End of ipeerconnection interface. | ||
|
r33803 | |||
|
r37336 | # Begin of ipeercommands interface. | ||
|
r33803 | |||
def capabilities(self): | ||||
return self._caps | ||||
|
r37336 | # End of ipeercommands interface. | ||
|
r33803 | |||
|
r33763 | def _readerr(self): | ||
_forwardoutput(self.ui, self._pipee) | ||||
|
r17192 | |||
def _abort(self, exception): | ||||
|
r33763 | self._cleanup() | ||
|
r17192 | raise exception | ||
|
r33763 | def _cleanup(self): | ||
|
r35951 | _cleanuppipes(self.ui, self._pipei, self._pipeo, self._pipee) | ||
|
r17192 | |||
|
r33763 | __del__ = _cleanup | ||
|
r17192 | |||
|
r36385 | def _sendrequest(self, cmd, args, framed=False): | ||
|
r35717 | if (self.ui.debugflag | ||
and self.ui.configbool('devel', 'debug.peer-request')): | ||||
dbg = self.ui.debug | ||||
line = 'devel-peer-request: %s\n' | ||||
dbg(line % cmd) | ||||
for key, value in sorted(args.items()): | ||||
if not isinstance(value, dict): | ||||
dbg(line % ' %s: %d bytes' % (key, len(value))) | ||||
else: | ||||
for dk, dv in sorted(value.items()): | ||||
dbg(line % ' %s-%s: %d' % (key, dk, len(dv))) | ||||
|
r17192 | self.ui.debug("sending %s command\n" % cmd) | ||
|
r33763 | self._pipeo.write("%s\n" % cmd) | ||
|
r17192 | _func, names = wireproto.commands[cmd] | ||
keys = names.split() | ||||
wireargs = {} | ||||
for k in keys: | ||||
if k == '*': | ||||
wireargs['*'] = args | ||||
break | ||||
else: | ||||
wireargs[k] = args[k] | ||||
del args[k] | ||||
for k, v in sorted(wireargs.iteritems()): | ||||
|
r33763 | self._pipeo.write("%s %d\n" % (k, len(v))) | ||
|
r17192 | if isinstance(v, dict): | ||
for dk, dv in v.iteritems(): | ||||
|
r33763 | self._pipeo.write("%s %d\n" % (dk, len(dv))) | ||
self._pipeo.write(dv) | ||||
|
r17192 | else: | ||
|
r33763 | self._pipeo.write(v) | ||
self._pipeo.flush() | ||||
|
r17192 | |||
|
r36385 | # We know exactly how many bytes are in the response. So return a proxy | ||
# around the raw output stream that allows reading exactly this many | ||||
# bytes. Callers then can read() without fear of overrunning the | ||||
# response. | ||||
if framed: | ||||
amount = self._getamount() | ||||
return util.cappedreader(self._pipei, amount) | ||||
|
r33763 | return self._pipei | ||
|
r17192 | |||
|
r36384 | def _callstream(self, cmd, **args): | ||
args = pycompat.byteskwargs(args) | ||||
|
r36385 | return self._sendrequest(cmd, args, framed=cmd in self._FRAMED_COMMANDS) | ||
|
r36384 | |||
|
r20905 | def _callcompressable(self, cmd, **args): | ||
|
r36384 | args = pycompat.byteskwargs(args) | ||
|
r36385 | return self._sendrequest(cmd, args, framed=cmd in self._FRAMED_COMMANDS) | ||
|
r20905 | |||
|
r17192 | def _call(self, cmd, **args): | ||
|
r36384 | args = pycompat.byteskwargs(args) | ||
|
r36385 | return self._sendrequest(cmd, args, framed=True).read() | ||
|
r17192 | |||
def _callpush(self, cmd, fp, **args): | ||||
|
r36390 | # The server responds with an empty frame if the client should | ||
# continue submitting the payload. | ||||
|
r17192 | r = self._call(cmd, **args) | ||
if r: | ||||
return '', r | ||||
|
r36390 | |||
# The payload consists of frames with content followed by an empty | ||||
# frame. | ||||
|
r29727 | for d in iter(lambda: fp.read(4096), ''): | ||
|
r36383 | self._writeframed(d) | ||
self._writeframed("", flush=True) | ||||
|
r36390 | |||
# In case of success, there is an empty frame and a frame containing | ||||
# the integer result (as a string). | ||||
# In case of error, there is a non-empty frame containing the error. | ||||
|
r36383 | r = self._readframed() | ||
|
r17192 | if r: | ||
return '', r | ||||
|
r36383 | return self._readframed(), '' | ||
|
r17192 | |||
|
r21073 | def _calltwowaystream(self, cmd, fp, **args): | ||
|
r36390 | # The server responds with an empty frame if the client should | ||
# continue submitting the payload. | ||||
|
r21073 | r = self._call(cmd, **args) | ||
if r: | ||||
# XXX needs to be made better | ||||
|
r29389 | raise error.Abort(_('unexpected remote reply: %s') % r) | ||
|
r36390 | |||
# The payload consists of frames with content followed by an empty | ||||
# frame. | ||||
|
r29727 | for d in iter(lambda: fp.read(4096), ''): | ||
|
r36383 | self._writeframed(d) | ||
self._writeframed("", flush=True) | ||||
|
r36390 | |||
|
r33763 | return self._pipei | ||
|
r17192 | |||
|
r28438 | def _getamount(self): | ||
|
r33763 | l = self._pipei.readline() | ||
|
r17192 | if l == '\n': | ||
|
r36626 | if self._autoreadstderr: | ||
self._readerr() | ||||
|
r25243 | msg = _('check previous remote output') | ||
self._abort(error.OutOfBandError(hint=msg)) | ||||
|
r36626 | if self._autoreadstderr: | ||
self._readerr() | ||||
|
r17192 | try: | ||
|
r28438 | return int(l) | ||
|
r17192 | except ValueError: | ||
self._abort(error.ResponseError(_("unexpected response:"), l)) | ||||
|
r28438 | |||
|
r36383 | def _readframed(self): | ||
|
r36646 | size = self._getamount() | ||
if not size: | ||||
return b'' | ||||
return self._pipei.read(size) | ||||
|
r17192 | |||
|
r36383 | def _writeframed(self, data, flush=False): | ||
|
r33763 | self._pipeo.write("%d\n" % len(data)) | ||
|
r17192 | if data: | ||
|
r33763 | self._pipeo.write(data) | ||
|
r17192 | if flush: | ||
|
r33763 | self._pipeo.flush() | ||
|
r36626 | if self._autoreadstderr: | ||
self._readerr() | ||||
|
r17192 | |||
|
r35996 | class sshv2peer(sshv1peer): | ||
"""A peer that speakers version 2 of the transport protocol.""" | ||||
# Currently version 2 is identical to version 1 post handshake. | ||||
# And handshake is performed before the peer is instantiated. So | ||||
# we need no custom code. | ||||
|
r36550 | def makepeer(ui, path, proc, stdin, stdout, stderr, autoreadstderr=True): | ||
|
r36505 | """Make a peer instance from existing pipes. | ||
``path`` and ``proc`` are stored on the eventual peer instance and may | ||||
not be used for anything meaningful. | ||||
``stdin``, ``stdout``, and ``stderr`` are the pipes connected to the | ||||
SSH server's stdio handles. | ||||
This function is factored out to allow creating peers that don't | ||||
actually spawn a new process. It is useful for starting SSH protocol | ||||
servers and clients via non-standard means, which can be useful for | ||||
testing. | ||||
""" | ||||
try: | ||||
protoname, caps = _performhandshake(ui, stdin, stdout, stderr) | ||||
except Exception: | ||||
_cleanuppipes(ui, stdout, stdin, stderr) | ||||
raise | ||||
|
r36553 | if protoname == wireprototypes.SSHV1: | ||
|
r36550 | return sshv1peer(ui, path, proc, stdin, stdout, stderr, caps, | ||
autoreadstderr=autoreadstderr) | ||||
|
r36553 | elif protoname == wireprototypes.SSHV2: | ||
|
r36550 | return sshv2peer(ui, path, proc, stdin, stdout, stderr, caps, | ||
autoreadstderr=autoreadstderr) | ||||
|
r36505 | else: | ||
_cleanuppipes(ui, stdout, stdin, stderr) | ||||
raise error.RepoError(_('unknown version of SSH protocol: %s') % | ||||
protoname) | ||||
|
r35946 | def instance(ui, path, create): | ||
|
r35949 | """Create an SSH peer. | ||
The returned object conforms to the ``wireproto.wirepeer`` interface. | ||||
""" | ||||
u = util.url(path, parsequery=False, parsefragment=False) | ||||
if u.scheme != 'ssh' or not u.host or u.path is None: | ||||
raise error.RepoError(_("couldn't parse location %s") % path) | ||||
util.checksafessh(path) | ||||
if u.passwd is not None: | ||||
raise error.RepoError(_('password in URL not supported')) | ||||
|
r35950 | sshcmd = ui.config('ui', 'ssh') | ||
remotecmd = ui.config('ui', 'remotecmd') | ||||
sshaddenv = dict(ui.configitems('sshenv')) | ||||
|
r37138 | sshenv = procutil.shellenviron(sshaddenv) | ||
|
r35950 | remotepath = u.path or '.' | ||
|
r37138 | args = procutil.sshargs(sshcmd, u.host, u.user, u.port) | ||
|
r35950 | |||
if create: | ||||
cmd = '%s %s %s' % (sshcmd, args, | ||||
|
r37138 | procutil.shellquote('%s init %s' % | ||
|
r35950 | (_serverquote(remotecmd), _serverquote(remotepath)))) | ||
ui.debug('running %s\n' % cmd) | ||||
res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv) | ||||
if res != 0: | ||||
raise error.RepoError(_('could not create remote repo')) | ||||
|
r35953 | proc, stdin, stdout, stderr = _makeconnection(ui, sshcmd, args, remotecmd, | ||
remotepath, sshenv) | ||||
|
r37411 | peer = makepeer(ui, path, proc, stdin, stdout, stderr) | ||
# Finally, if supported by the server, notify it about our own | ||||
# capabilities. | ||||
if 'protocaps' in peer.capabilities(): | ||||
try: | ||||
|
r37429 | peer._call("protocaps", | ||
caps=' '.join(sorted(_clientcapabilities()))) | ||||
|
r37411 | except IOError: | ||
peer._cleanup() | ||||
raise error.RepoError(_('capability exchange failed')) | ||||
return peer | ||||