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

pssh/clients/reader.py

@@ -17,31 +17,43 @@
 
 from io import BytesIO
 
-from gevent import sleep
 from gevent.event import Event
 from gevent.lock import RLock
 
 
+class _Eof(Event):
+    def __init__(self, unread_data):
+        self._unread_data = unread_data
+        Event.__init__(self)
+
+    def set(self):
+        self._unread_data.set()
+        Event.set(self)
+
+
 class ConcurrentRWBuffer(object):
     """Concurrent reader/writer of bytes for use from multiple greenlets.
 
-    Supports both concurrent reading and writing.
+    Supports both concurrent reading and writing and combinations there of.
 
-    Iterate on buffer object to read data, yielding greenlet if no data exists
+    Iterate on buffer object to read data, yielding event loop if no data exists
     until self.eof has been set.
 
-    Writers should ``eof.set()`` when finished writing data via ``write``.
+    Check if end-of-file without blocking with ``ConcurrentRWBuffer.eof.is_set()``.
+
+    Writers should call ``ConcurrentRWBuffer.eof.set()`` when finished writing data via ``write``.
 
     Readers can use ``read()`` to get any available data or ``None``.
     """
-    __slots__ = ('_buffer', '_read_pos', '_write_pos', 'eof', '_lock')
+    __slots__ = ('_buffer', '_read_pos', '_write_pos', 'eof', '_lock', '_unread_data')
 
     def __init__(self):
         self._buffer = BytesIO()
         self._read_pos = 0
         self._write_pos = 0
-        self.eof = Event()
         self._lock = RLock()
+        self._unread_data = Event()
+        self.eof = _Eof(self._unread_data)
 
     def write(self, data):
         """Write data to buffer.
@@ -53,14 +65,17 @@ class ConcurrentRWBuffer(object):
             if not self._buffer.tell() == self._write_pos:
                 self._buffer.seek(self._write_pos)
             self._write_pos += self._buffer.write(data)
+            if not self._unread_data.is_set() and self._read_pos < self._write_pos:
+                self._unread_data.set()
 
     def read(self):
-        """Read available data, or return None
+        """Read available data, or return None.
 
         :rtype: bytes
         """
         with self._lock:
             if self._write_pos == 0 or self._read_pos == self._write_pos:
+                self._unread_data.clear()
                 return
             elif not self._buffer.tell() == self._read_pos:
                 self._buffer.seek(self._read_pos)
@@ -73,5 +88,5 @@ class ConcurrentRWBuffer(object):
             data = self.read()
             if data:
                 yield data
-            elif self._read_pos == self._write_pos:
-                sleep(.1)
+            else:
+                self._unread_data.wait()

pssh/clients/ssh/parallel.py

@@ -217,6 +217,7 @@ class ParallelSSHClient(BaseParallelSSHClient):
         _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,
             _auth_thread_pool=cfg.auth_thread_pool or self._auth_thread_pool,

pssh/clients/ssh/single.py

@@ -19,18 +19,17 @@ import logging
 
 from gevent import sleep, spawn, Timeout as GTimeout, joinall
 from ssh import options
-from ssh.session import Session, SSH_READ_PENDING, SSH_WRITE_PENDING
-from ssh.key import import_privkey_file, import_cert_file, copy_cert_to_privkey,\
-    import_privkey_base64
-from ssh.exceptions import EOF
 from ssh.error_codes import SSH_AGAIN
+from ssh.exceptions import EOF
+from ssh.key import import_privkey_file, import_cert_file, copy_cert_to_privkey, \
+    import_privkey_base64
+from ssh.session import Session, SSH_READ_PENDING, SSH_WRITE_PENDING
 
 from ..base.single import BaseSSHClient
 from ..common import _validate_pkey_path
-from ...output import HostOutput
-from ...exceptions import SessionError, Timeout
 from ...constants import DEFAULT_RETRIES, RETRY_DELAY
-
+from ...exceptions import SessionError, Timeout
+from ...output import HostOutput
 
 logger = logging.getLogger(__name__)
 
