def inner(*args, **kwargs):
# Start server
_server = serve_responses(responses, files, passwords, home,
pubkeys, port)
_server.all_done = threading.Event()
worker = ThreadHandler('server', _server.serve_forever)
# Execute function
try:
return func(*args, **kwargs)
finally:
# Clean up client side connections
with hide('status'):
disconnect_all()
# Stop server
_server.all_done.set()
_server.shutdown()
# Why this is not called in shutdown() is beyond me.
_server.server_close()
worker.thread.join()
# Handle subthread exceptions
e = worker.exception
if e:
raise e[0], e[1], e[2]
def test_patch():
from fabric.thread_handling import ThreadHandler
from fabric.api import env, output
env.host_string = 'myhost'
output['test'] = 'ok'
# test dict proxy
assert env['host_string'] == 'myhost'
assert output['test'] == 'ok'
assert len(output.expand_aliases(['everything'])) > 0
# test attribute dict proxy
assert env.host_string == 'myhost'
# test state transfer
def test_state_transfer(x, y):
assert x == 1
assert y == 2
assert env.host_string == 'myhost'
# test fresh state
def test_default(x, y):
assert x == 1
assert y == 2
assert env.host_string == None
th = ThreadHandler('footest', test_state_transfer, [1], {'y': 2})
th.thread.join()
t = threading.Thread(None, test_default, args=[1], kwargs={'y': 2})
t.start()
t.join()
print 'OK'
def _execute(channel, command, pty=True, combine_stderr=None,
invoke_shell=False, stdout=None, stderr=None, timeout=None):
"""
Execute ``command`` over ``channel``.
``pty`` controls whether a pseudo-terminal is created.
``combine_stderr`` controls whether we call ``channel.set_combine_stderr``.
By default, the global setting for this behavior (:ref:`env.combine_stderr
<combine-stderr>`) is consulted, but you may specify ``True`` or ``False``
here to override it.
``invoke_shell`` controls whether we use ``exec_command`` or
``invoke_shell`` (plus a handful of other things, such as always forcing a
pty.)
Returns a three-tuple of (``stdout``, ``stderr``, ``status``), where
``stdout``/``stderr`` are captured output strings and ``status`` is the
program's return code, if applicable.
"""
# stdout/stderr redirection
stdout = stdout or sys.stdout
stderr = stderr or sys.stderr
# Timeout setting control
timeout = env.command_timeout if (timeout is None) else timeout
# What to do with CTRl-C?
remote_interrupt = env.remote_interrupt
with char_buffered(sys.stdin):
# Combine stdout and stderr to get around oddball mixing issues
if combine_stderr is None:
combine_stderr = env.combine_stderr
channel.set_combine_stderr(combine_stderr)
# Assume pty use, and allow overriding of this either via kwarg or env
# var. (invoke_shell always wants a pty no matter what.)
using_pty = True
if not invoke_shell and (not pty or not env.always_use_pty):
using_pty = False
# Request pty with size params (default to 80x24, obtain real
# parameters if on POSIX platform)
if using_pty:
rows, cols = _pty_size()
channel.get_pty(width=cols, height=rows)
# Use SSH agent forwarding from 'ssh' if enabled by user
config_agent = ssh_config().get('forwardagent', 'no').lower() == 'yes'
forward = None
if env.forward_agent or config_agent:
forward = ssh.agent.AgentRequestHandler(channel)
# Kick off remote command
if invoke_shell:
channel.invoke_shell()
if command:
channel.sendall(command + "\n")
else:
channel.exec_command(command=command)
# Init stdout, stderr capturing. Must use lists instead of strings as
# strings are immutable and we're using these as pass-by-reference
stdout_buf, stderr_buf = [], []
if invoke_shell:
stdout_buf = stderr_buf = None
workers = (
ThreadHandler('out', output_loop, channel, "recv",
capture=stdout_buf, stream=stdout, timeout=timeout),
ThreadHandler('err', output_loop, channel, "recv_stderr",
capture=stderr_buf, stream=stderr, timeout=timeout),
ThreadHandler('in', input_loop, channel, using_pty)
)
if remote_interrupt is None:
remote_interrupt = invoke_shell
if remote_interrupt and not using_pty:
remote_interrupt = False
while True:
if channel.exit_status_ready():
break
else:
# Check for thread exceptions here so we can raise ASAP
# (without chance of getting blocked by, or hidden by an
# exception within, recv_exit_status())
for worker in workers:
worker.raise_if_needed()
try:
time.sleep(ssh.io_sleep)
except KeyboardInterrupt:
if not remote_interrupt:
raise
channel.send('\x03')
# Obtain exit code of remote program now that we're done.
status = channel.recv_exit_status()
# Wait for threads to exit so we aren't left with stale threads
for worker in workers:
worker.thread.join()
worker.raise_if_needed()
# Close channel
channel.close()
# Close any agent forward proxies
if forward is not None:
forward.close()
# Update stdout/stderr with captured values if applicable
if not invoke_shell:
stdout_buf = ''.join(stdout_buf).strip()
stderr_buf = ''.join(stderr_buf).strip()
# Tie off "loose" output by printing a newline. Helps to ensure any
# following print()s aren't on the same line as a trailing line prefix
# or similar. However, don't add an extra newline if we've already
# ended up with one, as that adds a entire blank line instead.
if output.running \
and (output.stdout and stdout_buf and not stdout_buf.endswith("\n")) \
or (output.stderr and stderr_buf and not stderr_buf.endswith("\n")):
print("")
return stdout_buf, stderr_buf, status
def _execute(channel,
command,
pty=True,
combine_stderr=True,
invoke_shell=False):
"""
Execute ``command`` over ``channel``.
``pty`` controls whether a pseudo-terminal is created.
``combine_stderr`` controls whether we call ``channel.set_combine_stderr``.
``invoke_shell`` controls whether we use ``exec_command`` or
``invoke_shell`` (plus a handful of other things, such as always forcing a
pty.)
Returns a three-tuple of (``stdout``, ``stderr``, ``status``), where
``stdout``/``stderr`` are captured output strings and ``status`` is the
program's return code, if applicable.
"""
with char_buffered(sys.stdin):
# Combine stdout and stderr to get around oddball mixing issues
if combine_stderr or env.combine_stderr:
channel.set_combine_stderr(True)
# Assume pty use, and allow overriding of this either via kwarg or env
# var. (invoke_shell always wants a pty no matter what.)
using_pty = True
if not invoke_shell and (not pty or not env.always_use_pty):
using_pty = False
# Request pty with size params (default to 80x24, obtain real
# parameters if on POSIX platform)
if using_pty:
rows, cols = _pty_size()
channel.get_pty(width=cols, height=rows)
# Kick off remote command
if invoke_shell:
channel.invoke_shell()
if command:
channel.sendall(command + "\n")
else:
channel.exec_command(command)
# Init stdout, stderr capturing. Must use lists instead of strings as
# strings are immutable and we're using these as pass-by-reference
stdout, stderr = [], []
if invoke_shell:
stdout = stderr = None
workers = (ThreadHandler('out', output_loop, channel, "recv", stdout),
ThreadHandler('err', output_loop, channel, "recv_stderr",
stderr),
ThreadHandler('in', input_loop, channel, using_pty))
while True:
if channel.exit_status_ready():
break
else:
for worker in workers:
e = worker.exception
if e:
raise e[0], e[1], e[2]
# Obtain exit code of remote program now that we're done.
status = channel.recv_exit_status()
# Wait for threads to exit so we aren't left with stale threads
for worker in workers:
worker.thread.join()
# Close channel
channel.close()
# Update stdout/stderr with captured values if applicable
if not invoke_shell:
stdout = ''.join(stdout).strip()
stderr = ''.join(stderr).strip()
# Tie off "loose" output by printing a newline. Helps to ensure any
# following print()s aren't on the same line as a trailing line prefix
# or similar. However, don't add an extra newline if we've already
# ended up with one, as that adds a entire blank line instead.
if output.running \
and (output.stdout and stdout and not stdout.endswith("\n")) \
or (output.stderr and stderr and not stderr.endswith("\n")):
print("")
return stdout, stderr, status
channels.append(channel)
sock = socket.socket()
sockets.append(sock)
try:
sock.connect((local_host, local_port))
except Exception, e:
print "[%s] rtunnel: cannot connect to %s:%d (from local)" % (env.host_string, local_host, local_port)
chan.close()
return
print "[%s] rtunnel: opened reverse tunnel: %r -> %r -> %r"\
% (env.host_string, channel.origin_addr,
channel.getpeername(), (local_host, local_port))
th = ThreadHandler('fwd', _forwarder, channel, sock)
threads.append(th)
transport = connections[env.host_string].get_transport()
transport.request_port_forward(remote_bind_address, remote_port, handler=accept)
try:
yield
finally:
for sock, chan, th in zip(sockets, channels, threads):
sock.close()
chan.close()
th.thread.join()
th.raise_if_needed()
transport.cancel_port_forward(remote_bind_address, remote_port)
def remote_tunnel(remote_port,
local_port=None,
local_host="localhost",
remote_bind_address="127.0.0.1"):
"""
Create a tunnel forwarding a locally-visible port to the remote target.
For example, you can let the remote host access a database that is
installed on the client host::
# Map localhost:6379 on the server to localhost:6379 on the client,
# so that the remote 'redis-cli' program ends up speaking to the local
# redis-server.
with remote_tunnel(6379):
run("redis-cli -i")
The database might be installed on a client only reachable from the client
host (as opposed to *on* the client itself)::
# Map localhost:6379 on the server to redis.internal:6379 on the client
with remote_tunnel(6379, local_host="redis.internal")
run("redis-cli -i")
``remote_tunnel`` accepts up to four arguments:
* ``remote_port`` (mandatory) is the remote port to listen to.
* ``local_port`` (optional) is the local port to connect to; the default is
the same port as the remote one.
* ``local_host`` (optional) is the locally-reachable computer (DNS name or
IP address) to connect to; the default is ``localhost`` (that is, the
same computer Fabric is running on).
* ``remote_bind_address`` (optional) is the remote IP address to bind to
for listening, on the current target. It should be an IP address assigned
to an interface on the target (or a DNS name that resolves to such IP).
You can use "0.0.0.0" to bind to all interfaces.
.. note::
By default, most SSH servers only allow remote tunnels to listen to the
localhost interface (127.0.0.1). In these cases, `remote_bind_address`
is ignored by the server, and the tunnel will listen only to 127.0.0.1.
.. versionadded: 1.6
"""
if local_port is None:
local_port = remote_port
sockets = []
channels = []
threads = []
def accept(channel, (src_addr, src_port), (dest_addr, dest_port)):
channels.append(channel)
sock = socket.socket()
sockets.append(sock)
try:
sock.connect((local_host, local_port))
except Exception:
print "[%s] rtunnel: cannot connect to %s:%d (from local)" % (
env.host_string, local_host, local_port)
channel.close()
return
print "[%s] rtunnel: opened reverse tunnel: %r -> %r -> %r"\
% (env.host_string, channel.origin_addr,
channel.getpeername(), (local_host, local_port))
th = ThreadHandler('fwd', _forwarder, channel, sock)
threads.append(th)
