Ejemplo n.º 1
0
def __ssh_daemon_is_running(ip,user,pwd,parser):
	"""
	use ssh log in to the shell , check ssh is ready
	:param ip : FTOS ip
	:param user : FTOS user
	:param pwd : FTOS user password
	:param parser : parser: is a dict, get from Test config file
	"""
	t_start = time.time()
	while((time.time() - t_start) < float(parser["pre_wait_ssh_ready_time"])):
		time.sleep(float(1))
		try:
			ssh = shell_server.get_ssh(ip
                                  , user
                                  , pwd) #獲得ssh 
		except Exception:
			print " checking %s ssh " % user
			continue
		ssh.close()
		return True
	try:	
		ssh = shell_server.get_ssh(ip , user , pwd) #獲得ssh
	except Exception:
		print " %s ssh not ready" % user
		return False; 
	ssh.close()
Ejemplo n.º 2
0
def is_node_exists(cluster_name, node_name, parser):
    """
    check is node in HAagent
    :param cluster_name : cluster name
    :param node_name : node name
    :param parser : is a dict get from base.configure
    """
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  # get ssh object
    cmd = cmd_HAagent.overview_cmd()
    s_stdin, s_stdout, s_stderr = ssh.exec_command(cmd)

    overview = s_stdout.read()  # get overview in host terminal

    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])
    cluster_file_content = file.get_remote_file_content(
        parser["cluster_file_path"], ssh)  # get cluster file content in nfs

    print overview
    print cluster_file_content

    ssh.close()

    if node_name in overview and cluster_file_content:
        return True
    return False
Ejemplo n.º 3
0
def preprocess_hostOS_vm_running(parser):
    """
    preprocess vm become running

    :called func: preprocess_hostOS_vm
    :param parser: is a dict, get from Test config file
    """
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    if FTVM.is_running(parser["vm_name"], parser["PrimaryOS_ip"], ssh):
        print 59
        if "pre_hostOS_VM_restart" in parser.keys(
        ) and parser["pre_hostOS_VM_restart"] == "yes":  #根據參數若VM需重新啟動
            print 54
            prepocess_hostOS_vm_restart(parser)
            print 55
            time.sleep(float(parser["pre_hostOS_VM_boot_time"]))
    elif FTVM.is_shutoff(parser["vm_name"], parser["PrimaryOS_ip"], ssh):
        print 56
        prepocess_hostOS_vm_start(parser)
        print 57
        time.sleep(float(parser["pre_hostOS_VM_boot_time"]))
    print 58
    if not FTVM.is_running(parser["vm_name"], parser["PrimaryOS_ip"], ssh):
        ssh.close()
        raise TA_error.Preprocess_Error("PrimaryOS VM: %s can not start" %
                                        parser["vm_name"])

    ssh.close()
Ejemplo n.º 4
0
def preprocess_backupOS_FTsystem(parser):
    """
  preprocess backupOS FTsystem
  
  check FTsystem status 

  start/stop FTsystem

  raise exception if FTsystem can not start/stop
  """
    if parser["pre_check_backupOS_FTsystem"] == "yes":
        ssh = shell_server.get_ssh(parser["BackupOS_ip"], parser["BackupOS_usr"], parser["BackupOS_pwd"])
        status = FTsystem.get_status(ssh)
        if status == "not running" and parser["pre_backupOS_FTsystem_start"] == "yes":
            FTsystem.start(ssh)
            time.sleep(float(parser["pre_backupOS_FTsystem_start_time"]))
            if FTsystem.get_status(ssh) == "not running":
                ssh.close()
                raise TA_error.Preprocess_Error("backupOS FTsystem can not start")
        if status == "running" and parser["pre_backupOS_FTsystem_start"] == "no":
            FTsystem.stop(ssh)
            time.sleep(float(parser["pre_backupOS_FTsystem_start_time"]))
            if FTsystem.get_status(ssh) == "running":
                ssh.close()
                raise TA_error.Preprocess_Error("backupOS FTsystem can not stop")
        ssh.close()
