def _check_server_status_interval(self,
server_id,
status='ACTIVE',
interval=CONF.compute.build_interval,
timeout=CONF.compute.build_timeout):
"""Check server status interval, will raise status"""
check_build_interval = interval
check_timeout = timeout
while check_timeout >= 0:
server_status = self._get_server_status(server_id)
if server_status == status:
return
elif server_status == "ERROR":
LOG.warning(
_LW('Instance %(id)s changed into ERROR state '
'while waiting to change into %(status)s.'), {
'id': server_id,
'status': status
})
raise exceptions.ServerError
check_timeout -= check_build_interval
time.sleep(check_build_interval)
LOG.warning(
_LW('Instance %(id)s wait time out,'
'while waiting to change into %(status)s.'), {
'id': server_id,
'status': status
})
raise exceptions.ServerTimeOut
def test_create_volume_type(self):
try:
volume = Base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, '
'traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
try:
volume_type_created = \
volume.create_test_volume_type()
LOG.debug(_LI("The new volume_type is %s"), volume_type_created)
except Exception as e:
LOG.warning(
_LW('Create volume type failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise
finally:
volume.delete_all()
def test_create_volume_from_image(self):
try:
volume_created = \
self.volume.create_volume()
except Exception as e:
LOG.warning(_LW('Create volume before snapshot failed, '
'msg: %(msg)s, traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
self.volume.delete_all()
raise exceptions.VolumeBuildErrorException()
try:
kwargs = dict(force=True)
snapshot = self.volume.create_snapshot(volume_created['id'],
**kwargs)
except Exception as e:
LOG.warning(_LE('create volume snapshot failed, msg: '
'%(msg)s, traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
self.volume.delete_all()
raise exceptions.SnapshotBuildErrorException()
try:
volume_created = self.volume.\
create_volume(snapshot_id=snapshot.get('id'))
status = self.volume._get_volume_status(volume_created['id'])
if status != "available":
raise exceptions.VolumeBuildErrorException()
except Exception as e:
LOG.warning(_LW('Create volume from snapshot failed, '
'msg: %(msg)s, traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
raise e
finally:
self.volume.delete_all()
def check_snapshot_status_interval(self,
snapshot_id,
status='available',
interval=CONF.volume.build_interval,
timeout=CONF.volume.build_timeout):
check_build_interval = interval
check_timeout = timeout
while check_timeout >= 0:
server_status = self._get_snapshot_status(snapshot_id)
if server_status == status:
return
elif server_status == "error":
LOG.warning(
_LW('Volume %(id)s changed into error state '
'while waiting to change into %(status)s.'), {
'id': snapshot_id,
'status': status
})
raise exceptions.ServerError
check_timeout -= check_build_interval
time.sleep(check_build_interval)
LOG.warning(
_LW('Volume %(id)s wait time out,'
'while waiting to change into %(status)s.'), {
'id': snapshot_id,
'status': status
})
raise exceptions.ServerTimeOut
def _check_server_task_state_interval(self,
server_id,
t_task_state=None,
interval=CONF.compute.build_interval,
timeout=CONF.compute.build_timeout):
"""Check server status interval, will raise status"""
check_build_interval = interval
check_timeout = timeout
while check_timeout >= 0:
server_status, task_state = self._get_server_task_state(server_id)
if task_state.lower() == t_task_state:
return
elif server_status == "ERROR":
LOG.warning(
_LW('Instance %(id)s changed into ERROR state '
'while waiting task state %(status)s.'), {
'id': server_id,
'status': t_task_state
})
raise exceptions.ServerError
check_timeout -= check_build_interval
time.sleep(check_build_interval)
LOG.warning(
_LW('Instance %(id)s wait time out,'
'while waiting task state %(status)s.'), {
'id': server_id,
'status': t_task_state
})
raise exceptions.ServerTimeOut
def test_create_volume_snapshot(self):
try:
volume = Base()
except Exception as e:
LOG.warning(_LW('Init test env failed, msg: %(msg)s, '
'traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
raise exceptions.InitFailed
try:
volume_created = \
volume.create_volume()
except Exception as e:
LOG.warning(_LW('Create volume before snapshot failed, '
'msg: %(msg)s, traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
volume.delete_all()
raise exceptions.VolumeBuildErrorException()
try:
kwargs = dict(force=True)
volume.create_snapshot(volume_created['id'], **kwargs)
except Exception as e:
LOG.warning(_LE('create volume snapshot failed, msg: '
'%(msg)s, traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
volume.delete_all()
raise exceptions.SnapshotBuildErrorException()
finally:
volume.delete_all()
def _ping_floating_ip(self, ip_address):
LOG.warning(
_LW('During basic network test, '
'try to ping %(id)s, %(ip)s'), {
'id': self.floating_ips,
'ip': ip_address
})
p = None
try:
cmd = "ping -c %s %s" % ("4", ip_address)
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
LOG.warning(_LW('Run cmd "%(cmd)s", get result "%(res)s".'), {
'cmd': cmd,
'res': str(line)
})
if ', 0% packet loss' in line:
return True
return False
finally:
if p:
p.kill()
def test_associate_floatingip(self):
try:
instance = self.create_server()
fp_body = self.manager.floating_ips_client.\
create_floating_ip('external')
floating_ip_id_allocated = fp_body['id']
floating_ip_ip_allocated = fp_body['ip']
self.manager.floating_ips_client.\
associate_floating_ip_to_server(floating_ip_ip_allocated,
instance['id'])
# Check instance_id in the floating_ip body
body = self.manager.floating_ips_client.\
show_floating_ip(floating_ip_id_allocated)
if instance['id'] != body['instance_id']:
raise exceptions.FloatingIpNotCorrectlyAssociated()
except Exception as e:
LOG.warning(
_LW('Test associate floating ip failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise e
finally:
# Disassociation of floating IP that was associated in this method
try:
self.manager.\
floating_ips_client.\
disassociate_floating_ip_from_server(
floating_ip_ip_allocated,
instance['id'])
except Exception as e:
LOG.warning(
_LW('Disassociate floating ip failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
try:
self.manager.floating_ips_client.delete_floating_ip(
floating_ip_id_allocated)
except Exception as e:
LOG.warning(
_LW('Delete floating ip failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
self.delete_all()
def test_attach_volume(self):
volume = None
try:
instance = self.create_server()
name = "vol-" + self.__class__.__name__ + "-" + \
str(uuid.uuid4())[:5]
kwargs = dict()
kwargs['name'] = name
volume = self.volume_client.create_volume(1, **kwargs)
self.volume_client.wait_for_volume_status(volume['id'],
'available')
# Volume is attached and detached successfully from an instance
mount_point = '/dev/vdc'
self.volume_client.attach_volume(volume['id'],
instance['id'],
mount_point)
self.volume_client.wait_for_volume_status(volume['id'], 'in-use')
self.volume_client.detach_volume(volume['id'])
self.volume_client.wait_for_volume_status(volume['id'],
'available')
except Exception as e:
LOG.warning(_LW('Test volume attach failed, '
'msg: %(msg)s, traceback: %(tb)s.'),
{'msg': e, 'tb': traceback.format_exc()})
raise e
finally:
is_successfully_deleted = True
try:
self.delete_all()
except Exception as e:
LOG.warning(_LW('Server delete failed: %s.'), e)
is_successfully_deleted = False
try:
if volume is not None:
self.volume_client.delete_volume(volume['id'])
except exceptions.NotFound:
pass
except Exception as e:
LOG.warning(_LW('Delete volume %(volume)s failed, '
'msg: %(msg)s, traceback: %(tb)s.'),
{'volume': volume['id'],
'msg': e, 'tb': traceback.format_exc()})
is_successfully_deleted = False
if not is_successfully_deleted:
raise exceptions.DeleteException
def __init__(self):
try:
self.volume = Base()
except Exception as e:
LOG.warning(_LW('Init test env failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {'msg': e, 'tb': traceback.format_exc()})
raise exceptions.InitFailed
def __init__(self):
try:
random = str(uuid.uuid4())
network_name = "net-" + random
router_name = "router-" + random
sec_group_name = "sg-" + random
subnet_name = "subnet" + random
firewall_name = "firewall-" + random
server_name = "server-" + random
self.net_base = Base(network_name=network_name,
router_name=router_name,
sec_group_name=sec_group_name,
subnet_name=subnet_name,
firewall_name=firewall_name)
self.compute_base = compute_base(flavor_ref=None,
image_ref=None,
network_id=None,
security_group_id=None,
server_name=server_name)
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
def create_monitor(self, server_id):
auth_id = self.login_monitor()
if auth_id is None:
raise exceptions.CreateMonitorException()
# In the body, ip is useless but is needed, so i fake it
data = \
{
"jsonrpc": "2.0",
"method": "host.create",
"params": {
"host": server_id,
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": "192.168.0.1",
"dns": "",
"port": "10050"
}
],
"groups": [{"groupid": "2"}],
"templates": [{"templateid": "10002"}],
},
"auth": auth_id,
"id": 1,
}
response = self.session.post(self.base_url, data=json.dumps(data))
if response.status_code == 200:
return
else:
LOG.warning(_LW("Failed to create monitor of server %s"),
server_id)
raise exceptions.CreateMonitorException()
def test_capture_image(self):
instance = None
captured_image = None
try:
instance = self.create_server()
self.manager.servers_client.stop(instance['id'])
waiters.wait_for_server_status(self.manager.servers_client,
instance['id'], 'SHUTOFF')
cap_image_name = data_utils.rand_name('test-cap-img')
captured_image = self.\
_capture_image_from_server(instance['id'],
name=cap_image_name,
wait_until='ACTIVE')
if cap_image_name != captured_image['name'] or \
captured_image['status'] != 'ACTIVE':
raise exceptions.ImageNotCorrectlyCaptured
except Exception as e:
LOG.warning(
_LW('Test capture image failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise e
finally:
self.delete_all()
def _get_external_network(self, external=CONF.network.external_network):
networks_resp = self.network_client.list_networks()
networks = networks_resp.get('networks', [])
for network in networks:
if network['name'] == external:
return network['id']
LOG.warning(_LW('Specific network not found %s.'), external)
raise exceptions.NetworkNotFound
def delete_all(self):
try:
self.resource_cleanup()
except Exception as e:
LOG.warning(
_LW('Delete snapshots and volumes failed, %(msg)s.'
'Traceback: %(tb)s'), {
'msg': e,
'tb': traceback.format_exc()
})
def _check_delete_list(self):
flag = True
if self.firewalls:
LOG.warning(_LW('Delete firewalls not clear, '
'remaining %s'), self.firewalls)
flag = False
if self.firewall_policies:
LOG.warning(
_LW('Delete firewall_policies not clear, '
'remaining %s'), self.firewall_policies)
flag = False
if self.firewall_rules:
LOG.warning(
_LW('Delete firewall_rules not clear, '
'remaining %s'), self.firewall_rules)
flag = False
if self.floating_ips:
LOG.warning(_LW('Delete floating_ips not clear, '
'remaining %s'), self.floating_ips)
flag = False
if self.security_group_rules:
LOG.warning(
_LW('Delete security_group_rules not clear, '
'remaining %s'), self.security_group_rules)
flag = False
if self.security_groups:
LOG.warning(
_LW('Delete security_groups not clear, '
'remaining %s'), self.security_groups)
flag = False
if self.routers:
LOG.warning(_LW('Delete routers not clear, '
'remaining %s'), self.routers)
flag = False
if self.subnets:
LOG.warning(_LW('Delete subnets not clear, '
'remaining %s'), self.subnets)
flag = False
if self.networks:
LOG.warning(_LW('Delete networks not clear, '
'remaining %s'), self.networks)
flag = False
return flag
def test_create_volume_from_image(self):
try:
volume_created = \
self.volume.create_volume()
except Exception as e:
LOG.warning(
_LW('Create volume failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.VolumeBuildErrorException()
try:
Manager().volumes_v2_client.delete_volume(volume_created.get("id"))
except Exception as e:
LOG.warning(
_LW('Delete volume failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise e
def test_create_qos_type(self):
try:
volume = Base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, '
'traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
try:
qos_type_created = \
volume.create_test_qos_specs(**self.__disk_qos_low)
except Exception as e:
LOG.warning(
_LW('Create qos type for volume tests failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
volume.delete_all()
raise
try:
volume.show_qos_type(qos_type_created['id'])
except Exception as e:
LOG.warning(
_LE('show volume type failed, msg: '
'%(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise
finally:
volume.delete_all()
def test_rename_volume(self):
try:
volume = Base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, '
'traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
try:
volume_created = volume.create_volume()
except Exception as e:
LOG.warning(
_LW('Create volume failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
volume.delete_all()
raise
try:
params = {'name': 'newname'}
volume.update_volume(volume_created['id'], **params)
except Exception as e:
LOG.warning(
_LE('Update volume name failed, msg: '
'%(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise
finally:
volume.delete_all()
def login_monitor(self):
data = \
{
"jsonrpc": "2.0",
"method": "user.login",
"params":
{
"user": self.user,
"password": self.password
},
"id": 1
}
response = self.session.post(self.base_url, data=json.dumps(data))
if response.status_code == 200:
return response.json()['result']
else:
LOG.warning(_LW("Failed to login the monitor system"))
return None
def __init__(self):
try:
super(MultipleVMTest, self).__init__()
random = str(uuid.uuid4())[:5]
network_name = "net-" + random
router_name = "router-" + random
sec_group_name = "sg-" + random
self.net_base = Base(network_name=network_name,
router_name=router_name,
sec_group_name=sec_group_name)
self.compute = Compute_base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
def test_create_volume_from_image(self):
try:
image_name = CONF.compute.image_name
params = {"name": image_name}
images = self.image_client.list_images(params)
volume_created = self.volume.\
create_volume(imageRef=images[0].get('id'))
status = self.volume._get_volume_status(volume_created['id'])
if status != "available":
raise exceptions.VolumeBuildErrorException()
except Exception as e:
LOG.warning(
_LW('Create volume from image failed, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise e
finally:
self.volume.delete_all()
def delete_router(self, router_id):
# detach all the subnet
for subnet in self.subnets:
try:
self.router_remove_subnet(router_id, subnet)
except Exception as e:
LOG.warning(
_LW('detach subnet from router %(id)s failed, '
'%(msg)s. Traceback: %(tb)s'), {
'id': subnet,
'msg': e,
'tb': traceback.format_exc()
})
# remove the gateway
self.router_unset_external_gw(router_id)
self.network_client.delete_router(router_id)
self.network_client.wait_for_resource_deletion('router', router_id)
self.routers.remove(router_id)
def _check_server_volume_interval(self,
server_id,
volume_id,
interval=CONF.compute.build_interval,
timeout=CONF.compute.build_timeout):
"""Check server status interval, will raise status"""
check_build_interval = interval
check_timeout = timeout
while check_timeout >= 0:
volumes = self._get_server_volumes(server_id)
if volume_id in volumes:
return
check_timeout -= check_build_interval
time.sleep(check_build_interval)
LOG.warning(
_LW('Instance %(id)s wait time out,'
'while waiting attach volume %(status)s.'), {
'id': server_id,
'status': volume_id
})
raise exceptions.ServerTimeOut
def delete_all(self):
for server in self.servers:
try:
self.delete_server(server)
except Exception as e:
LOG.warning(
_LW('Delete server %(server_id)s failed, %(msg)s.'
'Traceback: %(tb)s'), {
'server_id': server,
'msg': e,
'tb': traceback.format_exc()
})
check_interval = CONF.compute.check_delete_interval
check_timeout = CONF.compute.check_delete_timeout
while self.servers and check_timeout >= 0:
check_timeout -= check_interval
for server in self.servers:
try:
self._get_server_status(server)
except exceptions.NotFound:
self.servers.remove(server)
time.sleep(check_interval)
# clear all the images
for image in self.images:
try:
self.delete_image(image)
except exceptions as e:
LOG.warning(
_LW('Delete image %(image_id)s failed, %(msg)s.'
'Traceback: %(tb)s'), {
'image_id': image,
'msg': e,
'tb': traceback.format_exc()
})
check_interval = CONF.compute.check_delete_interval
check_timeout = CONF.compute.check_delete_timeout
while self.images and check_timeout >= 0:
check_timeout -= check_interval
time.sleep(check_interval)
for image in self.images:
try:
status = self._get_image_status(image)
if status == "DELETED":
self.images.remove(image)
except exceptions as e:
LOG.warning(
_LW('Check image %(image_id)s status failed, '
'%(msg)s. Traceback: %(tb)s'), {
'image_id': image,
'msg': e,
'tb': traceback.format_exc()
})
if self.servers:
LOG.warning(_LW('Delete server timeout, remaining server: %(v)s'),
{'v': self.servers})
if self.images:
LOG.warning(_LW('Clear image(s) timeout, remaining images: %(v)s'),
{'v': self.images})
if self.servers:
self.servers = []
raise exceptions.ServerDeleteException
if self.images:
self.images = []
raise exceptions.ImageKilledException
from automation.common import exceptions
from automation import config
from automation.i18n import _LW
from oslo_log import log as logging
from testcases.compute_tests.base_compute import Base
CONF = config.CONF
LOG = logging.getLogger(__name__)
if __name__ == '__main__':
try:
server = Base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
try:
server_created = server.create_server()
server_details = server.show_server(server_created['id'])
server.power_off(server_created['id'])
server_current_qos = str(
server.get_server_current_qos(server_created['id']))
qos_list = server.get_qos_types()
qos_ids = []
for qos in qos_list:
qos_ids.append(str(qos['id']))
if server_current_qos in qos_ids:
from automation.common import exceptions
from automation import config
from automation.i18n import _LW
from oslo_log import log as logging
from testcases.volume_tests.base import Base
CONF = config.CONF
LOG = logging.getLogger(__name__)
if __name__ == '__main__':
try:
volume = Base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
try:
volume_created = volume.create_volume()
volume.extend_volume(volume_created['id'])
except Exception as e:
LOG.warning(
_LW('Test create volume failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise e
def test_server(self):
LOG.info('GKL-write some log')
LOG.debug('debug information %s' % self.pp)
LOG.exception('some exception')
LOG.warn("Unable to delete volume")
LOG.warn(_LW("Unable to delete volume"))
from automation import config
from automation.i18n import _LW
from oslo_log import log as logging
from testcases.compute_tests.base_compute import Base
CONF = config.CONF
LOG = logging.getLogger(__name__)
instance_types = [str(i) for i in range(1, 6)]
if __name__ == '__main__':
try:
server = Base()
except Exception as e:
LOG.warning(
_LW('Init test env failed, msg: %(msg)s, traceback: '
'%(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise exceptions.InitFailed
try:
server_created = server.create_server()
server_details = server.show_server(server_created['id'])
original_host = server_details.get("OS-EXT-SRV-ATTR:host")
original_flavor = server_details.get("flavor").get("id")
server.resize(server_created['id'], CONF.compute.flavor_name_alt)
server_details = server.show_server(server_created['id'])
new_host = server_details.get("OS-EXT-SRV-ATTR:host")
if new_host == original_host:
raise exceptions.ServerResizeFailed
except Exception as e:
def test_accessibility_between_networks(self):
try:
router = self.net_base.create_router()
network01 = self.net_base.create_network()
network02 = self.net_base.create_network()
subnet01 = self.net_base.create_subnet(network01['id'])
subnet02 = self.net_base.create_subnet(network02['id'])
self.net_base.router_set_external_gw(router['id'])
self.net_base.router_add_subnet(router['id'], subnet01['id'])
self.net_base.router_add_subnet(router['id'], subnet02['id'])
sec_grp = self.net_base.create_security_group()
self.net_base.create_security_group_rule(sec_grp['id'], 'IPv4',
'ingress', '0.0.0.0/0',
'ICMP')
self.net_base.create_security_group_rule(sec_grp['id'], 'IPv4',
'ingress', '0.0.0.0/0',
'TCP')
self.net_base.create_security_group_rule(sec_grp['id'], 'IPv4',
'egress', '0.0.0.0/0',
'TCP')
except Exception as e:
LOG.warning(
_LW('Create network env failed, msg: %(msg)s, '
'traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
self.net_base.delete_all()
raise e
# create instance01 on network01
try:
instance01 = self.compute_base.\
create_server(name=None, image_id=None, flavor_id=None,
network_id=network01['id'],
sec_grp_id=sec_grp['id'])
interfaces_first = self.compute_base.\
show_server_interfaces(instance01['id'])
interfaces_first = interfaces_first.get('interfaceAttachments', [])
if not interfaces_first:
LOG.warning(_LW('During network test server has no port!'))
raise
port_id_first = interfaces_first[0]['port_id']
floatingip = self.net_base.create_floating_ip()
floatingip_addr = floatingip['floating_ip_address']
self.net_base.associate_floating_ip(floatingip['id'],
port_id_first)
# test the floating connectable
self.net_base.test_ping_floatingip(floatingip_addr)
# create instance02 on network02
instance02 = self.compute_base.\
create_server(name=None, image_id=None, flavor_id=None,
network_id=network02['id'],
sec_grp_id=sec_grp['id'])
interfaces_sec = self.compute_base.\
show_server_interfaces(instance02['id'])
interfaces_sec = interfaces_sec.get('interfaceAttachments', [])
if not interfaces_sec:
LOG.warning(_LW('During network test server has no port!'))
raise
# port_id_second = interfaces_sec[0]['port_id']
except Exception as e:
LOG.warning(
_LW('Test network accessibility failed, msg: %(msg)s, '
'traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
is_successfully_deleted = True
try:
self.compute_base.delete_all()
except Exception as e:
LOG.warning(_LW('Compute clear process failed.'))
is_successfully_deleted = False
try:
self.net_base.delete_all()
except Exception as e:
LOG.warning(_LW('Network clear process failed.'))
is_successfully_deleted = False
if not is_successfully_deleted:
raise exceptions.DeleteException
# get the fixedip for instance02
try:
instance02_details = \
self.compute_base.show_server(instance02['id'])
network02_name = network02['name']
instance02_fixedip = \
instance02_details["addresses"][network02_name][0]["addr"]
# self.net_base.test_ping_floatingip(instance02_fixedip)
except Exception as e:
LOG.warning(
_LW('error happened when try to ping vm2 from vm1, '
'msg: %(msg)s, traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
is_successfully_deleted = True
try:
self.compute_base.delete_all()
except Exception as e:
LOG.warning(_LW('Network clear process failed.'))
is_successfully_deleted = False
try:
self.net_base.delete_all()
except Exception as e:
LOG.warning(_LW('Compute clear process failed.'))
is_successfully_deleted = False
if not is_successfully_deleted:
raise exceptions.DeleteException
# begin to ping from server01 to server02
try:
admin_pass = CONF.compute.admin_password
if not self.test_ip_accessibility(floatingip_addr,
instance02_fixedip,
admin_pass,
interval=None,
timeout=None):
LOG.info("ping failed between first and second vm")
return False
LOG.info("ping successfully from first vm to second vm.")
except Exception as e:
LOG.warning(
_LW('Test network ssh server01 failed, msg: %(msg)s, '
'traceback: %(tb)s.'), {
'msg': e,
'tb': traceback.format_exc()
})
raise e
finally:
is_successfully_deleted = True
try:
self.compute_base.delete_all()
except Exception as e:
LOG.warning(_LW('Compute clear process failed.'))
is_successfully_deleted = False
try:
self.net_base.delete_all()
except Exception as e:
LOG.warning(_LW('Network clear process failed.'))
is_successfully_deleted = False
if not is_successfully_deleted:
raise exceptions.DeleteException
