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 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_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 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 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 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 add_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", subnet_opt) Reporter.unit_test_stop('nok') return router_if_body = {'subnet_id': subnet_uuid} router_if_rst = self.neutron.add_interface_router( router_uuid, router_if_body) Reporter.REPORT_MSG(" >> Add Router Interface ---> %s", router_if_rst) Reporter.unit_test_stop('ok') return router_if_rst except exceptions.BadRequest as e: if 'Router already has a port' in str(e): Reporter.REPORT_MSG( " >> Router Interface alreay exist ---> %s", e) Reporter.unit_test_stop('skip') 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 create_router(self, router_opt, network_opt): Reporter.unit_test_start(True, router_opt, network_opt) try: if self.get_router(router_opt): Reporter.unit_test_stop('skip') return router_cfg_body = ast.literal_eval(dict(self.router_conf)[router_opt]) if not router_cfg_body: Reporter.REPORT_MSG(" >> Not Exist Config file ---> %s", router_opt) Reporter.unit_test_stop('nok') return router_body = {} if network_opt: network_uuid = self.get_network_uuid(network_opt) if not network_uuid: Reporter.unit_test_stop('nok') return router_cfg_body['external_gateway_info'] = {'network_id': network_uuid} router_body = {'router': router_cfg_body} router_rst = self.neutron.create_router(router_body) Reporter.REPORT_MSG(" >> Create Router ---> %s", router_rst) Reporter.unit_test_stop('ok') return router_rst except: Reporter.exception_err_write()
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()
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 device_status(self, conn_info): try: dev_list = self.device_info(conn_info) if None is dev_list: return False br_int_status = 0 vxlan_status = 0 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 # Reporter.REPORT_MSG(' >>[%d] %s', i, dev_info_dic) if False is dev_info_dic['available']: Reporter.REPORT_MSG(' >> [%s] device[%s] status nok', conn_info['host'], dev_info_dic['id']) return False # Port status(br-int) port_result = self.port_info(conn_info, dev_info_dic['id']) status = 0 for x in port_result: str = dict(x) if str.has_key('br-int') == True: status = 1 break br_int_status += status # Port status(vxlan) for x in port_result: str = dict(x) if str.has_key('vxlan') == True: if True is str['vxlan']: vxlan_status += 1 # br-int if dev_cnt != br_int_status: Reporter.REPORT_MSG(' >> [%s] port status(br-int) -- nok', conn_info['host']) return False # vxlan-int if dev_cnt != vxlan_status: Reporter.REPORT_MSG(' >> [%s] port status(vxlan) -- nok', conn_info['host']) return False Reporter.REPORT_MSG(' >> [%s] device, port status -- ok', conn_info['host']) return True except: Reporter.exception_err_write()
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 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_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_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_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 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 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 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 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 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 ret = self.app_info(conn_info, 'org.onosproject.openstackswitching') state_info['openstackswitching'] = ret state_list.append(ret) ret = self.app_info(conn_info, 'org.onosproject.openstackrouting') state_info['openstackrouting'] = ret state_list.append(ret) ret = self.app_info(conn_info, 'org.onosproject.openstacknode') state_info['openstacknode'] = ret state_list.append(ret) ret = self.app_info(conn_info, 'org.onosproject.openstackinterface') state_info['openstackinterface'] = ret state_list.append(ret) if 'ACTIVE' not in state_list: Reporter.REPORT_MSG(' >> [%s][Application NOK] : %s', onos_ip, state_info) if report_flag is None: Reporter.unit_test_stop('nok') return False else: Reporter.REPORT_MSG(' >> [%s][Application OK] : %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 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_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 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 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 find_instance(self, instance_opt): instance_conf = dict(self.instance_conf)[instance_opt] if not instance_conf: Reporter.REPORT_MSG(" >> Not exist in config ---> %s", instance_opt) return config_value = ast.literal_eval(instance_conf) return config_value
def wget_clear(self, *insts): Reporter.REPORT_MSG( ' >> all wget process kill / download file and all wget log files delete.' ) cmd = 'killall -9 wget; ' + 'rm ' + self.wget_url.split( '/')[-1] + '*' + ' ' + 'wget-log*' self.wget_ssh_cmd(cmd, *insts) return