def _normal_list(docstrings=True): result = [] task_names, modules = _task_names(state.commands) # Want separator between name, description to be straight col max_len = reduce(lambda a, b: max(a, len(b)), task_names, 0) max_len2 = reduce(lambda a, b: max(a, len(b)), modules, 0) sep = ' ' trail = '...' max_width = _pty_size()[1] - 1 - len(trail) for i in range(0, len(task_names) - 1): output = None docstring = _print_docstring(docstrings, task_names[i]) if docstring: lines = filter(None, docstring.splitlines()) first_line = list(lines)[0].strip() # Truncate it if it's longer than N chars size = max_width - (max_len + max_len2 + len(sep) + len(trail)) if len(first_line) > size: first_line = first_line[:size] + trail output = task_names[i].ljust(max_len) + sep + modules[i].ljust( max_len2) + sep + first_line # Or nothing (so just the name) else: output = task_names[i] result.append(indent(output)) return result
def __init__(self, channel, command=None, stdout=None, stderr=None, timeout=None): # timeout is for interact thread self.channel = channel self.stdout = stdout or sys.stdout self.stderr = stderr or sys.stderr self.timeout = env.command_timeout if (timeout is None) else timeout self.last_line = None self.last_match = None self.channel.set_combine_stderr(True) rows, cols = _pty_size() channel.get_pty(width=cols, height=rows) channel.settimeout(timeout) channel.invoke_shell() if command: channel.sendall(command + "\n") # switch to file IO self.fd = self.channel.makefile('rwb')
def _normal_list(docstrings=True): result = [] task_names = _task_names(state.commands) # Want separator between name, description to be straight col max_len = reduce(lambda a, b: max(a, len(b)), task_names, 0) sep = ' ' trail = '...' max_width = _pty_size()[1] - 1 - len(trail) for name in task_names: docstring = _print_docstring(docstrings, name) if docstring: lines = filter(None, docstring.splitlines()) first_line = lines[0].strip() # Truncate it if it's longer than N chars size = max_width - (max_len + len(sep) + len(trail)) if len(first_line) > size: first_line = first_line[:size] + trail output = name.ljust(max_len) + sep + first_line # Or nothing (so just the name) else: output = name result.append(indent(output)) return result
def _list_formatter(task_names, docstrings=True): # Want separator between name, description to be straight col result = [] max_len = reduce(lambda a, b: max(a, len(b)), task_names, 0) sep = ' ' trail = '...' max_width = _pty_size()[1] - 1 - len(trail) for name in task_names: output = None docstring = _print_docstring(docstrings, name) if docstring: lines = filter(None, docstring.splitlines()) first_line = lines[0].strip() # Truncate it if it's longer than N chars size = max_width - (max_len + len(sep) + len(trail)) if len(first_line) > size: first_line = first_line[:size] + trail output = name.ljust(max_len) + sep + first_line # Or nothing (so just the name) else: output = name result.append(indent(output)) return result
def __init__(self, channel, command = None, stdout=None, stderr=None, timeout=None): # timeout is for interact thread self.channel = channel self.stdout = stdout or sys.stdout self.stderr = stderr or sys.stderr self.timeout = env.command_timeout if (timeout is None) else timeout self.last_line = None self.last_match = None self.channel.set_combine_stderr(True) rows, cols = _pty_size() channel.get_pty(width=cols, height=rows) channel.settimeout(timeout) channel.invoke_shell() if command: channel.sendall(command + "\n") # switch to file IO self.fd = self.channel.makefile('rwb')
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): """ 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. """ 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', unless user has turned it off. if not env.no_agent_forward: forward = ssh.agent.AgentClientProxy(channel) # 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] time.sleep(ssh.io_sleep) # 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
def _execute(channel, command, pty=True, combine_stderr=None, 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``. 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. """ 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', unless user has turned it off. if not env.no_agent_forward: forward = ssh.agent.AgentClientProxy(channel) # 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] time.sleep(ssh.io_sleep) # 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