Ejemplo n.º 5
0
def vm_running_in_slaveOS(parser):
    """
	vm is running in SlaveOS or not

	:param parser: config
	:return: True/raise exception
	"""

    ssh = shell_server.get_ssh(parser["SlaveOS_ip"], parser["SlaveOS_usr"],
                               parser["SlaveOS_pwd"])  #獲得ssh

    t_end = time.time()
    if "ast_vm_running_wait_time" in parser.keys(
    ):  #若參數ast_vm_running_wait_time存在於parser,則進入
        t_end = time.time() + float(
            parser["ast_vm_running_wait_time"])  #計算出等待之時間,並存於t_end
    while time.time() < t_end:  #超過t_end則跳出迴圈
        #每sleep一秒就詢問一次狀態
        time.sleep(1)
        if FTVM.is_running(parser["vm_name"], parser["SlaveOS_ip"],
                           ssh):  #狀態為running就跳出迴圈
            break
    if FTVM.is_running(parser["vm_name"], parser["SlaveOS_ip"],
                       ssh):  #若回傳之狀態是running,則test oracle通過,否則raise exception
        ssh.close()
        return True
    ssh.close()
    raise TA_error.Assert_Error("VM (name : %s) is not running in SlaveOS" %
                                parser["vm_name"])
Ejemplo n.º 6
0
def libvirt_stop_start_ftvm(parser):
    """
	detect when libvirt daemon shutdown , can HAAgent start ftvm
	:param parser: config
	:return: True/raise exception
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    cmd = cmd_HAagent.start_ftvm_cmd(parser["PrimaryOS_name"],
                                     parser["vm_name"])
    s_stdin, s_stdout, s_stderr = ssh.exec_command("sudo " + cmd)
    out = s_stdout.read()
    expected = HAagent_terminal.Startvm_create_vm_failed % (
        HAagent_terminal.Libvirt_connection_failed %
        HAagent_terminal.Libvirt_self_connection) + "\n"

    success = (out == expected)

    print out
    print expected

    FTsystem.start(ssh)

    #print success
    if success:
        return True
    raise TA_error.Assert_Error("libvirt stop then start ftvm fail")
Ejemplo n.º 7
0
def postprocess_slaveOS_vm_shutdown(parser):
    """
  	postprocess backupOS vm become shutdown

  	:called func: postprocess_backupOS_vm
  	:param parser: is a dict, get from Test config file
  	"""
    ssh = shell_server.get_ssh(parser["SlaveOS_ip"], parser["SlaveOS_usr"],
                               parser["SlaveOS_pwd"])  #獲得ssh
    if FTVM.is_running(parser["vm_name"], parser["SlaveOS_ip"], ssh):
        FTVM.destroy(parser["vm_name"], parser["SlaveOS_ip"], ssh)
        time.sleep(float(parser["pos_slaveOS_VM_shutdown_time"]))
    elif FTVM.is_paused(parser["vm_name"], parser["SlaveOS_ip"], ssh):
        FTVM.resume(parser["vm_name"], parser["SlaveOS_ip"], ssh)
        FTVM.destroy(parser["vm_name"], parser["SlaveOS_ip"], ssh)
        time.sleep(float(parser["pos_slaveOS_VM_shutdown_time"]))
    times = 0
    while times < 30:
        print "check slave os vm status"
        if FTVM.is_running(parser["vm_name"], parser["SlaveOS_ip"], ssh):
            print "destroy slave os vm "
            FTVM.destroy(parser["vm_name"], parser["SlaveOS_ip"], ssh)
            break
        time.sleep(float(1))
        times += 1
    if not FTVM.is_shutoff(parser["vm_name"], parser["SlaveOS_ip"], ssh):
        ssh.close()
        raise TA_error.Postprocess_Error("SlaveOS %s can not shutdown" %
                                         parser["vm_name"])
    ssh.close()
Ejemplo n.º 8
0
def preprocess_slaveOS_FTsystem(parser):
    """
    preprocess backupOS FTsystem part
  
    check FTsystem status 

    start/stop FTsystem

    raise exception if FTsystem can not start/stop

    :called func: preprocess_backupOS_OS
    :param parser: is a dict, get from Test config file
    """
    if parser["pre_check_slaveOS_FTsystem"] == "yes":
        ssh = shell_server.get_ssh(parser["SlaveOS_ip"], parser["SlaveOS_usr"],
                                   parser["SlaveOS_pwd"])  #獲得ssh
        status = FTsystem.get_status(ssh)
        if status == "not running" and parser[
                "pre_slaveOS_FTsystem_start"] == "yes":  #若狀態不為running且根據參數必需是running則進入
            FTsystem.start(ssh)  #透過ssh開啟libvirt
            time.sleep(float(parser["pre_slaveOS_FTsystem_start_time"]))
        if FTsystem.get_status(
                ssh) == "not running":  #若狀態不為running則raise exception
            ssh.close()
            raise TA_error.Preprocess_Error("slaveOS FTsystem can not start")
        if status == "running" and parser[
                "pre_slaveOS_FTsystem_start"] == "no":  #若狀態為running且根據參數必需不是running則進入
            FTsystem.stop(ssh)
            time.sleep(float(parser["pre_slaveOS_FTsystem_start_time"]))
            if FTsystem.get_status(
                    ssh) == "running":  #若狀態為running則raise exception
                ssh.close()
                raise TA_error.Preprocess_Error(
                    "slaveOS FTsystem can not stop")
    ssh.close()
Ejemplo n.º 9
0
def vm_is_login_in_slaveOS(parser):
    """
	vm is login in hostOS or not
	:param parser: config
	:return: True/raise exception
	"""

    if FTVM.is_login(parser["vm_name"], parser["TA_ip"],
                     parser["TA_msg_sock_port"],
                     int(parser["ast_vm_login_wait_time"]
                         )):  #若回傳VM登入完成,則test oracle通過,否則raise exception
        return True
    else:
        ssh = shell_server.get_ssh(parser["GuestOS_ip_S"],
                                   parser["GuestOS_usr"],
                                   parser["GuestOS_pwd"])  #獲得ssh

        cmd = "sudo %s" % parser["login_reply_path"]
        #print cmd
        s_stdin, s_stdout, s_stderr = ssh.exec_command(cmd)  #透過ssh執行指令
        if FTVM.is_login(parser["vm_name"], parser["TA_ip"],
                         parser["TA_msg_sock_port"],
                         int(parser["ast_vm_login_wait_time"]
                             )):  #若回傳VM登入完成,則test oracle通過,否則raise exception
            return True
        ssh.close()
    raise TA_error.Assert_Error("VM (name : %s) is not login in backupOS" %
                                parser["vm_name"])
Ejemplo n.º 10
0
def preprocess_slaveOS_HAagent(parser):
    ssh = shell_server.get_ssh(parser["SlaveOS_ip"], parser["SlaveOS_usr"],
                               parser["SlaveOS_pwd"])  #獲得ssh
    if HAagent.is_running(ssh, parser):
        ssh.close()
        return True
    ssh.close()
    raise TA_error.Preprocess_Error("Slave OS HAAgent process not ready")
Ejemplo n.º 11
0
def __reset_pid(node , parser):
	if node == "primary":
		ssh = shell_server.get_ssh(parser["PrimaryOS_ip"]
							, parser["PrimaryOS_usr"]
							, parser["PrimaryOS_pwd"]) #獲得ssh
		ssh.exec_command("sudo rm /home/primary/Desktop/pid.txt")
	elif node == "backup":
		ssh = shell_server.get_ssh(parser["BackupOS_ip"]
							, parser["BackupOS_usr"]
							, parser["BackupOS_pwd"]) #獲得ssh
		ssh.exec_command("sudo rm /home/backup-node/Desktop/pid.txt")
	elif node == "slave":
		ssh = shell_server.get_ssh(parser["SlaveOS_ip"]
							, parser["SlaveOS_usr"]
							, parser["SlaveOS_pwd"]) #獲得ssh
		ssh.exec_command("sudo rm /home/slave/Desktop/pid.txt")
	ssh.close()
Ejemplo n.º 12
0
def stop_libvirt_process(parser):

    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh
    FTsystem.stop(ssh)
    if FTsystem.get_status(ssh) == "running":
        raise TA_error.Process_Error("libvirt in host OS cannot stop")
    ssh.close()
Ejemplo n.º 13
0
def postprocess_NFS_OS_reboot(parser):
    """
	when test case done , Host OS reboot
	:param parser: is a dict, get from Test config file
	"""

    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])  #獲得ssh
    if FTOS.OS_is_running(parser["NFS_ip"], parser):
        FTOS.reboot(ssh)
Ejemplo n.º 14
0
def postprocess_slaveOS_HAAgent(parser):
    ssh = shell_server.get_ssh(parser["SlaveOS_ip"], parser["SlaveOS_usr"],
                               parser["SlaveOS_pwd"])  #獲得ssh
    if HAagent.is_running(ssh, parser):
        HAagent.exit(parser, ssh)
        if HAagent.is_running(ssh, parser):
            ssh.close()
            raise TA_error.Postprocess_Error("Slave HAAgent cannot shutdown")
    else:
        pass
Ejemplo n.º 15
0
def hostOS_role_is_Slave_on_BackupOS(parser):
    ssh = shell_server.get_ssh(parser["BackupOS_ip"], parser["BackupOS_usr"],
                               parser["BackupOS_pwd"])  #獲得ssh

    role = mmsh.inforole(parser["PrimaryOS_name"], ssh)
    ssh.close()
    if role == "slave":
        return True
    raise TA_error.Assert_Error("Host (name : %s) role is not slave" %
                                parser["PrimaryOS_name"])
Ejemplo n.º 16
0
def exec_L1_hostOS_crasher(parser):
	"""
	execute level 1 crasher in hostOS
	"""
	ssh = shell_server.get_ssh(parser["HostOS_ip"]
                              , parser["HostOS_usr"]
                              , parser["HostOS_pwd"])
	f_path = parser["HostOS_process_dir"]+"L1_crasher"
	s_stdin, s_stdout, s_stderr = ssh.exec_command("sudo "+cmd)
	ssh.close()
Ejemplo n.º 17
0
def detect_overview(parser):
    """
	detect remove node or not
	:param parser: config
	:return: True/raise exception
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    out = HAagent.overview(parser, ssh)
Ejemplo n.º 18
0
def postprocess_NFS_reset(parser):
    """
	when test done , clear nfs file

	:param parser: is a dict, get from Test config file
	:param ssh : shell server
	"""
    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])  #獲得ssh
    NFS.reset(parser, ssh)
    ssh.close()
