def setUp(self): """ Instantiates OpenStack instances that cannot be spawned by Heat """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) stack_name = guid + '-stack' self.net_name = guid + '-net' self.subnet_name = guid + '-subnet' self.router_name = guid + '-router' env_values = { 'net_name': self.net_name, 'subnet_name': self.subnet_name, 'router_name': self.router_name, 'external_net_name': self.ext_net_name } heat_tmplt_path = pkg_resources.resource_filename( 'snaps.openstack.tests.heat', 'router_heat_template.yaml') self.stack_settings = StackConfig(name=stack_name, template_path=heat_tmplt_path, env_values=env_values) self.stack = None self.heat_client = heat_utils.heat_client(self.os_creds, self.os_session) self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
def generate_creator(os_creds, vm_inst, image_config, project_name, keypair_config=None): """ Initializes an OpenStackVmInstance object :param os_creds: the OpenStack credentials :param vm_inst: the SNAPS-OO VmInst domain object :param image_config: the associated ImageConfig object :param project_name: the associated project ID :param keypair_config: the associated KeypairConfig object (optional) :return: an initialized OpenStackVmInstance object """ session = keystone_utils.keystone_session(os_creds) nova = nova_utils.nova_client(os_creds, session) keystone = keystone_utils.keystone_client(os_creds, session) neutron = neutron_utils.neutron_client(os_creds, session) try: derived_inst_config = settings_utils.create_vm_inst_config( nova, keystone, neutron, vm_inst, project_name) derived_inst_creator = OpenStackVmInstance(os_creds, derived_inst_config, image_config, keypair_config) derived_inst_creator.initialize() return derived_inst_creator finally: keystone_utils.close_session(session)
def __reboot_openstack_node(vm_info): creds_dict = vm_info.get('os_creds') os_creds = OSCreds(**creds_dict) logger.debug('Retrieving keystone session %s', creds_dict) os_sess = keystone_utils.keystone_session(os_creds) try: logger.debug('Retrieving OpenStack clients with %s', creds_dict) nova = nova_utils.nova_client(os_creds, os_sess) neutron = neutron_utils.neutron_client(os_creds, os_sess) keystone = keystone_utils.keystone_client(os_creds, os_sess) logger.info('Retrieved OpenStack clients') vm_inst = nova_utils.get_server_object_by_id(nova, neutron, keystone, vm_info['id']) logger.info('Looking up VM named [%s]', vm_inst.name) if vm_inst: logger.debug('Generating VM SNAPS creator with creds [%s]', creds_dict) snaps_vm = create_instance.generate_creator( os_creds, vm_inst, None, os_creds.project_name) if snaps_vm: logger.info('Rebooting VM with name %s', vm_inst.name) snaps_vm.reboot(RebootType.hard) else: logger.warn('Unable to obtain a SNAPS-OO VM creator [%s]', vm_inst.name) else: logger.warn('Unable to locate VM with name %s', vm_inst.name) finally: logger.info('Closing keystone session') keystone_utils.close_session(os_sess)
def tearDown(self): """ Cleans the remote OpenStack objects """ if self.project: neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) default_sec_grp = neutron_utils.get_security_group( neutron, self.keystone, sec_grp_name='default', project_name=self.os_creds.project_name) if default_sec_grp: try: neutron_utils.delete_security_group( neutron, default_sec_grp) except: pass keystone_utils.delete_project(self.keystone, self.project) if self.user: keystone_utils.delete_user(self.keystone, self.user) if self.role: keystone_utils.delete_role(self.keystone, self.role) super(self.__class__, self).__clean__()
def test_update_quotas(self): """ Tests the creation of an OpenStack project where the quotas get updated. """ self.project_creator = OpenStackProject(self.os_creds, self.project_settings) created_project = self.project_creator.create() self.assertIsNotNone(created_project) retrieved_project = keystone_utils.get_project( keystone=self.keystone, project_settings=self.project_settings) self.assertIsNotNone(retrieved_project) self.assertEqual(created_project, retrieved_project) self.assertTrue( validate_project(self.keystone, self.project_settings, created_project)) update_compute_quotas = ComputeQuotas( **{ 'metadata_items': 64, 'cores': 5, 'instances': 5, 'injected_files': 3, 'injected_file_content_bytes': 5120, 'ram': 25600, 'fixed_ips': 100, 'key_pairs': 50 }) self.project_creator.update_compute_quotas(update_compute_quotas) update_network_quotas = NetworkQuotas( **{ 'security_group': 5, 'security_group_rule': 50, 'floatingip': 25, 'network': 5, 'port': 25, 'router': 6, 'subnet': 7 }) self.project_creator.update_network_quotas(update_network_quotas) self.assertEqual(update_compute_quotas, self.project_creator.get_compute_quotas()) self.assertEqual(update_network_quotas, self.project_creator.get_network_quotas()) nova = nova_utils.nova_client(self.os_creds, self.os_session) new_compute_quotas = nova_utils.get_compute_quotas( nova, self.project_creator.get_project().id) self.assertEqual(update_compute_quotas, new_compute_quotas) neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) new_network_quotas = neutron_utils.get_network_quotas( neutron, self.project_creator.get_project().id) self.assertEqual(update_network_quotas, new_network_quotas)
def __init__(self): self.os_creds = openstack_tests.get_credentials( os_env_file=constants.ENV_FILE) self.creators = [] self.nova = nova_utils.nova_client(self.os_creds) self.neutron = neutron_utils.neutron_client(self.os_creds) self.heat = heat_utils.heat_client(self.os_creds) self.keystone = keystone_utils.keystone_client(self.os_creds)
def check_neutron(self): """ checks that a simple neutron operation works """ try: client = neutron_utils.neutron_client(self.os_creds) client.list_networks() LOGGER.info("Neutron service ...OK") except Exception as error: LOGGER.error("Neutron service ...FAILED") raise error
def get_ext_net_name(os_creds): """ Returns the first external network name :param: os_creds: an instance of snaps OSCreds object :return: """ neutron = neutron_utils.neutron_client(os_creds) ext_nets = neutron_utils.get_external_networks(neutron) return ext_nets[0].name
def setUp(self): """ Setup objects required by VM instances :return: """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.nova = nova_utils.nova_client( self.os_creds, self.os_session) self.keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) self.neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) self.glance = glance_utils.glance_client( self.os_creds, self.os_session) self.image_creator = None self.network_creator = None self.flavor_creator = None self.port = None self.vm_inst = None try: image_settings = openstack_tests.cirros_image_settings( name=guid + '-image', image_metadata=self.image_metadata) self.image_creator = OpenStackImage( self.os_creds, image_settings=image_settings) self.image_creator.create() network_settings = openstack_tests.get_priv_net_config( project_name=self.os_creds.project_name, net_name="{}-{}".format(guid, 'net'), subnet_name="{}-{}".format(guid, 'subnet')).network_settings self.network_creator = OpenStackNetwork( self.os_creds, network_settings) self.network_creator.create() flavor_config = openstack_tests.get_flavor_config( name="{}-{}".format(guid, 'flavor-name'), ram=256, disk=10, vcpus=1, metadata=self.flavor_metadata) self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config) self.flavor_creator.create() port_settings = PortConfig( name=guid + '-port', network_name=network_settings.name) self.port = neutron_utils.create_port( self.neutron, self.os_creds, port_settings) self.instance_settings = VmInstanceConfig( name=guid + '-vm_inst', flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings]) except: self.tearDown() raise
def setUp(self): """ Instantiates OpenStack instances that cannot be spawned by Heat """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.network_name = guid + '-net' self.subnet_name = guid + '-subnet' self.net_creator = None self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
def get_ext_net_name(): """ Returns the first external network name :return: """ os_env_file = CONST.openstack_creds os_creds = openstack_tests.get_credentials(os_env_file=os_env_file) neutron = neutron_utils.neutron_client(os_creds) ext_nets = neutron_utils.get_external_networks(neutron) return ext_nets[0]['network']['name']
def deploy_vnf(self): """Deploy ABOT-OAI-EPC.""" self.__logger.info("Upload VNFD") descriptor = self.vnf['descriptor'] self.__logger.info("Get or create flavor for all Abot-EPC") flavor_settings = FlavorConfig( name=self.vnf['requirements']['flavor']['name'], ram=self.vnf['requirements']['flavor']['ram_min'], disk=10, vcpus=1) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) self.__logger.info("Deploying Abot-epc bundle file ...") os.system('juju deploy {}'.format('/' + descriptor.get('file_name'))) self.__logger.info("Waiting for instances .....") status = os.system('juju-wait') self.__logger.info("juju wait completed: %s", status) self.__logger.info("Deployed Abot-epc on Openstack") nova_client = nova_utils.nova_client(self.snaps_creds) neutron_client = neutron_utils.neutron_client(self.snaps_creds) if status == 0: instances = os_utils.get_instances(nova_client) for items in instances: metadata = get_instance_metadata(nova_client, items) if 'juju-units-deployed' in metadata: sec_group = ('juju-' + metadata['juju-controller-uuid'] + '-' + metadata['juju-model-uuid']) self.sec_group_id = os_utils.get_security_group_id( neutron_client, sec_group) break self.__logger.info("Adding Security group rule....") os_utils.create_secgroup_rule( neutron_client, self.sec_group_id, 'ingress', 132) self.__logger.info("Copying the feature files to Abot_node ") os.system('juju scp -- -r {}/featureFiles abot-' 'epc-basic/0:~/'.format(self.case_dir)) self.__logger.info("Copying the feature files in Abot_node ") os.system("juju ssh abot-epc-basic/0 'sudo rsync -azvv " "~/featureFiles /etc/rebaca-test-suite" "/featureFiles'") count = 0 while count < 10: epcstatus = os.system('juju status oai-epc | ' 'grep {} | grep {} | grep {}' .format('EPC', 'is', 'running')) if epcstatus == 0: break else: time.sleep(60) count = count + 1 os.system('juju-wait') return True return False
def get_network_quotas(self): """ Returns the network quotas as an instance of the NetworkQuotas class :return: """ neutron = neutron_utils.neutron_client(self._os_creds, self._os_session) try: return neutron_utils.get_network_quotas(neutron, self.__project.id) finally: neutron.httpclient.session.session.close()
def update_network_quotas(self, network_quotas): """ Updates the network quotas for this project :param network_quotas: a NetworkQuotas object. """ neutron = neutron_utils.neutron_client(self._os_creds, self._os_session) try: neutron_utils.update_quotas(neutron, self.__project.id, network_quotas) finally: neutron.httpclient.session.session.close()
def setUp(self): """ Sets up object for test """ super(self.__class__, self).__start__() self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) # Initialize for cleanup self.net_creator = None
def setUp(self): """ Initializes objects used for router testing """ super(self.__class__, self).__start__() self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.router_creator = None self.network_creator1 = None self.network_creator2 = None self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
def setUp(self): """ Instantiates the CreateSecurityGroup object that is responsible for downloading and creating an OS image file within OpenStack """ super(self.__class__, self).__start__() guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.sec_grp_name = guid + 'name' self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) # Initialize for cleanup self.sec_grp_creator = None
def test_detach_volume_nowait(self): """ Tests the nova_utils.detach_volume() with a timeout value that is too small to have the volume attachment data to be included on the VmInst object that was supposed to be returned """ self.assertIsNotNone(self.volume_creator.get_volume()) self.assertEqual(0, len(self.volume_creator.get_volume().attachments)) # Attach volume to VM neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) nova_utils.attach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name) # Check VmInst for attachment keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) latest_vm = nova_utils.get_server_object_by_id( self.nova, neutron, keystone, self.instance_creator.get_vm_inst().id, self.os_creds.project_name) self.assertEqual(1, len(latest_vm.volume_ids)) # Check Volume for attachment vol_attach = None attached = False start_time = time.time() while time.time() < start_time + 120: vol_attach = cinder_utils.get_volume_by_id( self.cinder, self.volume_creator.get_volume().id) if len(vol_attach.attachments) > 0: attached = True break time.sleep(3) self.assertTrue(attached) self.assertIsNotNone(vol_attach) # Detach volume with self.assertRaises(NovaException): nova_utils.detach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name, 0)
def test_create_stack(self): """ Tests the creation of an OpenStack Heat stack1 that does not exist. """ self.stack1 = heat_utils.create_stack(self.heat_client, self.stack_settings1) stack_query_1 = heat_utils.get_stack( self.heat_client, stack_settings=self.stack_settings1) self.assertEqual(self.stack1, stack_query_1) stack_query_2 = heat_utils.get_stack( self.heat_client, stack_name=self.stack_settings1.name) self.assertEqual(self.stack1, stack_query_2) stack_query_3 = heat_utils.get_stack_by_id(self.heat_client, self.stack1.id) self.assertEqual(self.stack1, stack_query_3) resources = heat_utils.get_resources(self.heat_client, self.stack1.id) self.assertIsNotNone(resources) self.assertEqual(4, len(resources)) outputs = heat_utils.get_outputs(self.heat_client, self.stack1) self.assertIsNotNone(outputs) self.assertEqual(0, len(outputs)) self.assertTrue(stack_active(self.heat_client, self.stack1)) neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) networks = heat_utils.get_stack_networks(self.heat_client, neutron, self.stack1) self.assertIsNotNone(networks) self.assertEqual(1, len(networks)) self.assertEqual(self.network_name, networks[0].name) subnets = neutron_utils.get_subnets_by_network(neutron, networks[0]) self.assertEqual(1, len(subnets)) self.assertEqual(self.subnet_name, subnets[0].name) nova = nova_utils.nova_client(self.os_creds, self.os_session) keystone = keystone_utils.keystone_client(self.os_creds, self.os_session) servers = heat_utils.get_stack_servers(self.heat_client, nova, neutron, keystone, self.stack1, self.os_creds.project_name) self.assertIsNotNone(servers) self.assertEqual(1, len(servers)) self.assertEqual(self.vm_inst_name, servers[0].name)
def get_ext_net_name(os_creds): """ Returns the configured external network name or the first retrieved external network name :param: os_creds: an instance of snaps OSCreds object :return: """ neutron = neutron_utils.neutron_client(os_creds) ext_nets = neutron_utils.get_external_networks(neutron) if env.get('EXTERNAL_NETWORK'): extnet_config = env.get('EXTERNAL_NETWORK') for ext_net in ext_nets: if ext_net.name == extnet_config: return extnet_config return ext_nets[0].name if ext_nets else ""
def setUp(self): """ Sets up object for test """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.net_config = openstack_tests.get_pub_net_config( project_name=self.os_creds.project_name, net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet') self.neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) self.keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) # Initialize for cleanup self.net_creator = None
def setUp(self): """ Initializes objects used for router testing """ super(self.__class__, self).__start__() self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.router_creator = None self.network_creator = None self.sec_grp_creator = OpenStackSecurityGroup( self.os_creds, SecurityGroupConfig(name=self.guid + '-sec_grp')) self.sec_grp_creator.create() self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
def test_create_router_with_ext_port(self): """ Test creation of a router with a port to an external network as an 'admin' user. """ port_settings = [ create_network.PortConfig(name=self.guid + '-port1', network_name=self.ext_net_name) ] router_settings = RouterConfig(name=self.guid + '-pub-router', port_settings=port_settings) self.router_creator = create_router.OpenStackRouter( self.admin_os_creds, router_settings) self.router_creator.create() admin_neutron = neutron_utils.neutron_client(self.admin_os_creds, self.admin_os_session) admin_keystone = keystone_utils.keystone_client( self.admin_os_creds, self.admin_os_session) router = neutron_utils.get_router( admin_neutron, admin_keystone, router_settings=router_settings, project_name=self.admin_os_creds.project_name) self.assertIsNotNone(router) self.assertEquals(router, self.router_creator.get_router()) ext_net = neutron_utils.get_network(admin_neutron, admin_keystone, network_name=self.ext_net_name) self.assertIsNotNone(ext_net) self.assertIsNotNone(router.port_subnets) id_found = False for port, subnets in router.port_subnets: self.assertIsNotNone(subnets) self.assertIsNotNone(port) if ext_net.id == port.network_id: id_found = True for subnet in subnets: self.assertIsNotNone(subnet) self.assertEqual(ext_net.id, subnet.network_id) self.assertTrue(id_found)
def clean(self): """ Cleanse environment of all artifacts :return: void """ if self.__project: # Delete security group 'default' if exists neutron = neutron_utils.neutron_client(self._os_creds, self._os_session) try: default_sec_grp = neutron_utils.get_security_group( neutron, self._keystone, sec_grp_name='default', project_name=self.__project.name) if default_sec_grp: try: neutron_utils.delete_security_group( neutron, default_sec_grp) except: pass finally: neutron.httpclient.session.session.close() # Delete Project try: keystone_utils.delete_project(self._keystone, self.__project) except NotFound: pass self.__project = None if self.__role: try: keystone_utils.delete_role(self._keystone, self.__role) except NotFound: pass self.__project = None # Final role check in case init was done from an existing instance role = keystone_utils.get_role_by_name(self._keystone, self.__role_name) if role: keystone_utils.delete_role(self._keystone, role) super(self.__class__, self).clean()
def initialize(self): """ Loads the existing VMInst, Port, FloatingIps :return: VMInst domain object """ super(self.__class__, self).initialize() self.__neutron = neutron_utils.neutron_client(self._os_creds, self._os_session) self.__keystone = keystone_utils.keystone_client( self._os_creds, self._os_session) self.__cinder = cinder_utils.cinder_client(self._os_creds, self._os_session) self.__glance = glance_utils.glance_client(self._os_creds, self._os_session) self.__ports = self.__query_ports(self.instance_settings.port_settings) self.__lookup_existing_vm_by_name()
def setUp(self): """ Initializes objects used for router testing """ super(self.__class__, self).__start__() self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.router_creator = None ext_network_settings = NetworkConfig( name=self.guid + '-ext-net', external=True, subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-ext-subnet1') ]) self.ext_network_creator = OpenStackNetwork(self.admin_os_creds, ext_network_settings) self.ext_network_creator.create() shared_network_settings = NetworkConfig( name=self.guid + '-shared-net', shared=True, subnet_settings=[ create_network.SubnetConfig(cidr=cidr2, name=self.guid + '-shared-subnet1') ]) self.shared_network_creator = OpenStackNetwork( self.admin_os_creds, shared_network_settings) self.shared_network_creator.create() overlay_network_settings = NetworkConfig( name=self.guid + '-overlay-net', subnet_settings=[ create_network.SubnetConfig(cidr=cidr3, name=self.guid + '-overlay-subnet1') ]) self.overlay_network_creator = OpenStackNetwork( self.os_creds, overlay_network_settings) self.overlay_network_creator.create() self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
def setUp(self): """ Instantiates the CreateSecurityGroup object that is responsible for downloading and creating an OS image file within OpenStack """ super(self.__class__, self).__start__() guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.sec_grp_name = guid + 'name' self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) # Initialize for cleanup self.admin_sec_grp_config = SecurityGroupConfig( name=self.sec_grp_name, description='hello group') self.sec_grp_creator_admin = OpenStackSecurityGroup( self.admin_os_creds, self.admin_sec_grp_config) self.sec_grp_creator_admin.create() self.sec_grp_creator_proj = None
def test_attach_volume_nowait(self): """ Tests the nova_utils.attach_volume() with a timeout value that is too small to have the volume attachment data to be included on the VmInst object that was supposed to be returned """ self.assertIsNotNone(self.volume_creator.get_volume()) self.assertEqual(0, len(self.volume_creator.get_volume().attachments)) # Attach volume to VM neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) with self.assertRaises(NovaException): nova_utils.attach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name, 0)
def setUp(self): """ Sets up object for test """ super(self.__class__, self).__start__() guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.net_config = openstack_tests.get_pub_net_config( project_name=self.os_creds.project_name, net_name="{}-{}".format(guid, 'pub-net'), mtu=999, subnet_name="{}-{}".format(guid, 'pub-subnet'), router_name="{}-{}".format(guid, 'pub-router'), external_net=self.ext_net_name, netconf_override=self.netconf_override) self.neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) # Initialize for cleanup self.net_creator = None self.router_creator = None
def initialize(self): """ Loads the existing heat stack :return: The Stack domain object or None """ super(self.__class__, self).initialize() self.__neutron = neutron_utils.neutron_client(self._os_creds, self._os_session) self.__nova = nova_utils.nova_client(self._os_creds, self._os_session) self.__glance = glance_utils.glance_client(self._os_creds, self._os_session) self.__cinder = cinder_utils.cinder_client(self._os_creds, self._os_session) self.__heat_cli = heat_utils.heat_client(self._os_creds, self._os_session) self.__stack = heat_utils.get_stack(self.__heat_cli, stack_settings=self.stack_settings) if self.__stack: logger.info('Found stack with name - ' + self.stack_settings.name) return self.__stack