def _connection_settings(self, vm=None, **ssh_config_overrides):
host = 'vagrant-temporary-%s' % self.uuid(vm=vm)
# Extract current SSH settings
self.up(vm=vm)
ssh_settings = self.ssh_config(vm=vm)
ssh_settings.update({'host': host, 'stricthostkeychecking': 'no'})
ssh_settings.update(ssh_config_overrides)
# Ensure that SSH config is being picked up and update it with the
# connection settings for the vagrant box
with settings(use_ssh_config=True):
from fabric.network import ssh_config
ssh_config('test') # ensure that ssh config is in use and cached
modified_config = copy.deepcopy(env._ssh_config)
modified_config._config.append(ssh_settings)
return {
'use_ssh_config': True,
'host': host,
'host_string': '%(user)s@%(host)s:%(port)s' % ssh_settings,
'_ssh_config': modified_config,
'cwd': '',
'path': ''
}
def _connection_settings(self, vm=None, **ssh_config_overrides):
host = 'vagrant-temporary-%s' % self.uuid(vm=vm)
# Extract current SSH settings
self.up(vm=vm)
ssh_settings = self.ssh_config(vm=vm)
ssh_settings.update({
'host': host,
'stricthostkeychecking': 'no'
})
ssh_settings.update(ssh_config_overrides)
# Ensure that SSH config is being picked up and update it with the
# connection settings for the vagrant box
with settings(use_ssh_config=True):
from fabric.network import ssh_config
ssh_config('test') # ensure that ssh config is in use and cached
modified_config = copy.deepcopy(env._ssh_config)
modified_config._config.append(ssh_settings)
return {
'use_ssh_config': True,
'host': host,
'host_string': '%(user)s@%(host)s:%(port)s' % ssh_settings,
'_ssh_config': modified_config,
'cwd': '',
'path': ''
}
def _check_if_using_the_correct_account():
# Ensure that the user we use to log in has the right credentials
# OpenVMS' SSH2 doesn't handle well the connections where both a wrong
# pkey and a valid password are given with paramiko under the hoods.
# This is an issue with paramiko as of 1.16 (see related Issue#519)
with settings(use_ssh_config=True):
if 'user' in ssh_config() and 'user' in env:
if ssh_config(env.host_string)['user'].upper() != env.user.upper():
# Avoid using private keys if user doesn't match env.user
puts('Avoid using ssh_config')
env.use_ssh_config = False
else:
puts('Not using ssh_config:\n {}'
.format(ssh_config(env.host_string)))
env.use_ssh_config = False
def this_hostname(hostname):
"""
Context manager that uses the current SSH confg to switch Fabric to a specific hostname.
Updates hostname and port.
"""
host_config = ssh_config(hostname)
host_string = hostname
port = host_config.get("port", env.default_port)
with settings(host_string=host_string,
port=port):
yield
def main():
parser = argparse.ArgumentParser(description="Run youtube-dl on a remote host and bring the resulting file back here.", add_help=False)
parser.add_argument('-h', '--host', action='store', required=False)
parser.add_argument('--verbose', action='store_true', required=False)
parser.add_argument('--save-default', action='store_true', required=False)
parser.add_argument('url', action='store', nargs='?', default=None)
args = parser.parse_args()
xargs = args
host = validate_host(args)
if args.url is None:
parser.print_help()
sys.exit(1)
env.use_ssh_config = True
env.host_string = host
if not args.verbose:
fabric_output['stdout'] = False
fabric_output['stderr'] = False
fabric_output['status'] = False
fabric_output['aborts'] = False
fabric_output['warnings'] = False
fabric_output['running'] = False
#XXX: does every ssh config actually need a user? (shrug)
if ssh_config().get('user') is None:
output('Host {} does not appear to be configured in your ssh config file, it must be configured for {} to work.'.format(host, PROGRAM))
sys.exit(1)
try:
download(args.url)
except ProgramNotFound:
output('Host {} does not appear to have youtube-dl installed. Please install it.'.format(host))
except YoutubeDLError as e:
output(e.message)
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=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