Ejemplo n.º 19
0
def preprocess_NFS_OS(parser):
    if FTOS.OS_is_running(parser["NFS_ip"], parser) == False:
        #FTOS.L1_boot(parser["NFS_NetworkAdaptor"])
        if FTOS.OS_is_running(parser["NFS_ip"], parser) == False:
            raise TA_error.Preprocess_Error("NFS node can not start")
    if FTOS.ssh_is_ready(parser["NFS_ip"], parser["NFS_usr"],
                         parser["NFS_pwd"], parser) == False:
        raise TA_error.Preprocess_Error("NFS node ssh can not access")

    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])  #獲得ssh
Ejemplo n.º 20
0
def exec_overview(parser):
    """
	HAagent overview
	:param parser: is a dict, get from Test config file
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    #HAagent.quick_create_cluster(parser, ssh)
    time.sleep(1)
    ssh.close()
Ejemplo n.º 21
0
def exec_non_primary_de_node(parser):
    """
	use non-primary node remove node 
	:param parser: is a dict, get from Test config file
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh
    #use primary node create cluster
    HAagent.create_cluster(parser["Cluster_name"], parser["PrimaryOS_name"],
                           parser["PrimaryOS_ipmb"], parser["Shelf_ip"],
                           parser, ssh)
    HAagent.add_backup_node(parser, ssh)
    time.sleep(float(parser["pro_wait_add_node_time"]))
    #use backup node to remove node
    backup = shell_server.get_ssh(parser["BackupOS_ip"],
                                  parser["BackupOS_usr"],
                                  parser["BackupOS_pwd"])  #獲得ssh
    HAagent.rm_node(parser["Cluster_name"], parser["PrimaryOS_name"], parser,
                    backup)
    backup.close()
