Provides connection check for package download.

[functest.git] / testcases / security_scan / connect.py

diff --git a/testcases/security_scan/connect.py b/testcases/security_scan/connect.py
index 9430e9a..18ca96d 100644 (file)
--- a/testcases/security_scan/connect.py
+++ b/testcases/security_scan/connect.py
@@ -16,45 +16,69 @@ import paramiko
 
 import functest.utils.functest_logger as ft_logger
 
-# Enable below for connection debugging
-# paramiko.util.log_to_file('ssh.log')
-
 # add installer IP from env
 INSTALLER_IP = os.getenv('INSTALLER_IP')
 
-# Set up logger
+# Set up loggers
 logger = ft_logger.Logger("security_scan").getLogger()
+paramiko.util.log_to_file("/var/log/paramiko.log")
 
 
-class novaManager:
+class SetUp:
     def __init__(self, *args):
         self.args = args
 
     def keystonepass(self):
         com = self.args[0]
         client = paramiko.SSHClient()
+        privatekeyfile = os.path.expanduser('/root/.ssh/id_rsa')
+        selectedkey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
-            client.connect(INSTALLER_IP, port=22, username='stack')
+            client.connect(INSTALLER_IP, port=22, username='stack',
+                           pkey=selectedkey)
         except paramiko.SSHException:
             logger.error("Password is invalid for "
-                         "undercloud host: {0}").format(INSTALLER_IP)
+                         "undercloud host: {0}".format(INSTALLER_IP))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "undercloud host: {0}").format(INSTALLER_IP)
+                         "undercloud host: {0}".format(INSTALLER_IP))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(INSTALLER_IP)
+                         "undercloud host: {0}".format(INSTALLER_IP))
         stdin, stdout, stderr = client.exec_command(com)
         return stdout.read()
+        client.close()
+
+    def getockey(self):
+        remotekey = self.args[0]
+        localkey = self.args[1]
+        privatekeyfile = os.path.expanduser('/root/.ssh/id_rsa')
+        selectedkey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
+        transport = paramiko.Transport((INSTALLER_IP, 22))
+        transport.connect(username='stack', pkey=selectedkey)
+        try:
+            sftp = paramiko.SFTPClient.from_transport(transport)
+        except paramiko.SSHException:
+            logger.error("Authentication failed for "
+                         "host: {0}".format(INSTALLER_IP))
+        except paramiko.AuthenticationException:
+            logger.error("Authentication failed for "
+                         "host: {0}".format(INSTALLER_IP))
+        except socket.error:
+            logger.error("Socker Connection failed for "
+                         "undercloud host: {0}".format(INSTALLER_IP))
+        sftp.get(remotekey, localkey)
+        sftp.close()
+        transport.close()
 
 
-class connectionManager:
-    def __init__(self, host, port, user, user_key, *args):
+class ConnectionManager:
+    def __init__(self, host, port, user, localkey, *args):
         self.host = host
         self.port = port
         self.user = user
-        self.user_key = user_key
+        self.localkey = localkey
         self.args = args
 
     def remotescript(self):
@@ -63,19 +87,22 @@ class connectionManager:
         com = self.args[2]
 
         client = paramiko.SSHClient()
+        privatekeyfile = os.path.expanduser('/root/.ssh/id_rsa')
+        selectedkey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         # Connection to undercloud
         try:
-            client.connect(INSTALLER_IP, port=22, username='stack')
+            client.connect(INSTALLER_IP, port=22, username='stack',
+                           pkey=selectedkey)
         except paramiko.SSHException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(self.host)
+                         "undercloud host: {0}".format(self.host))
 
         transport = client.get_transport()
         local_addr = ('127.0.0.1', 0)
@@ -87,18 +114,18 @@ class connectionManager:
         # Tunnel to overcloud
         try:
             remote_client.connect('127.0.0.1', port=22, username=self.user,
-                                  key_filename=self.user_key, sock=channel)
+                                  key_filename=self.localkey, sock=channel)
             sftp = remote_client.open_sftp()
             sftp.put(localpath, remotepath)
         except paramiko.SSHException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(self.host)
+                         "undercloud host: {0}".format(self.host))
 
         output = ""
         stdin, stdout, stderr = remote_client.exec_command(com)
@@ -117,19 +144,22 @@ class connectionManager:
         com = self.args[0]
 
         client = paramiko.SSHClient()
+        privatekeyfile = os.path.expanduser('/root/.ssh/id_rsa')
+        selectedkey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         # Connection to undercloud
         try:
-            client.connect(INSTALLER_IP, port=22, username='stack')
+            client.connect(INSTALLER_IP, port=22, username='stack',
+                           pkey=selectedkey)
         except paramiko.SSHException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(self.host)
+                         "undercloud host: {0}".format(self.host))
 
         transport = client.get_transport()
         local_addr = ('127.0.0.1', 0)  # 0 denotes choose random port
@@ -141,22 +171,22 @@ class connectionManager:
         # Tunnel to overcloud
         try:
             remote_client.connect('127.0.0.1', port=22, username=self.user,
-                                  key_filename=self.user_key, sock=channel)
+                                  key_filename=self.localkey, sock=channel)
         except paramiko.SSHException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(self.host)
+                         "undercloud host: {0}".format(self.host))
 
         chan = remote_client.get_transport().open_session()
         chan.get_pty()
-        f = chan.makefile()
+        feed = chan.makefile()
         chan.exec_command(com)
-        print f.read()
+        print feed.read()
 
         remote_client.close()
         client.close()
@@ -167,19 +197,22 @@ class connectionManager:
         reportname = self.args[2]
         resultsname = self.args[3]
         client = paramiko.SSHClient()
+        privatekeyfile = os.path.expanduser('/root/.ssh/id_rsa')
+        selectedkey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         # Connection to overcloud
         try:
-            client.connect(INSTALLER_IP, port=22, username='stack')
+            client.connect(INSTALLER_IP, port=22, username='stack',
+                           pkey=selectedkey)
         except paramiko.SSHException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(self.host)
+                         "undercloud host: {0}".format(self.host))
 
         transport = client.get_transport()
         local_addr = ('127.0.0.1', 0)  # 0 denotes choose random port
@@ -191,21 +224,21 @@ class connectionManager:
         # Tunnel to overcloud
         try:
             remote_client.connect('127.0.0.1', port=22, username=self.user,
-                                  key_filename=self.user_key, sock=channel)
+                                  key_filename=self.localkey, sock=channel)
         except paramiko.SSHException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except paramiko.AuthenticationException:
             logger.error("Authentication failed for "
-                         "host: {0}").format(self.host)
+                         "host: {0}".format(self.host))
         except socket.error:
             logger.error("Socker Connection failed for "
-                         "undercloud host: {0}").format(self.host)
+                         "undercloud host: {0}".format(self.host))
         # Download the reports
         sftp = remote_client.open_sftp()
-        logger.info('Downloading \"{0}\"...\n').format(reportname)
+        logger.info("Downloading \"{0}\"...".format(reportname))
         sftp.get(reportfile, ('{0}/{1}'.format(dl_folder, reportname)))
-        logger.info('Downloading \"{0}\"...\n').format(resultsname)
+        logger.info("Downloading \"{0}\"...".format(resultsname))
         sftp.get(reportfile, ('{0}/{1}'.format(dl_folder, resultsname)))
         sftp.close()
         transport.close()