Removed deprecated API endpoints. Resolves #73

Author: Dan

pssh/pssh_client.py

@@ -594,22 +594,6 @@ def run_command(self, *args, **kwargs):
                     raise
         return output
 
-    def exec_command(self, *args, **kwargs):
-        """Run command on all hosts in parallel, honoring `self.pool_size`
-        
-        **Deprecated by** :mod:`pssh.pssh_client.ParallelSSHClient.run_command`
-        
-        :param args: Position arguments for command
-        :type args: tuple
-        :param kwargs: Keyword arguments for command
-        :type kwargs: dict
-        
-        :rtype: List of :mod:`gevent.Greenlet`"""
-        warnings.warn("This method is being deprecated and will be removed in \
-future releases - use self.run_command instead", DeprecationWarning)
-        return [self.pool.spawn(self._exec_command, host, *args, **kwargs)
-                for host in self.hosts]
-    
     def _get_host_config_values(self, host):
         _user = self.host_config.get(host, {}).get('user', self.user)
         _port = self.host_config.get(host, {}).get('port', self.port)
@@ -767,47 +751,6 @@ def _get_exit_code(self, channel):
         channel.close()
         return channel.recv_exit_status()
 
-    def get_stdout(self, greenlet, return_buffers=False):
-        """Get/print stdout from greenlet and return exit code for host
-        
-        **Deprecated** - use :mod:`pssh.pssh_client.ParallelSSHClient.get_output` instead.
-        
-        :param greenlet: Greenlet object containing an \
-        SSH channel reference, hostname, stdout and stderr buffers
-        :type greenlet: :mod:`gevent.Greenlet`
-        :param return_buffers: Flag to turn on returning stdout and stderr \
-        buffers along with exit code. Defaults to off.
-        :type return_buffers: bool
-        :rtype: Dictionary containing ``{host: {'exit_code': exit code}}`` entry \
-        for example ``{'myhost1': {'exit_code': 0}}``
-        :rtype: With ``return_buffers=True``: ``{'myhost1': {'exit_code': 0,
-                                                             'channel' : None or SSH channel of command if command is still executing,
-                                                             'stdout' : <iterable>,
-                                                             'stderr' : <iterable>,}}``
-        """
-        warnings.warn("This method is being deprecated and will be removed in"
-                      "future releases - use self.get_output instead", DeprecationWarning)
-        gevent.sleep(.2)
-        channel, host, stdout, stderr, stdin = greenlet.get()
-        if channel.exit_status_ready():
-            channel.close()
-        else:
-            logger.debug("Command still executing on get_stdout call - not closing channel and returning None as exit code.")
-            # If channel is not closed we cannot get full stdout/stderr so must return buffers
-            return_buffers = True
-        # Channel must be closed or reading stdout/stderr will block forever
-        if not return_buffers and channel.closed:
-            for _ in stdout:
-                pass
-            for _ in stderr:
-                pass
-            return {host: {'exit_code': channel.recv_exit_status(),}}
-        gevent.sleep(.2)
-        return {host: {'exit_code': channel.recv_exit_status() if channel.exit_status_ready() else None,
-                       'channel' : channel if not channel.closed else None,
-                       'stdout' : stdout,
-                       'stderr' : stderr, }}
-
     def copy_file(self, local_file, remote_file, recurse=False):
         """Copy local file to remote file in parallel
 

tests/test_pssh_client.py

@@ -68,13 +68,6 @@ def tearDown(self):
         del self.listen_socket
         del self.client
 
-    def test_pssh_client_exec_command(self):
-        cmd = self.client.exec_command(self.fake_cmd)[0]
-        output = self.client.get_stdout(cmd)
-        self.assertTrue(self.host in output,
-                        msg="No output for host")
-        self.assertTrue(output[self.host]['exit_code'] == 0)
-
     def test_pssh_client_no_stdout_non_zero_exit_code_immediate_exit(self):
         output = self.client.run_command('exit 1')
         expected_exit_code = 1
@@ -85,31 +78,6 @@ def test_pssh_client_no_stdout_non_zero_exit_code_immediate_exit(self):
                          (exit_code,
                           expected_exit_code,))
 
-    def test_pssh_client_exec_command_get_buffers(self):
-        client = ParallelSSHClient([self.host], port=self.listen_port,
-                                   pkey=self.user_key,
-                                   agent=self.agent)
-        cmd = client.exec_command(self.fake_cmd)[0]
-        output = client.get_stdout(cmd, return_buffers=True)
-        expected_exit_code = 0
-        expected_stdout = [self.fake_resp]
-        expected_stderr = []
-        exit_code = output[self.host]['exit_code']
-        stdout = list(output[self.host]['stdout'])
-        stderr = list(output[self.host]['stderr'])
-        self.assertEqual(expected_exit_code, exit_code,
-                         msg="Got unexpected exit code - %s, expected %s" %
-                         (exit_code,
-                          expected_exit_code,))
-        self.assertEqual(expected_stdout, stdout,
-                         msg="Got unexpected stdout - %s, expected %s" % 
-                         (stdout,
-                          expected_stdout,))
-        self.assertEqual(expected_stderr, stderr,
-                         msg="Got unexpected stderr - %s, expected %s" % 
-                         (stderr,
-                          expected_stderr,))
-
     def test_pssh_client_run_command_get_output(self):
         client = ParallelSSHClient([self.host], port=self.listen_port,
                                    pkey=self.user_key,
@@ -175,21 +143,15 @@ def test_pssh_client_run_long_command(self):
         del client
 
     def test_pssh_client_auth_failure(self):
-        listen_socket = make_socket(self.host)
-        listen_port = listen_socket.getsockname()[1]
-        server = start_server(listen_socket, fail_auth=True)
+        self.server.kill()
+        server_socket = make_socket(self.host)
+        listen_port = server_socket.getsockname()[1]
+        server = start_server(server_socket, fail_auth=True)
         client = ParallelSSHClient([self.host], port=listen_port,
                                    pkey=self.user_key,
                                    agent=self.agent)
-        cmd = client.exec_command(self.fake_cmd)[0]
-        # Handle exception
-        try:
-            cmd.get()
-            raise Exception("Expected AuthenticationException, got none")
-        except AuthenticationException:
-            pass
+        self.assertRaises(AuthenticationException, client.run_command, self.fake_cmd)
         del client
-        server.kill()
 
     def test_pssh_client_hosts_list_part_failure(self):
         """Test getting output for remainder of host list in the case where one
