parallel-ssh 2.11.1__py3-none-any.whl → 2.13.0__py3-none-any.whl

pssh/clients/base/parallel.py

@@ -23,7 +23,7 @@ import gevent.pool
 from gevent import joinall, spawn, Timeout as GTimeout
 from gevent.hub import Hub
 
-from ..common import _validate_pkey_path
+from ..common import _validate_pkey_path, _validate_pkey
 from ...config import HostConfig
 from ...constants import DEFAULT_RETRIES, RETRY_DELAY
 from ...exceptions import HostArgumentError, Timeout, ShellError, HostConfigError
@@ -39,7 +39,7 @@ class BaseParallelSSHClient(object):
     def __init__(self, hosts, user=None, password=None, port=None, pkey=None,
                  allow_agent=True,
                  num_retries=DEFAULT_RETRIES,
-                 timeout=120, pool_size=10,
+                 timeout=120, pool_size=100,
                  host_config=None, retry_delay=RETRY_DELAY,
                  identity_auth=True,
                  ipv6_only=False,
@@ -64,7 +64,8 @@ class BaseParallelSSHClient(object):
         self.user = user
         self.password = password
         self.port = port
-        self.pkey = pkey
+        self.pkey = _validate_pkey(pkey)
+        self.__pkey_data = self._load_pkey_data(pkey) if pkey is not None else None
         self.num_retries = num_retries
         self.timeout = timeout
         self._host_clients = {}
@@ -113,9 +114,26 @@ class BaseParallelSSHClient(object):
             self._host_clients.pop((i, host), None)
         self._hosts = _hosts
 
+    def __del__(self):
+        self.disconnect()
+
+    def disconnect(self):
+        """Disconnect all clients."""
+        if not hasattr(self, '_host_clients'):
+            return
+        for s_client in self._host_clients.values():
+            try:
+                s_client.disconnect()
+            except Exception as ex:
+                logger.debug("Client disconnect failed with %s", ex)
+                pass
+
     def _check_host_config(self):
         if self.host_config is None:
             return
+        if not isinstance(self.host_config, list):
+            raise HostConfigError("Host configuration of type %s is invalid - valid types are List[HostConfig]",
+                                  type(self.host_config))
         host_len = len(self.hosts)
         if host_len != len(self.host_config):
             raise ValueError(
@@ -231,6 +249,7 @@ class BaseParallelSSHClient(object):
 
     def _get_output_from_greenlet(self, cmd_i, cmd, raise_error=False):
         host = self.hosts[cmd_i]
+        alias = self._get_host_config(cmd_i).alias
         try:
             host_out = cmd.get()
             return host_out
@@ -239,8 +258,7 @@ class BaseParallelSSHClient(object):
                 ex = Timeout()
             if raise_error:
                 raise ex
-            return HostOutput(host, None, None, None,
-                              exception=ex)
+            return HostOutput(host, None, None, None, exception=ex, alias=alias)
 
     def get_last_output(self, cmds=None):
         """Get output for last commands executed by ``run_command``.
@@ -248,7 +266,7 @@ class BaseParallelSSHClient(object):
         :param cmds: Commands to get output for. Defaults to ``client.cmds``
         :type cmds: list(:py:class:`gevent.Greenlet`)
 
-        :rtype: dict or list
+        :rtype: list(:py:class:`pssh.output.HostOutput`)
         """
         cmds = self.cmds if cmds is None else cmds
         if cmds is None:
@@ -256,7 +274,7 @@ class BaseParallelSSHClient(object):
         return self._get_output_from_cmds(
             cmds, raise_error=False)
 
-    def _get_host_config(self, host_i, host):
+    def _get_host_config(self, host_i):
         if self.host_config is None:
             config = HostConfig(
                 user=self.user, port=self.port, password=self.password, private_key=self.pkey,
@@ -274,9 +292,6 @@ class BaseParallelSSHClient(object):
                 gssapi_delegate_credentials=self.gssapi_delegate_credentials,
             )
             return config
-        elif not isinstance(self.host_config, list):
-            raise HostConfigError("Host configuration of type %s is invalid - valid types are list[HostConfig]",
-                                  type(self.host_config))
         config = self.host_config[host_i]
         return config
 
@@ -284,7 +299,6 @@ class BaseParallelSSHClient(object):
                      shell=None, use_pty=False,
                      encoding='utf-8', read_timeout=None):
         """Make SSHClient if needed, run command on host"""
-        logger.debug("_run_command with read timeout %s", read_timeout)
         try:
             _client = self._get_ssh_client(host_i, host)
             host_out = _client.run_command(
@@ -310,13 +324,13 @@ class BaseParallelSSHClient(object):
         :returns: list of greenlets to ``joinall`` with.
         :rtype: list(:py:mod:`gevent.greenlet.Greenlet`)
         """
-        cmds = [spawn(self._get_ssh_client, i, host) for i, host in enumerate(self.hosts)]
+        cmds = [self.pool.spawn(self._get_ssh_client, i, host) for i, host in enumerate(self.hosts)]
         return cmds
 
     def _consume_output(self, stdout, stderr):
-        for line in stdout:
+        for _ in stdout:
             pass
-        for line in stderr:
+        for _ in stderr:
             pass
 
     def join(self, output=None, consume_output=False, timeout=None):
@@ -345,6 +359,9 @@ class BaseParallelSSHClient(object):
         :rtype: ``None``"""
         if output is None:
             output = self.get_last_output()
+            if output is None:
+                logger.info("No last output to join on - run_command has never been run.")
+                return
         elif not isinstance(output, list):
             raise ValueError("Unexpected output object type")
         cmds = [self.pool.spawn(self._join, host_out, timeout=timeout,
@@ -543,19 +560,13 @@ class BaseParallelSSHClient(object):
         return client.copy_remote_file(
             remote_file, local_file, recurse=recurse, **kwargs)
 
-    def _handle_greenlet_exc(self, func, host, *args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as ex:
-            raise ex
-
     def _get_ssh_client(self, host_i, host):
         logger.debug("Make client request for host %s, (host_i, host) in clients: %s",
                      host, (host_i, host) in self._host_clients)
         _client = self._host_clients.get((host_i, host))
         if _client is not None:
             return _client
-        cfg = self._get_host_config(host_i, host)
+        cfg = self._get_host_config(host_i)
         _pkey = self.pkey if cfg.private_key is None else cfg.private_key
         _pkey_data = self._load_pkey_data(_pkey)
         _client = self._make_ssh_client(host, cfg, _pkey_data)
@@ -563,12 +574,12 @@ class BaseParallelSSHClient(object):
         return _client
 
     def _load_pkey_data(self, _pkey):
-        if isinstance(_pkey, str):
-            _validate_pkey_path(_pkey)
-            with open(_pkey, 'rb') as fh:
-                _pkey_data = fh.read()
-            return _pkey_data
-        return _pkey
+        if not isinstance(_pkey, str):
+            return _pkey
+        _pkey = _validate_pkey_path(_pkey)
+        with open(_pkey, 'rb') as fh:
+            _pkey_data = fh.read()
+        return _pkey_data
 
     def _make_ssh_client(self, host, cfg, _pkey_data):
         raise NotImplementedError

pssh/clients/base/single.py

@@ -23,19 +23,17 @@ from socket import gaierror as sock_gaierror, error as sock_error
 from gevent import sleep, socket, Timeout as GTimeout
 from gevent.hub import Hub
 from gevent.select import poll, POLLIN, POLLOUT
-
-from ssh2.utils import find_eol
 from ssh2.exceptions import AgentConnectionError, AgentListIdentitiesError, \
     AgentAuthenticationError, AgentGetIdentityError
+from ssh2.utils import find_eol
 
 from ..common import _validate_pkey
-from ...constants import DEFAULT_RETRIES, RETRY_DELAY
 from ..reader import ConcurrentRWBuffer
+from ...constants import DEFAULT_RETRIES, RETRY_DELAY
 from ...exceptions import UnknownHostError, AuthenticationError, \
     ConnectionError, Timeout, NoIPv6AddressFoundError
 from ...output import HostOutput, HostOutputBuffers, BufferData
 
-
 Hub.NOT_ERROR = (Exception,)
 host_logger = logging.getLogger('pssh.host_logger')
 logger = logging.getLogger(__name__)
@@ -70,6 +68,8 @@ class Stdin(object):
 
     def flush(self):
         """Flush pending data written to stdin."""
+        if not hasattr(self._channel, "flush"):
+            return
         return self._client._eagain(self._channel.flush)
 
 
@@ -159,7 +159,7 @@ class BaseSSHClient(object):
 
     def __init__(self, host,
                  user=None, password=None, port=None,
-                 pkey=None,
+                 pkey=None, alias=None,
                  num_retries=DEFAULT_RETRIES,
                  retry_delay=RETRY_DELAY,
                  allow_agent=True, timeout=None,
@@ -171,6 +171,7 @@ class BaseSSHClient(object):
                  ):
         self._auth_thread_pool = _auth_thread_pool
         self.host = host
+        self.alias = alias
         self.user = user if user else getuser()
         self.password = password
         self.port = port if port else 22
@@ -286,7 +287,7 @@ class BaseSSHClient(object):
             raise unknown_ex from ex
         for i, (family, _type, proto, _, sock_addr) in enumerate(addr_info):
             try:
-                return self._connect_socket(family, _type, proto, sock_addr, host, port, retries)
+                return self._connect_socket(family, _type, sock_addr, host, port, retries)
             except ConnectionRefusedError as ex:
                 if i+1 == len(addr_info):
                     logger.error("No available addresses from %s", [addr[4] for addr in addr_info])
@@ -294,7 +295,7 @@ class BaseSSHClient(object):
                     raise
                 continue
 
-    def _connect_socket(self, family, _type, proto, sock_addr, host, port, retries):
+    def _connect_socket(self, family, _type, sock_addr, host, port, retries):
         self.sock = socket.socket(family, _type)
         if self.timeout:
             self.sock.settimeout(self.timeout)
@@ -409,7 +410,7 @@ class BaseSSHClient(object):
             stdout=BufferData(rw_buffer=_stdout_buffer, reader=_stdout_reader),
             stderr=BufferData(rw_buffer=_stderr_buffer, reader=_stderr_reader))
         host_out = HostOutput(
-            host=self.host, channel=channel, stdin=Stdin(channel, self),
+            host=self.host, alias=self.alias, channel=channel, stdin=Stdin(channel, self),
             client=self, encoding=encoding, read_timeout=read_timeout,
             buffers=_buffers,
         )
@@ -427,6 +428,8 @@ class BaseSSHClient(object):
 
         :param stderr_buffer: Buffer to read from.
         :type stderr_buffer: :py:class:`pssh.clients.reader.ConcurrentRWBuffer`
+        :param timeout: Timeout in seconds - defaults to no timeout.
+        :type timeout: int or float
         :rtype: generator
         """
         logger.debug("Reading from stderr buffer, timeout=%s", timeout)
@@ -438,6 +441,8 @@ class BaseSSHClient(object):
 
         :param stdout_buffer: Buffer to read from.
         :type stdout_buffer: :py:class:`pssh.clients.reader.ConcurrentRWBuffer`
+        :param timeout: Timeout in seconds - defaults to no timeout.
+        :type timeout: int or float
         :rtype: generator
         """
         logger.debug("Reading from stdout buffer, timeout=%s", timeout)
@@ -491,14 +496,16 @@ class BaseSSHClient(object):
                            encoding='utf-8'):
         """Read from output buffers and log to ``host_logger``.
 
-        :param output_buffer: Iterator containing buffer
+        :param output_buffer: Iterator containing buffer.
         :type output_buffer: iterator
-        :param prefix: String to prefix log output to ``host_logger`` with
+        :param prefix: String to prefix log output to ``host_logger`` with.
         :type prefix: str
-        :param callback: Function to call back once buffer is depleted:
+        :param callback: Function to call back once buffer is depleted.
         :type callback: function
-        :param callback_args: Arguments for call back function
+        :param callback_args: Arguments for call back function.
         :type callback_args: tuple
+        :param encoding: Encoding for output.
+        :type encoding: str
         """
         prefix = '' if prefix is None else prefix
         for line in output_buffer:
@@ -552,7 +559,7 @@ class BaseSSHClient(object):
         host_out = self._make_host_output(channel, encoding, _timeout)
         return host_out
 
-    def _eagain_write_errcode(self, write_func, data, eagain, timeout=None):
+    def _eagain_write_errcode(self, write_func, data, eagain):
         data_len = len(data)
         total_written = 0
         while total_written < data_len:
@@ -569,9 +576,10 @@ class BaseSSHClient(object):
             while ret == eagain:
                 self.poll()
                 ret = func(*args, **kwargs)
+                sleep()
             return ret
 
-    def _eagain_write(self, write_func, data, timeout=None):
+    def _eagain_write(self, write_func, data):
         raise NotImplementedError
 
     def _eagain(self, func, *args, **kwargs):

pssh/clients/native/parallel.py

@@ -127,7 +127,6 @@ class ParallelSSHClient(BaseParallelSSHClient):
             identity_auth=identity_auth,
             ipv6_only=ipv6_only,
         )
-        self.pkey = _validate_pkey(pkey)
         self.proxy_host = proxy_host
         self.proxy_port = proxy_port
         self.proxy_pkey = _validate_pkey(proxy_pkey)
@@ -216,21 +215,11 @@ class ParallelSSHClient(BaseParallelSSHClient):
             read_timeout=read_timeout,
         )
 
-    def __del__(self):
-        if not hasattr(self, '_host_clients'):
-            return
-        for s_client in self._host_clients.values():
-            try:
-                s_client.disconnect()
-            except Exception as ex:
-                logger.debug("Client disconnect failed with %s", ex)
-                pass
-            del s_client
-
     def _make_ssh_client(self, host, cfg, _pkey_data):
         _client = SSHClient(
             host, user=cfg.user or self.user, password=cfg.password or self.password, port=cfg.port or self.port,
             pkey=_pkey_data, num_retries=cfg.num_retries or self.num_retries,
+            alias=cfg.alias,
             timeout=cfg.timeout or self.timeout,
             allow_agent=cfg.allow_agent or self.allow_agent, retry_delay=cfg.retry_delay or self.retry_delay,
             proxy_host=cfg.proxy_host or self.proxy_host,
@@ -370,16 +359,12 @@ class ParallelSSHClient(BaseParallelSSHClient):
             encoding=encoding)
 
     def _scp_send(self, host_i, host, local_file, remote_file, recurse=False):
-        self._get_ssh_client(host_i, host)
-        return self._handle_greenlet_exc(
-            self._host_clients[(host_i, host)].scp_send, host,
-            local_file, remote_file, recurse=recurse)
+        _client = self._get_ssh_client(host_i, host)
+        return _client.scp_send(local_file, remote_file, recurse=recurse)
 
     def _scp_recv(self, host_i, host, remote_file, local_file, recurse=False):
-        self._get_ssh_client(host_i, host)
-        return self._handle_greenlet_exc(
-            self._host_clients[(host_i, host)].scp_recv, host,
-            remote_file, local_file, recurse=recurse)
+        _client = self._get_ssh_client(host_i, host)
+        return _client.scp_recv(remote_file, local_file, recurse=recurse)
 
     def scp_send(self, local_file, remote_file, recurse=False, copy_args=None):
         """Copy local file to remote file in parallel via SCP.
@@ -404,6 +389,11 @@ class ParallelSSHClient(BaseParallelSSHClient):
         :type local_file: str
         :param remote_file: Remote filepath on remote host to copy file to
         :type remote_file: str
+        :param copy_args: (Optional) format local_file and remote_file strings
+          with per-host arguments in ``copy_args``.   ``copy_args`` length must
+          equal length of host list -
+          :py:class:`pssh.exceptions.HostArgumentError` is raised otherwise
+        :type copy_args: tuple or list
         :param recurse: Whether or not to descend into directories recursively.
         :type recurse: bool
 
@@ -415,7 +405,7 @@ class ParallelSSHClient(BaseParallelSSHClient):
         """
         copy_args = [{'local_file': local_file,
                       'remote_file': remote_file}
-                     for i, host in enumerate(self.hosts)] \
+                     for _ in self.hosts] \
             if copy_args is None else copy_args
         local_file = "%(local_file)s"
         remote_file = "%(remote_file)s"

