Removed deprecated since 2.0.0 functions and parameters. Updated tests (#314)

Author: pkittenis

Changelog.rst

@@ -8,6 +8,7 @@ Changes
 -------
 
 * ``user`` keyword argument no longer required on Windows - exception is raised if user cannot be identified.
+* Removed deprecated since ``2.0.0`` functions and parameters.
 
 2.5.4
 +++++

pssh/clients/base/parallel.py

@@ -21,7 +21,6 @@
 
 import gevent.pool
 
-from warnings import warn
 from gevent import joinall, spawn, Timeout as GTimeout
 from gevent.hub import Hub
 
@@ -171,7 +170,7 @@ def join_shells(self, shells, timeout=None):
 
     def run_command(self, command, user=None, stop_on_errors=True,
                     host_args=None, use_pty=False, shell=None,
-                    encoding='utf-8', return_list=True,
+                    encoding='utf-8',
                     *args, **kwargs):
         if host_args:
             try:
@@ -194,11 +193,9 @@ def run_command(self, command, user=None, stop_on_errors=True,
                     for host_i, host in enumerate(self.hosts)]
         self.cmds = cmds
         joinall(cmds, timeout=self.timeout)
-        return self._get_output_from_cmds(cmds, raise_error=stop_on_errors,
-                                          return_list=return_list)
+        return self._get_output_from_cmds(cmds, raise_error=stop_on_errors)
 
-    def _get_output_from_cmds(self, cmds, raise_error=False,
-                              return_list=True):
+    def _get_output_from_cmds(self, cmds, raise_error=False):
         _cmds = [spawn(self._get_output_from_greenlet, cmd, raise_error=raise_error)
                  for cmd in cmds]
         finished = joinall(_cmds, raise_error=True)
@@ -217,33 +214,19 @@ def _get_output_from_greenlet(self, cmd, raise_error=False):
             return HostOutput(host, None, None, None,
                               exception=ex)
 
-    def get_last_output(self, cmds=None, timeout=None,
-                        return_list=True):
+    def get_last_output(self, cmds=None):
         """Get output for last commands executed by ``run_command``.
 
         :param cmds: Commands to get output for. Defaults to ``client.cmds``
         :type cmds: list(:py:class:`gevent.Greenlet`)
-        :param timeout: No-op - to be removed.
-        :param return_list: No-op - list of ``HostOutput`` always returned.
-          Parameter kept for backwards compatibility - to be removed in future
-          releases.
-        :type return_list: bool
 
         :rtype: dict or list
         """
         cmds = self.cmds if cmds is None else cmds
         if cmds is None:
             return
         return self._get_output_from_cmds(
-            cmds, return_list=return_list,
-            raise_error=False)
-
-    def reset_output_generators(self, host_out, timeout=None,
-                                client=None, channel=None,
-                                encoding='utf-8'):
-        """No-op - to be removed."""
-        warn("This function is a no-op and deprecated. "
-             "It will be removed in future releases")
+            cmds, raise_error=False)
 
     def _get_host_config_values(self, host_i, host):
         if self.host_config is None:
@@ -308,8 +291,7 @@ def _consume_output(self, stdout, stderr):
         for line in stderr:
             pass
 
-    def join(self, output=None, consume_output=False, timeout=None,
-             encoding='utf-8'):
+    def join(self, output=None, consume_output=False, timeout=None):
         """Wait until all remote commands in output have finished.
         Does *not* block other commands from running in parallel.
 
@@ -328,9 +310,6 @@ def join(self, output=None, consume_output=False, timeout=None,
           Since self.timeout is passed onto each individual SSH session it is
           **not** used for any parallel functions like `run_command` or `join`.
         :type timeout: int
-        :param encoding: Unused - encoding from each ``HostOutput`` is used instead.
-          To be removed in future releases.
-        :type encoding: str
 
         :raises: :py:class:`pssh.exceptions.Timeout` on timeout requested and
           reached with commands still running.
@@ -341,7 +320,7 @@ def join(self, output=None, consume_output=False, timeout=None,
         elif not isinstance(output, list):
             raise ValueError("Unexpected output object type")
         cmds = [self.pool.spawn(self._join, host_out, timeout=timeout,
-                                consume_output=consume_output, encoding=encoding)
+                                consume_output=consume_output)
                 for host_i, host_out in enumerate(output)]
         # Errors raised by self._join should be propagated.
         finished_cmds = joinall(cmds, raise_error=True, timeout=timeout)

pssh/clients/native/parallel.py

@@ -35,7 +35,7 @@ def __init__(self, hosts, user=None, password=None, port=22, pkey=None,
                  allow_agent=True, host_config=None, retry_delay=RETRY_DELAY,
                  proxy_host=None, proxy_port=None,
                  proxy_user=None, proxy_password=None, proxy_pkey=None,
-                 forward_ssh_agent=False, tunnel_timeout=None,
+                 forward_ssh_agent=False,
                  keepalive_seconds=60, identity_auth=True):
         """
         :param hosts: Hosts to connect to