Ejemplo n.º 22
0
def exec_L1_vm_crasher(parser):
	"""
	execute level 1 crasher in vm 
	"""
	ssh = shell_server.get_ssh(parser["GuestOS_ip"]
                              , parser["GuestOS_usr"]
                              , parser["GuestOS_pwd"])
	cmd = data_dir.OS_PROCESS_DIR+"L1_crasher"
	print cmd
	s_stdin, s_stdout, s_stderr = ssh.exec_command("sudo "+cmd)
	ssh.close()
Ejemplo n.º 23
0
def kill_vm_process(parser):
	"""
	kill vm process on hostOS
	"""
	ssh = shell_server.get_ssh(parser["HostOS_ip"]
                              , parser["HostOS_usr"]
                              , parser["HostOS_pwd"])
	pid = FTVM.get_pid(parser["vm_name"], parser["HostOS_ip"], ssh)
	cmd = cmd_kill.kill_cmd(pid, 9)
	s_stdin, s_stdout, s_stderr = ssh.exec_command("sudo "+cmd)
	ssh.close()
Ejemplo n.º 24
0
def kill_libvirt_process(parser):
	"""
	kill libvirt process on hostOS
	"""
	ssh = shell_server.get_ssh(parser["GuestOS_ip"]
                              , parser["GuestOS_usr"]
                              , parser["GuestOS_pwd"])
	pid = FTsystem.get_pid(ssh)
	cmd = cmd_kill.kill_cmd(pid, 9)
	s_stdin, s_stdout, s_stderr = ssh.exec_command("sudo "+cmd)
	ssh.close()