pssh/clients/native/single.py

@@ -18,7 +18,6 @@
 import logging
 import os
 from collections import deque
-from warnings import warn
 
 from gevent import sleep, spawn, get_hub
 from gevent.lock import RLock
@@ -33,11 +32,10 @@ from ssh2.sftp import LIBSSH2_FXF_READ, LIBSSH2_FXF_CREAT, LIBSSH2_FXF_WRITE, \
 
 from .tunnel import FORWARDER
 from ..base.single import BaseSSHClient
-from ...output import HostOutput
+from ...constants import DEFAULT_RETRIES, RETRY_DELAY
 from ...exceptions import SessionError, SFTPError, \
     SFTPIOError, Timeout, SCPError, ProxyError
-from ...constants import DEFAULT_RETRIES, RETRY_DELAY
-
+from ...output import HostOutput
 
 logger = logging.getLogger(__name__)
 THREAD_POOL = get_hub().threadpool
@@ -50,7 +48,7 @@ class SSHClient(BaseSSHClient):
 
     def __init__(self, host,
                  user=None, password=None, port=None,
-                 pkey=None,
+                 pkey=None, alias=None,
                  num_retries=DEFAULT_RETRIES,
                  retry_delay=RETRY_DELAY,
                  allow_agent=True, timeout=None,
@@ -64,12 +62,15 @@ class SSHClient(BaseSSHClient):
                  identity_auth=True,
                  ipv6_only=False,
                  ):
