def create_instance_with_different_disktype(self):
"""Create instances with different disk type."""
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
image = os_conn.get_image(self.vmware_image)
net = os_conn.get_network(self.net_name)
os_conn.update_image(image, properties={"vmware_disktype": "sparse"})
vm = os_conn.create_server(image=image,
availability_zone=self.vcenter_az,
net_id=net['id'],
timeout=210)
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
os_conn.update_image(image,
properties={"vmware_disktype": "preallocated "})
vm = os_conn.create_server(image=image,
availability_zone=self.vcenter_az,
net_id=net['id'],
timeout=210)
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
os_conn.update_image(image, properties={"vmware_disktype": "thin "})
vm = os_conn.create_server(image=image,
availability_zone=self.vcenter_az,
net_id=net['id'],
timeout=210)
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
def check_neutron_public(self):
"""Check that public network was assigned to all nodes."""
cluster = self.fuel_web.client.get_cluster(self.cluster_id)
assert_equal(str(cluster['net_provider']), NEUTRON)
os_conn = OpenStackActions(
self.fuel_web.get_public_vip(self.cluster_id))
self.fuel_web.check_fixed_network_cidr(self.cluster_id, os_conn)
def create_instance_with_vmxnet3_adapter(self):
"""Create instance with vmxnet3 adapter."""
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
image = os_conn.get_image(self.image_name)
os_conn.update_image(image,
properties={"hw_vif_model": "VirtualVmxnet3"})
flavor = os_conn.get_flavor_by_name('m1.small')
sg = os_conn.get_security_group(self.sg_name)
net = os_conn.get_network(self.net_name)
vm = os_conn.create_server(image=image,
availability_zone=self.vcenter_az,
net_id=net['id'],
security_groups=[sg],
flavor_id=flavor.id,
timeout=900)
floating_ip = os_conn.assign_floating_ip(vm)
helpers.wait(lambda: helpers.tcp_ping(floating_ip.ip, 22),
timeout=210,
timeout_msg="Node {ip} is not accessible by SSH.".format(
ip=floating_ip.ip))
controller = self.fuel_web.get_nailgun_cluster_nodes_by_roles(
self.cluster_id, ["controller"])[0]
with self.fuel_web.get_ssh_for_nailgun_node(controller) as remote:
cmd = '/usr/bin/lshw -class network | grep vmxnet3'
res = remote.execute_through_host(hostname=floating_ip.ip,
cmd=cmd,
auth=self.image_creds)
logger.debug('OUTPUT: {}'.format(res['stdout_str']))
assert_equal(res['exit_code'], 0, "VMxnet3 driver is not found")
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
def check_batch_instance_creation(self):
"""Create several instance simultaneously."""
count = 10
vm_name = 'vcenter_vm'
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
image = os_conn.get_image(self.vmware_image)
net = os_conn.get_network(self.net_name)
sg = os_conn.get_security_group(self.sg_name)
os_conn.create_server(name=vm_name,
image=image,
availability_zone=self.vcenter_az,
net_id=net['id'],
security_groups=[sg],
min_count=count,
timeout=210)
for i in range(1, count + 1):
vm = os_conn.get_server_by_name('{name}-{index}'.format(
name=vm_name, index=i))
logger.info("Check state for {} instance".format(vm.name))
helpers.wait(
lambda: os_conn.get_instance_detail(vm).status == "ACTIVE",
timeout=180,
timeout_msg="Instance state is not active")
for i in range(1, count + 1):
vm = os_conn.get_server_by_name('{name}-{index}'.format(
name=vm_name, index=i))
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
def check_instance_creation(self):
"""Create instance and check connection."""
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
flavor = os_conn.get_flavor_by_name('m1.small')
if self.image_name:
image = os_conn.get_image(self.image_name)
else:
image = os_conn.get_image(self.vmware_image)
sg = os_conn.get_security_group(self.sg_name)
net = os_conn.get_network(self.net_name)
vm = os_conn.create_server(image=image,
availability_zone=self.vcenter_az,
net_id=net['id'],
security_groups=[sg],
flavor_id=flavor.id,
timeout=900)
floating_ip = os_conn.assign_floating_ip(vm)
helpers.wait(lambda: helpers.tcp_ping(floating_ip.ip, 22),
timeout=210,
timeout_msg="Node {ip} is not accessible by SSH.".format(
ip=floating_ip.ip))
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
def check_vmware_service_actions(self):
"""Disable vmware host (cluster) and check instance creation on
enabled cluster."""
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
services = os_conn.get_nova_service_list()
vmware_services = []
for service in services:
if service.binary == 'nova-compute' and \
service.zone == self.vcenter_az:
vmware_services.append(service)
os_conn.disable_nova_service(service)
image = os_conn.get_image(self.vmware_image)
sg = os_conn.get_security_group(self.sg_name)
net = os_conn.get_network(self.net_name)
for service in vmware_services:
logger.info("Check {}".format(service.host))
os_conn.enable_nova_service(service)
vm = os_conn.create_server(image=image,
timeout=210,
availability_zone=self.vcenter_az,
net_id=net['id'],
security_groups=[sg])
vm_host = getattr(vm, 'OS-EXT-SRV-ATTR:host')
assert_true(
service.host == vm_host, 'Instance was launched on a'
' disabled vmware cluster')
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
os_conn.disable_nova_service(service)
def create_bootable_volume_and_run_instance(self):
"""Create bootable volume and launch instance from it."""
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
image = os_conn.get_image(self.vmware_image)
vol = os_conn.create_volume(image_id=image.id,
availability_zone=self.cinder_az)
block_device_mapping = {'vda': vol.id}
net = os_conn.get_network(self.net_name)
vm = os_conn.create_server(availability_zone=self.vcenter_az,
image=False,
net_id=net['id'],
block_device_mapping=block_device_mapping,
timeout=210)
floating_ip = os_conn.assign_floating_ip(vm)
helpers.wait(lambda: helpers.tcp_ping(floating_ip.ip, 22),
timeout=180,
timeout_msg="Node {ip} is not accessible by SSH.".format(
ip=floating_ip.ip))
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
os_conn.delete_volume_and_wait(vol)
def create_and_attach_empty_volume(self):
"""Create and attach to instance empty volume."""
mount_point = '/dev/sdb'
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
vol = os_conn.create_volume(availability_zone=self.cinder_az)
image = os_conn.get_image(self.vmware_image)
net = os_conn.get_network(self.net_name)
sg = os_conn.get_security_group(self.sg_name)
vm = os_conn.create_server(image=image,
availability_zone=self.vcenter_az,
security_groups=[sg],
net_id=net['id'],
timeout=210)
floating_ip = os_conn.assign_floating_ip(vm)
helpers.wait(lambda: helpers.tcp_ping(floating_ip.ip, 22),
timeout=180,
timeout_msg="Node {ip} is not accessible by SSH.".format(
ip=floating_ip.ip))
logger.info("Attaching volume via cli")
ctrl_nodes = self.fuel_web.get_nailgun_cluster_nodes_by_roles(
self.cluster_id, ["controller"])
cmd = '. openrc; nova volume-attach {srv_id} {volume_id} {mount}' \
''.format(srv_id=vm.id, volume_id=vol.id, mount=mount_point)
logger.debug('CMD: {}'.format(cmd))
SSHManager().execute_on_remote(ctrl_nodes[0]['ip'], cmd)
helpers.wait(lambda: os_conn.get_volume_status(vol) == "in-use",
timeout=30,
timeout_msg="Volume doesn't reach 'in-use' state")
vm.reboot()
sleep(10)
helpers.wait(lambda: helpers.tcp_ping(floating_ip.ip, 22),
timeout=180,
timeout_msg="Node {ip} is not accessible by SSH.".format(
ip=floating_ip.ip))
controller = self.fuel_web.get_nailgun_cluster_nodes_by_roles(
self.cluster_id, ["controller"])[0]
with self.fuel_web.get_ssh_for_nailgun_node(controller) as remote:
cmd = 'sudo /sbin/fdisk -l | grep {}'.format(mount_point)
res = remote.execute_through_host(hostname=floating_ip.ip,
cmd=cmd,
auth=cirros_auth)
logger.debug('OUTPUT: {}'.format(res['stdout_str']))
assert_equal(res['exit_code'], 0, "Attached volume is not found")
os_conn.delete_instance(vm)
os_conn.verify_srv_deleted(vm)
os_conn.delete_volume(vol)
def endpoints_with_disabled_ssl(self):
"""Check MOS services are NOT running ssl on public endpoints
when TLS is disabled
Scenario:
1. Pre-condition - perform steps
from master_node_with_https_only test
2. Create a new cluster
3. Go to the Settings tab
4. Disable TLS for public endpoints
5. Add 1 controller and compute+cinder
6. Deploy cluster
7. Run OSTF
8. Check that all endpoints link to plain http protocol.
Duration 30m
"""
self.show_step(1)
self.show_step(2)
self.show_step(3)
self.show_step(4)
self.env.revert_snapshot("master_node_with_https_only")
self.show_step(5)
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
configure_ssl=False,
mode=DEPLOYMENT_MODE)
self.fuel_web.update_nodes(cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute', 'cinder'],
})
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
# Run OSTF
self.fuel_web.run_ostf(cluster_id=cluster_id, test_sets=['smoke'])
self.show_step(8)
# Get controller ip address
controller_keystone_ip = self.fuel_web.get_public_vip(cluster_id)
action = OpenStackActions(controller_ip=controller_keystone_ip)
endpoint_list = action.get_keystone_endpoints()
for endpoint in endpoint_list:
url = urllib.parse.urlparse(endpoint.publicurl)
assert_equal(
url.scheme,
"http",
message=("Endpoint id {0} uses {1} instead http.".format(
endpoint.id, url.scheme)))
def create_instances(self):
"""Create instances with nova az and vcenter az."""
os_ip = self.fuel_web.get_public_vip(self.cluster_id)
self.os_conn = OpenStackActions(os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD, SERVTEST_TENANT)
vcenter_az = self.env_settings['vmware_vcenter']['settings']['az']
net = self.os_conn.get_network(self.net_name)
sec_group = self.os_conn.create_sec_group_for_ssh()
inst_count = 1 # amount of VMs to create on each az
vc_inst_name_prefix = 'vcenter-test'
vc_image = self.os_conn.get_image('TestVM-VMDK')
nova_inst_name_prefix = 'nova-test'
nova_image = self.os_conn.get_image('TestVM')
logger.info('Started: create {num} VM(s) with net="{net}", az="{az}", '
'image="{image}"'.format(num=inst_count,
net=net['name'],
az=vcenter_az,
image='TestVM-VMDK'))
self.os_conn.create_server(name=vc_inst_name_prefix,
net_id=net['id'],
availability_zone=vcenter_az,
image=vc_image,
timeout=210,
security_groups=[sec_group],
min_count=inst_count)
logger.info('Started: create {num} VM(s) with net="{net}", az="{az}", '
'image="{image}"'.format(num=inst_count,
net=net['name'],
az='nova',
image='TestVM'))
self.os_conn.create_server(name=nova_inst_name_prefix,
net_id=net['id'],
image=nova_image,
security_groups=[sec_group],
availability_zone='nova',
min_count=inst_count)
servers = self.os_conn.nova.servers.list()
self.vms_to_ping = [
srv for srv in servers if srv.name.startswith(vc_inst_name_prefix)
or srv.name.startswith(nova_inst_name_prefix)
]
def upload_image(self):
"""Upload vmdk image."""
controller = self.fuel_web.get_nailgun_cluster_nodes_by_roles(
self.cluster_id, ["controller"])[0]
cmd_add_img = 'glance image-create --name {0!r} --disk-format vmdk ' \
'--container-format bare --file {1!r} ' \
'--property hypervisor_type=vmware ' \
'--property vmware_adaptertype=lsiLogic ' \
'--property vmware_disktype=sparse' \
''.format(self.image_name, self.image_name)
cmd = '. openrc; test -f {0} || (wget -q {1} && {2})'.format(
self.image_name, self.image_url, cmd_add_img)
SSHManager().execute_on_remote(controller['ip'], cmd)
public_ip = self.fuel_web.get_public_vip(self.cluster_id)
os_conn = OpenStackActions(public_ip)
image = os_conn.get_image(self.image_name)
helpers.wait(lambda: os_conn.get_image(image.name).status == 'active',
timeout=60 * 2,
timeout_msg='Image is not active')