@@ -40,7 +39,7 @@ class SSHClient(BaseSSHClient):
 
     def __init__(self, host,
                  user=None, password=None, port=None,
-                 pkey=None,
+                 pkey=None, alias=None,
                  cert_file=None,
                  num_retries=DEFAULT_RETRIES,
                  retry_delay=RETRY_DELAY,
@@ -60,6 +59,8 @@ class SSHClient(BaseSSHClient):
         :type password: str
         :param port: SSH port to connect to. Defaults to SSH default (22)
         :type port: int
+        :param alias: Use an alias for this host.
+        :type alias: str
         :param pkey: Private key file path to use for authentication. Path must
           be either absolute path or relative to user home directory
           like ``~/<path>``.
@@ -114,7 +115,7 @@ class SSHClient(BaseSSHClient):
         self.gssapi_client_identity = gssapi_client_identity
         self.gssapi_delegate_credentials = gssapi_delegate_credentials
         super(SSHClient, self).__init__(
-            host, user=user, password=password, port=port, pkey=pkey,
+            host, user=user, password=password, port=port, pkey=pkey, alias=alias,
             num_retries=num_retries, retry_delay=retry_delay,
             allow_agent=allow_agent,
             _auth_thread_pool=_auth_thread_pool,
@@ -238,25 +239,22 @@ class SSHClient(BaseSSHClient):
         if use_pty:
             self._eagain(channel.request_pty, timeout=self.timeout)
         logger.debug("Executing command '%s'", cmd)
-        self._eagain(channel.request_exec, cmd, timeout=self.timeout)
+        self._eagain(channel.request_exec, cmd)
         return channel
 
     def _read_output_to_buffer(self, channel, _buffer, is_stderr=False):
-        while True:
-            self.poll()
-            try:
-                size, data = channel.read_nonblocking(is_stderr=is_stderr)
-            except EOF:
-                _buffer.eof.set()
-                sleep(.1)
-                return
-            if size > 0:
-                _buffer.write(data)
-            else:
-                # Yield event loop to other greenlets if we have no data to
-                # send back, meaning the generator does not yield and can there
-                # for block other generators/greenlets from running.
-                sleep(.1)
+        try:
+            while True:
+                self.poll()
+                try:
+                    size, data = channel.read_nonblocking(is_stderr=is_stderr)
+                except EOF:
+                    return
+                if size > 0:
+                    _buffer.write(data)
+                sleep()
+        finally:
+            _buffer.eof.set()
 
     def wait_finished(self, host_output, timeout=None):
         """Wait for EOF from channel and close channel.
@@ -313,7 +311,7 @@ class SSHClient(BaseSSHClient):
         :type channel: :py:class:`ssh.channel.Channel`
         """
         logger.debug("Closing channel")
-        self._eagain(channel.close, timeout=self.timeout)
+        self._eagain(channel.close)
 
     def poll(self, timeout=None):
         """ssh-python based co-operative gevent poll on session socket.
@@ -329,5 +327,5 @@ class SSHClient(BaseSSHClient):
         """Run function given and handle EAGAIN for an ssh-python session"""
         return self._eagain_errcode(func, SSH_AGAIN, *args, **kwargs)
 
-    def _eagain_write(self, write_func, data, timeout=None):
-        return self._eagain_write_errcode(write_func, data, SSH_AGAIN, timeout=timeout)
+    def _eagain_write(self, write_func, data):
+        return self._eagain_write_errcode(write_func, data, SSH_AGAIN)

pssh/config.py

@@ -25,7 +25,7 @@ class HostConfig(object):
     Used to hold individual configuration for each host in ParallelSSHClient host list.
     """
     __slots__ = ('user', 'port', 'password', 'private_key', 'allow_agent',
-                 'num_retries', 'retry_delay', 'timeout', 'identity_auth',
+                 'alias', 'num_retries', 'retry_delay', 'timeout', 'identity_auth',
                  'proxy_host', 'proxy_port', 'proxy_user', 'proxy_password', 'proxy_pkey',
                  'keepalive_seconds', 'ipv6_only', 'cert_file', 'auth_thread_pool', 'gssapi_auth',
                  'gssapi_server_identity', 'gssapi_client_identity', 'gssapi_delegate_credentials',
@@ -33,7 +33,7 @@ class HostConfig(object):
                  )
 
     def __init__(self, user=None, port=None, password=None, private_key=None,
-                 allow_agent=None, num_retries=None, retry_delay=None, timeout=None,
+                 allow_agent=None, alias=None, num_retries=None, retry_delay=None, timeout=None,
                  identity_auth=None,
                  proxy_host=None, proxy_port=None, proxy_user=None, proxy_password=None,
                  proxy_pkey=None,
@@ -58,6 +58,8 @@ class HostConfig(object):
         :type private_key: str
         :param allow_agent: Enable/disable SSH agent authentication.
         :type allow_agent: bool
+        :param alias: Use an alias for this host.
+        :type alias: str
         :param num_retries: Number of retry attempts before giving up on connection
           and SSH operations.
         :type num_retries: int
@@ -103,6 +105,7 @@ class HostConfig(object):
         self.password = password
         self.private_key = private_key
         self.allow_agent = allow_agent
+        self.alias = alias
         self.num_retries = num_retries
         self.timeout = timeout
         self.retry_delay = retry_delay
@@ -130,6 +133,8 @@ class HostConfig(object):
             raise ValueError("Port %s is not an integer" % (self.port,))
         if self.password is not None and not isinstance(self.password, str):
             raise ValueError("Password %s is not a string" % (self.password,))
+        if self.alias is not None and not isinstance(self.alias, str):
+            raise ValueError("Alias %s is not a string" % (self.alias,))
         if self.private_key is not None and not (
                 isinstance(self.private_key, str) or isinstance(self.private_key, bytes)
         ):

pssh/output.py

@@ -44,7 +44,7 @@ class BufferData(object):
         """
         :param reader: Greenlet reading data from channel and writing to rw_buffer
         :type reader: :py:class:`gevent.Greenlet`
-        :param rw_bufffer: Read/write buffer
+        :param rw_buffer: Read/write buffer
         :type rw_buffer: :py:class:`pssh.clients.reader.ConcurrentRWBuffer`
         """
         self.reader = reader
@@ -55,12 +55,12 @@ class HostOutput(object):
     """Host output"""
 
     __slots__ = ('host', 'channel', 'stdin',
-                 'client', 'exception', 'encoding', 'read_timeout',
-                 'buffers',
+                 'client', 'alias', 'exception',
+                 'encoding', 'read_timeout', 'buffers',
                  )
 
     def __init__(self, host, channel, stdin,
-                 client, exception=None, encoding='utf-8', read_timeout=None,
+                 client, alias=None, exception=None, encoding='utf-8', read_timeout=None,
                  buffers=None):
         """
         :param host: Host name output is for
@@ -70,7 +70,9 @@ class HostOutput(object):
         :param stdin: Standard input buffer
         :type stdin: :py:func:`file`-like object
         :param client: `SSHClient` output is coming from.
-        :type client: :py:class:`pssh.clients.base.single.BaseSSHClient`
+        :type client: :py:class:`pssh.clients.base.single.BaseSSHClient` or `None`.
+        :param alias: Host alias.
+        :type alias: str
         :param exception: Exception from host if any
         :type exception: :py:class:`Exception` or ``None``
         :param read_timeout: Timeout in seconds for reading from buffers.
@@ -82,6 +84,7 @@ class HostOutput(object):
         self.channel = channel
         self.stdin = stdin
         self.client = client
+        self.alias = alias
         self.exception = exception
         self.encoding = encoding
         self.read_timeout = read_timeout
@@ -117,12 +120,13 @@ class HostOutput(object):
 
     def __repr__(self):
         return "\thost={host}{linesep}" \
+            "\talias={alias}{linesep}" \
             "\texit_code={exit_code}{linesep}" \
             "\tchannel={channel}{linesep}" \
             "\texception={exception}{linesep}" \
             "\tencoding={encoding}{linesep}" \
             "\tread_timeout={read_timeout}".format(
-                host=self.host, channel=self.channel,
+                host=self.host, alias=self.alias, channel=self.channel,
                 exception=self.exception, linesep=linesep,
                 exit_code=self.exit_code, encoding=self.encoding, read_timeout=self.read_timeout,
             )

parallel_ssh-2.11.1.dist-info/RECORD

@@ -1,27 +0,0 @@
-pssh/__init__.py,sha256=Kd_8EGJTiujApfM-2gB4JlCr1m37rGQvtrlIaWu3CzM,1451
-pssh/_version.py,sha256=Oc3htkNS0sL05sUFjLa2gXhHYAZ65Defi2SyddJyChk,18445
-pssh/config.py,sha256=ypMYKOEt-9VgeVEyIP7KYX59HDInpri0z0tl4YBxo00,9783
-pssh/constants.py,sha256=toVllZuLBKxLYB8fuY_46UoPjmAA3J59oH1wS4OlL7g,1056
-pssh/exceptions.py,sha256=ZjnrT_Ye1v4OH582jNwYUCkI4NVgujCWwu8aB8XymUM,2561
-pssh/output.py,sha256=3m2EfWHBAadxyc-iwTVcHnskaUPKXv3OHm5OVr4vMQg,4489
-pssh/utils.py,sha256=qdsVnKGxZovWGZpGS3eUyrfCaeWTKX7yETfA29zbLMk,1802
-pssh/clients/__init__.py,sha256=ByjAWGrbhFnNz5dX3ED7sT3m8A-qKgWgBH4xsmZROrg,871
-pssh/clients/common.py,sha256=fd_jJj8ezDjwr3peN3LonLff5EYSNkMEre0yjlnRjBU,1375
-pssh/clients/reader.py,sha256=_9PgsPtlK1rsHbhwoxj_bSnWZlk1DgXFzYK8cGdzL88,2561
-pssh/clients/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pssh/clients/base/parallel.py,sha256=XjWFXai-pK5mwW-V49oUrOx41NHNrMt4ty_jZ4sR564,24526
-pssh/clients/base/single.py,sha256=zDI1-lAn5SMFsV_8PedTyceIXacze2lCWRk7z6POQBs,25741
-pssh/clients/native/__init__.py,sha256=dydX5Fae9U9gRBT8koPTM8H9u4t0rIgD1q9XammFYSs,865
-pssh/clients/native/parallel.py,sha256=RhVTc9Try_PP8QuI4MHLqseQYo6gHFXrfbLNGWsYkwY,24335
-pssh/clients/native/single.py,sha256=jKY--0H5szZiMkirfLJG5noDirsI4RLJpNDOSpUjksk,31162
-pssh/clients/native/tunnel.py,sha256=3YWDNS6YXb1cdbCehaeLyXZEY7m4sHlqj0dH_LHxrlc,9369
-pssh/clients/ssh/__init__.py,sha256=HgYZkVJ5QOgaVFp5snwyLZvQbp0Tbdxj8Gbyic2_Ibo,857
-pssh/clients/ssh/parallel.py,sha256=GMobYTyxuylqNJNKUYIIAZEGMYNpZe7ZniG3CnId2KU,11368
-pssh/clients/ssh/single.py,sha256=hqVRGUGy5srwQrbNwWP2adzSVFEQLh-8E3QNCpq4kD4,13805
-parallel_ssh-2.11.1.dist-info/COPYING,sha256=ZA2Q9u5AEkH_YoNNDRsz-DBJ6ZuL_foE7RsKFjXd4-c,18093
-parallel_ssh-2.11.1.dist-info/COPYING.LESSER,sha256=AKibDRiqzUEU3s95Ei24e_Nb3a8rxQ44PJyfTCYzkLI,24486
-parallel_ssh-2.11.1.dist-info/LICENSE,sha256=m4cqigcLitMpxL04D7G_AAD1ZMdQI-yOHmgD8VNkuek,26461
-parallel_ssh-2.11.1.dist-info/METADATA,sha256=BuxgH3pBR0R-5oF9kKPvVx-zT7z_OSfq2ck2sa9XC1w,10933
-parallel_ssh-2.11.1.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-parallel_ssh-2.11.1.dist-info/top_level.txt,sha256=s8P6ZHOwt2BYgDc62Cpd2z7i-rebGzIhhnO09pger0U,5
-parallel_ssh-2.11.1.dist-info/RECORD,,