def test_rebuild_server(self): # The server should be rebuilt using the provided image and data meta = {"rebuild": "server"} new_name = data_utils.rand_name("server") file_contents = "Test server rebuild." personality = [{"path": "rebuild.txt", "contents": base64.b64encode(file_contents)}] password = "******" resp, rebuilt_server = self.client.rebuild( self.server_id, self.image_ref_alt, name=new_name, metadata=meta, personality=personality, adminPass=password, ) self.addCleanup(self.client.rebuild, self.server_id, self.image_ref) # Verify the properties in the initial response are correct self.assertEqual(self.server_id, rebuilt_server["id"]) rebuilt_image_id = rebuilt_server["image"]["id"] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(self.flavor_ref, rebuilt_server["flavor"]["id"]) # Verify the server properties after the rebuild completes self.client.wait_for_server_status(rebuilt_server["id"], "ACTIVE") resp, server = self.client.get_server(rebuilt_server["id"]) rebuilt_image_id = server["image"]["id"] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(new_name, server["name"]) if self.run_ssh: # Verify that the user can authenticate with the provided password linux_client = RemoteClient(server, self.ssh_user, password) linux_client.validate_authentication()
def test_attach_detach_volume(self): # Stop and Start a server with an attached volume, ensuring that # the volume remains attached. self._create_and_attach() server = self.server volume = self.volume self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.image_ssh_user, server['adminPass']) partitions = linux_client.get_partitions() self.assertIn(self.device, partitions) self._detach(server['id'], volume['id']) self.attached = False self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.image_ssh_user, server['adminPass']) partitions = linux_client.get_partitions() self.assertNotIn(self.device, partitions)
def test_rebuild_server(self): # The server should be rebuilt using the provided image and data meta = {'rebuild': 'server'} new_name = data_utils.rand_name('server') file_contents = 'Test server rebuild.' personality = [{'path': 'rebuild.txt', 'contents': base64.b64encode(file_contents)}] password = '******' resp, rebuilt_server = self.client.rebuild(self.server_id, self.image_ref_alt, name=new_name, metadata=meta, personality=personality, admin_password=password) # Verify the properties in the initial response are correct self.assertEqual(self.server_id, rebuilt_server['id']) rebuilt_image_id = rebuilt_server['image']['id'] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(self.flavor_ref, rebuilt_server['flavor']['id']) # Verify the server properties after the rebuild completes self.client.wait_for_server_status(rebuilt_server['id'], 'ACTIVE') resp, server = self.client.get_server(rebuilt_server['id']) rebuilt_image_id = rebuilt_server['image']['id'] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(new_name, rebuilt_server['name']) if self.run_ssh: # Verify that the user can authenticate with the provided password linux_client = RemoteClient(server, self.ssh_user, password) linux_client.validate_authentication()
def test_rebuild_server(self): # The server should be rebuilt using the provided image and data meta = {'rebuild': 'server'} new_name = rand_name('server') file_contents = 'Test server rebuild.' personality = [{ 'path': 'rebuild.txt', 'contents': base64.b64encode(file_contents) }] password = '******' resp, rebuilt_server = self.client.rebuild(self.server_id, self.image_ref_alt, name=new_name, meta=meta, personality=personality, adminPass=password) # Verify the properties in the initial response are correct self.assertEqual(self.server_id, rebuilt_server['id']) rebuilt_image_id = rebuilt_server['image']['id'] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(self.flavor_ref, int(rebuilt_server['flavor']['id'])) # Verify the server properties after the rebuild completes self.client.wait_for_server_status(rebuilt_server['id'], 'ACTIVE') resp, server = self.client.get_server(rebuilt_server['id']) rebuilt_image_id = rebuilt_server['image']['id'] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(new_name, rebuilt_server['name']) if self.run_ssh: # Verify that the user can authenticate with the provided password linux_client = RemoteClient(server, self.ssh_user, password) self.assertTrue(linux_client.can_authenticate())
def test_rebuild_server(self): # The server should be rebuilt using the provided image and data meta = {'rebuild': 'server'} new_name = data_utils.rand_name('server') password = '******' resp, rebuilt_server = self.client.rebuild(self.server_id, self.image_ref_alt, name=new_name, metadata=meta, admin_password=password) self.addCleanup(self.client.rebuild, self.server_id, self.image_ref) # Verify the properties in the initial response are correct self.assertEqual(self.server_id, rebuilt_server['id']) rebuilt_image_id = rebuilt_server['image']['id'] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(self.flavor_ref, rebuilt_server['flavor']['id']) # Verify the server properties after the rebuild completes self.client.wait_for_server_status(rebuilt_server['id'], 'ACTIVE') resp, server = self.client.get_server(rebuilt_server['id']) rebuilt_image_id = server['image']['id'] self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) self.assertEqual(new_name, server['name']) if self.run_ssh: # Verify that the user can authenticate with the provided password linux_client = RemoteClient(server, self.ssh_user, password) linux_client.validate_authentication()
def test_metadata_agent_on_concurrent_deployment(self): """Verifies created neutron resources.""" neutron_basic_template = self.load_template( 'concurrent_deployment_of_vms_with_fip') keypair = self.create_keypair(manager=self.admin_manager) stack_name = data_utils.rand_name('heat') user_data = '#!/bin/sh\necho "pass" > /tmp/userdata.out' template = self.read_template('concurrent_deployment_of_vms_with_fip') network_name = data_utils.rand_name('priv_net') parameters = { 'public_net': CONF.network.public_network_id, 'private_net_name': network_name, 'private_net_cidr': '97.0.0.0/24', 'private_net_gateway': '97.0.0.1', 'private_net_pool_start': '97.0.0.5', 'private_net_pool_end': '97.0.0.100', 'image': CONF.compute.image_ref, 'flavor': CONF.compute.flavor_ref, 'key_name': keypair['name'], 'user_data': user_data } # create the stack stack_identifier = self.create_stack(stack_name, template, parameters) stack_id = stack_identifier.split('/')[1] self.client.wait_for_stack_status(stack_id, 'CREATE_COMPLETE') resources = (self.client.list_resources(stack_identifier)['resources']) test_resources = {} for resource in resources: test_resources[resource['logical_resource_id']] = resource resources = [ ('vm1', neutron_basic_template['resources']['vm1']['type']), ('vm2', neutron_basic_template['resources']['vm2']['type']), ('vm3', neutron_basic_template['resources']['vm3']['type']), ('vm4', neutron_basic_template['resources']['vm4']['type']), ('vm5', neutron_basic_template['resources']['vm5']['type']), ('vm6', neutron_basic_template['resources']['vm6']['type']), ('vm7', neutron_basic_template['resources']['vm7']['type']) ] for resource_name, resource_type in resources: resource = test_resources.get(resource_name, None) server = NuageBaseTest.get_server( self, server_id=resource['physical_resource_id'], manager=self.admin_manager) fip = None for net in server['addresses'][network_name]: if net['OS-EXT-IPS:type'] == 'floating': fip = net['addr'] self.fip_acs = RemoteClient( ip_address=fip, username=CONF.validation.image_ssh_user, pkey=keypair['private_key']) self.assertTrue( test_utils.call_until_true(self.is_userdata_ready, 300, 30)) self._clear_stacks()
def test_verify_created_server_vcpus(self): """ Verify that the number of vcpus reported by the instance matches the amount stated by the flavor """ resp, flavor = self.flavors_client.get_flavor_details(self.flavor_ref) linux_client = RemoteClient(self.server, self.ssh_user, self.password) self.assertEqual(flavor['vcpus'], linux_client.get_number_of_vcpus())
def test_change_server_password(self): # The server's password should be set to the provided password new_password = '******' resp, body = self.client.change_password(self.server_id, new_password) self.assertEqual(202, resp.status) self.client.wait_for_server_status(self.server_id, 'ACTIVE') if self.run_ssh: # Verify that the user can authenticate with the new password resp, server = self.client.get_server(self.server_id) linux_client = RemoteClient(server, self.ssh_user, new_password) linux_client.validate_authentication()
def test_change_server_password(self): # The server's password should be set to the provided password new_password = '******' resp, body = self.client.change_password(self.server_id, new_password) self.assertEqual(202, resp.status) self.client.wait_for_server_status(self.server_id, 'ACTIVE') if self.run_ssh: # Verify that the user can authenticate with the new password resp, server = self.client.get_server(self.server_id) linux_client = RemoteClient(server, self.ssh_user, new_password) self.assertTrue(linux_client.can_authenticate())
def test_reboot_server_hard(self): # The server should be power cycled if self.run_ssh: # Get the time the server was last rebooted, resp, server = self.client.get_server(self.server_id) linux_client = RemoteClient(server, self.ssh_user, self.password) boot_time = linux_client.get_boot_time() resp, body = self.client.reboot(self.server_id, "HARD") self.assertEqual(202, resp.status) self.client.wait_for_server_status(self.server_id, "ACTIVE") if self.run_ssh: # Log in and verify the boot time has changed linux_client = RemoteClient(server, self.ssh_user, self.password) new_boot_time = linux_client.get_boot_time() self.assertGreater(new_boot_time, boot_time)
def test_reboot_server_soft(self): # The server should be signaled to reboot gracefully if self.run_ssh: # Get the time the server was last rebooted, resp, server = self.client.get_server(self.server_id) linux_client = RemoteClient(server, self.ssh_user, self.password) boot_time = linux_client.get_boot_time() resp, body = self.client.reboot(self.server_id, 'SOFT') self.assertEqual(202, resp.status) self.client.wait_for_server_status(self.server_id, 'ACTIVE') if self.run_ssh: # Log in and verify the boot time has changed linux_client = RemoteClient(server, self.ssh_user, self.password) new_boot_time = linux_client.get_boot_time() self.assertGreater(new_boot_time, boot_time)
def _ssh_to_server(self, server): username = self.config.scenario.ssh_user ip = server.networks[self.config.compute.network_for_ssh][0] linux_client = RemoteClient(ip, username, pkey=self.keypair.private_key) return linux_client.ssh_client
def test_reboot_server_soft(self): """The server should be signaled to reboot gracefully""" if self.run_ssh: # Get the time the server was last rebooted, # waiting for one minute as who doesn't have seconds precision resp, server = self.client.get_server(self.server_id) linux_client = RemoteClient(server, self.ssh_user, self.password) boot_time = linux_client.get_boot_time() time.sleep(60) resp, body = self.client.reboot(self.server_id, 'SOFT') self.assertEqual(202, resp.status) self.client.wait_for_server_status(self.server_id, 'ACTIVE') if self.run_ssh: # Log in and verify the boot time has changed linux_client = RemoteClient(server, self.ssh_user, self.password) new_boot_time = linux_client.get_boot_time() self.assertGreater(new_boot_time, boot_time)
def test_can_log_into_created_server(self): sid = self.stack_identifier rid = 'SmokeServer' # wait for server resource create to complete. self.client.wait_for_resource_status(sid, rid, 'CREATE_COMPLETE') resp, body = self.client.get_resource(sid, rid) self.assertEqual('CREATE_COMPLETE', body['resource_status']) # fetch the IP address from servers client, since we can't get it # from the stack until stack create is complete resp, server = self.servers_client.get_server( body['physical_resource_id']) # Check that the user can authenticate with the generated password linux_client = RemoteClient(server, 'ec2-user', pkey=self.keypair['private_key']) linux_client.validate_authentication()
def test_can_log_into_created_server(self): sid = self.stack_identifier rid = 'SmokeServer' # wait for server resource create to complete. self.client.wait_for_resource_status(sid, rid, 'CREATE_COMPLETE') resp, body = self.client.get_resource(sid, rid) self.assertEqual('CREATE_COMPLETE', body['resource_status']) # fetch the IP address from servers client, since we can't get it # from the stack until stack create is complete resp, server = self.servers_client.get_server( body['physical_resource_id']) # Check that the user can authenticate with the generated password linux_client = RemoteClient( server, 'ec2-user', pkey=self.keypair['private_key']) self.assertTrue(linux_client.can_authenticate())
def _remote_client_to_server(self, server_or_ip): if isinstance(server_or_ip, basestring): ip = server_or_ip else: network_name_for_ssh = self.config.compute.network_for_ssh ip = server_or_ip.networks[network_name_for_ssh][0] username = self.config.scenario.ssh_user linux_client = RemoteClient(ip, username, pkey=self.keypair.private_key) return linux_client
def get_remote_client(self, server_or_ip, username=None, private_key=None): if isinstance(server_or_ip, basestring): ip = server_or_ip else: network_name_for_ssh = self.config.compute.network_for_ssh ip = server_or_ip.networks[network_name_for_ssh][0] if username is None: username = self.config.scenario.ssh_user if private_key is None: private_key = self.keypair.private_key return RemoteClient(ip, username, pkey=private_key)
def test_attach_detach_volume(self): # Stop and Start a server with an attached volume, ensuring that # the volume remains attached. self._create_and_attach() server = self.server volume = self.volume self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.image_ssh_user, server['admin_password']) partitions = linux_client.get_partitions() self.assertIn(self.device, partitions) self._detach(server['id'], volume['id']) self.attached = False self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.image_ssh_user, server['admin_password']) partitions = linux_client.get_partitions() self.assertNotIn(self.device, partitions)
def test_attach_detach_volume(self): # Stop and Start a server with an attached volume, ensuring that # the volume remains attached. try: self._create_and_attach() server = self.server volume = self.volume self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.ssh_user, server['adminPass']) partitions = linux_client.get_partitions() self.assertTrue(self.device in partitions) self._detach(server['id'], volume['id']) self.attached = False self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.ssh_user, server['adminPass']) partitions = linux_client.get_partitions() self.assertFalse(self.device in partitions) except Exception: self.fail("The test_attach_detach_volume is faild!") finally: if self.attached: self._detach(server['id'], volume['id']) # NOTE(maurosr): here we do the cleanup for volume, servers are # dealt on BaseComputeTest.tearDownClass self._delete(self.volume)
def test_attach_detach_volume(self): """ Stop and Start a server with an attached volume, ensuring that the volume remains attached. """ server, volume = self._create_and_attach() attached = True try: self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.ssh_user, server['adminPass']) partitions = linux_client.get_partitions() self.assertTrue(self.device in partitions) self._detach(server['id'], volume['id']) attached = False self.servers_client.stop(server['id']) self.servers_client.wait_for_server_status(server['id'], 'SHUTOFF') self.servers_client.start(server['id']) self.servers_client.wait_for_server_status(server['id'], 'ACTIVE') linux_client = RemoteClient(server, self.ssh_user, server['adminPass']) partitions = linux_client.get_partitions() self.assertFalse(self.device in partitions) finally: if attached: self._detach(server['id'], volume['id']) self._delete(server['id'], volume['id'])
def test_host_name_is_same_as_server_name(self): # Verify the instance host name is the same as the server name linux_client = RemoteClient(self.server, self.ssh_user, self.password) self.assertTrue(linux_client.hostname_equals_servername(self.name))
def ssh_to_server(self): username = self.config.scenario.ssh_user self.linux_client = RemoteClient(self.floating_ip.ip, username, pkey=self.keypair.private_key)
class TestMinimumBasicScenario(manager.OfficialClientTest): """ This is a basic minimum scenario test. This test below: * across the multiple components * as a regular user * with and without optional parameters * check command outputs """ def _wait_for_server_status(self, status): server_id = self.server.id self.status_timeout( self.compute_client.servers, server_id, status) def _wait_for_volume_status(self, status): volume_id = self.volume.id self.status_timeout( self.volume_client.volumes, volume_id, status) def _image_create(self, name, fmt, path, properties={}): name = rand_name('%s-' % name) image_file = open(path, 'rb') self.addCleanup(image_file.close) params = { 'name': name, 'container_format': fmt, 'disk_format': fmt, 'is_public': 'True', } params.update(properties) image = self.image_client.images.create(**params) self.addCleanup(self.image_client.images.delete, image) self.assertEqual("queued", image.status) image.update(data=image_file) return image.id def glance_image_create(self): aki_img_path = self.config.scenario.img_dir + "/" + \ self.config.scenario.aki_img_file ari_img_path = self.config.scenario.img_dir + "/" + \ self.config.scenario.ari_img_file ami_img_path = self.config.scenario.img_dir + "/" + \ self.config.scenario.ami_img_file LOG.debug("paths: ami: %s, ari: %s, aki: %s" % (ami_img_path, ari_img_path, aki_img_path)) kernel_id = self._image_create('scenario-aki', 'aki', aki_img_path) ramdisk_id = self._image_create('scenario-ari', 'ari', ari_img_path) properties = { 'properties': {'kernel_id': kernel_id, 'ramdisk_id': ramdisk_id} } self.image = self._image_create('scenario-ami', 'ami', path=ami_img_path, properties=properties) def nova_keypair_add(self): name = rand_name('scenario-keypair-') self.keypair = self.compute_client.keypairs.create(name=name) self.addCleanup(self.compute_client.keypairs.delete, self.keypair) self.assertEqual(name, self.keypair.name) def nova_boot(self): name = rand_name('scenario-server-') client = self.compute_client flavor_id = self.config.compute.flavor_ref self.server = client.servers.create(name=name, image=self.image, flavor=flavor_id, key_name=self.keypair.name) self.addCleanup(self.compute_client.servers.delete, self.server) self.assertEqual(name, self.server.name) self._wait_for_server_status('ACTIVE') def nova_list(self): servers = self.compute_client.servers.list() LOG.debug("server_list:%s" % servers) self.assertIn(self.server, servers) def nova_show(self): got_server = self.compute_client.servers.get(self.server) LOG.debug("got server:%s" % got_server) self.assertEqual(self.server, got_server) def cinder_create(self): name = rand_name('scenario-volume-') LOG.debug("volume display-name:%s" % name) self.volume = self.volume_client.volumes.create(size=1, display_name=name) LOG.debug("volume created:%s" % self.volume.display_name) self._wait_for_volume_status('available') self.addCleanup(self.volume_client.volumes.delete, self.volume) self.assertEqual(name, self.volume.display_name) def cinder_list(self): volumes = self.volume_client.volumes.list() self.assertIn(self.volume, volumes) def cinder_show(self): volume = self.volume_client.volumes.get(self.volume.id) self.assertEqual(self.volume, volume) def nova_volume_attach(self): attach_volume_client = self.compute_client.volumes.create_server_volume volume = attach_volume_client(self.server.id, self.volume.id, '/dev/vdb') self.assertEqual(self.volume.id, volume.id) self._wait_for_volume_status('in-use') def nova_reboot(self): self.server.reboot() self._wait_for_server_status('ACTIVE') def nova_floating_ip_create(self): self.floating_ip = self.compute_client.floating_ips.create() self.addCleanup(self.floating_ip.delete) def nova_floating_ip_add(self): self.server.add_floating_ip(self.floating_ip) def nova_security_group_rule_create(self): sgs = self.compute_client.security_groups.list() for sg in sgs: if sg.name == 'default': secgroup = sg ruleset = { # ssh 'ip_protocol': 'tcp', 'from_port': 22, 'to_port': 22, 'cidr': '0.0.0.0/0', 'group_id': None } sg_rule = self.compute_client.security_group_rules.create(secgroup.id, **ruleset) self.addCleanup(self.compute_client.security_group_rules.delete, sg_rule.id) def ssh_to_server(self): username = self.config.scenario.ssh_user self.linux_client = RemoteClient(self.floating_ip.ip, username, pkey=self.keypair.private_key) def check_partitions(self): partitions = self.linux_client.get_partitions() self.assertEqual(1, partitions.count('vdb')) def nova_volume_detach(self): detach_volume_client = self.compute_client.volumes.delete_server_volume detach_volume_client(self.server.id, self.volume.id) self._wait_for_volume_status('available') volume = self.volume_client.volumes.get(self.volume.id) self.assertEqual('available', volume.status) def test_minimum_basic_scenario(self): self.glance_image_create() self.nova_keypair_add() self.nova_boot() self.nova_list() self.nova_show() self.cinder_create() self.cinder_list() self.cinder_show() self.nova_volume_attach() self.cinder_show() self.nova_reboot() self.nova_floating_ip_create() self.nova_floating_ip_add() self.nova_security_group_rule_create() self.ssh_to_server() self.check_partitions() self.nova_volume_detach()
class TestMinimumBasicScenario(manager.OfficialClientTest): """ This is a basic minimum scenario test. This test below: * across the multiple components * as a regular user * with and without optional parameters * check command outputs """ def _wait_for_server_status(self, status): server_id = self.server.id self.status_timeout( self.compute_client.servers, server_id, status) def _wait_for_volume_status(self, status): volume_id = self.volume.id self.status_timeout( self.volume_client.volumes, volume_id, status) def _image_create(self, name, fmt, path, properties={}): name = rand_name('%s-' % name) image_file = open(path, 'rb') self.addCleanup(image_file.close) params = { 'name': name, 'container_format': fmt, 'disk_format': fmt, 'is_public': 'True', } params.update(properties) image = self.image_client.images.create(**params) self.addCleanup(self.image_client.images.delete, image) self.assertEqual("queued", image.status) image.update(data=image_file) return image.id def glance_image_create(self): aki_img_path = self.config.scenario.img_dir + "/" + \ self.config.scenario.aki_img_file ari_img_path = self.config.scenario.img_dir + "/" + \ self.config.scenario.ari_img_file ami_img_path = self.config.scenario.img_dir + "/" + \ self.config.scenario.ami_img_file LOG.debug("paths: ami: %s, ari: %s, aki: %s" % (ami_img_path, ari_img_path, aki_img_path)) kernel_id = self._image_create('scenario-aki', 'aki', aki_img_path) ramdisk_id = self._image_create('scenario-ari', 'ari', ari_img_path) properties = { 'properties': {'kernel_id': kernel_id, 'ramdisk_id': ramdisk_id} } self.image = self._image_create('scenario-ami', 'ami', path=ami_img_path, properties=properties) def nova_keypair_add(self): name = rand_name('scenario-keypair-') self.keypair = self.compute_client.keypairs.create(name=name) self.addCleanup(self.compute_client.keypairs.delete, self.keypair) self.assertEqual(name, self.keypair.name) def nova_boot(self): name = rand_name('scenario-server-') client = self.compute_client flavor_id = self.config.compute.flavor_ref self.server = client.servers.create(name=name, image=self.image, flavor=flavor_id, key_name=self.keypair.name) self.addCleanup(self.compute_client.servers.delete, self.server) self.assertEqual(name, self.server.name) self._wait_for_server_status('ACTIVE') def nova_list(self): servers = self.compute_client.servers.list() LOG.debug("server_list:%s" % servers) self.assertTrue(self.server in servers) def nova_show(self): got_server = self.compute_client.servers.get(self.server) LOG.debug("got server:%s" % got_server) self.assertEqual(self.server, got_server) def cinder_create(self): name = rand_name('scenario-volume-') LOG.debug("volume display-name:%s" % name) self.volume = self.volume_client.volumes.create(size=1, display_name=name) LOG.debug("volume created:%s" % self.volume.display_name) self._wait_for_volume_status('available') self.addCleanup(self.volume_client.volumes.delete, self.volume) self.assertEqual(name, self.volume.display_name) def cinder_list(self): volumes = self.volume_client.volumes.list() self.assertTrue(self.volume in volumes) def cinder_show(self): volume = self.volume_client.volumes.get(self.volume.id) self.assertEqual(self.volume, volume) def nova_volume_attach(self): attach_volume_client = self.compute_client.volumes.create_server_volume volume = attach_volume_client(self.server.id, self.volume.id, '/dev/vdb') self.assertEqual(self.volume.id, volume.id) self._wait_for_volume_status('in-use') def nova_reboot(self): self.server.reboot() self._wait_for_server_status('ACTIVE') def nova_floating_ip_create(self): self.floating_ip = self.compute_client.floating_ips.create() self.addCleanup(self.floating_ip.delete) def nova_floating_ip_add(self): self.server.add_floating_ip(self.floating_ip) def nova_security_group_rule_create(self): sgs = self.compute_client.security_groups.list() for sg in sgs: if sg.name == 'default': secgroup = sg ruleset = { # ssh 'ip_protocol': 'tcp', 'from_port': 22, 'to_port': 22, 'cidr': '0.0.0.0/0', 'group_id': None } sg_rule = self.compute_client.security_group_rules.create(secgroup.id, **ruleset) self.addCleanup(self.compute_client.security_group_rules.delete, sg_rule.id) def ssh_to_server(self): username = self.config.scenario.ssh_user self.linux_client = RemoteClient(self.floating_ip.ip, username, pkey=self.keypair.private_key) def check_partitions(self): partitions = self.linux_client.get_partitions() self.assertEqual(1, partitions.count('vdb')) def nova_volume_detach(self): detach_volume_client = self.compute_client.volumes.delete_server_volume detach_volume_client(self.server.id, self.volume.id) self._wait_for_volume_status('available') volume = self.volume_client.volumes.get(self.volume.id) self.assertEqual('available', volume.status) def test_minimum_basic_scenario(self): self.glance_image_create() self.nova_keypair_add() self.nova_boot() self.nova_list() self.nova_show() self.cinder_create() self.cinder_list() self.cinder_show() self.nova_volume_attach() self.cinder_show() self.nova_reboot() self.nova_floating_ip_create() self.nova_floating_ip_add() self.nova_security_group_rule_create() self.ssh_to_server() self.check_partitions() self.nova_volume_detach()
def test_verify_created_server_ephemeral_disk(self): # Verify that the ephemeral disk is created when creating server def create_flavor_with_extra_specs(self): flavor_with_eph_disk_name = data_utils.rand_name('eph_flavor') flavor_with_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # Create a flavor with extra specs resp, flavor = (self.flavor_client. create_flavor(flavor_with_eph_disk_name, ram, vcpus, disk, flavor_with_eph_disk_id, ephemeral=1)) self.addCleanup(self.flavor_clean_up, flavor['id']) self.assertEqual(200, resp.status) return flavor['id'] def create_flavor_without_extra_specs(self): flavor_no_eph_disk_name = data_utils.rand_name('no_eph_flavor') flavor_no_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # Create a flavor without extra specs resp, flavor = (self.flavor_client. create_flavor(flavor_no_eph_disk_name, ram, vcpus, disk, flavor_no_eph_disk_id)) self.addCleanup(self.flavor_clean_up, flavor['id']) self.assertEqual(200, resp.status) return flavor['id'] def flavor_clean_up(self, flavor_id): resp, body = self.flavor_client.delete_flavor(flavor_id) self.assertEqual(resp.status, 202) self.flavor_client.wait_for_resource_deletion(flavor_id) flavor_with_eph_disk_id = self.create_flavor_with_extra_specs() flavor_no_eph_disk_id = self.create_flavor_without_extra_specs() admin_pass = self.image_ssh_password resp, server_no_eph_disk = (self. create_test_server( wait_until='ACTIVE', adminPass=admin_pass, flavor=flavor_no_eph_disk_id)) resp, server_with_eph_disk = (self.create_test_server( wait_until='ACTIVE', adminPass=admin_pass, flavor=flavor_with_eph_disk_id)) # Get partition number of server without extra specs. linux_client = RemoteClient(server_no_eph_disk, self.ssh_user, self.password) partition_num = len(linux_client.get_partitions()) linux_client = RemoteClient(server_with_eph_disk, self.ssh_user, self.password) self.assertEqual(partition_num + 1, linux_client.get_partitions())
def test_integration_1(self): # EC2 1. integration test (not strict) image_ami = self.ec2_client.get_image(self.images["ami"]["image_id"]) sec_group_name = data_utils.rand_name("securitygroup-") group_desc = sec_group_name + " security group description " security_group = self.ec2_client.create_security_group(sec_group_name, group_desc) self.addResourceCleanUp(self.destroy_security_group_wait, security_group) self.assertTrue( self.ec2_client.authorize_security_group( sec_group_name, ip_protocol="icmp", cidr_ip="0.0.0.0/0", from_port=-1, to_port=-1)) self.assertTrue( self.ec2_client.authorize_security_group( sec_group_name, ip_protocol="tcp", cidr_ip="0.0.0.0/0", from_port=22, to_port=22)) reservation = image_ami.run(kernel_id=self.images["aki"]["image_id"], ramdisk_id=self.images["ari"]["image_id"], instance_type=self.instance_type, key_name=self.keypair_name, security_groups=(sec_group_name,)) self.addResourceCleanUp(self.destroy_reservation, reservation) volume = self.ec2_client.create_volume(1, self.zone) self.addResourceCleanUp(self.destroy_volume_wait, volume) instance = reservation.instances[0] LOG.info("state: %s", instance.state) if instance.state != "running": self.assertInstanceStateWait(instance, "running") address = self.ec2_client.allocate_address() rcuk_a = self.addResourceCleanUp(address.delete) self.assertTrue(address.associate(instance.id)) rcuk_da = self.addResourceCleanUp(address.disassociate) # TODO(afazekas): ping test. dependecy/permission ? self.assertVolumeStatusWait(volume, "available") # NOTE(afazekas): it may be reports availble before it is available ssh = RemoteClient(address.public_ip, CONF.compute.ssh_user, pkey=self.keypair.material) text = data_utils.rand_name("Pattern text for console output -") resp = ssh.write_to_console(text) self.assertFalse(resp) def _output(): output = instance.get_console_output() return output.output re_search_wait(_output, text) part_lines = ssh.get_partitions().split('\n') volume.attach(instance.id, "/dev/vdh") def _volume_state(): volume.update(validate=True) return volume.status self.assertVolumeStatusWait(_volume_state, "in-use") re_search_wait(_volume_state, "in-use") # NOTE(afazekas): Different Hypervisor backends names # differently the devices, # now we just test is the partition number increased/decrised def _part_state(): current = ssh.get_partitions().split('\n') if current > part_lines: return 'INCREASE' if current < part_lines: return 'DECREASE' return 'EQUAL' state_wait(_part_state, 'INCREASE') part_lines = ssh.get_partitions().split('\n') # TODO(afazekas): Resource compare to the flavor settings volume.detach() self.assertVolumeStatusWait(_volume_state, "available") re_search_wait(_volume_state, "available") LOG.info("Volume %s state: %s", volume.id, volume.status) state_wait(_part_state, 'DECREASE') instance.stop() address.disassociate() self.assertAddressDissasociatedWait(address) self.cancelResourceCleanUp(rcuk_da) address.release() self.assertAddressReleasedWait(address) self.cancelResourceCleanUp(rcuk_a) LOG.info("state: %s", instance.state) if instance.state != "stopped": self.assertInstanceStateWait(instance, "stopped")
class OrchestrationVMwithMetadata(nuage_base.NuageBaseOrchestrationTest, NuageBaseTest): @classmethod def skip_checks(cls): super(OrchestrationVMwithMetadata, cls).skip_checks() if not CONF.compute_feature_enabled.metadata_service: raise cls.skipException('Test requires functional metadata agent') @classmethod def setup_credentials(cls): cls.set_network_resources() super(OrchestrationVMwithMetadata, cls).setup_credentials() @classmethod def setup_clients(cls): super(OrchestrationVMwithMetadata, cls).setup_clients() cls.floating_ips_client = cls.os_admin.floating_ips_client @decorators.attr(type='smoke') def test_metadata_agent_on_concurrent_deployment(self): """Verifies created neutron resources.""" neutron_basic_template = self.load_template( 'concurrent_deployment_of_vms_with_fip') keypair = self.create_keypair(manager=self.admin_manager) stack_name = data_utils.rand_name('heat') user_data = '#!/bin/sh\necho "pass" > /tmp/userdata.out' template = self.read_template('concurrent_deployment_of_vms_with_fip') network_name = data_utils.rand_name('priv_net') parameters = { 'public_net': CONF.network.public_network_id, 'private_net_name': network_name, 'private_net_cidr': '97.0.0.0/24', 'private_net_gateway': '97.0.0.1', 'private_net_pool_start': '97.0.0.5', 'private_net_pool_end': '97.0.0.100', 'image': CONF.compute.image_ref, 'flavor': CONF.compute.flavor_ref, 'key_name': keypair['name'], 'user_data': user_data } # create the stack stack_identifier = self.create_stack(stack_name, template, parameters) stack_id = stack_identifier.split('/')[1] self.client.wait_for_stack_status(stack_id, 'CREATE_COMPLETE') resources = (self.client.list_resources(stack_identifier)['resources']) test_resources = {} for resource in resources: test_resources[resource['logical_resource_id']] = resource resources = [ ('vm1', neutron_basic_template['resources']['vm1']['type']), ('vm2', neutron_basic_template['resources']['vm2']['type']), ('vm3', neutron_basic_template['resources']['vm3']['type']), ('vm4', neutron_basic_template['resources']['vm4']['type']), ('vm5', neutron_basic_template['resources']['vm5']['type']), ('vm6', neutron_basic_template['resources']['vm6']['type']), ('vm7', neutron_basic_template['resources']['vm7']['type']) ] for resource_name, resource_type in resources: resource = test_resources.get(resource_name, None) server = NuageBaseTest.get_server( self, server_id=resource['physical_resource_id'], manager=self.admin_manager) fip = None for net in server['addresses'][network_name]: if net['OS-EXT-IPS:type'] == 'floating': fip = net['addr'] self.fip_acs = RemoteClient( ip_address=fip, username=CONF.validation.image_ssh_user, pkey=keypair['private_key']) self.assertTrue( test_utils.call_until_true(self.is_userdata_ready, 300, 30)) self._clear_stacks() def is_userdata_ready(self): try: return 'pass' in self.fip_acs.exec_command('cat /tmp/userdata.out') except exceptions.SSHExecCommandFailed: return False
class TestMinimumBasicScenario(manager.OfficialClientTest): """ This is a basic minimum scenario test. This test below: * across the multiple components * as a regular user * with and without optional parameters * check command outputs """ def _wait_for_server_status(self, status): server_id = self.server.id self.status_timeout(self.compute_client.servers, server_id, status) def _wait_for_volume_status(self, status): volume_id = self.volume.id self.status_timeout(self.volume_client.volumes, volume_id, status) def _image_create(self, name, fmt, path, properties={}): name = rand_name("%s-" % name) image_file = open(path, "rb") self.addCleanup(image_file.close) params = {"name": name, "container_format": fmt, "disk_format": fmt, "is_public": "True"} params.update(properties) image = self.image_client.images.create(**params) self.addCleanup(self.image_client.images.delete, image) self.assertEqual("queued", image.status) image.update(data=image_file) return image.id def glance_image_create(self): aki_img_path = self.config.scenario.img_dir + "/" + self.config.scenario.aki_img_file ari_img_path = self.config.scenario.img_dir + "/" + self.config.scenario.ari_img_file ami_img_path = self.config.scenario.img_dir + "/" + self.config.scenario.ami_img_file LOG.debug("paths: ami: %s, ari: %s, aki: %s" % (ami_img_path, ari_img_path, aki_img_path)) kernel_id = self._image_create("scenario-aki", "aki", aki_img_path) ramdisk_id = self._image_create("scenario-ari", "ari", ari_img_path) properties = {"properties": {"kernel_id": kernel_id, "ramdisk_id": ramdisk_id}} self.image = self._image_create("scenario-ami", "ami", path=ami_img_path, properties=properties) def nova_keypair_add(self): name = rand_name("scenario-keypair-") self.keypair = self.compute_client.keypairs.create(name=name) self.addCleanup(self.compute_client.keypairs.delete, self.keypair) self.assertEqual(name, self.keypair.name) def nova_boot(self): name = rand_name("scenario-server-") client = self.compute_client flavor_id = self.config.compute.flavor_ref self.server = client.servers.create(name=name, image=self.image, flavor=flavor_id, key_name=self.keypair.name) self.addCleanup(self.compute_client.servers.delete, self.server) self.assertEqual(name, self.server.name) self._wait_for_server_status("ACTIVE") def nova_list(self): servers = self.compute_client.servers.list() LOG.debug("server_list:%s" % servers) self.assertTrue(self.server in servers) def nova_show(self): got_server = self.compute_client.servers.get(self.server) LOG.debug("got server:%s" % got_server) self.assertEqual(self.server, got_server) def cinder_create(self): name = rand_name("scenario-volume-") LOG.debug("volume display-name:%s" % name) self.volume = self.volume_client.volumes.create(size=1, display_name=name) LOG.debug("volume created:%s" % self.volume.display_name) self._wait_for_volume_status("available") self.addCleanup(self.volume_client.volumes.delete, self.volume) self.assertEqual(name, self.volume.display_name) def cinder_list(self): volumes = self.volume_client.volumes.list() self.assertTrue(self.volume in volumes) def cinder_show(self): volume = self.volume_client.volumes.get(self.volume.id) self.assertEqual(self.volume, volume) def nova_volume_attach(self): attach_volume_client = self.compute_client.volumes.create_server_volume volume = attach_volume_client(self.server.id, self.volume.id, "/dev/vdb") self.assertEqual(self.volume.id, volume.id) self._wait_for_volume_status("in-use") def nova_reboot(self): self.server.reboot() self._wait_for_server_status("ACTIVE") def nova_floating_ip_create(self): self.floating_ip = self.compute_client.floating_ips.create() self.addCleanup(self.floating_ip.delete) def nova_floating_ip_add(self): self.server.add_floating_ip(self.floating_ip) def nova_security_group_rule_create(self): sgs = self.compute_client.security_groups.list() for sg in sgs: if sg.name == "default": secgroup = sg ruleset = { # ssh "ip_protocol": "tcp", "from_port": 22, "to_port": 22, "cidr": "0.0.0.0/0", "group_id": None, } sg_rule = self.compute_client.security_group_rules.create(secgroup.id, **ruleset) self.addCleanup(self.compute_client.security_group_rules.delete, sg_rule.id) def ssh_to_server(self): username = self.config.scenario.ssh_user self.linux_client = RemoteClient(self.floating_ip.ip, username, pkey=self.keypair.private_key) def check_partitions(self): partitions = self.linux_client.get_partitions() self.assertEqual(1, partitions.count("vdb")) def nova_volume_detach(self): detach_volume_client = self.compute_client.volumes.delete_server_volume detach_volume_client(self.server.id, self.volume.id) self._wait_for_volume_status("available") volume = self.volume_client.volumes.get(self.volume.id) self.assertEqual("available", volume.status) def test_minimum_basic_scenario(self): self.glance_image_create() self.nova_keypair_add() self.nova_boot() self.nova_list() self.nova_show() self.cinder_create() self.cinder_list() self.cinder_show() self.nova_volume_attach() self.cinder_show() self.nova_reboot() self.nova_floating_ip_create() self.nova_floating_ip_add() self.nova_security_group_rule_create() self.ssh_to_server() self.check_partitions() self.nova_volume_detach()
def test_can_log_into_created_server(self): # Check that the user can authenticate with the generated password linux_client = RemoteClient(self.server, self.ssh_user, self.password) self.assertTrue(linux_client.can_authenticate())
def _check_ssh_connectivity(self, ip_address, username, pkey): ssh_client = RemoteClient(ip_address, username, pkey=pkey) self.assertTrue(ssh_client.can_authenticate())
def test_verify_created_server_ephemeral_disk(self): # Verify that the ephemeral disk is created when creating server def create_flavor_with_extra_specs(self): flavor_with_eph_disk_name = data_utils.rand_name('eph_flavor') flavor_with_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 512 vcpus = 1 disk = 10 # Create a flavor with extra specs resp, flavor = (self.flavor_client.create_flavor( flavor_with_eph_disk_name, ram, vcpus, disk, flavor_with_eph_disk_id, ephemeral=1, swap=1024, rxtx=1)) self.addCleanup(self.flavor_clean_up, flavor['id']) self.assertEqual(200, resp.status) return flavor['id'] def create_flavor_without_extra_specs(self): flavor_no_eph_disk_name = data_utils.rand_name('no_eph_flavor') flavor_no_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 512 vcpus = 1 disk = 10 # Create a flavor without extra specs resp, flavor = (self.flavor_client.create_flavor( flavor_no_eph_disk_name, ram, vcpus, disk, flavor_no_eph_disk_id)) self.addCleanup(self.flavor_clean_up, flavor['id']) self.assertEqual(200, resp.status) return flavor['id'] def flavor_clean_up(self, flavor_id): resp, body = self.flavor_client.delete_flavor(flavor_id) self.assertEqual(resp.status, 202) self.flavor_client.wait_for_resource_deletion(flavor_id) flavor_with_eph_disk_id = self.create_flavor_with_extra_specs() flavor_no_eph_disk_id = self.create_flavor_without_extra_specs() admin_pass = self.image_ssh_password resp, server_no_eph_disk = (self.create_test_server( wait_until='ACTIVE', adminPass=admin_pass, flavor=flavor_no_eph_disk_id)) resp, server_with_eph_disk = (self.create_test_server( wait_until='ACTIVE', adminPass=admin_pass, flavor=flavor_with_eph_disk_id)) # Get partition number of server without extra specs. linux_client = RemoteClient(server_no_eph_disk, self.ssh_user, self.password) partition_num = len(linux_client.get_partitions()) linux_client = RemoteClient(server_with_eph_disk, self.ssh_user, self.password) self.assertEqual(partition_num + 1, linux_client.get_partitions())