def scenario_test(): # navi_menu = SCEN_TEST_MENU os.system('clear') # file search title_print(' # scenario test') scen_list = scenario_file_search() scen_list.sort() for i in range(len(scen_list)): Reporter.PRINTB("| %2d. %s|", i+1, (scen_list[i]).ljust(menu_string2_len)) Reporter.PRINTB("|%s|", (' 0. return to main menu').ljust(menu_string_len)) Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) while 1: sel_scen = input(RED + 'select scenario : '+ENDC) if len(scen_list) < sel_scen: Reporter.PRINTR(" Invalid value !!") continue elif 0 is sel_scen: break else: if 'create_' in scen_list[sel_scen-1]: create_start_scenario(scen_list[sel_scen-1]) elif 'delete_' in scen_list[sel_scen-1]: delete_start_scenario(scen_list[sel_scen-1]) break
def ssh_connect(self, host, user, port, password): try: ssh_newkey = 'Are you sure you want to continue connecting' if '' is port: connStr = 'ssh ' + user + '@' + host else: connStr = 'ssh ' + '-p ' + port + ' ' + user + '@' + host # print connStr conn = pexpect.spawn(connStr) ret = conn.expect([pexpect.TIMEOUT, ssh_newkey, '[P|p]assword:'], timeout=3) if ret == 0: Reporter.REPORT_MSG( ' >> [%s] Error Connection to SSH Server', host) return False if ret == 1: conn.sendline('yes') ret = conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=3) if ret == 0: Reporter.REPORT_MSG( ' >> [%s] Error Connection to SSH Server', host) return False conn.sendline(password) conn.expect(PROMPT, timeout=5) except Exception, e: Reporter.REPORT_MSG(' >> [%s] Error Connection to SSH Server', host) # print e return False
def port_info(self, conn_info, dev_id): try: conn = self.onos_create_session(conn_info) url = 'http://' + conn_info[ 'host'] + ':8181/onos/v1/devices/' + dev_id + '/ports' header = {'Accept': 'application/json'} # print json.dumps(conn.get(url, headers=header).json(),indent=4, separators=('',':')) ret = json.dumps( conn.get(url, headers=header, timeout=self._config.get_onos_timeout()).json(), ensure_ascii=False, sort_keys=False).encode('utf-8') result = dict() for x in json.loads(ret)['ports']: result[x['annotations']['portName']] = x['isEnabled'] if not len(result): Reporter.REPORT_MSG( ' >> Device[%s] Get port fail from [%s] ', dev_id, conn_info['host']) return return result except: Reporter.exception_err_write() return
def config_subnet(type): value = [] value_list=[] title_print(' # ' + type + ' subnet') # network while 1: if 'create' in type: net_list, sel, sel_state = display_config_item('network') if False is sel_state: value = [] ; continue if 0 is sel: value = [] ; break value.append(net_list[sel-1]) Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) ## subnet sub_list, sel, sel_state = display_config_item('subnet') if False is sel_state: value = [] ; continue if 0 is sel: value = [] ; break value.append(sub_list[sel-1]) if 'create' in type: val_str = ', '.join(value) else: val_str = ''.join(value) value_list.append(val_str) value=[] choice = select_yesno_menu('Do you want to continue to ' + type + ' subnet?(y/n) : ') if 'n' in choice: break Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) if len(value_list) > 0: set_list = list(set(value_list)) set_list.sort() save_scenario('subnet', set_list, type)
def config_router_interface(type): value = [] value_list=[] if 'create' in type: title_print(' # add router-interface') else: title_print(' # del router-interface') while 1: # router router_list, sel, sel_state = display_config_item('router') if False is sel_state: value = [] ; continue if 0 is sel: value = [] ; break value.append(router_list[sel-1]) # subnet Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) sub_list, sel, sel_state = display_config_item('subnet') if False is sel_state: value = [] ; continue if 0 is sel: value = [] ; break value.append(sub_list[sel-1]) val_str = ', '.join(value) value_list.append(val_str) value=[] choice = select_yesno_menu('Do you want to continue to ' + type + ' router-interface?(y/n) : ') if 'n' in choice: break Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) if len(value_list) > 0: set_list = list(set(value_list)) set_list.sort() save_scenario('router-interface', set_list, type)
def ssh_connect(self, host, user, port, password): try: ssh_newkey = 'want to continue connecting' if '' is port: connStr = 'ssh ' + user + '@' + host else: connStr = 'ssh ' + '-p ' + port + ' ' + user + '@' + host Reporter.REPORT_MSG(' >> connection : %s', connStr) conn = pexpect.spawn(connStr) ret = conn.expect([pexpect.TIMEOUT, ssh_newkey, '[P|p]assword:'], timeout=self.conn_timeout) if ret == 0: Reporter.REPORT_MSG( ' >> [%s] Error Connection to SSH Servcer(%d)', host, ret) self.ssh_disconnect(conn) return False if ret == 1: # Reporter.REPORT_MSG(' >> [%s] wait %s ', host, ssh_newkey) conn.sendline('yes') ret = conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=self.conn_timeout) conn.sendline(password) conn.expect(PROMPT, timeout=self.conn_timeout) except Exception, e: Reporter.REPORT_MSG( ' >> [%s] Error Connection to SSH Servcer (timeout except)', host) self.ssh_disconnect(conn) return False
def add_securitygroup_rule(self, sg_uuid, rule_opt_list): rule_rst = [] for rule in rule_opt_list: rule_conf = dict(self.rule_conf)[rule.strip()] if not rule_conf: Reporter.REPORT_MSG(" >> Not Exist Rule ---> %s", rule) return rule_body = ast.literal_eval(rule_conf) rule_body['security_group_id'] = sg_uuid rule_body = {'security_group_rule': rule_body} try: remote_group_name = rule_body['security_group_rule'][ 'remote_group_id'] if remote_group_name: remote_group_id = self.get_sg_uuid_by_name( remote_group_name) rule_body['security_group_rule'][ 'remote_group_id'] = remote_group_id except: Reporter.REPORT_MSG( " >> no remote security group in the rule -> OK") rule_rst.append(self.neutron.create_security_group_rule(rule_body)) Reporter.REPORT_MSG(" >> Security Group ---> %s", rule_rst) return rule_rst
def openstack_get_service(self, report_flag=None): if report_flag is None: Reporter.unit_test_start(True) try: keystone = kclient.Client(auth_url=self.auth['auth_url'], username=self.auth['username'], password=self.auth['api_key'], tenant_name=self.auth['project_id']) service_list = [{ a.name: a.enabled } for a in keystone.services.list()] for i in range(len(service_list)): if service_list[i].values()[0] is False: Reporter.REPORT_MSG( " >> OpenStack Service status NOK ---> %s", service_list[i]) if report_flag is None: Reporter.unit_test_stop('nok') return False Reporter.REPORT_MSG(" >> OpenStack Service status OK ---> %s", service_list) if report_flag is None: Reporter.unit_test_stop('ok') return True except: if report_flag is None: Reporter.exception_err_write() return False
def create_subnet(self, network_opt, subnet_opt): Reporter.unit_test_start(True, network_opt, subnet_opt) try: # if not subnet_body: # Reporter.REPORT_MSG(" >> Not Exist Subnet in config --->") # return network_uuid = self.get_network_uuid(network_opt) if not network_uuid: Reporter.unit_test_stop('nok') return if self.get_subnet_uuid(subnet_opt): Reporter.unit_test_stop('skip') return subnet_cfg_body = dict(self.subnet_conf)[subnet_opt] subnet_body = ast.literal_eval("{'subnets': [" + subnet_cfg_body + "]}") subnet_body['subnets'][0]['network_id'] = network_uuid subnet_rst = self.neutron.create_subnet(body=subnet_body) Reporter.REPORT_MSG(" >> Create Subnet --->%s, %s, %s", network_opt, subnet_opt, dict(subnet_rst).values()) Reporter.unit_test_stop('ok') return subnet_rst except: Reporter.exception_err_write()
def create_securitygroup(self, sg_opt, rule_opt_list): Reporter.unit_test_start(True, sg_opt, rule_opt_list) try: sg_uuid = self.get_sg_uuid_by_name(self.get_sg_name(sg_opt)) if sg_uuid: Reporter.REPORT_MSG(" >> Already Exist Security Group ---> %s: %s", sg_opt, sg_uuid) Reporter.unit_test_stop('skip') return sg_body = dict(self.sg_conf)[sg_opt] sg_body = ast.literal_eval("{'security_group': " + sg_body + "}") # Create New Security Group sg_rst = self.neutron.create_security_group(sg_body) Reporter.REPORT_MSG(" >> Create Security Group ---> %s", sg_rst) # Make Rule to Security Group rule_rst = self.add_securitygroup_rule(sg_rst['security_group']['id'], rule_opt_list.split(',')) if not rule_rst: Reporter.REPORT_MSG(" >> Security Group Rule Create Error ") Reporter.REPORT_MSG(" >> Delete Security Group") self.neutron.delete_security_group(sg_rst['security_group']['id']) Reporter.unit_test_stop('nok') return Reporter.REPORT_MSG(" >> Create Security Group Rule ---> %s", rule_rst) Reporter.unit_test_stop('ok') return rule_rst except: Reporter.exception_err_write()
def delete_securitygroup(self, sg_opt): Reporter.unit_test_start(True, sg_opt) sg_uuid = '' sg_rst = [] try: sg_uuid = self.get_sg_uuid_by_name(self.get_sg_name(sg_opt)) if not sg_uuid: Reporter.unit_test_stop('skip') return sg_rst.append(self.neutron.delete_security_group(sg_uuid)) Reporter.REPORT_MSG(" >> Delete Security Group Succ ---> %s, %s", sg_opt, sg_rst) Reporter.unit_test_stop('ok') return sg_rst except client.exceptions.Conflict, err: Reporter.REPORT_MSG(" >> Conflict error, after sleep 3 seconds, delete retry") time.sleep(3) try: self.neutron.delete_security_group(sg_uuid) except: Reporter.exception_err_write() Reporter.REPORT_MSG(" >> Delete Security Group Succ ---> %s", sg_opt) Reporter.unit_test_stop('ok') return
def get_subnet_lists(self): subnet_rst = self.neutron.list_subnets() if not subnet_rst: Reporter.REPORT_MSG(" >> Not Exist Subnet --->") return Reporter.REPORT_MSG(" Subnet All List ---> %s ", dict(subnet_rst).values()) return subnet_rst
def title_print(menu='None'): Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) print BLUE + '|' + BG_BLUEW + \ ("{0:^"+str(menu_string_len)+"}").format("SONA-TOOL") + BLUE + '|'+ENDC Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len)) if 'None' not in menu: print BLUE + '|' + BG_PINKW + \ ("{0:<"+str(menu_string_len)+"}").format(menu) + BLUE + '|'+ENDC Reporter.PRINTB("|%s|", ('-'*menu_string_len).ljust(menu_string_len))
def openstack_get_token(self, report_flag=None): if report_flag is None: Reporter.unit_test_start(True) try: auth = v2.Password(username=self.auth['username'], password=self.auth['password'], tenant_name=self.auth['tenant_id'], auth_url=self.auth['auth_url']) sess = session.Session(auth=auth, timeout=5) token = sess.get_token() if not token: Reporter.REPORT_MSG( " >> OpentStack Authentication NOK ---> get token fail") if report_flag is None: Reporter.unit_test_stop('nok') return False else: Reporter.REPORT_MSG( " >> OpenStack Authentication OK ---> user: %s, token: %s", self.auth['username'], token) if report_flag is None: Reporter.unit_test_stop('ok') return True except exceptions.AuthorizationFailure, err: Reporter.REPORT_MSG(" >> OpentStack Authentication Fail ---> %s", err) return False
def get_admin_auth(self, user): try: auth = v2.Password(username=user['username'], password=user['api_key'], tenant_name=user['project_id'], auth_url=user['auth_url']) sess = session.Session(auth=auth, timeout=5) return client.Client(session=sess) # return sess except: Reporter.exception_err_write()
def set_router_state(type): Reporter.initial_test_count() title_print(' # router ' + type) # Router while 1: router_list, sel, sel_state = display_config_item('router') if False is sel_state: continue if 0 is sel: break test.network.set_router_up(router_list[sel-1]) test.reporter.test_summary() report_log_viewer() break
def get_network_uuid(self, network_opt): network_name = self.get_network_name(network_opt) if not network_name: return network_rst = self.neutron.list_networks(name=network_name) if dict(network_rst)['networks']: Reporter.REPORT_MSG(" >> Exist Network on OpenStack ---> %s", network_rst) network_uuid = dict(network_rst)['networks'][0]['id'] return network_uuid else: Reporter.REPORT_MSG(" >> Not Exist Network on OpenStack ---> %s", network_opt) return
def get_subnet_uuid(self, subnet_opt): subnet_name = self.get_subnet_name(subnet_opt) if not subnet_name: return subnet_rst = self.neutron.list_subnets(name=subnet_name) if dict(subnet_rst)['subnets']: Reporter.REPORT_MSG(" >> Exist Subnet on OpenStack ---> response: %s", subnet_rst) subnet_uuid = dict(subnet_rst)['subnets'][0]['id'] return subnet_uuid else: Reporter.REPORT_MSG(" >> Not Exist Subnet on OpenStack --->") return
def create_user(self): Reporter.unit_test_start(True) tenant_id = '' user_id = '' try: tenant_id = self.admin_user.tenants.create(tenant_name=self.identity['tenant_id'], description="SONA Test Temporary Tenant", enabled=True).id except exceptions.Conflict, err: tenant_list = self.admin_user.tenants.list() tenant_id = [x.id for x in tenant_list if x.name == self.identity['tenant_id']][0] Reporter.REPORT_MSG(" >> Already exist tenant(%s) > tenant_id: %s", self.identity['tenant_id'], tenant_id)
def delete_start_scenario(scen_name): Reporter.initial_test_count() ret = display_scenario(scen_name) if False is ret: return False # global test scen_file = SCENARIO_PATH+scen_name+'.ini' scen_ini = ConfigParser() scen_ini.read(scen_file) # Instance item = scen_ini._sections['instance'] for i in range(len(item)): if i is not 0: test.instance.delete_instance((item.values()[i]).split(', ')[0]) # Floating IP test.instance.delete_floatingip_all() # Security Group item = scen_ini._sections['security_group'] for i in range(len(item)): if i is not 0: test.network.delete_seuritygroup((item.values()[i]).split(', ')[0]) # Router interface item = scen_ini._sections['router-interface'] for i in range(len(item)): if i is not 0: test.network.remove_router_interface((item.values()[i]).split(', ')[0], (item.values()[i]).split(', ')[1]) # Router item = scen_ini._sections['router'] for i in range(len(item)): if i is not 0: test.network.delete_router((item.values()[i]).split(', ')[0]) # SubNet item = scen_ini._sections['subnet'] for i in range(len(item)): if i is not 0: test.network.delete_subnet((item.values()[i]).split(', ')[0]) # Network item = scen_ini._sections['network'] for i in range(len(item)): if i is not 0: test.network.delete_network(item.values()[i]) test.reporter.test_summary() report_log_viewer()
def delete_floatingip_all(self): Reporter.unit_test_start(True) try: floatingip_list = self.get_floatingip_list() if not floatingip_list: Reporter.REPORT_MSG(" >> Not exist Floating IP --->") Reporter.unit_test_stop('skip') return for f in floatingip_list: self.nova.floating_ips.delete(f) Reporter.REPORT_MSG(" >> All Floating IP Delete Succ --->") Reporter.unit_test_stop('ok') return except: Reporter.exception_err_write()
def get_instance(self, instance_opt): config_value = self.find_instance(instance_opt) if not config_value: return instance_rst = self.nova.servers.list( search_opts={'name': config_value['name']}) if not instance_rst: Reporter.REPORT_MSG(" >> Not exist openstack ---> %s", instance_opt) return Reporter.REPORT_MSG(" >> Get Instance ---> %s %s", instance_opt, instance_rst) return instance_rst
def delete_router(self, router_opt): Reporter.unit_test_start(True, router_opt) try: router_uuid = self.get_router_uuid(router_opt) if not router_uuid: Reporter.unit_test_stop('skip') return router_rst = self.neutron.delete_router(router_uuid) Reporter.REPORT_MSG(" >> Delete Router ---> %s", router_rst) Reporter.unit_test_stop('ok') except: Reporter.exception_err_write()
def set_port_state(type): Reporter.initial_test_count() title_print(' # port ' + type) while 1: # Instance inst_list, inst_sel, inst_sel_state = display_config_item('instance') if False is inst_sel_state: continue if 0 is inst_sel: break # Network net_list, net_sel, net_sel_state = display_config_item('network') if False is net_sel_state: continue if 0 is net_sel: break test.network.set_port_up(inst_list[inst_sel-1], net_list[net_sel-1]) test.reporter.test_summary() report_log_viewer() break
def get_router_name(self, router_opt): router_conf = dict(self.router_conf)[router_opt] if not router_conf: Reporter.REPORT_MSG(" >> Not Exist config file ---> %s", router_opt) return router_name = ast.literal_eval(router_conf)['name'] return router_name
def get_network_name(self, network_opt): network_body = dict(self.network_conf)[network_opt] if not network_body: Reporter.REPORT_MSG(" >> Not Exist Network in Config ---> %s", network_opt) return network_name = ast.literal_eval(network_body)['name'] return network_name
def get_network(self, network_opt): Reporter.unit_test_start(True, network_opt) try: network_name = self.get_network_name(network_opt) if not network_name: return network_rst = self.neutron.list_networks(name=network_name) if not dict(network_rst)['networks']: Reporter.REPORT_MSG(" >> Not Exist Network in OpenStack") return Reporter.REPORT_MSG(" >> Network List ---> %s %s", network_opt, dict(network_rst).values()) return network_rst except: Reporter.exception_err_write()
def delete_router(self, router_opt): Reporter.unit_test_start(True, router_opt) try: router_uuid = self.get_router_uuid(router_opt) if not router_uuid: Reporter.unit_test_stop('skip') return elif router_uuid == 'fail': Reporter.unit_test_stop('nok') return router_rst = self.neutron.delete_router(router_uuid) Reporter.REPORT_MSG(" >> Delete Router ---> %s", router_rst) Reporter.unit_test_stop('ok') except: Reporter.exception_err_write()
def get_router(self, router_opt): try: router_name = self.get_router_name(router_opt) if not router_name: return router_rst = self.neutron.list_routers(name=router_name) if not router_rst['routers']: Reporter.REPORT_MSG(" >> Not exist in OpenStack ---> %s, %s", router_opt, router_name) return Reporter.REPORT_MSG(" >> Router list ---> %s", router_rst) return router_rst except: Reporter.exception_err_write()
def delete_network(self, network_opt): Reporter.unit_test_start(True, network_opt) try: network_uuid = self.get_network_uuid(network_opt) if not network_uuid: Reporter.unit_test_stop('skip') return network_rst = self.neutron.delete_network(network_uuid) Reporter.REPORT_MSG(" >> Delete Network ---> %s %s", network_opt, network_uuid) Reporter.unit_test_stop('ok') return network_rst except: Reporter.exception_err_write()
def get_subnet_name(self, subnet_opt): subnet_conf = dict(self.subnet_conf)[subnet_opt] if not subnet_conf: Reporter.REPORT_MSG(" >> Not Exist Subnet in config --->") return subnet_name = ast.literal_eval(subnet_conf)['name'] return subnet_name
def get_sg_name(self, sg_opt): sg_conf = dict(self.sg_conf)[sg_opt] if not sg_conf: Reporter.REPORT_MSG(' >> Not Exist config file ---> %s', sg_opt) return sg_name = ast.literal_eval(sg_conf)['name'] return sg_name
def set_network_up(self, network_opt): Reporter.unit_test_start(True, network_opt) try: network_uuid = self.get_network_uuid(network_opt) if not network_uuid: Reporter.REPORT_MSG(" >> Network not find --> %s", network_opt) Reporter.unit_test_stop('nok') return body = {'network': {'admin_state_up': True}} network_rst = self.neutron.update_network(network_uuid, body) Reporter.REPORT_MSG(" >> Network Up Succ --> %s", network_opt) Reporter.unit_test_stop('ok') return network_rst except: Reporter.exception_err_write()
def set_router_up(self, router_opt): Reporter.unit_test_start(True, router_opt) try: router_uuid = self.get_router_uuid(router_opt) if not router_uuid: Reporter.REPORT_MSG(" >> Router not find --> %s", router_opt) Reporter.unit_test_stop('nok') return body = {'router': {'admin_state_up': True}} network_rst = self.neutron.update_router(router_uuid, body) Reporter.REPORT_MSG(" >> Router Up Succ --> %s", router_opt) Reporter.unit_test_stop('ok') return network_rst except: Reporter.exception_err_write()
def get_router(self, router_opt): try: router_name = self.get_router_name(router_opt) if not router_name: return router_rst = self.neutron.list_routers(name=router_name) if not router_rst['routers']: Reporter.REPORT_MSG(" >> Not exist in OpenStack ---> %s, %s", router_opt, router_name) return Reporter.REPORT_MSG(" >> Router list ---> %s", router_rst) return router_rst except: Reporter.exception_err_write2() return 'fail'
def delete_subnet(self, subnet_opt): Reporter.unit_test_start(True, subnet_opt) try: subnet_uuid = self.get_subnet_uuid(subnet_opt) if not subnet_uuid: Reporter.unit_test_stop('skip') return subnet_rst = self.neutron.delete_subnet(subnet_uuid) Reporter.REPORT_MSG(" >> Delete network ---> %s, %s", subnet_opt, subnet_uuid) Reporter.unit_test_stop('ok') return subnet_rst except: Reporter.exception_err_write()
def create_network(self, network_opt): Reporter.unit_test_start(True, network_opt) try: network_body = dict(self.network_conf)[network_opt] if not network_body: Reporter.REPORT_MSG(" >> Not Exist Network in config_file") Reporter.unit_test_stop('nok') return if self.get_network_uuid(network_opt): # Reporter.REPORT_MSG(" >> Already Exist same Network name") Reporter.unit_test_stop('skip') else: network_body = ast.literal_eval("{'network': " + network_body + "}") network_rst = self.neutron.create_network(body=network_body) Reporter.REPORT_MSG(" >> Create Network Succ ---> %s %s", network_opt, dict(network_rst).values()) Reporter.unit_test_stop('ok') return network_rst except: Reporter.exception_err_write()
def onos_and_openstack_check(self): Reporter.unit_test_start(True) try: flag = 'no' app_stat = self.onos.application_status(report_flag=flag) device_stat = self.onos.devices_status(report_flag=flag) token_stat = self.openstack_get_token(report_flag=flag) service_stat = self.openstack_get_service(report_flag=flag) # Reporter.NRET_PRINT("%s %s %s %s", app_stat, device_stat, token_stat, service_stat) if (app_stat and device_stat and token_stat and service_stat): Reporter.unit_test_stop('ok') else: Reporter.unit_test_stop('nok') if False is self.result_skip_mode: Reporter.test_summary() os._exit(1) except: Reporter.exception_err_write()
def get_subnet(self, subnet_opt): Reporter.unit_test_start(True, subnet_opt) try: subnet_name = self.get_subnet_name(subnet_opt) if not subnet_name: Reporter.unit_test_stop('nok') return subnet_rst = self.neutron.list_subnets(name=subnet_name) if not subnet_rst['subnets']: Reporter.REPORT_MSG(" >> Not Exist Subnet ---> %s, response: %s", subnet_name, subnet_rst) Reporter.unit_test_stop('nok') return Reporter.REPORT_MSG(" >> Subnet List ---> %s, response: %s", subnet_opt, dict(subnet_rst).values()) Reporter.unit_test_stop('ok') return subnet_rst except: Reporter.exception_err_write()
def openstack_get_token(self, report_flag=None): if report_flag is None: Reporter.unit_test_start(True) try: auth = v2.Password(username=self.auth['username'], password=self.auth['password'], tenant_name=self.auth['tenant_id'], auth_url=self.auth['auth_url']) sess = session.Session(auth=auth, timeout=5) token = sess.get_token() if not token: Reporter.REPORT_MSG(" >> OpentStack Authentication NOK ---> get token fail") if report_flag is None: Reporter.unit_test_stop('nok') return False else: Reporter.REPORT_MSG(" >> OpenStack Authentication OK ---> user: %s, token: %s", self.auth['username'], token) if report_flag is None: Reporter.unit_test_stop('ok') return True except exceptions.AuthorizationFailure, err: Reporter.REPORT_MSG(" >> OpentStack Authentication Fail ---> %s", err) return False
def openstack_get_service(self, report_flag=None): if report_flag is None: Reporter.unit_test_start(True) try: auth = v2.Password(username=self.auth['username'], password=self.auth['password'], tenant_name=self.auth['tenant_id'], auth_url=self.auth['auth_url']) sess = session.Session(auth=auth, timeout=5) keystone = client.Client(session=sess) service_list = [{a.name: a.enabled} for a in keystone.services.list()] for i in range(len(service_list)): if service_list[i].values()[0] is False: Reporter.REPORT_MSG(" >> OpenStack Service status NOK ---> %s", service_list[i]) if report_flag is None: Reporter.unit_test_stop('nok') return False Reporter.REPORT_MSG(" >> OpenStack Service status OK ---> %s", service_list) if report_flag is None: Reporter.unit_test_stop('ok') return True except exceptions.AuthorizationFailure, err: Reporter.REPORT_MSG(" >> OpentStack Authentication Fail ---> %s", err) return False
def floatingip_associate(self, instance_opt, network_opt): Reporter.unit_test_start(True, instance_opt, network_opt) try: server = self.get_instance(instance_opt) pool_opt = ast.literal_eval(dict(self.network_conf)[network_opt])['name'] if not server: Reporter.unit_test_stop('nok') return for vm_net_name in server[0].addresses.keys(): for server_ip in server[0].addresses[vm_net_name]: if str(server_ip['OS-EXT-IPS:type']) == 'floating': Reporter.REPORT_MSG(" >> %s already associated floating ip to %s network(%s)--->", instance_opt, vm_net_name, server_ip['addr']) Reporter.unit_test_stop('skip') return floatingip_list = self.nova.floating_ips.list() if not floatingip_list: Reporter.REPORT_MSG(" >> Not exist floating IPs --->") extra_floatingip = '' for a in floatingip_list: if not a.fixed_ip: extra_floatingip = a.ip break if not extra_floatingip: extra_floatingip = self.nova.floating_ips.create(pool=pool_opt).ip # TODO add fixed_address option self.nova.servers.add_floating_ip(server[0], extra_floatingip, fixed_address=None) Reporter.REPORT_MSG(" >> Floating IP Associate ---> %s", self.nova.floating_ips.list()) Reporter.unit_test_stop('ok') except: Reporter.exception_err_write()
def each_device_status(self, conn_info): try: dev_list = self.device_info(conn_info) if None is dev_list: Reporter.REPORT_MSG(' >> Device Get Fail from [%s] -->', conn_info['host']) return False dev_cnt = 0 for i in range(len(dev_list)): dev_info_dic = dict(dev_list[i]) proto = dict(dev_info_dic['annotations']).get('protocol') if None is proto: continue dev_cnt += 1 if False is dev_info_dic['available']: Reporter.REPORT_MSG(' >> ONOS Device[%s] Status NOK [%s] ', dev_info_dic['id'], conn_info['host']) return False # Port status(br-int) if 'of' in dev_info_dic['id']: port_status = self.port_info(conn_info, dev_info_dic['id']) if not port_status: return False status = 0 for x in list(port_status): if x == 'br-int' : continue else: if not port_status[x]: Reporter.REPORT_MSG(' >> ONOS Device[%s]\' Port(%s) status is False [%s]', dev_info_dic['id'], x, conn_info['host']) return False Reporter.REPORT_MSG(' >> ONOS Device/Port status OK [%s] ', conn_info['host']) return True except: Reporter.exception_err_write()
def port_info(self, conn_info, dev_id): try: conn = self.onos_create_session(conn_info) url = 'http://' + conn_info['host'] + ':8181/onos/v1/devices/' + dev_id + '/ports' header = {'Accept': 'application/json'} # print json.dumps(conn.get(url, headers=header).json(),indent=4, separators=('',':')) ret = json.dumps(conn.get(url, headers=header, timeout= self._config.get_onos_timeout()).json(), ensure_ascii=False, sort_keys=False).encode('utf-8') result = dict() for x in json.loads(ret)['ports']: result[x['annotations']['portName']] = x['isEnabled'] if not len(result): Reporter.REPORT_MSG(' >> Device[%s] Get port fail from [%s] ', dev_id, conn_info['host']) return return result except: Reporter.exception_err_write() return
def delete_instance(self, instance_opt): Reporter.unit_test_start(True, instance_opt) try: instance_list = self.get_instance(instance_opt) if not instance_list: Reporter.unit_test_stop('skip') return for i in instance_list: self.nova.servers.delete(i) # time.sleep(5) Reporter.REPORT_MSG(" >> Delete Instance ---> %s", instance_opt) Reporter.unit_test_stop('ok') return except: Reporter.exception_err_write()
def remove_router_interface(self, router_opt, subnet_opt): Reporter.unit_test_start(True, router_opt, subnet_opt) try: router_uuid = self.get_router_uuid(router_opt) if not router_uuid: Reporter.REPORT_MSG(" >> Router Not Exist --->> %s", router_opt) Reporter.unit_test_stop('nok') return subnet_uuid = self.get_subnet_uuid(subnet_opt) if not subnet_uuid: Reporter.REPORT_MSG(" >> Subnet Not Exist --->> %s", router_opt) Reporter.unit_test_stop('nok') return router_if_body = {'subnet_id': subnet_uuid} router_if_rst = self.neutron.remove_interface_router(router_uuid, router_if_body) Reporter.REPORT_MSG(" >> Remove Router Interface ---> %s, %s", router_opt, subnet_opt) Reporter.unit_test_stop('ok') return router_if_rst except: Reporter.exception_err_write()
def set_network_down(self, network_opt): Reporter.unit_test_start(True, network_opt) try: network_uuid = self.get_network_uuid(network_opt) if not network_uuid: Reporter.unit_test_stop('nok') return body = {'network': {'admin_state_up': False}} network_rst = self.neutron.update_network(network_uuid, body) Reporter.REPORT_MSG(" >> Network Down Succ --> %s", network_opt) Reporter.unit_test_stop('ok') return network_rst except: Reporter.exception_err_write()
def floating_ip_check(self, inst1): Reporter.unit_test_start(False) try: # floating ip floating_ip = self.instance.get_instance_floatingip(inst1) if None is floating_ip: Reporter.REPORT_MSG(' >> Get floating_ip[%s] fail', floating_ip) Reporter.unit_test_stop('nok', False) return False ping_result = [] sucs_cnt = 0 (exitstatus, outtext) = commands.getstatusoutput('uname -a') if 'Linux' in outtext: cmd = 'ping ' + floating_ip + ' -w 1' else: cmd = 'ping -t 1 ' + floating_ip for i in range(self.ping_timeout): (exitstatus, outtext) = commands.getstatusoutput(cmd) ping_result.append(outtext) if 'from ' + floating_ip in outtext: sucs_cnt += 1 if 2 is sucs_cnt: break if 2 is sucs_cnt: Reporter.REPORT_MSG(' >> result : local --> %s : ok', floating_ip) time.sleep(5) Reporter.unit_test_stop('ok', False) return True else: Reporter.REPORT_MSG(' >> result : local --> %s : nok', floating_ip) Reporter.unit_test_stop('nok', False) return False except: Reporter.exception_err_write()
def set_port_up(self, instance_opt, network_opt): Reporter.unit_test_start(True, instance_opt, network_opt) try: port_uuid = self.get_port_uuid(instance_opt, network_opt) if not port_uuid: Reporter.REPORT_MSG(" >> Port Not find --> %s, %s", instance_opt, network_opt) Reporter.unit_test_stop('nok') return body = {'port': {'admin_state_up': True}} port_rst = [] for i in range(len(port_uuid)): port_rst.append(self.neutron.update_port(port_uuid[i], body)) Reporter.REPORT_MSG(" >> Port Down Succ --> %s", port_uuid) Reporter.unit_test_stop('ok') return port_rst except: Reporter.exception_err_write()
def application_status(self, report_flag=None): if report_flag is None: Reporter.unit_test_start(True) try: onos_info = self._config.get_onos_info() conn_info = {} state_info = {} for onos_ip in onos_info.onos_service_ip.split(','): state_list = [] conn_info['host'] = onos_ip conn_info['user'] = onos_info.user_id conn_info['password'] = onos_info.password for app in onos_info.app_list: # Reporter.NRET_PRINT("aaa %s", app) ret = self.app_info(conn_info, 'org.onosproject.' + app) state_info[app] = ret; state_list.append(ret) # ret = self.app_info(conn_info, 'org.onosproject.scalablegateway') # state_info['scalablegateway'] = ret; state_list.append(ret) # ret = self.app_info(conn_info, 'org.onosproject.openstacknode') # state_info['openstacknode'] = ret; state_list.append(ret) # if 'ACTIVE' not in state_list: if state_list.count('ACTIVE') != len(state_list): Reporter.REPORT_MSG(' >> ONOS Application NOK [%s]: %s', onos_ip, state_info) if report_flag is None: Reporter.unit_test_stop('nok') return False else: Reporter.REPORT_MSG(' >> ONOS Application OK [%s]: %s', onos_ip, state_info) if report_flag is None: Reporter.unit_test_stop('ok') return True except: Reporter.exception_err_write() return False
def devices_status(self, report_flag=None): if report_flag is None: Reporter.unit_test_start(True) try: onos_info = self._config.get_onos_info() conn_info = {} for onos_ip in onos_info.onos_service_ip.split(','): conn_info['host'] = onos_ip conn_info['user'] = onos_info.user_id conn_info['port'] = onos_info.ssh_port conn_info['password'] = onos_info.password ret = self.each_device_status(conn_info) if False is ret: if report_flag is None: Reporter.unit_test_stop('nok') return False if report_flag is None: Reporter.unit_test_stop('ok') return True except: Reporter.exception_err_write() return False
def onos_application_status(self): # onos status Reporter.unit_test_start() conn_info = {} # onos_info = self.config.get_onos_info() for onos_ip in self.onos_info.onos_list: conn_info['host'] = onos_ip conn_info['user'] = self.onos_info.user_id conn_info['port'] = self.onos_info.ssh_port conn_info['password'] = self.onos_info.password ret = self.apps_status(conn_info) if 0 is ret: Reporter.unit_test_stop('nok') return False Reporter.unit_test_stop('ok')
def create_instance(self, instance_opt, network_opt, sg_opt): Reporter.unit_test_start(True, instance_opt, network_opt, sg_opt) try: config_value = self.find_instance(instance_opt) if not config_value: Reporter.unit_test_stop('nok') return instance_rst = self.nova.servers.list(search_opts={'name': config_value['name']}) if instance_rst: Reporter.REPORT_MSG(" >> Already exist in OpenStack ---> %s", instance_rst) Reporter.unit_test_stop('skip') return image = self.nova.images.find(name=config_value['image']) flavor = self.nova.flavors.find(name=config_value['flavor']) # Get openstack network name from network config net_name_list = [] network_opt = network_opt.split(',') for a in network_opt: net_conf_body = ast.literal_eval(dict(self.network_conf)[a.strip()]) if not net_conf_body: Reporter.REPORT_MSG(" >> Not exist in config file ---> %s", network_opt) Reporter.unit_test_stop('nok') return net_name_list.append(net_conf_body['name']) # Get network uuid from openstack neutron and make nics list nics_list = [] for a in net_name_list: nics_list.append({'net-id': self.nova.networks.find(label=a).id}) if sg_opt is '': sg_list = ['default'] else: sg_list = [ast.literal_eval(dict(self.sg_config)[sg_opt])['name']] # create instance instance_rst = self.nova.servers.create(name=config_value['name'], image=image, flavor=flavor, availability_zone=config_value['zone'], nics=nics_list, security_groups=sg_list) Reporter.REPORT_MSG(" >> Create Succ ---> %s", instance_rst) Reporter.unit_test_stop('ok') return instance_rst except: Reporter.exception_err_write()