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 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 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 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_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 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 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 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 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_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 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_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 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 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_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_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 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 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_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 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 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 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 delete_securitygroup(self, sg_opt):
Reporter.unit_test_start(True, sg_opt)
try:
sg_uuid = self.get_sg_uuid(sg_opt)
if not sg_uuid:
Reporter.unit_test_stop('skip')
return
sg_rst = []
for i in range(len(sg_uuid)):
sg_rst.append(self.neutron.delete_security_group(sg_uuid[i]))
Reporter.REPORT_MSG(" >> Delete Security Group Succ ---> %s, %s",
sg_opt, sg_rst)
Reporter.unit_test_stop('ok')
return sg_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 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)
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 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 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 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 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 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_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_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 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 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_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 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.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 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 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 delete_user(self):
Reporter.unit_test_start(True)
try:
instance_list = self.nova_client.get_instance_lists()
network_list = self.neutron_client.get_network_lists()['networks']
if instance_list or network_list:
Reporter.REPORT_MSG(" >> Delete User Fail, cause --> Instance or Network Exist, "
"This user can delete after deleted instance and network\n"
"instance: %s\n network: %s", instance_list, network_list)
Reporter.unit_test_stop('nok')
return
# Delete default Security Group
default_sg_uuid = self.neutron_client.get_sg_uuid_by_name('default')
self.neutron_client.neutron.delete_security_group(default_sg_uuid)
user_list = self.admin_user.users.list()
user_id = [x.id for x in user_list if x.name == self.identity['username']][0]
if not user_id:
Reporter.REPORT_MSG(" >> User(%s) Not Exist > ", self.identity['username'])
Reporter.unit_test_stop('skip')
return
else:
self.admin_user.users.delete(user_id)
Reporter.REPORT_MSG(" >> User(%s) Delete OK > ", self.identity['username'])
tenant_list = self.admin_user.tenants.list()
tenant_id = [x.id for x in tenant_list if x.name == self.identity['tenant_id']][0]
if not tenant_id:
Reporter.REPORT_MSG(" >> Tenent(%s) Not Exist > ", self.identity['username'])
Reporter.unit_test_stop('skip')
return
else:
self.admin_user.tenants.delete(tenant_id)
Reporter.REPORT_MSG(" >> Tenant(%s) Delete OK > ", self.identity['tenant_id'])
if user_id and tenant_id:
Reporter.unit_test_stop('ok')
return
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 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 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 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 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 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 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 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 ssh_ping(self, inst1, inst2, dest):
Reporter.unit_test_start()
ping_ip = dest
try:
socket.inet_aton(dest)
except socket.error:
ping_ip = self.instance.get_instance_ip(dest)
if None is ping_ip:
Reporter.unit_test_stop('nok')
return False
pass
# instance connection info
if '' is not inst2:
name_list = inst2.split(':')
# inst_conf = self.config.get_instance_config()
inst_info_1 = ast.literal_eval(self.inst_conf[inst1])
if '' is not inst2:
inst_info_2 = ast.literal_eval(self.inst_conf[name_list[0]])
# instance connection info
# 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')
return False
# print '\n1st ssh_cmd : ', floating_ip, inst_info_1['user'], inst_info_1['password']
conn = self.ssh_connect(floating_ip, inst_info_1['user'], '', inst_info_1['password'])
if conn is False:
Reporter.unit_test_stop('nok')
return False
# instance ip
if '' is not inst2:
inst2_ip = self.instance.get_instance_ip(inst2)
ssh_cmd = 'ssh ' + inst_info_2['user'] + '@' + inst2_ip
conn.sendline(ssh_cmd)
# print '2nd ssh_cmd : ', ssh_cmd
ssh_newkey = 'Are you sure you want to continue connecting'
ret = conn.expect([pexpect.TIMEOUT, ssh_newkey, '[P|p]assword:'], timeout=3)
if ret == 0:
Reporter.REPORT_MSG(' >> [%s] Error Connection to SSH Server', inst2_ip)
Reporter.unit_test_stop('nok')
self.ssh_disconnect(conn)
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', inst2_ip)
Reporter.unit_test_stop('nok')
self.ssh_disconnect(conn)
return False
conn.sendline(inst_info_2['password'])
conn.expect(PROMPT, timeout=3)
self.change_prompt(conn)
cmd = 'ping ' + ping_ip + ' -c 2'
conn.sendline(cmd)
conn.expect(CMD_PROMPT)
# parsing loss rate
# print '\nret : ' + conn.before
ping_list = conn.before.splitlines()
for list in ping_list:
if 'loss' in list:
split_list = list.split(', ')
for x in split_list:
if '%' in x:
result = x.split('%')
break
self.ssh_disconnect(conn)
if int(result[0]) != 0:
Reporter.unit_test_stop('nok')
return False
Reporter.unit_test_stop('ok')
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 wget_ssh_cmd(self, cmd, *insts):
# floating ip
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 ['sshConFail']
inst_info_1 = ast.literal_eval(self.inst_conf[insts[0]])
sudo_key = 'password for ' + inst_info_1['user']
conn = self.ssh_connect(floating_ip, inst_info_1['user'], '', inst_info_1['password'])
if conn is False:
Reporter.REPORT_MSG(' >> %s ssh connection fail.', insts[0])
Reporter.unit_test_stop('nok', False)
return ['sshConFail']
# get second instance connection info
if len(insts) is 2:
name_list = insts[1].split(':')
inst_info_2 = ast.literal_eval(self.inst_conf[name_list[0]])
inst2_ip = self.instance.get_instance_ip(insts[1])
ssh_cmd = 'ssh ' + inst_info_2['user'] + '@' + inst2_ip
sudo_key = 'password for ' + inst_info_2['user']
Reporter.REPORT_MSG(' >> second instance SSH connecting(%s)', inst2_ip)
conn.sendline(ssh_cmd)
ssh_newkey = 'want to continue connecting'
ret = conn.expect([pexpect.TIMEOUT, ssh_newkey, '[P|p]assword:'], timeout=2)
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 ['sshConFail']
if ret == 1:
conn.sendline('yes')
conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=self.conn_timeout)
if ret == 2:
conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=self.conn_timeout)
conn.sendline(inst_info_2['password'])
conn.expect(PROMPT, timeout=self.conn_timeout)
try:
if 'sudo' not in cmd:
conn.sendline(cmd)
conn.expect(PROMPT, timeout=self.conn_timeout)
elif 'sudo' in cmd:
conn.sendline(cmd)
ret = conn.expect([pexpect.TIMEOUT, sudo_key, '[P|p]assword'], timeout=self.conn_timeout)
if ret == 2:
conn.expect([pexpect.TIMEOUT, '[P|p]assword'], timeout=self.conn_timeout)
conn.sendline(inst_info_1['password'])
conn.expect(PROMPT, timeout=self.conn_timeout)
except pexpect.TIMEOUT:
Reporter.REPORT_MSG(' >> wget download Timeout. limit %s second', self.conn_timeout)
# self.wget_clear(*insts)
self.ssh_disconnect(conn)
return ['timeoutError', conn.before.splitlines()]
except:
Reporter.REPORT_MSG(' >> Unexpected Error.')
return ['unexpectedError', conn.before.splitlines()]
self.ssh_disconnect(conn)
return [True, conn.before.splitlines()]
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
