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 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 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 create_router(self, router_opt, network_opt):
Reporter.unit_test_start(True, router_opt, network_opt)
try:
router_rt = self.get_router(router_opt)
if router_rt == 'fail':
Reporter.unit_test_stop('nok')
return
elif 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 openstack_get_token(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'])
token = keystone.auth_token
if not token:
Reporter.REPORT_MSG(" >> OpentStack Authentication NOK --->")
if report_flag is None:
Reporter.unit_test_stop('nok')
return False
Reporter.REPORT_MSG(
" >> OpenStack Authentication OK ---> token: %s", token)
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 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 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)
except:
Reporter.exception_err_write()
return
# Reporter.NRET_PRINT("aaa %s\n", tenant_id)
try:
user_id = self.admin_user.users.create(name=self.identity['username'],
password=self.identity['password'],
tenant_id=tenant_id).id
admin_role_id = [x.id for x in self.admin_user.roles.list() if x.name == 'admin'][0]
self.admin_user.roles.add_user_role(user_id, admin_role_id, tenant_id)
except exceptions.Conflict, err:
user_list = self.admin_user.users.list()
user_id = [x.id for x in user_list if x.name == self.identity['username']][0]
Reporter.REPORT_MSG(" >> Already exist User(%s) > user_id: %s",
def ssh_wget(self, *insts):
try:
if len(insts) in [1, 2]:
Reporter.unit_test_start(False, *insts)
floating_ip = self.instance.get_instance_floatingip(insts[0])
if None is floating_ip:
Reporter.REPORT_MSG(' >> Get floating_ip[%s] fail', floating_ip)
Reporter.unit_test_stop('nok', False)
return False
clear_key = 'ssh-keygen -f "' + os.path.expanduser('~')+'/.ssh/known_hosts" -R ' + floating_ip
commands.getstatusoutput(clear_key)
else:
Reporter.unit_test_start(False, *insts)
Reporter.REPORT_MSG(' >> Check the arguments(need 1 or 2)')
Reporter.unit_test_stop('nok', False)
return False
cmd = 'wget ' + self.wget_url
Reporter.REPORT_MSG(' >> wget %s', self.wget_url)
wget_result = self.wget_ssh_cmd(cmd, *insts)
if wget_result[0] is True or wget_result[0] is 'timeoutError':
if self.wget_progress_check(wget_result[1]):
self.wget_clear(*insts)
Reporter.unit_test_stop('ok')
return True
if wget_result[0] is 'sshConFail':
return False
elif wget_result[0] is 'unexpectedError' or wget_result[0] is 'timeoutError':
Reporter.REPORT_MSG(' >> Interface MTU size DOWN to 1400')
cmd = 'sudo ifconfig eth0 mtu 1400;'
if self.wget_ssh_cmd(cmd, *insts)[0] is False:
Reporter.REPORT_MSG(' >> Interface mtu size down fail')
Reporter.unit_test_stop('nok', False)
return False
Reporter.REPORT_MSG(' >> second wget %s', self.wget_url)
cmd = 'wget ' + self.wget_url
wget_sd_result = self.wget_ssh_cmd(cmd, *insts)
if wget_sd_result[0] is True or wget_sd_result[0] is 'timeoutError':
if self.wget_progress_check(wget_sd_result[1]) is True:
Reporter.REPORT_MSG(' >> Please check MTU SIZE on ALL DATA PATH ~ !!!')
Reporter.REPORT_MSG(' >> You should be set more 1600 bytes for Data Path interfaces !!!')
else:
Reporter.REPORT_MSG(' >> Second wget fail ~ !!!')
Reporter.unit_test_stop('nok', False)
return False
self.wget_clear(*insts)
else:
Reporter.unit_test_stop('nok', False)
return False
Reporter.REPORT_MSG(' >> Interface MTU size RETURN to 1500')
cmd = 'sudo ifconfig eth0 mtu 1500'
if self.wget_ssh_cmd(cmd, *insts)[0] is False:
Reporter.REPORT_MSG(' >> Interface mtu size return fail')
Reporter.unit_test_stop('nok', False)
return False
Reporter.unit_test_stop('nok', False)
except:
Reporter.exception_err_write()
return True
def ssh_ping(self, inst1, *insts):
if len(insts) > 1:
Reporter.unit_test_start(False, inst1, insts[0], insts[1])
else:
Reporter.unit_test_start(False, inst1, insts[0])
if len(insts) > 2 or len(insts) < 1:
Reporter.REPORT_MSG(' >> Check the arguments(Min : 2, Max : 3)')
Reporter.unit_test_stop('nok', False)
return 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
# check dest type
ping_ip = insts[-1]
try:
socket.inet_aton(insts[-1])
except socket.error:
ping_ip = self.instance.get_instance_ip(insts[-1])
if None is ping_ip:
Reporter.unit_test_stop('nok', False)
return False
pass
# clear ssh key
clear_key = 'ssh-keygen -f "' + os.path.expanduser('~')+'/.ssh/known_hosts" -R ' + floating_ip
commands.getstatusoutput(clear_key)
# first ssh connection
# get first instance connection info
inst_info_1 = ast.literal_eval(self.inst_conf[inst1])
conn = self.ssh_connect(floating_ip, inst_info_1['user'], '', inst_info_1['password'])
if conn is False:
Reporter.unit_test_stop('nok', False)
return False
# get second instance connection info
if len(insts) > 1:
# if ':' in inst2:
name_list = insts[0].split(':')
inst_info_2 = ast.literal_eval(self.inst_conf[name_list[0]])
inst2_ip = self.instance.get_instance_ip(insts[0])
ssh_cmd = 'ssh ' + inst_info_2['user'] + '@' + inst2_ip
conn.sendline(ssh_cmd)
# Reporter.REPORT_MSG(' >> connection: %s', ssh_cmd)
ssh_newkey = 'want to continue connecting'
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 Server(%d)', inst2_ip, ret)
Reporter.unit_test_stop('nok', False)
self.ssh_disconnect(conn)
return False
if ret == 1:
conn.sendline('yes')
ret = conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=self.conn_timeout)
if ret == 2:
ret = conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=self.conn_timeout)
conn.sendline(inst_info_2['password'])
conn.expect(PROMPT, timeout=self.conn_timeout)
cmd = 'ping ' + ping_ip + ' -w 2'
conn.sendline(cmd)
conn.expect(PROMPT, timeout=self.conn_timeout)
# parsing loss rate
ping_list = conn.before.splitlines()
self.ssh_disconnect(conn)
ping_result = False
for list in ping_list:
if 'loss' in list:
split_list = list.split(', ')
for x in split_list:
if '%' in x:
result = x.split('%')
if 0 is int(result[0]):
ping_result = True
break
# result output
if True is ping_result:
if len(insts) > 1:
Reporter.REPORT_MSG(' >> result : %s --> %s --> %s : ok',
inst1, insts[0], insts[-1])
else:
Reporter.REPORT_MSG(' >> result : %s --> %s : ok',
inst1, insts[-1])
Reporter.unit_test_stop('ok', False)
else:
if len(insts) > 1:
Reporter.REPORT_MSG(' >> result : %s --> %s --> %s : nok',
inst1, insts[0], insts[-1])
else:
Reporter.REPORT_MSG(' >> result : %s --> %s : nok',
inst1, insts[-1])
Reporter.REPORT_MSG("%s", '\n'.join(' >> '
+ line for line in ping_list))
Reporter.unit_test_stop('nok', False)
return False
return True
except:
Reporter.exception_err_write()
return False
def main():
global exit_flag
main_menu()
while exit_flag:
try:
global navi_menu
if MAIN_MENU is navi_menu:
menu = input(PROMPT)
if menu < len(main_menu_map):
main_menu_map.get(menu)()
if SCEN_CRT_MENU is menu:
navi_menu = SCEN_CRT_MENU
elif SCEN_DEL_MENU is menu:
navi_menu = SCEN_DEL_MENU
elif ETC_MENU is menu:
navi_menu = ETC_MENU
elif 0 is menu:
break
else:
main_menu()
else:
Reporter.PRINTR(" Invalid Value.!")
main_menu()
elif SCEN_CRT_MENU is navi_menu:
menu = input(PROMPT)
if menu < len(scen_create_menu_map):
if 0 is menu:
scen_create_menu_map.get(menu)()
navi_menu = MAIN_MENU
save_scenario_dic.clear()
else:
scen_create_menu_map.get(menu)('create')
scen_create_menu()
else:
Reporter.PRINTR(" Invalid Value.!")
scen_create_menu()
elif SCEN_DEL_MENU is navi_menu:
menu = input(PROMPT)
if menu < len(scen_delete_menu_map):
if 0 is menu:
scen_delete_menu_map.get(menu)()
navi_menu = MAIN_MENU
save_scenario_dic.clear()
else:
scen_delete_menu_map.get(menu)('delete')
scen_delete_menu()
else:
Reporter.PRINTR(" Invalid Value.!")
scen_delete_menu()
elif ETC_MENU is navi_menu:
menu = input(PROMPT)
if menu < len(etc_menu_map):
if menu > 2:
if 0 is menu%2:
etc_menu_map.get(menu)('down')
else:
etc_menu_map.get(menu)('up')
else:
etc_menu_map.get(menu)()
if 0 is menu:
navi_menu = MAIN_MENU
else:
state_test_menu()
else:
Reporter.PRINTR(" Invalid Value.!")
state_test_menu()
except Exception, e:
# print 'Invailid command!'
print 'err : ', e
Reporter.exception_err_write()
if MAIN_MENU is navi_menu:
main_menu()
elif SCEN_CRT_MENU is navi_menu:
scen_create_menu()
elif SCEN_DEL_MENU is navi_menu:
scen_delete_menu()
elif ETC_MENU is navi_menu:
state_test_menu()
# print e
continue
def ssh_wget(self, *insts):
try:
if len(insts) in [1, 2]:
Reporter.unit_test_start(False, *insts)
floating_ip = self.instance.get_instance_floatingip(insts[0])
if None is floating_ip:
Reporter.REPORT_MSG(' >> Get floating_ip[%s] fail',
floating_ip)
Reporter.unit_test_stop('nok', False)
return False
clear_key = 'ssh-keygen -f "' + os.path.expanduser(
'~') + '/.ssh/known_hosts" -R ' + floating_ip
commands.getstatusoutput(clear_key)
else:
Reporter.unit_test_start(False, *insts)
Reporter.REPORT_MSG(' >> Check the arguments(need 1 or 2)')
Reporter.unit_test_stop('nok', False)
return False
cmd = 'wget ' + self.wget_url
Reporter.REPORT_MSG(' >> wget %s', self.wget_url)
wget_result = self.wget_ssh_cmd(cmd, *insts)
if wget_result[0] is True or wget_result[0] is 'timeoutError':
if self.wget_progress_check(wget_result[1]):
self.wget_clear(*insts)
Reporter.unit_test_stop('ok')
return True
if wget_result[0] is 'sshConFail':
return False
elif wget_result[0] is 'unexpectedError' or wget_result[
0] is 'timeoutError':
Reporter.REPORT_MSG(' >> Interface MTU size DOWN to 1400')
cmd = 'sudo ifconfig eth0 mtu 1400;'
if self.wget_ssh_cmd(cmd, *insts)[0] is False:
Reporter.REPORT_MSG(' >> Interface mtu size down fail')
Reporter.unit_test_stop('nok', False)
return False
Reporter.REPORT_MSG(' >> second wget %s', self.wget_url)
cmd = 'wget ' + self.wget_url
wget_sd_result = self.wget_ssh_cmd(cmd, *insts)
if wget_sd_result[0] is True or wget_sd_result[
0] is 'timeoutError':
if self.wget_progress_check(wget_sd_result[1]) is True:
Reporter.REPORT_MSG(
' >> Please check MTU SIZE on ALL DATA PATH ~ !!!'
)
Reporter.REPORT_MSG(
' >> You should be set more 1600 bytes for Data Path interfaces !!!'
)
else:
Reporter.REPORT_MSG(' >> Second wget fail ~ !!!')
Reporter.unit_test_stop('nok', False)
return False
self.wget_clear(*insts)
else:
Reporter.unit_test_stop('nok', False)
return False
Reporter.REPORT_MSG(
' >> Interface MTU size RETURN to 1500')
cmd = 'sudo ifconfig eth0 mtu 1500'
if self.wget_ssh_cmd(cmd, *insts)[0] is False:
Reporter.REPORT_MSG(' >> Interface mtu size return fail')
Reporter.unit_test_stop('nok', False)
return False
Reporter.unit_test_stop('nok', False)
except:
Reporter.exception_err_write()
return True
def ssh_ping(self, inst1, *insts):
if len(insts) > 1:
Reporter.unit_test_start(False, inst1, insts[0], insts[1])
else:
Reporter.unit_test_start(False, inst1, insts[0])
if len(insts) > 2 or len(insts) < 1:
Reporter.REPORT_MSG(' >> Check the arguments(Min : 2, Max : 3)')
Reporter.unit_test_stop('nok', False)
return 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
# check dest type
ping_ip = insts[-1]
try:
socket.inet_aton(insts[-1])
except socket.error:
ping_ip = self.instance.get_instance_ip(insts[-1])
if None is ping_ip:
Reporter.unit_test_stop('nok', False)
return False
pass
# clear ssh key
clear_key = 'ssh-keygen -f "' + os.path.expanduser(
'~') + '/.ssh/known_hosts" -R ' + floating_ip
commands.getstatusoutput(clear_key)
# first ssh connection
# get first instance connection info
inst_info_1 = ast.literal_eval(self.inst_conf[inst1])
conn = self.ssh_connect(floating_ip, inst_info_1['user'], '',
inst_info_1['password'])
if conn is False:
Reporter.unit_test_stop('nok', False)
return False
# get second instance connection info
if len(insts) > 1:
# if ':' in inst2:
name_list = insts[0].split(':')
inst_info_2 = ast.literal_eval(self.inst_conf[name_list[0]])
inst2_ip = self.instance.get_instance_ip(insts[0])
ssh_cmd = 'ssh ' + inst_info_2['user'] + '@' + inst2_ip
conn.sendline(ssh_cmd)
# Reporter.REPORT_MSG(' >> connection: %s', ssh_cmd)
ssh_newkey = 'want to continue connecting'
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 Server(%d)',
inst2_ip, ret)
Reporter.unit_test_stop('nok', False)
self.ssh_disconnect(conn)
return False
if ret == 1:
conn.sendline('yes')
ret = conn.expect([pexpect.TIMEOUT, '[P|p]assword'],
timeout=self.conn_timeout)
if ret == 2:
ret = conn.expect([pexpect.TIMEOUT, '[P|p]assword'],
timeout=self.conn_timeout)
conn.sendline(inst_info_2['password'])
conn.expect(PROMPT, timeout=self.conn_timeout)
cmd = 'ping ' + ping_ip + ' -w 2'
conn.sendline(cmd)
conn.expect(PROMPT, timeout=self.conn_timeout)
# parsing loss rate
ping_list = conn.before.splitlines()
self.ssh_disconnect(conn)
ping_result = False
for list in ping_list:
if 'loss' in list:
split_list = list.split(', ')
for x in split_list:
if '%' in x:
result = x.split('%')
if 0 is int(result[0]):
ping_result = True
break
# result output
if True is ping_result:
if len(insts) > 1:
Reporter.REPORT_MSG(' >> result : %s --> %s --> %s : ok',
inst1, insts[0], insts[-1])
else:
Reporter.REPORT_MSG(' >> result : %s --> %s : ok', inst1,
insts[-1])
Reporter.unit_test_stop('ok', False)
else:
if len(insts) > 1:
Reporter.REPORT_MSG(
' >> result : %s --> %s --> %s : nok', inst1,
insts[0], insts[-1])
else:
Reporter.REPORT_MSG(' >> result : %s --> %s : nok',
inst1, insts[-1])
Reporter.REPORT_MSG(
"%s", '\n'.join(' >> ' + line for line in ping_list))
Reporter.unit_test_stop('nok', False)
return False
return True
except:
Reporter.exception_err_write()
return False
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
except:
Reporter.exception_err_write()
#
# Router Control Method
#
def get_router_lists(self):
router_rst = self.neutron.list_routers()
print ' >> Router List --->', router_rst
return router_rst
def get_router(self, router_opt):
try:
router_name = self.get_router_name(router_opt)
if not router_name:
return