@@ -109,7 +109,6 @@ def __init__(self, hosts, user=None, password=None, port=22, pkey=None,
           Defaults to False if not set.
           Requires agent forwarding implementation in libssh2 version used.
         :type forward_ssh_agent: bool
-        :param tunnel_timeout: No-op - to be removed.
 
         :raises: :py:class:`pssh.exceptions.PKeyFileError` on errors finding
           provided private key.
@@ -131,8 +130,8 @@ def __init__(self, hosts, user=None, password=None, port=22, pkey=None,
 
     def run_command(self, command, sudo=False, user=None, stop_on_errors=True,
                     use_pty=False, host_args=None, shell=None,
-                    encoding='utf-8', timeout=None, read_timeout=None,
-                    return_list=False):
+                    encoding='utf-8', read_timeout=None,
+                    ):
         """Run command on all hosts in parallel, honoring self.pool_size,
         and return output.
 
@@ -181,14 +180,6 @@ def run_command(self, command, sudo=False, user=None, stop_on_errors=True,
           raise :py:class:`pssh.exceptions.Timeout`
           after ``timeout`` seconds when set if remote output is not ready.
         :type read_timeout: float
-        :param timeout: Deprecated - use read_timeout. Same as
-          read_timeout and kept for backwards compatibility - to be removed
-          in future release.
-        :type timeout: float
-        :param return_list: No-op - list of ``HostOutput`` always returned.
-          Parameter kept for backwards compatibility - to be removed in future
-          releases.
-        :type return_list: bool
         :rtype: list(:py:class:`pssh.output.HostOutput`)
 
         :raises: :py:class:`pssh.exceptions.AuthenticationError` on
@@ -214,7 +205,7 @@ def run_command(self, command, sudo=False, user=None, stop_on_errors=True,
             self, command, stop_on_errors=stop_on_errors, host_args=host_args,
             user=user, shell=shell, sudo=sudo,
             encoding=encoding, use_pty=use_pty,
-            return_list=return_list, read_timeout=read_timeout if read_timeout else timeout,
+            read_timeout=read_timeout,
         )
 
     def __del__(self):

pssh/clients/ssh/parallel.py

@@ -143,8 +143,8 @@ def __init__(self, hosts, user=None, password=None, port=22, pkey=None,
 
     def run_command(self, command, sudo=False, user=None, stop_on_errors=True,
                     use_pty=False, host_args=None, shell=None,
-                    encoding='utf-8', timeout=None, read_timeout=None,
-                    return_list=False):
+                    encoding='utf-8', read_timeout=None,
+                    ):
         """Run command on all hosts in parallel, honoring self.pool_size,
         and return output.
 
@@ -193,14 +193,6 @@ def run_command(self, command, sudo=False, user=None, stop_on_errors=True,
           raise :py:class:`pssh.exceptions.Timeout`
           after ``timeout`` number seconds if remote output is not ready.
         :type read_timeout: float
-        :param timeout: Deprecated - use read_timeout. Same as
-          read_timeout and kept for backwards compatibility - to be removed
-          in future release.
-        :type timeout: float
-        :param return_list: No-op - list of ``HostOutput`` always returned.
-          Parameter kept for backwards compatibility - to be removed in future
-          releases.
-        :type return_list: bool
         :rtype: list(:py:class:`pssh.output.HostOutput`)
 
         :raises: :py:class:`pssh.exceptions.AuthenticationError` on
@@ -225,8 +217,7 @@ def run_command(self, command, sudo=False, user=None, stop_on_errors=True,
             self, command, stop_on_errors=stop_on_errors, host_args=host_args,
             user=user, shell=shell, sudo=sudo,
             encoding=encoding, use_pty=use_pty,
-            return_list=return_list,
-            read_timeout=read_timeout if read_timeout else timeout,
+            read_timeout=read_timeout,
         )
 
     def _make_ssh_client(self, host_i, host):

tests/native/test_parallel_client.py

@@ -199,7 +199,7 @@ def test_client_join_stdout(self):
         self.assertTrue(len(_output) == len(output))
 
     def test_pssh_client_no_stdout_non_zero_exit_code_immediate_exit(self):
-        output = self.client.run_command('exit 1', return_list=True)
+        output = self.client.run_command('exit 1')
         expected_exit_code = 1
         self.client.join(output)
         exit_code = output[0].exit_code
@@ -209,7 +209,7 @@ def test_pssh_client_no_stdout_non_zero_exit_code_immediate_exit(self):
                           expected_exit_code,))
 
     def test_pssh_client_no_stdout_non_zero_exit_code_immediate_exit_no_join(self):
