refactor code related with setup env

- modify env.py and scripts
- add unit test

Change-Id: I416cd517bdddfeb907675705009d83ecada7f87c
Signed-off-by: wu.zhihui <wu.zhihui1@zte.com.cn>

1 files changed, 58 insertions, 95 deletions

diff --git a/qtip/util/env.py b/qtip/util/env.py
index 4e7a31c7..0585a4c1 100644
--- a/qtip/util/env.py
+++ b/qtip/util/env.py
@@ -7,131 +7,94 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
 import os
-import paramiko
 import socket
 import time
 from os import path
-from os.path import expanduser
+
+import paramiko
 
 SCRIPT_DIR = path.join(path.dirname(__file__), path.pardir, 'scripts')
-CONFIG_DIR = path.join(path.dirname(__file__), path.pardir, path.pardir,
-                       'config')
-PRIVATE_KEY = CONFIG_DIR + '/QtipKey'
-PUBLIC_KEY = CONFIG_DIR + '/QtipKey.pub'
-IPS_FILE = expanduser('~') + "/qtip/ips.log"
-HOST_FILE = CONFIG_DIR + "/host"
+KEYNAME = 'QtipKey'
+PRIVATE_KEY = '{0}/qtip/{1}'.format(os.environ['HOME'], KEYNAME)
+PUBLIC_KEY = PRIVATE_KEY + '.pub'
+HOST_FILE = '{0}/qtip/hosts'.format(os.environ['HOME'])
 
 
-def fetch_compute_ips_via_installer():
-    clean_file(IPS_FILE)
+def all_files_exist(*files):
+    if len(files) == 0:
+        return False
+    flag = True
+    for f_item in files:
+        flag &= path.isfile(f_item)
+        print("Is {0} existed: {1}".format(f_item, flag))
+    return flag
 
+
+def clean_file(*files):
+    if len(files) == 0:
+        print('Nothing to clean')
+        return False
+
+    def clean(f):
+        try:
+            if all_files_exist(f):
+                os.remove(f)
+                print("Removed: {0}".format(f))
+            else:
+                print("Not exists: {0}".format(f))
+            return True
+        except OSError as error:
+            print("Not able to Remove: {0}".format(f), error)
+            return False
+
+    results = map(clean, files)
+    return len(results) == len(files) and False not in results
+
+
+def generate_host_file(hostfile=HOST_FILE):
     installer_type = str(os.environ['INSTALLER_TYPE'].lower())
     installer_ip = str(os.environ['INSTALLER_IP'])
+
     if installer_type not in ["fuel"]:
-        raise RuntimeError("%s is not supported" % installer_type)
+        raise ValueError("%s is not supported" % installer_type)
     if not installer_ip:
-        raise RuntimeError("undefine environment variable INSTALLER_IP")
+        raise ValueError("The value of environment variable INSTALLER_IP is empty")
 
-    cmd = "bash %s/fetch_compute_ips.sh -i %s -a %s" % \
-        (SCRIPT_DIR, installer_type, installer_ip)
+    cmd = "bash %s/generate_host_file.sh -i %s -a %s -d %s" % \
+        (SCRIPT_DIR, installer_type, installer_ip, hostfile)
     os.system(cmd)
-    if path.isfile(IPS_FILE):
-        return True
-    else:
-        return False
+    return all_files_exist(hostfile)
 
 
-def parse_ips():
-    ip_list = []
-    with open(IPS_FILE, "r") as outfile:
-        data = outfile.read()
-        if data:
-            ip_list.extend(data.rstrip('\n').split('\n'))
-    return ip_list
+def generate_keypair(keyname='QtipKey'):
+    """Generating ssh keypair"""
+    cmd = "ssh-keygen -t rsa -N "" -f {0} -q -b 2048".format(keyname)
+    os.system(cmd)
+    return all_files_exist(PRIVATE_KEY, PUBLIC_KEY)
 
 
-def ssh_test(ip):
+def pass_keypair(ip, private_key=PRIVATE_KEY):
     os.system('ssh-keyscan %s >> /root/.ssh/known_hosts' % ip)
     time.sleep(2)
 
-    ssh_cmd = '%s/qtip_creds.sh %s' % (SCRIPT_DIR, ip)
+    ssh_cmd = '%s/qtip_creds.sh %s %s' % (SCRIPT_DIR, ip, private_key)
     os.system(ssh_cmd)
 
+
+def ssh_is_ok(ip, private_key=PRIVATE_KEY, attempts=100):
     ssh = paramiko.SSHClient()
     ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-    ssh.connect(ip, key_filename='{0}/QtipKey'.format(CONFIG_DIR))
+    ssh.connect(ip, key_filename=private_key)
 
-    for attempts in range(100):
+    for attempt in range(attempts):
         try:
             stdin, stdout, stderr = ssh.exec_command('uname')
             if not stderr.readlines():
-                print("{0}: SSH test successful")
+                print("{0}: SSH test successful".format(ip))
                 return True
         except socket.error:
-            if attempts == 99:
+            if attempt == (attempts - 1):
                 return False
+            print("%s times ssh test......failed" % attempt)
             time.sleep(2)
-
-
-def ping_test(ip, attempts=30):
-    ping_cmd = 'ping -D -c1 {0}'.format(ip)
-    for i in range(attempts):
-        if os.system(ping_cmd):
-            print('\nWaiting for machine\n')
-            time.sleep(10)
-        else:
-            print('\n\n %s is UP \n\n ' % ip)
-            return True
-        if i == 29:
-            return False
-
-
-def check_nodes_connectivity():
-    ip_list = parse_ips()
-    for ip in ip_list:
-        if not ping_test(ip):
-            raise RuntimeError("{0}: Ping test failed".format(ip))
-        if not ssh_test(ip):
-            raise RuntimeError("{0}: SSH test failed".format(ip))
-
-
-def generate_host_file():
-    ip_list = parse_ips()
-    with open(HOST_FILE, 'w') as host_file:
-        for index, item in enumerate(ip_list):
-            host_file.write("[host_{0}]\n".format(index))
-            host_file.write(item + '\n')
-
-
-def generate_keypair():
-    """Generating ssh keypair"""
-    if not clean_keypair():
-        raise RuntimeError("Cann't remove old keypair")
-
-    cmd = "ssh-keygen -t rsa -N "" -f {0} -q".format(PRIVATE_KEY)
-    os.system(cmd)
-
-    if path.isfile(PRIVATE_KEY) and path.isfile(PUBLIC_KEY):
-        return True
-    else:
-        return False
-
-
-def clean_file(file_path):
-    try:
-        if path.isfile(file_path):
-            os.remove(file_path)
-            print("Removed: " + file_path)
-        else:
-            print("Not exists: " + file_path)
-    except OSError, error:
-        print("Not able to Remove: " + file_path, error)
-        return False
-    return True
-
-
-def clean_keypair():
-    flag = True
-    flag &= clean_file(PRIVATE_KEY)
-    flag &= clean_file(PUBLIC_KEY)
-    return flag
+    return False