Added fake SSH server to test command execution via the ParallelSSHClient. Added ParallelSSHClient tests

Author: pkittenis

fake_server/__init__.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+
+"""Fake SSH server to test our SSH clients.
+Supports execution of commands via exec_command. Does _not_ support interactive shells,
+our clients do not use them.
+Server private key is hardcoded, server listen code inspired by demo_server.py in paramiko repository"""
+
+import os
+import socket
+import sys
+import threading
+import traceback
+import logging
+import paramiko
+import time
+
+logger = logging.getLogger(__name__)
+paramiko_logger = logging.getLogger('paramiko.transport')
+
+host_key = paramiko.RSAKey(filename = os.path.sep.join([os.path.dirname(__file__), 'rsa.key']))
+
+class Server (paramiko.ServerInterface):
+    def __init__(self, cmd_req_response = {}, fail_auth = False):
+        self.event = threading.Event()
+        self.cmd_req_response = cmd_req_response
+        self.fail_auth = fail_auth
+
+    def check_channel_request(self, kind, chanid):
+        return paramiko.OPEN_SUCCEEDED
+
+    def check_auth_password(self, username, password):
+        return paramiko.AUTH_SUCCESSFUL
+
+    def check_auth_publickey(self, username, key):
+        if self.fail_auth: return paramiko.AUTH_FAILED
+        return paramiko.AUTH_SUCCESSFUL
+
+    def get_allowed_auths(self, username):
+        return 'password,publickey'
+
+    def check_channel_shell_request(self, channel):
+        return False
+
+    def check_channel_pty_request(self, channel, term, width, height, pixelwidth,
+                                  pixelheight, modes):
+        return True
+
+    def check_channel_exec_request(self, channel, cmd):
+        logger.debug("Got exec request on channel %s for cmd %s" % (channel, cmd,))
+        if not cmd in self.cmd_req_response:
+            return False
+        channel.send(self.cmd_req_response[cmd])
+        channel.send_exit_status(0)
+        self.event.set()
+        return True
+
+def _make_socket(listen_ip, listen_port):
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((listen_ip, listen_port))
+    except Exception, e:
+        logger.error('Failed to bind to address - %s' % (str(e),))
+        traceback.print_exc()
+        return
+    return sock
+
+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
+    try:
+        sock.listen(100)
+        logger.info('Listening for connection ...')
+        client, addr = sock.accept()
+    except Exception, e:
+        logger.error('*** Listen/accept failed: %s' % (str(e),))
+        traceback.print_exc()
+        return
+    logger.info('Got connection..')
+    try:
+        t = paramiko.Transport(client)
+        try:
+            t.load_server_moduli()
+        except:
+            raise
+        t.add_server_key(host_key)
+        server = Server(cmd_req_response = cmd_req_response, fail_auth = fail_auth)
+        try:
+            t.start_server(server=server)
+        except paramiko.SSHException, _:
+            logger.error('SSH negotiation failed.')
+            return
+        chan = t.accept(20)
+        if not chan:
+            logger.error("Could not establish channel")
+            return
+        logger.info("Authenticated..")
+        chan.send_ready()
+        server.event.wait(10)
+        if not server.event.isSet():
+            logger.error('Client never sent command')
+            chan.close()
+            return
+        while not chan.send_ready():
+            time.sleep(.5)
+        chan.close()
+
+    except Exception, e:
+        logger.error('*** Caught exception: %s: %s' % (str(e.__class__), str(e),))
+        traceback.print_exc()
+        try:
+            t.close()
+        except:
+            pass
+        return
+
+if __name__ == "__main__":
+    logging.basicConfig()
+    logger.setLevel(logging.DEBUG)
+    listen({'fake' : 'fake response' + os.linesep})

fake_server/fake_server.py

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDI7iK3d8eWYZlYloat94c5VjtFY7c/0zuGl8C7uMnZ3t6i2G99
+66hEW0nCFSZkOW5F0XKEVj+EUCHvo8koYC6wiohAqWQnEwIoOoh7GSAcB8gP/qaq
++adIl/Rvlby/mHakj+y05LBND6nFWHAn1y1gOFFKUXSJNRZPXSFy47gqzwIBIwKB
+gQCbANjz7q/pCXZLp1Hz6tYHqOvlEmjK1iabB1oqafrMpJ0eibUX/u+FMHq6StR5
+M5413BaDWHokPdEJUnabfWXXR3SMlBUKrck0eAer1O8m78yxu3OEdpRk+znVo4DL
+guMeCdJB/qcF0kEsx+Q8HP42MZU1oCmk3PbfXNFwaHbWuwJBAOQ/ry/hLD7AqB8x
+DmCM82A9E59ICNNlHOhxpJoh6nrNTPCsBAEu/SmqrL8mS6gmbRKUaya5Lx1pkxj2
+s/kWOokCQQDhXCcYXjjWiIfxhl6Rlgkk1vmI0l6785XSJNv4P7pXjGmShXfIzroh
+S8uWK3tL0GELY7+UAKDTUEVjjQdGxYSXAkEA3bo1JzKCwJ3lJZ1ebGuqmADRO6UP
+40xH977aadfN1mEI6cusHmgpISl0nG5YH7BMsvaT+bs1FUH8m+hXDzoqOwJBAK3Z
+X/za+KV/REya2z0b+GzgWhkXUGUa/owrEBdHGriQ47osclkUgPUdNqcLmaDilAF4
+1Z4PHPrI5RJIONAx+JECQQC/fChqjBgFpk6iJ+BOdSexQpgfxH/u/457W10Y43HR
+soS+8btbHqjQkowQ/2NTlUfWvqIlfxs6ZbFsIp/HrhZL
+-----END RSA PRIVATE KEY-----

fake_server/rsa.key

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+"""Unittests for parallel-ssh"""
+
+import unittest
+import gevent
+from gevent import monkey
+monkey.patch_all()
+from pssh import ParallelSSHClient, UnknownHostException
+from paramiko import AuthenticationException
+from fake_server.fake_server import listen
+
+class ParallelSSHClientTest(unittest.TestCase):
+
+    def setUp(self):
+        self.fake_cmd = 'fake cmd'
+        self.fake_resp = 'fake response'
+
+    def test_pssh_client_exec_command(self):
+        server = gevent.spawn(listen, { self.fake_cmd : self.fake_resp })
+        client = ParallelSSHClient(['localhost'], port = 2200)
+        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,))
+        server.kill()
+
+    def test_pssh_client_auth_failure(self):
+        server = gevent.spawn(listen, { self.fake_cmd : self.fake_resp }, listen_port = 2201, fail_auth = True)
+        client = ParallelSSHClient(['localhost'], port = 2201)
+        try:
+            cmd = client.exec_command(self.fake_cmd)[0]
+        except AuthenticationException:
+            pass