-        output = self.client.run_command('exit 1', return_list=True)
+        output = self.client.run_command('exit 1')
         expected_exit_code = 1
         for host_out in output:
             for line in host_out.stdout:
@@ -891,7 +891,7 @@ def test_identical_hosts_in_host_list(self):
         client = ParallelSSHClient(hosts, port=self.port,
                                    pkey=self.user_key,
                                    num_retries=1)
-        output = client.run_command(self.cmd, stop_on_errors=False, return_list=True)
+        output = client.run_command(self.cmd, stop_on_errors=False)
         client.join(output)
         self.assertEqual(len(hosts), len(output),
                          msg="Host list contains %s identical hosts, only got output for %s" % (
@@ -1347,7 +1347,7 @@ def test_unknown_host_failure(self):
     def test_open_channel_failure(self):
         client = ParallelSSHClient([self.host], port=self.port,
                                    pkey=self.user_key)
-        output = client.run_command(self.cmd, return_list=True)
+        output = client.run_command(self.cmd)
         client.join(output)
         output[0].client.session.disconnect()
         self.assertRaises(SessionError, output[0].client.open_session)
@@ -1411,7 +1411,7 @@ def test_join_timeout_set_no_timeout(self):
     def test_read_timeout(self):
         client = ParallelSSHClient([self.host], port=self.port,
                                    pkey=self.user_key)
-        output = client.run_command('sleep .3; echo me; echo me; echo me', timeout=.2)
+        output = client.run_command('sleep .3; echo me; echo me; echo me', read_timeout=.2)
         for host_out in output:
             self.assertRaises(Timeout, list, host_out.stdout)
         self.assertFalse(client.finished(output))
@@ -1425,7 +1425,7 @@ def test_read_timeout(self):
     def test_partial_read_timeout_close_cmd(self):
         self.assertTrue(self.client.finished())
         output = self.client.run_command('while true; do echo a line; sleep .1; done',
-                                         use_pty=True, timeout=.15)
+                                         use_pty=True, read_timeout=.15)
         stdout = []
         try:
             with GTimeout(seconds=.25):
@@ -1473,8 +1473,6 @@ def test_partial_read_timeout_join_no_output(self):
         else:
             raise Exception("Should have timed out")
         self.assertTrue(len(stdout) > 0)
-        # Should be no-op
-        self.client.reset_output_generators(output[0], timeout=None)
         # Setting timeout
         output[0].read_timeout = .2
         stdout = []
@@ -1522,7 +1520,7 @@ def test_file_read_no_timeout(self):
         with open(_file, 'wb') as fh:
             fh.writelines(contents)
         try:
-            output = self.client.run_command('cat %s' % (_file,), timeout=10)
+            output = self.client.run_command('cat %s' % (_file,), read_timeout=10)
             _out = list(output[0].stdout)
         finally:
             os.unlink(_file)
@@ -1830,11 +1828,11 @@ def test_multiple_join_timeout(self):
         client = ParallelSSHClient([self.host], port=self.port,
                                    pkey=self.user_key)
         for _ in range(5):
-            output = client.run_command(self.cmd, return_list=True)
+            output = client.run_command(self.cmd)
             client.join(output, timeout=1, consume_output=True)
             for host_out in output:
                 self.assertTrue(host_out.client.finished(host_out.channel))
-        output = client.run_command('sleep .2', return_list=True)
+        output = client.run_command('sleep .2')
         self.assertRaises(Timeout, client.join, output, timeout=.1, consume_output=True)
         for host_out in output:
             self.assertFalse(host_out.client.finished(host_out.channel))
@@ -1843,12 +1841,12 @@ def test_multiple_run_command_timeout(self):
         client = ParallelSSHClient([self.host], port=self.port,
                                    pkey=self.user_key)
         for _ in range(5):
-            output = client.run_command('pwd', return_list=True, timeout=1)
+            output = client.run_command('pwd', read_timeout=1)
             for host_out in output:
                 stdout = list(host_out.stdout)
                 self.assertTrue(len(stdout) > 0)
                 self.assertTrue(host_out.client.finished(host_out.channel))
-        output = client.run_command('sleep .25; echo me', return_list=True, timeout=.1)
+        output = client.run_command('sleep .25; echo me', read_timeout=.1)
         for host_out in output:
             self.assertRaises(Timeout, list, host_out.stdout)
         client.join(output)
@@ -1893,7 +1891,7 @@ def test_read_stdout_no_timeout(self):
         cmd = 'sleep .1; echo me; sleep .1; echo me'
         read_timeout = 1
         output = self.client.run_command(
-            cmd, timeout=read_timeout, stop_on_errors=False)
+            cmd, read_timeout=read_timeout, stop_on_errors=False)
         for host_out in output:
             dt, timed_out = self.read_stream_dt(host_out, host_out.stdout, read_timeout)
             self.assertFalse(timed_out)