-        """:param host: Host name or IP to connect to.
+        """
+        :param host: Host name or IP to connect to.
         :type host: str
         :param user: User to connect as. Defaults to logged in user.
         :type user: str
         :param password: Password to use for password authentication.
         :type password: str
+        :param alias: Use an alias for this host.
+        :type alias: str
         :param port: SSH port to connect to. Defaults to SSH default (22)
         :type port: int
         :param pkey: Private key file path to use for authentication. Path must
@@ -115,6 +116,7 @@ class SSHClient(BaseSSHClient):
         self.keepalive_seconds = keepalive_seconds
         self._keepalive_greenlet = None
         self._proxy_client = None
+        self.alias = alias
         self.host = host
         self.port = port if port is not None else 22
         if proxy_host is not None:
@@ -131,9 +133,10 @@ class SSHClient(BaseSSHClient):
                 identity_auth=identity_auth,
             )
             proxy_host = '127.0.0.1'
-        self._chan_lock = RLock()
+        self._chan_stdout_lock = RLock()
+        self._chan_stderr_lock = RLock()
         super(SSHClient, self).__init__(
-            host, user=user, password=password, port=port, pkey=pkey,
+            host, user=user, password=password, alias=alias, port=port, pkey=pkey,
             num_retries=num_retries, retry_delay=retry_delay,
             allow_agent=allow_agent, _auth_thread_pool=_auth_thread_pool,
             timeout=timeout,
@@ -146,7 +149,7 @@ class SSHClient(BaseSSHClient):
         return self._eagain(channel.shell)
 
     def _connect_proxy(self, proxy_host, proxy_port, proxy_pkey,
-                       user=None, password=None,
+                       user=None, password=None, alias=None,
                        num_retries=DEFAULT_RETRIES,
                        retry_delay=RETRY_DELAY,
                        allow_agent=True, timeout=None,
@@ -156,7 +159,7 @@ class SSHClient(BaseSSHClient):
         assert isinstance(self.port, int)
         try:
             self._proxy_client = SSHClient(
-                proxy_host, port=proxy_port, pkey=proxy_pkey,
+                proxy_host, port=proxy_port, pkey=proxy_pkey, alias=alias,
                 num_retries=num_retries, user=user, password=password,
                 retry_delay=retry_delay, allow_agent=allow_agent,
                 timeout=timeout, forward_ssh_agent=forward_ssh_agent,
@@ -210,10 +213,12 @@ class SSHClient(BaseSSHClient):
             sleep(self._eagain(self.session.keepalive_send))
 
     def configure_keepalive(self):
+        """Configures keepalive on the server for `self.keepalive_seconds`."""
         self.session.keepalive_config(False, self.keepalive_seconds)
 
     def _init_session(self, retries=1):
         self.session = Session()
+
         if self.timeout:
             # libssh2 timeout is in ms
             self.session.set_timeout(self.timeout * 1000)
@@ -228,6 +233,8 @@ class SSHClient(BaseSSHClient):
                 return self._connect_init_session_retry(retries=retries+1)
             msg = "Error connecting to host %s:%s - %s"
             logger.error(msg, self.host, self.port, ex)
+            if not self.sock.closed:
+                self.sock.close()
             if isinstance(ex, SSH2Timeout):
                 raise Timeout(msg, self.host, self.port, ex)
             raise
@@ -261,16 +268,15 @@ class SSHClient(BaseSSHClient):
         return chan
 
     def open_session(self):
-        """Open new channel from session"""
+        """Open new channel from session.
+
+        :rtype: :py:class:`ssh2.channel.Channel`
+        """
         try:
             chan = self._open_session()
         except Exception as ex:
             raise SessionError(ex)
-        if self.forward_ssh_agent and not self._forward_requested:
-            if not hasattr(chan, 'request_auth_agent'):
-                warn("Requested SSH Agent forwarding but libssh2 version used "
-                     "does not support it - ignoring")
-                return chan
+        # if self.forward_ssh_agent and not self._forward_requested:
             # self._eagain(chan.request_auth_agent)
             # self._forward_requested = True
         return chan
@@ -300,18 +306,19 @@ class SSHClient(BaseSSHClient):
         self._eagain(channel.execute, cmd)
         return channel
 
-    def _read_output_to_buffer(self, read_func, _buffer):
+    def _read_output_to_buffer(self, read_func, _buffer, is_stderr=False):
+        _lock = self._chan_stderr_lock if is_stderr else self._chan_stdout_lock
         try:
             while True:
-                with self._chan_lock:
+                with _lock:
                     size, data = read_func()
-                while size == LIBSSH2_ERROR_EAGAIN:
+                if size == LIBSSH2_ERROR_EAGAIN:
                     self.poll()
-                    with self._chan_lock:
-                        size, data = read_func()
+                    continue
                 if size <= 0:
                     break
                 _buffer.write(data)
+                sleep()
         finally:
             _buffer.eof.set()
 
@@ -339,7 +346,7 @@ class SSHClient(BaseSSHClient):
         self.close_channel(channel)
 
     def close_channel(self, channel):
-        with self._chan_lock:
+        with self._chan_stdout_lock, self._chan_stderr_lock:
             logger.debug("Closing channel")
             self._eagain(channel.close)
 
@@ -350,7 +357,6 @@ class SSHClient(BaseSSHClient):
         return self._eagain(self.session.sftp_init)
 
     def _make_sftp(self):
-        """Make SFTP client from open transport"""
         try:
             sftp = self._make_sftp_eagain()
         except Exception as ex:
@@ -358,7 +364,7 @@ class SSHClient(BaseSSHClient):
         return sftp
 
     def _mkdir(self, sftp, directory):
-        """Make directory via SFTP channel
+        """Make directory via SFTP channel.
 
         :param sftp: SFTP client object
         :type sftp: :py:class:`ssh2.sftp.SFTP`
@@ -428,10 +434,22 @@ class SSHClient(BaseSSHClient):
                 data = local_fh.read(self._BUF_SIZE)
 
     def sftp_put(self, sftp, local_file, remote_file):
+        """Perform an SFTP put - copy local file path to remote via SFTP.
+
+        :param sftp: SFTP client object.
+        :type sftp: :py:class:`ssh2.sftp.SFTP`
+        :param local_file: Local filepath to copy to remote host.
+        :type local_file: str
+        :param remote_file: Remote filepath on remote host to copy file to.
+        :type remote_file: str
+
+        :raises: :py:class:`pssh.exceptions.SFTPIOError` on I/O errors writing
+          via SFTP.
+        """
         mode = LIBSSH2_SFTP_S_IRUSR | \
-               LIBSSH2_SFTP_S_IWUSR | \
-               LIBSSH2_SFTP_S_IRGRP | \
-               LIBSSH2_SFTP_S_IROTH
+            LIBSSH2_SFTP_S_IWUSR | \
+            LIBSSH2_SFTP_S_IRGRP | \
+            LIBSSH2_SFTP_S_IROTH
         f_flags = LIBSSH2_FXF_CREAT | LIBSSH2_FXF_WRITE | LIBSSH2_FXF_TRUNC
         with self._sftp_openfh(
                 sftp.open, remote_file, f_flags, mode) as remote_fh:
@@ -557,6 +575,9 @@ class SSHClient(BaseSSHClient):
         :type local_file: str
         :param recurse: Whether or not to recursively copy directories
         :type recurse: bool
+        :param sftp: The SFTP channel to use instead of creating a new one.
+          Only used when ``recurse`` is ``True``.
+        :type sftp: :py:class:`ssh2.sftp.SFTP`
         :param encoding: Encoding to use for file paths when recursion is
           enabled.
         :type encoding: str
@@ -614,6 +635,9 @@ class SSHClient(BaseSSHClient):
         :type local_file: str
         :param remote_file: Remote filepath on remote host to copy file to
         :type remote_file: str
+        :param sftp: The SFTP channel to use instead of creating a new one.
+          Only used when ``recurse`` is ``True``.
+        :type sftp: :py:class:`ssh2.sftp.SFTP`
         :param recurse: Whether or not to descend into directories recursively.
         :type recurse: bool
 
@@ -643,9 +667,9 @@ class SSHClient(BaseSSHClient):
         elif remote_file.endswith('/'):
             local_filename = local_file.rsplit('/')[-1]
             remote_file += local_filename
-        self._scp_send(local_file, remote_file)
         logger.info("SCP local file %s to remote destination %s:%s",
                     local_file, self.host, remote_file)
+        self._scp_send(local_file, remote_file)
 
     def _scp_send(self, local_file, remote_file):
         fileinfo = os.stat(local_file)
@@ -734,12 +758,12 @@ class SSHClient(BaseSSHClient):
             LIBSSH2_SESSION_BLOCK_OUTBOUND,
         )
 
-    def _eagain_write(self, write_func, data, timeout=None):
+    def _eagain_write(self, write_func, data):
         """Write data with given write_func for an ssh2-python session while
         handling EAGAIN and resuming writes from last written byte on each call to
         write_func.
         """
-        return self._eagain_write_errcode(write_func, data, LIBSSH2_ERROR_EAGAIN, timeout=timeout)
+        return self._eagain_write_errcode(write_func, data, LIBSSH2_ERROR_EAGAIN)
 
-    def eagain_write(self, write_func, data, timeout=None):
-        return self._eagain_write(write_func, data, timeout=timeout)
+    def eagain_write(self, write_func, data):
+        return self._eagain_write(write_func, data)

pssh/clients/native/tunnel.py

@@ -16,12 +16,8 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 import logging
-
+from queue import Queue
 from threading import Thread, Event
-try:
-    from queue import Queue
-except ImportError:
-    from Queue import Queue
 
 from gevent import spawn, joinall, get_hub, sleep
 from gevent.server import StreamServer
@@ -29,7 +25,6 @@ from ssh2.error_codes import LIBSSH2_ERROR_EAGAIN
 
 from ...constants import DEFAULT_RETRIES
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -193,7 +188,7 @@ class TunnelServer(StreamServer):
                 sleep(.01)
                 continue
             try:
-                self._client._eagain_write(channel.write, data)
+                self._client.eagain_write(channel.write, data)
             except Exception as ex:
                 logger.error("Error writing data to channel - %s", ex)
                 raise