Ejemplo n.º 25
0
def exec_add_duplicate_node(parser):
    """
	HAagent add duplicate node to cluster
	:param parser: is a dict, get from Test config file
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    HAagent.create_cluster(parser["Cluster_name"], parser["PrimaryOS_name"],
                           parser["PrimaryOS_ipmb"], parser["Shelf_ip"],
                           parser, ssh)
    ssh.close()
Ejemplo n.º 26
0
def exec_non_primary_de_cluster(parser):
    """
	HAagent add node to cluster
	:param parser: is a dict, get from Test config file
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    # create cluster
    HAagent.create_cluster(parser["Cluster_name"], parser["PrimaryOS_name"],
                           parser["PrimaryOS_ipmb"], parser["Shelf_ip"],
                           parser, ssh)
    HAagent.add_backup_node(parser, ssh)
    time.sleep(float(1))
    ssh.close()

    #use backup node to decluster
    ssh = shell_server.get_ssh(parser["BackupOS_ip"], parser["BackupOS_usr"],
                               parser["BackupOS_pwd"])  #獲得ssh
    HAagent.de_cluster(parser["Cluster_name"], parser, ssh)
    ssh.close()
Ejemplo n.º 27
0
def exec_primaryOS_network_isolation(parser):

    if "pro_wait_time_exe_L1_crasher" in parser.keys(
    ):  #若pro_wait_time_exe_L1_crasher存在於parser
        time.sleep(int(parser["pro_wait_time_exe_L1_crasher"]))

    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    cmd = "sudo ifconfig %s down" % (parser["PrimaryOS_network_interface"])
    print cmd
    s_stdin, s_stdout, s_stderr = ssh.exec_command(cmd)  #透過ssh執行指令

    ssh.close()

    ssh = shell_server.get_ssh(parser["BackupOS_ip"], parser["BackupOS_usr"],
                               parser["BackupOS_pwd"])  #獲得ssh

    #print "stdout",s_stdout.read()
    #print "stderr",s_stderr.read()
    ssh.close()
Ejemplo n.º 28
0
def FTsystem_running_in_hostOS(parser):
	"""
	FTsystem is running in hostOS or not

	return True/raise exception
	"""
	ssh = shell_server.get_ssh(parser["HostOS_ip"]
                              , parser["HostOS_usr"]
                              , parser["HostOS_pwd"])
	if FTsystem.get_status(ssh) == "running":
		return True
	raise TA_error.Assert_Error("FTsystem is not running on hostOS")
Ejemplo n.º 29
0
def detect_primaryOS_crash(parser):
    ssh = shell_server.get_ssh(parser["BackupOS_ip"], parser["BackupOS_usr"],
                               parser["BackupOS_pwd"])  #獲得ssh
    if mmsh.statehost(
            parser["PrimaryOS_name"], ssh
    ) == "shutdown":  #若回傳之狀態是hardware shutdown,則test oracle通過,否則raise exception
        ssh.close()
        return True
    ssh.close()
    raise TA_error.Assert_Error(
        "Host (name : %s) has not detect host os crash " %
        parser["PrimaryOS_name"])
