Made fake server asynchronous. Fixed exception handling in parallel tests. Added port to error message when connecting.

Author: pkittenis

fake_server/fake_server.py

@@ -6,13 +6,12 @@
 Server private key is hardcoded, server listen code inspired by demo_server.py in paramiko repository"""
 
 import os
-import socket
+from gevent import socket
+import gevent.event
 import sys
-import threading
 import traceback
 import logging
 import paramiko
-import time
 
 logger = logging.getLogger(__name__)
 paramiko_logger = logging.getLogger('paramiko.transport')
@@ -21,7 +20,7 @@
 
 class Server (paramiko.ServerInterface):
     def __init__(self, cmd_req_response = {}, fail_auth = False):
-        self.event = threading.Event()
+        self.event = gevent.event.Event()
         self.cmd_req_response = cmd_req_response
         self.fail_auth = fail_auth
 
@@ -68,10 +67,12 @@ def _make_socket(listen_ip, listen_port):
 def listen(cmd_req_response, listen_ip = '127.0.0.1', listen_port = 2200, fail_auth = False):
     """Run a fake ssh server and given a cmd_to_run, send given response"""
     sock = _make_socket(listen_ip, listen_port)
-    if not sock: return
+    if not sock:
+        logger.error("Could not establish listening connection on %s:%s", listen_ip, listen_port)
+        return 
     try:
         sock.listen(100)
-        logger.info('Listening for connection ...')
+        logger.info('Listening for connection on %s:%s..', listen_ip, listen_port)
         client, addr = sock.accept()
     except Exception, e:
         logger.error('*** Listen/accept failed: %s' % (str(e),))
@@ -103,7 +104,7 @@ def listen(cmd_req_response, listen_ip = '127.0.0.1', listen_port = 2200, fail_a
             chan.close()
             return
         while not chan.send_ready():
-            time.sleep(.5)
+            gevent.sleep(.5)
         chan.close()
 
     except Exception, e:

pssh.py

@@ -81,7 +81,7 @@ def _connect(self):
             raise UnknownHostException("%s - %s" % (str(e.args[1]), self.host,))
         except socket.error, e:
             logger.error("Error connecting to host '%s'" % (self.host,))
-            raise ConnectionErrorException("%s for host '%s'" % (str(e.args[1]), self.host,))
+            raise ConnectionErrorException("%s for host '%s:%s'" % (str(e.args[1]), self.host, self.port,))
 
     def exec_command(self, command, sudo = False, **kwargs):
         """Wrapper to paramiko.SSHClient.exec_command"""

tests/test_pssh_client.py

@@ -4,12 +4,13 @@
 
 import unittest
 import gevent
-from gevent import monkey
-monkey.patch_all()
-from pssh import ParallelSSHClient, UnknownHostException, ConnectionErrorException
+from pssh import ParallelSSHClient, UnknownHostException, ConnectionErrorException, _setup_logger
 from paramiko import AuthenticationException
-from fake_server.fake_server import listen
+from fake_server.fake_server import listen, logger as server_logger
 import random
+import logging
+
+# _setup_logger(server_logger)
 
 class ParallelSSHClientTest(unittest.TestCase):
 
@@ -18,21 +19,31 @@ def setUp(self):
         self.fake_resp = 'fake response'
 
     def test_pssh_client_exec_command(self):
-        listen_port = random.randint(1025, 65534)
+        listen_port = random.randint(1026, 65534)
         server = gevent.spawn(listen, { self.fake_cmd : self.fake_resp }, listen_port = listen_port)
-        client = ParallelSSHClient(['localhost'], port = listen_port)
+        gevent.sleep(.1)
+        client = ParallelSSHClient(['localhost'], port=listen_port)
         cmd = client.exec_command(self.fake_cmd)[0]
         output = client.get_stdout(cmd)
         expected = {'localhost' : {'exit_code' : 0}}
-        self.assertEqual(expected, output, msg = "Got unexpected command output - %s" % (output,))
+        self.assertEqual(expected, output,
+                         msg = "Got unexpected command output - %s" % (output,))
         server.kill()
+        del client
 
     def test_pssh_client_auth_failure(self):
-        listen_port = random.randint(1025, 65534)
-        server = gevent.spawn(listen, { self.fake_cmd : self.fake_resp }, listen_port = listen_port, fail_auth = True)
-        client = ParallelSSHClient(['localhost'], port = listen_port)
+        listen_port = random.randint(2048, 65534)
+        server = gevent.spawn(listen, { self.fake_cmd : self.fake_resp },
+                              listen_port=listen_port, fail_auth=True, )# link_callback=)
+        gevent.sleep(.1)
+        client = ParallelSSHClient(['localhost'], port=listen_port)
+        cmd = client.exec_command(self.fake_cmd)[0]
+        # Handle exception 
         try:
-            cmd = client.exec_command(self.fake_cmd)[0]
+            cmd.get()
+            raise Exception("Expected AuthenticationException, got none")
         except AuthenticationException:
             pass
         server.kill()
+        del client
+