@@ -1907,7 +1905,7 @@ def test_read_timeout_no_timeouts(self):
         read_timeout = 1
         # No timeouts
         output = self.client.run_command(
-            cmd, timeout=read_timeout, stop_on_errors=False, return_list=True)
+            cmd, read_timeout=read_timeout, stop_on_errors=False)
         for host_out in output:
             dt, timed_out = self.read_stream_dt(host_out, host_out.stdout, read_timeout)
             self.assertTrue(dt.total_seconds() < read_timeout)
@@ -1917,11 +1915,11 @@ def test_read_timeout_no_timeouts(self):
             self.assertTrue(dt.total_seconds() < read_timeout)
 
     def test_read_stdout_timeout_stderr_no_timeout(self):
+        """No timeouts for stderr only"""
         cmd = 'sleep .1; echo me >&2; sleep .1; echo me >&2; sleep .1'
         read_timeout = .25
-        # No timeouts for stderr only
         output = self.client.run_command(
-            cmd, timeout=read_timeout, stop_on_errors=False)
+            cmd, read_timeout=read_timeout, stop_on_errors=False)
         for host_out in output:
             dt, timed_out = self.read_stream_dt(host_out, host_out.stdout, read_timeout)
             self.assertTrue(timed_out)

tests/ssh/test_parallel_client.py

@@ -370,7 +370,7 @@ def test_escaped_quotes(self):
     def test_read_timeout(self):
         client = ParallelSSHClient([self.host], port=self.port,
                                    pkey=self.user_key)
-        output = client.run_command('sleep .3; echo me; echo me; echo me', timeout=.2)
+        output = client.run_command('sleep .3; echo me; echo me; echo me', read_timeout=.2)
         for host_out in output:
             self.assertRaises(Timeout, list, host_out.stdout)
         self.assertFalse(output[0].channel.is_eof())
@@ -412,7 +412,7 @@ def test_file_read_no_timeout(self):
         with open(_file, 'wb') as fh:
             fh.writelines(contents)
         try:
-            output = self.client.run_command('cat %s' % (_file,), timeout=10)
+            output = self.client.run_command('cat %s' % (_file,), read_timeout=10)
             _out = list(output[0].stdout)
         finally:
             os.unlink(_file)
@@ -439,7 +439,7 @@ def test_gssapi_auth(self):
         self.assertRaises(AuthenticationException, client.run_command, self.cmd)
 
     def test_long_running_cmd_join_timeout(self):
-        output = self.client.run_command('sleep 1', return_list=True)
+        output = self.client.run_command('sleep 1')
         self.assertRaises(Timeout, self.client.join, output, timeout=0.2)
 
     def test_default_finished(self):
@@ -459,11 +459,11 @@ def test_multiple_join_timeout(self):
         client = ParallelSSHClient([self.host], port=self.port,
                                    pkey=self.user_key)
         for _ in range(5):
-            output = client.run_command(self.cmd, return_list=True)
+            output = client.run_command(self.cmd)
             client.join(output, timeout=1, consume_output=True)
             for host_out in output:
                 self.assertTrue(host_out.client.finished(host_out.channel))
-        output = client.run_command('sleep .2', return_list=True)
+        output = client.run_command('sleep .2')
         self.assertRaises(Timeout, client.join, output, timeout=.1, consume_output=True)
         for host_out in output:
             self.assertFalse(host_out.client.finished(host_out.channel))