Revert "Removed deprecated API endpoints. Resolves #73"

This reverts commit b53749f.

Author: Dan

pssh/pssh_client.py

@@ -594,6 +594,22 @@ 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)
@@ -751,6 +767,47 @@ 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,6 +68,13 @@ 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
@@ -78,6 +85,31 @@ 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,
@@ -143,15 +175,21 @@ def test_pssh_client_run_long_command(self):
         del client
 
     def test_pssh_client_auth_failure(self):
-        self.server.kill()
-        server_socket = make_socket(self.host)
-        listen_port = server_socket.getsockname()[1]
-        server = start_server(server_socket, fail_auth=True)
+        listen_socket = make_socket(self.host)
+        listen_port = listen_socket.getsockname()[1]
+        server = start_server(listen_socket, fail_auth=True)
         client = ParallelSSHClient([self.host], port=listen_port,
                                    pkey=self.user_key,
                                    agent=self.agent)
-        self.assertRaises(AuthenticationException, client.run_command, self.fake_cmd)
+        cmd = client.exec_command(self.fake_cmd)[0]
+        # Handle exception
+        try:
+            cmd.get()
+            raise Exception("Expected AuthenticationException, got none")
+        except AuthenticationException:
+            pass
         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
@@ -200,7 +238,6 @@ 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
@@ -221,23 +258,40 @@ 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_run_command_password(self):
+    def test_pssh_client_exec_command_password(self):
         """Test password authentication. Embedded server accepts any password
         even empty string"""
         client = ParallelSSHClient([self.host], port=self.listen_port,
                                    password='')
-        output = client.run_command(self.fake_cmd)
-        client.join(output)
+        cmd = client.exec_command(self.fake_cmd)[0]
+        output = client.get_stdout(cmd)
         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,