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