@@ -238,6 +200,7 @@ def test_pssh_client_ssh_exception(self):
         server.kill()
 
     def test_pssh_client_timeout(self):
+        self.server.kill()
         listen_socket = make_socket(self.host)
         listen_port = listen_socket.getsockname()[1]
         server_timeout=0.2
@@ -258,40 +221,23 @@ def test_pssh_client_timeout(self):
             raise server.exception
         except gevent.Timeout:
             pass
-        # chan_timeout = output[self.host]['channel'].gettimeout()
-        # self.assertEqual(client_timeout, chan_timeout,
-        #                  msg="Channel timeout %s does not match requested timeout %s" %(
-        #                      chan_timeout, client_timeout,))
         del client
         server.kill()
 
-    def test_pssh_client_exec_command_password(self):
+    def test_pssh_client_run_command_password(self):
         """Test password authentication. Embedded server accepts any password
         even empty string"""
         client = ParallelSSHClient([self.host], port=self.listen_port,
                                    password='')
-        cmd = client.exec_command(self.fake_cmd)[0]
-        output = client.get_stdout(cmd)
+        output = client.run_command(self.fake_cmd)
+        client.join(output)
         self.assertTrue(self.host in output,
                         msg="No output for host")
         self.assertTrue(output[self.host]['exit_code'] == 0,
                         msg="Expected exit code 0, got %s" % (
                             output[self.host]['exit_code'],))
         del client
 
-    def test_pssh_client_long_running_command(self):
-        expected_lines = 5
-        client = ParallelSSHClient([self.host], port=self.listen_port,
-                                   pkey=self.user_key)
-        cmd = client.exec_command(self.long_cmd(expected_lines))[0]
-        output = client.get_stdout(cmd, return_buffers=True)
-        self.assertTrue(self.host in output, msg="Got no output for command")
-        stdout = list(output[self.host]['stdout'])
-        self.assertTrue(len(stdout) == expected_lines,
-                        msg="Expected %s lines of response, got %s" % (
-                            expected_lines, len(stdout)))
-        del client
-
     def test_pssh_client_long_running_command_exit_codes(self):
         expected_lines = 5
         client = ParallelSSHClient([self.host], port=self.listen_port,