Ejemplo n.º 30
0
def detect_no_fail(parser):
    """
	FTsystem find no fail or not
	:param parser: config
	:return: True/raise exception
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲取ssh
    if mmsh.infofail(parser["vm_name"], ssh) == "no fail":
        return True
    raise TA_error.Assert_Error("VM (name : %s) has fail in hostOS" %
                                parser["vm_name"])
Ejemplo n.º 31
0
def get_node_role(name, parser):
    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])

    cluster_file_content = file.get_remote_file_content(
        parser["cluster_file_path"], ssh)  # get cluster file content in nfs
    try:
        res = json.loads(cluster_file_content)["nodes"][name]["role"]
        ssh.close()
        return role_parse(res)
    except KeyError:
        return "Key not found"
Ejemplo n.º 32
0
def detect_slaveOS_network_isolation_info(parser):
    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])  #獲取ssh

    fail = HAagent_info.get_node_infofail(parser["SlaveOS_name"], parser, ssh)
    expected = HAagent_terminal.Node_status_self_network_isolation
    success = (fail == expected)

    if success:
        return True
    raise TA_error.Assert_Error(
        "slave network isolation info fail , Fail msg : %s , Expected msg : %s"
        % fail, expected)
Ejemplo n.º 33
0
def exec_de_outer_cluster(parser):
    """
	HAagent external cluster primary delete cluster
	:param parser: is a dict, get from Test config file
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    HAagent.create_cluster("test_c", parser["PrimaryOS_name"],
                           parser["PrimaryOS_ipmb"], parser["Shelf_ip"],
                           parser, ssh)
    HAagent.de_cluster("test_b", parser, ssh)
    ssh.close()
Ejemplo n.º 34
0
def recovery_vm_reboot(parser):
    """
	FTsystem recover vm reboot or not
	:param parser: config
	:return: True/raise exception
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲取ssh

    if mmsh.inforecover(parser["vm_name"], ssh) == "vm reboot":
        return True
    raise TA_error.Assert_Error("VM (name : %s) has no recovery : vm reboot" %
                                parser["vm_name"])
Ejemplo n.º 35
0
def exec_add_node(parser):
    """
	HAagnet add node (primary , backup , slave)
	:param parser: is a dict, get from Test config file
	"""
    ssh = shell_server.get_ssh(parser["PrimaryOS_ip"], parser["PrimaryOS_usr"],
                               parser["PrimaryOS_pwd"])  #獲得ssh

    backup = shell_server.get_ssh(parser["BackupOS_ip"],
                                  parser["BackupOS_usr"],
                                  parser["BackupOS_pwd"])  #獲得ssh

    HAagent.create_cluster(parser["Cluster_name"], parser["PrimaryOS_name"],
                           parser["PrimaryOS_ipmb"], parser["Shelf_ip"],
                           parser, ssh)
    time.sleep(float(parser["pro_wait_add_node_time"]))
    HAagent.add_backup_node(parser, ssh)
    time.sleep(float(parser["pro_wait_add_node_time"]))
    HAagent.add_slave_node(parser, ssh)
    time.sleep(float(parser["pro_wait_add_node_time"]))

    ssh.close()
Ejemplo n.º 36
0
def detect_backupOS_crash_info(parser):
    ssh = shell_server.get_ssh(parser["NFS_ip"], parser["NFS_usr"],
                               parser["NFS_pwd"])  #獲取ssh

    fail = HAagent_info.get_node_infofail(parser["BackupOS_name"], parser, ssh)
    expected = HAagent_terminal.Node_status_hostdown
    success = (fail == expected)

    if success:
        return True
    raise TA_error.Assert_Error(
        "backup OS crash info fail , Fail msg : %s , Expected msg : %s" % fail,
        expected)
Ejemplo n.º 37
0
	get vm process id in OS
	"""
	pid_file_path = data_dir.VM_PID_DIR+vm_name+".pid"
	cmd = "sudo cat %s" % pid_file_path
	s_stdin, s_stdout, s_stderr = ssh.exec_command(cmd)
	pid = s_stdout.read()
	if pid != "":
		return int(pid)
	return False

	




if __name__ == '__main__':
	"""
	if get_vm_status("VM1", "140.115.53.42") != "running":
		start("VM1", "140.115.53.42")
	get_vm_status("VM1", "140.115.53.42")
	"""
	#print "start"
	#if get_vm_status("VM1", "140.115.53.42") == "running":
		#print "in"
	#get_vm_status("VM1", "140.115.53.42")
	#print is_shutoff("VM1", "140.115.53.42")
	#restart("VM1", "140.115.53.42")
	#shutdown("VM1", "140.115.53.42")
	ssh = shell_server.get_ssh("140.115.53.42", "ting", "oolabting")
	print get_pid("VM1", "140.115.53.42", ssh)