def __init__(self, **kwargs): super(SnapsTestRunner, self).__init__(**kwargs) self.logger = logging.getLogger(__name__) self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials() if 'ext_net_name' in kwargs: self.ext_net_name = kwargs['ext_net_name'] else: self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) self.netconf_override = None if hasattr(CONST, 'snaps_network_config'): self.netconf_override = CONST.__getattribute__( 'snaps_network_config') self.use_fip = ( CONST.__getattribute__('snaps_use_floating_ips') == 'True') self.use_keystone = ( CONST.__getattribute__('snaps_use_keystone') == 'True') scenario = CONST.__getattribute__('DEPLOY_SCENARIO') self.flavor_metadata = None if 'ovs' in scenario or 'fdio' in scenario: self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE self.logger.info("Using flavor metadata '%s'", self.flavor_metadata) self.image_metadata = None if hasattr(CONST, 'snaps_images'): self.image_metadata = CONST.__getattribute__('snaps_images')
def __init__(self, **kwargs): super(SnapsTestRunner, self).__init__(**kwargs) self.logger = logging.getLogger(__name__) self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials() if 'ext_net_name' in kwargs: self.ext_net_name = kwargs['ext_net_name'] else: self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) self.netconf_override = None if hasattr(config.CONF, 'snaps_network_config'): self.netconf_override = getattr(config.CONF, 'snaps_network_config') self.use_fip = (getattr(config.CONF, 'snaps_use_floating_ips') == 'True') self.use_keystone = (getattr(config.CONF, 'snaps_use_keystone') == 'True') self.flavor_metadata = getattr(config.CONF, 'snaps_flavor_extra_specs', None) self.logger.info("Using flavor metadata '%s'", self.flavor_metadata) self.image_metadata = None if hasattr(config.CONF, 'snaps_images'): self.image_metadata = getattr(config.CONF, 'snaps_images')
def prepare_network(self): """Create network/subnet/router if they doen't exist yet""" self.logger.info( "Creating network/subnet/router if they doen't exist yet...") subnet_settings = SubnetSettings( name='%s_subnet' % self.case_name, cidr="192.168.100.0/24") network_settings = NetworkSettings( name='%s_net' % self.case_name, subnet_settings=[subnet_settings]) orchestra_network = OpenStackNetwork( self.snaps_creds, network_settings) orchestra_network_info = orchestra_network.create() self.mano['details']['network'] = {} self.mano['details']['network']['id'] = orchestra_network_info.id self.mano['details']['network']['name'] = orchestra_network_info.name self.mano['details']['external_net_name'] = \ snaps_utils.get_ext_net_name(self.snaps_creds) self.created_resources.append(orchestra_network) orchestra_router = OpenStackRouter( self.snaps_creds, RouterSettings( name='%s_router' % self.case_name, external_gateway=self.mano['details']['external_net_name'], internal_subnets=[ subnet_settings.name])) orchestra_router.create() self.created_resources.append(orchestra_router) self.logger.info("Created network and router for Open Baton NFVO...")
def check_ext_net(self): """ checks if external network exists """ ext_net = snaps_utils.get_ext_net_name(self.os_creds) if ext_net: LOGGER.info("External network found: %s", ext_net) else: raise Exception("ERROR: No external networks in the deployment.")
def __init__(self, **kwargs): super(SnapsTestRunner, self).__init__(**kwargs) self.logger = logging.getLogger(__name__) if 'os_creds' in kwargs: self.os_creds = kwargs['os_creds'] else: creds_override = None if hasattr(CONST, 'snaps_os_creds_override'): creds_override = CONST.__getattribute__( 'snaps_os_creds_override') self.os_creds = openstack_tests.get_credentials( os_env_file=CONST.__getattribute__('openstack_creds'), proxy_settings_str=None, ssh_proxy_cmd=None, overrides=creds_override) if 'ext_net_name' in kwargs: self.ext_net_name = kwargs['ext_net_name'] else: self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) self.use_fip = CONST.__getattribute__('snaps_use_floating_ips') self.use_keystone = CONST.__getattribute__('snaps_use_keystone') scenario = CONST.__getattribute__('DEPLOY_SCENARIO') self.flavor_metadata = None if 'ovs' in scenario or 'fdio' in scenario: self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE self.logger.info("Using flavor metadata '%s'", self.flavor_metadata) self.image_metadata = None if hasattr(CONST, 'snaps_images'): self.image_metadata = CONST.__getattribute__('snaps_images')
def __init__(self, **kwargs): super(SnapsTestRunner, self).__init__(**kwargs) self.logger = logging.getLogger(__name__) try: cloud_config = os_client_config.get_config() self.orig_cloud = shade.OpenStackCloud(cloud_config=cloud_config) guid = str(uuid.uuid4()) self.project = tenantnetwork.NewProject(self.orig_cloud, self.case_name, guid) self.project.create() except Exception: # pylint: disable=broad-except raise Exception("Cannot create user or project") if self.orig_cloud.get_role("admin"): role_name = "admin" elif self.orig_cloud.get_role("Admin"): role_name = "Admin" else: raise Exception("Cannot detect neither admin nor Admin") self.orig_cloud.grant_role(role_name, user=self.project.user.id, project=self.project.project.id, domain=self.project.domain.id) self.role = None if not self.orig_cloud.get_role("heat_stack_owner"): self.role = self.orig_cloud.create_role("heat_stack_owner") self.orig_cloud.grant_role("heat_stack_owner", user=self.project.user.id, project=self.project.project.id, domain=self.project.domain.id) creds_overrides = dict(username=self.project.user.name, project_name=self.project.project.name, project_id=self.project.project.id, password=self.project.password) self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials( overrides=creds_overrides) if 'ext_net_name' in kwargs: self.ext_net_name = kwargs['ext_net_name'] else: self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) self.netconf_override = None if hasattr(config.CONF, 'snaps_network_config'): self.netconf_override = getattr(config.CONF, 'snaps_network_config') self.use_fip = (getattr(config.CONF, 'snaps_use_floating_ips') == 'True') self.use_keystone = (getattr(config.CONF, 'snaps_use_keystone') == 'True') self.flavor_metadata = getattr(config.CONF, 'snaps_flavor_extra_specs', None) self.logger.info("Using flavor metadata '%s'", self.flavor_metadata) self.image_metadata = None if hasattr(config.CONF, 'snaps_images'): self.image_metadata = getattr(config.CONF, 'snaps_images')
def __init__(self): super(SnapsTestRunner, self).__init__() self.ext_net_name = snaps_utils.get_ext_net_name() scenario = functest_utils.get_scenario() self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_ANY if 'ovs' in scenario or 'fdio' in scenario: self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE
def __init__(self, case_name=''): super(SnapsTestRunner, self).__init__(case_name) self.ext_net_name = snaps_utils.get_ext_net_name() self.logger = ft_logger.Logger(self.project_name).getLogger() scenario = functest_utils.get_scenario() self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_ANY if 'ovs' in scenario or 'fdio' in scenario: self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE self.logger.info("Using flavor metatdata '%s'" % self.flavor_metadata)
def __init__(self): super(ConnectionCheck, self).__init__() self.suite = unittest.TestSuite() self.case_name = "connection_check" ext_net_name = snaps_utils.get_ext_net_name() test_suite_builder.add_openstack_client_tests( self.suite, CONST.openstack_creds, ext_net_name, use_keystone=CONST.snaps_use_keystone)
def __init__(self): super(HealthCheck, self).__init__() self.suite = unittest.TestSuite() self.case_name = "snaps_health_check" ext_net_name = snaps_utils.get_ext_net_name() self.suite.addTest( OSIntegrationTestCase.parameterize( SimpleHealthCheck, CONST.openstack_creds, ext_net_name, use_keystone=CONST.snaps_use_keystone))
def __init__(self): super(SnapsSmoke, self).__init__() self.suite = unittest.TestSuite() self.case_name = "snaps_smoke" use_fip = CONST.snaps_use_floating_ips ext_net_name = snaps_utils.get_ext_net_name() # Tests requiring floating IPs leverage files contained within the # SNAPS repository and are found relative to that path if use_fip: snaps_dir = CONST.dir_repo_snaps + '/snaps' os.chdir(snaps_dir) test_suite_builder.add_openstack_integration_tests( self.suite, CONST.openstack_creds, ext_net_name, use_keystone=CONST.snaps_use_keystone, use_floating_ips=use_fip)
def deploy_orchestrator(self): # pylint: disable=too-many-locals """ Create network, subnet, router Bootstrap juju """ self.__logger.info("Deployed Orchestrator") private_net_name = getattr( config.CONF, 'vnf_{}_private_net_name'.format(self.case_name)) private_subnet_name = '{}-{}'.format( getattr(config.CONF, 'vnf_{}_private_subnet_name'.format(self.case_name)), self.uuid) private_subnet_cidr = getattr( config.CONF, 'vnf_{}_private_subnet_cidr'.format(self.case_name)) abot_router = '{}-{}'.format( getattr(config.CONF, 'vnf_{}_external_router'.format(self.case_name)), self.uuid) self.__logger.info("Creating full network ...") subnet_settings = SubnetConfig(name=private_subnet_name, cidr=private_subnet_cidr, dns_nameservers=[env.get('NAMESERVER')]) network_settings = NetworkConfig(name=private_net_name, subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) net_id = network_creator.create().id self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) self.__logger.info("Creating network Router ....") router_creator = OpenStackRouter( self.snaps_creds, RouterConfig(name=abot_router, external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) self.__logger.info("Creating Flavor ....") flavor_settings = FlavorConfig( name=self.orchestrator['requirements']['flavor']['name'], ram=self.orchestrator['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("Upload some OS images if it doesn't exist") images = get_config("tenant_images", self.config_file) self.__logger.info("Images needed for vEPC: %s", images) for image_name, image_file in images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageConfig(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_id = image_creator.create().id cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'metadata', 'generate-image', '-d', '/root', '-i', image_id, '-s', image_name, '-r', self.snaps_creds.region_name, '-u', self.public_auth_url ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) self.created_object.append(image_creator) self.__logger.info("Network ID : %s", net_id) cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'bootstrap', 'abot-epc', 'abot-controller', '--metadata-source', '/root', '--constraints', 'mem=2G', '--bootstrap-series', 'xenial', '--config', 'network={}'.format(net_id), '--config', 'ssl-hostname-verification=false', '--config', 'use-floating-ip=true', '--config', 'use-default-secgroup=true', '--debug' ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) return True
def run(self, **kwargs): # pylint: disable=too-many-locals """ Begins the test execution which should originate from the subclass """ self.logger.info('Begin virtual environment setup') self.start_time = time.time() self.logger.info( "vPing Start Time:'%s'", datetime.fromtimestamp( self.start_time).strftime('%Y-%m-%d %H:%M:%S')) image_base_name = '{}-{}'.format(getattr(CONST, 'vping_image_name'), str(self.guid)) os_image_settings = openstack_tests.cirros_image_settings( image_base_name, image_metadata=self.cirros_image_config) self.logger.info("Creating image with name: '%s'", image_base_name) self.image_creator = deploy_utils.create_image(self.os_creds, os_image_settings) self.creators.append(self.image_creator) private_net_name = getattr(CONST, 'vping_private_net_name') + self.guid private_subnet_name = getattr(CONST, 'vping_private_subnet_name') + self.guid private_subnet_cidr = getattr(CONST, 'vping_private_subnet_cidr') vping_network_type = None vping_physical_network = None vping_segmentation_id = None if hasattr(CONST, 'vping_network_type'): vping_network_type = getattr(CONST, 'vping_network_type') if hasattr(CONST, 'vping_physical_network'): vping_physical_network = getattr(CONST, 'vping_physical_network') if hasattr(CONST, 'vping_segmentation_id'): vping_segmentation_id = getattr(CONST, 'vping_segmentation_id') self.logger.info("Creating network with name: '%s'", private_net_name) self.network_creator = deploy_utils.create_network( self.os_creds, NetworkConfig(name=private_net_name, network_type=vping_network_type, physical_network=vping_physical_network, segmentation_id=vping_segmentation_id, subnet_settings=[ SubnetConfig(name=private_subnet_name, cidr=private_subnet_cidr) ])) self.creators.append(self.network_creator) # Creating router to external network log = "Creating router with name: '%s'" % self.router_name self.logger.info(log) ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) self.router_creator = deploy_utils.create_router( self.os_creds, RouterConfig(name=self.router_name, external_gateway=ext_net_name, internal_subnets=[private_subnet_name])) self.creators.append(self.router_creator) self.logger.info("Creating flavor with name: '%s'", self.flavor_name) scenario = getattr(CONST, 'DEPLOY_SCENARIO') flavor_metadata = None flavor_ram = 512 if 'ovs' in scenario or 'fdio' in scenario: flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE flavor_ram = 1024 flavor_creator = OpenStackFlavor( self.os_creds, FlavorConfig(name=self.flavor_name, ram=flavor_ram, disk=1, vcpus=1, metadata=flavor_metadata)) flavor_creator.create() self.creators.append(flavor_creator)
def deploy_orchestrator(self): """ Deploy Cloudify Manager. network, security group, fip, VM creation """ # network creation start_time = time.time() self.__logger.info("Creating keypair ...") kp_file = os.path.join(self.data_dir, "cloudify_vrouter.pem") keypair_settings = KeypairSettings(name='cloudify_vrouter_kp', private_filepath=kp_file) keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings) keypair_creator.create() self.created_object.append(keypair_creator) self.__logger.info("Creating full network ...") subnet_settings = SubnetSettings(name='cloudify_vrouter_subnet', cidr='10.67.79.0/24') network_settings = NetworkSettings(name='cloudify_vrouter_network', subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) network_creator.create() self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) router_creator = OpenStackRouter( self.snaps_creds, RouterSettings(name='cloudify_vrouter_router', external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) # security group creation self.__logger.info("Creating security group for cloudify manager vm") sg_rules = list() sg_rules.append( SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager", direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager", direction=Direction.ingress, protocol=Protocol.udp, port_range_min=1, port_range_max=65535)) security_group_creator = OpenStackSecurityGroup( self.snaps_creds, SecurityGroupSettings(name="sg-cloudify-manager", rule_settings=sg_rules)) security_group_creator.create() self.created_object.append(security_group_creator) # orchestrator VM flavor self.__logger.info("Get or create flavor for cloudify manager vm ...") flavor_settings = FlavorSettings( name=self.orchestrator['requirements']['flavor']['name'], ram=self.orchestrator['requirements']['flavor']['ram_min'], disk=50, vcpus=2) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) image_settings = ImageSettings( name=self.orchestrator['requirements']['os_image'], image_user='******', exists=True) port_settings = PortSettings(name='cloudify_manager_port', network_name=network_settings.name) manager_settings = VmInstanceSettings( name='cloudify_manager', flavor=flavor_settings.name, port_settings=[port_settings], security_group_names=[ security_group_creator.sec_grp_settings.name ], floating_ip_settings=[ FloatingIpSettings( name='cloudify_manager_fip', port_name=port_settings.name, router_name=router_creator.router_settings.name) ]) manager_creator = OpenStackVmInstance(self.snaps_creds, manager_settings, image_settings, keypair_settings) self.__logger.info("Creating cloudify manager VM") manager_creator.create() self.created_object.append(manager_creator) public_auth_url = os_utils.get_endpoint('identity') self.__logger.info("Set creds for cloudify manager") cfy_creds = dict(keystone_username=self.tenant_name, keystone_password=self.tenant_name, keystone_tenant_name=self.tenant_name, keystone_url=public_auth_url) cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip, username='******', password='******', tenant='default_tenant') self.orchestrator['object'] = cfy_client self.cfy_manager_ip = manager_creator.get_floating_ip().ip self.__logger.info("Attemps running status of the Manager") cfy_status = None retry = 10 while str(cfy_status) != 'running' and retry: try: cfy_status = cfy_client.manager.get_status()['status'] self.__logger.debug("The current manager status is %s", cfy_status) except Exception: # pylint: disable=broad-except self.__logger.warning("Cloudify Manager isn't " + "up and running. Retrying ...") retry = retry - 1 time.sleep(30) if str(cfy_status) == 'running': self.__logger.info("Cloudify Manager is up and running") else: raise Exception("Cloudify Manager isn't up and running") self.__logger.info("Put OpenStack creds in manager") secrets_list = cfy_client.secrets.list() for k, val in cfy_creds.iteritems(): if not any(d.get('key', None) == k for d in secrets_list): cfy_client.secrets.create(k, val) else: cfy_client.secrets.update(k, val) duration = time.time() - start_time self.__logger.info("Put private keypair in manager") if manager_creator.vm_ssh_active(block=True): ssh = manager_creator.ssh_client() scp = SCPClient(ssh.get_transport(), socket_timeout=15.0) scp.put(kp_file, '~/') cmd = "sudo cp ~/cloudify_vrouter.pem /etc/cloudify/" run_blocking_ssh_command(ssh, cmd) cmd = "sudo chmod 444 /etc/cloudify/cloudify_vrouter.pem" run_blocking_ssh_command(ssh, cmd) cmd = "sudo yum install -y gcc python-devel" run_blocking_ssh_command(ssh, cmd, "Unable to install packages on manager") self.details['orchestrator'].update(status='PASS', duration=duration) self.vnf['inputs'].update(dict(external_network_name=ext_net_name)) return True
def deploy_orchestrator(self): # pylint: disable=too-many-locals """ Create network, subnet, router Bootstrap juju """ self.__logger.info("Deployed Orchestrator") private_net_name = getattr( CONST, 'vnf_{}_private_net_name'.format(self.case_name)) private_subnet_name = getattr( CONST, 'vnf_{}_private_subnet_name'.format(self.case_name)) private_subnet_cidr = getattr( CONST, 'vnf_{}_private_subnet_cidr'.format(self.case_name)) abot_router = getattr( CONST, 'vnf_{}_external_router'.format(self.case_name)) self.__logger.info("Creating full network ...") subnet_settings = SubnetConfig( name=private_subnet_name, cidr=private_subnet_cidr) network_settings = NetworkConfig( name=private_net_name, subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) net_id = network_creator.create().id self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) self.__logger.info("Creating network Router ....") router_creator = OpenStackRouter( self.snaps_creds, RouterConfig( name=abot_router, external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) self.__logger.info("Creating Flavor ....") flavor_settings = FlavorConfig( name=self.orchestrator['requirements']['flavor']['name'], ram=self.orchestrator['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("Upload some OS images if it doesn't exist") images = get_config("tenant_images", self.config_file) self.__logger.info("Images needed for vEPC: %s", images) for image_name, image_file in images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage(self.snaps_creds, ImageConfig( name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_id = image_creator.create().id os.system( 'juju metadata generate-image -d ~ -i {} -s {} -r ' '{} -u {}'.format( image_id, image_name, os.environ.get( "OS_REGION_NAME", self.default_region_name), self.public_auth_url)) self.created_object.append(image_creator) self.__logger.info("Credential information : %s", net_id) juju_bootstrap_command = ( 'juju bootstrap abot-epc abot-controller --config network={} ' '--metadata-source ~ --config ssl-hostname-verification=false ' '--constraints mem=2G --bootstrap-series xenial ' '--config use-floating-ip=true --debug ' '--config use-default-secgroup=true'.format(net_id)) os.system(juju_bootstrap_command) return True
def run(self): """ Excecute VPingSSH testcase. Sets up the OpenStack keypair, router, security group, and VM instance objects then validates the ping. :return: the exit code from the super.execute() method """ try: super(VPingSSH, self).run() log = "Creating keypair with name: '%s'" % self.kp_name self.logger.info(log) kp_creator = deploy_utils.create_keypair( self.os_creds, KeypairSettings(name=self.kp_name, private_filepath=self.kp_priv_file, public_filepath=self.kp_pub_file)) self.creators.append(kp_creator) # Creating router to external network log = "Creating router with name: '%s'" % self.router_name self.logger.info(log) net_set = self.network_creator.network_settings sub_set = [net_set.subnet_settings[0].name] ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) router_creator = deploy_utils.create_router( self.os_creds, RouterSettings( name=self.router_name, external_gateway=ext_net_name, internal_subnets=sub_set)) self.creators.append(router_creator) # Creating Instance 1 port1_settings = PortSettings( name=self.vm1_name + '-vPingPort', network_name=self.network_creator.network_settings.name) instance1_settings = VmInstanceSettings( name=self.vm1_name, flavor=self.flavor_name, vm_boot_timeout=self.vm_boot_timeout, vm_delete_timeout=self.vm_delete_timeout, ssh_connect_timeout=self.vm_ssh_connect_timeout, port_settings=[port1_settings]) log = ("Creating VM 1 instance with name: '%s'" % instance1_settings.name) self.logger.info(log) self.vm1_creator = deploy_utils.create_vm_instance( self.os_creds, instance1_settings, self.image_creator.image_settings, keypair_creator=kp_creator) self.creators.append(self.vm1_creator) # Creating Instance 2 sg_creator = self.__create_security_group() self.creators.append(sg_creator) port2_settings = PortSettings( name=self.vm2_name + '-vPingPort', network_name=self.network_creator.network_settings.name) instance2_settings = VmInstanceSettings( name=self.vm2_name, flavor=self.flavor_name, vm_boot_timeout=self.vm_boot_timeout, vm_delete_timeout=self.vm_delete_timeout, ssh_connect_timeout=self.vm_ssh_connect_timeout, port_settings=[port2_settings], security_group_names=[sg_creator.sec_grp_settings.name], floating_ip_settings=[FloatingIpSettings( name=self.vm2_name + '-FIPName', port_name=port2_settings.name, router_name=router_creator.router_settings.name)]) log = ("Creating VM 2 instance with name: '%s'" % instance2_settings.name) self.logger.info(log) self.vm2_creator = deploy_utils.create_vm_instance( self.os_creds, instance2_settings, self.image_creator.image_settings, keypair_creator=kp_creator) self.creators.append(self.vm2_creator) return self._execute() except Exception as exc: # pylint: disable=broad-except self.logger.error('Unexpected error running test - ' + exc.message) return TestCase.EX_RUN_ERROR finally: self._cleanup()
def test_vnf(self): """Run IXIA Stress test on clearwater ims instance.""" start_time = time.time() cfy_client = self.orchestrator['object'] outputs = cfy_client.deployments.outputs.get( self.vnf['descriptor'].get('name'))['outputs'] dns_ip = outputs['dns_ip'] ellis_ip = outputs['ellis_ip'] self.__logger.info("Creating full IXIA network ...") subnet_settings = SubnetConfig(name='ixia_management_subnet', cidr='10.10.10.0/24', dns_nameservers=[env.get('NAMESERVER')]) network_settings = NetworkConfig(name='ixia_management_network', subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) network_creator.create() self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) router_creator = OpenStackRouter( self.snaps_creds, RouterConfig(name='ixia_management_router', external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) # security group creation self.__logger.info("Creating security groups for IXIA VMs") sg_rules = list() sg_rules.append( SecurityGroupRuleConfig(sec_grp_name="ixia_management", direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleConfig(sec_grp_name="ixia_management", direction=Direction.ingress, protocol=Protocol.udp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleConfig(sec_grp_name="ixia_management", direction=Direction.ingress, protocol=Protocol.icmp)) ixia_managment_sg_settings = SecurityGroupConfig( name="ixia_management", rule_settings=sg_rules) securit_group_creator = OpenStackSecurityGroup( self.snaps_creds, ixia_managment_sg_settings) securit_group_creator.create() self.created_object.append(securit_group_creator) sg_rules = list() sg_rules.append( SecurityGroupRuleConfig(sec_grp_name="ixia_ssh_http", direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) ixia_ssh_http_sg_settings = SecurityGroupConfig(name="ixia_ssh_http", rule_settings=sg_rules) securit_group_creator = OpenStackSecurityGroup( self.snaps_creds, ixia_ssh_http_sg_settings) securit_group_creator.create() self.created_object.append(securit_group_creator) chassis_flavor_settings = FlavorConfig(name="ixia_vChassis", ram=4096, disk=40, vcpus=2) flavor_creator = OpenStackFlavor(self.snaps_creds, chassis_flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) card_flavor_settings = FlavorConfig(name="ixia_vCard", ram=4096, disk=4, vcpus=2) flavor_creator = OpenStackFlavor(self.snaps_creds, card_flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) load_flavor_settings = FlavorConfig(name="ixia_vLoad", ram=8192, disk=100, vcpus=4) flavor_creator = OpenStackFlavor(self.snaps_creds, load_flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) chassis_image_settings = ImageConfig( name=self.test['requirements']['chassis']['image'], image_user='******', exists=True) card_image_settings = ImageConfig( name=self.test['requirements']['card']['image'], image_user='******', exists=True) load_image_settings = ImageConfig( name=self.test['requirements']['load']['image'], image_user='******', exists=True) chassis_port_settings = PortConfig(name='ixia_chassis_port', network_name=network_settings.name) card1_port1_settings = PortConfig(name='ixia_card1_port1', network_name=network_settings.name) card2_port1_settings = PortConfig(name='ixia_card2_port1', network_name=network_settings.name) card1_port2_settings = PortConfig(name='ixia_card1_port2', network_name="cloudify_ims_network") card2_port2_settings = PortConfig(name='ixia_card2_port2', network_name="cloudify_ims_network") load_port_settings = PortConfig(name='ixia_load_port', network_name=network_settings.name) chassis_settings = VmInstanceConfig( name='ixia_vChassis', flavor=chassis_flavor_settings.name, port_settings=[chassis_port_settings], security_group_names=[ ixia_ssh_http_sg_settings.name, ixia_managment_sg_settings.name ], floating_ip_settings=[ FloatingIpConfig( name='ixia_vChassis_fip', port_name=chassis_port_settings.name, router_name=router_creator.router_settings.name) ]) vm_creator = OpenStackVmInstance(self.snaps_creds, chassis_settings, chassis_image_settings) self.__logger.info("Creating Ixia vChassis VM") vm_creator.create() fip_chassis = vm_creator.get_floating_ip().ip self.created_object.append(vm_creator) card1_settings = VmInstanceConfig( name='ixia_vCard1', flavor=card_flavor_settings.name, port_settings=[card1_port1_settings, card1_port2_settings], security_group_names=[ixia_managment_sg_settings.name]) vm_creator = OpenStackVmInstance(self.snaps_creds, card1_settings, card_image_settings) self.__logger.info("Creating Ixia vCard1 VM") vm_creator.create() vcard_ips = list() vcard_ips_p2 = list() vcard_ips.append(vm_creator.get_port_ip('ixia_card1_port1')) vcard_ips_p2.append(vm_creator.get_port_ip('ixia_card1_port2')) self.created_object.append(vm_creator) card2_settings = VmInstanceConfig( name='ixia_vCard2', flavor=card_flavor_settings.name, port_settings=[card2_port1_settings, card2_port2_settings], security_group_names=[ixia_managment_sg_settings.name]) vm_creator = OpenStackVmInstance(self.snaps_creds, card2_settings, card_image_settings) self.__logger.info("Creating Ixia vCard2 VM") vm_creator.create() vcard_ips.append(vm_creator.get_port_ip('ixia_card2_port1')) vcard_ips_p2.append(vm_creator.get_port_ip('ixia_card2_port2')) self.created_object.append(vm_creator) load_settings = VmInstanceConfig( name='ixia_vLoad', flavor=load_flavor_settings.name, port_settings=[load_port_settings], security_group_names=[ ixia_ssh_http_sg_settings.name, ixia_managment_sg_settings.name ], floating_ip_settings=[ FloatingIpConfig( name='ixia_vLoad_fip', port_name=load_port_settings.name, router_name=router_creator.router_settings.name) ]) vm_creator = OpenStackVmInstance(self.snaps_creds, load_settings, load_image_settings) self.__logger.info("Creating Ixia vLoad VM") vm_creator.create() fip_load = vm_creator.get_floating_ip().ip self.created_object.append(vm_creator) self.__logger.info("Chassis IP is: %s", fip_chassis) login_url = "https://" + str(fip_chassis) + "/api/v1/auth/session" cards_url = "https://" + str(fip_chassis) + "/api/v2/ixos/cards/" payload = json.dumps({ "username": "******", "password": "******", "rememberMe": "false" }) api_key = json.loads( (IxChassisUtils.ChassisRestAPI.postWithPayload(login_url, payload)))["apiKey"] self.__logger.info("Adding 2 card back inside the ixia chassis...") for ip in vcard_ips: payload = {"ipAddress": str(ip)} response = json.loads( IxChassisUtils.ChassisRestAPI.postOperation( cards_url, api_key, payload)) count = 0 while (int( IxChassisUtils.ChassisRestAPI.getWithHeaders( response['url'], api_key)['progress']) != 100): self.__logger.debug("Operation did not finish yet. \ Waiting for 1 more second..") time.sleep(1) if count > 60: raise Exception("Adding card take more than 60 seconds") count += 1 ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) ssh.connect(fip_chassis, username="******", password="******") cmd = "set license-check disable" run_blocking_ssh_command(ssh, cmd) cmd = "restart-service ixServer" run_blocking_ssh_command(ssh, cmd) self.config_ellis(ellis_ip) # Get IPs of P-CSCF resolver = dns.resolver.Resolver() resolver.nameservers = [dns_ip] result = resolver.query("bono.clearwater.local") iplistims = '' i = 0 for rdata in result: i = i + 1 print rdata.address iplistims += str(rdata.address) if i != len(result): iplistims += ';' kResourcesUrl = 'http://%s:%s/api/v0/resources' % (fip_load, 8080) kRxfPath = r"REG_CALL_OPNFV_v13.rxf" test_filname = self.test['inputs']['test_filname'] kGatewaySharedFolder = '/mnt/ixload-share/' kRxfRelativeUploadPath = 'uploads/%s' % os.path.split(kRxfPath)[1] kRxfAbsoluteUploadPath = os.path.join(kGatewaySharedFolder, kRxfRelativeUploadPath) kChassisList = [str(fip_chassis)] dataFileNameList = [ test_filname, 'Registration_only_LPS.tst', 'SIPCall.tst' ] kPortListPerCommunityCommunity = { "VoIP1@VM1": [(1, 1, 1)], "VoIP2@VM2": [(1, 2, 1)] } kStatsToDisplayDict = self.test['inputs']['stats'] connection = IxRestUtils.getConnection(fip_load, 8080) self.__logger.info("Creating a new session...") sessionUrl = IxLoadUtils.createSession(connection, self.test['version']) license_server = self.test['inputs']['licenseServer'] IxLoadUtils.configureLicenseServer(connection, sessionUrl, license_server) files_dir = os.path.join(self.case_dir, 'ixia/files') target_file = open(os.path.join(files_dir, test_filname), 'w') j2_env = Environment(loader=FileSystemLoader(files_dir), trim_blocks=True) self.test['inputs'].update( dict(ipchassis=fip_chassis, ipcard1=vcard_ips_p2[0], ipcard2=vcard_ips_p2[1], iplistims=iplistims)) target_file.write( j2_env.get_template(test_filname + '.template').render( self.test['inputs'])) target_file.close() self.__logger.info('Uploading files %s...' % kRxfPath) for dataFile in dataFileNameList: localFilePath = os.path.join(files_dir, dataFile) remoteFilePath = os.path.join(kGatewaySharedFolder, 'uploads/%s' % dataFile) IxLoadUtils.uploadFile(connection, kResourcesUrl, localFilePath, remoteFilePath) self.__logger.info('Upload file finished.') self.__logger.info("Loading repository %s..." % kRxfAbsoluteUploadPath) IxLoadUtils.loadRepository(connection, sessionUrl, kRxfAbsoluteUploadPath) self.__logger.info("Clearing chassis list...") IxLoadUtils.clearChassisList(connection, sessionUrl) self.__logger.info("Adding chassis %s..." % (kChassisList)) IxLoadUtils.addChassisList(connection, sessionUrl, kChassisList) self.__logger.info("Assigning new ports...") IxLoadUtils.assignPorts(connection, sessionUrl, kPortListPerCommunityCommunity) self.__logger.info("Starting the test...") IxLoadUtils.runTest(connection, sessionUrl) self.__logger.info("Polling values for stats %s..." % (kStatsToDisplayDict)) result = IxLoadUtils.pollStats(connection, sessionUrl, kStatsToDisplayDict) self.__logger.info("Test finished.") self.__logger.info("Checking test status...") testRunError = IxLoadUtils.getTestRunError(connection, sessionUrl) self.__logger.info(result) duration = time.time() - start_time self.details['test_vnf'].update(status='PASS', result=result, duration=duration) if testRunError: self.__logger.info("The test exited with following error: %s" % (testRunError)) self.details['test_vnf'].update(status='FAIL', duration=duration) return False else: self.__logger.info("The test completed successfully.") self.details['test_vnf'].update(status='PASS', duration=duration) self.result += 1 / 3 * 100 return True
def deploy_orchestrator(self): # pylint: disable=too-many-locals,too-many-statements """ Deploy Cloudify Manager. network, security group, fip, VM creation """ start_time = time.time() # orchestrator VM flavor self.__logger.info("Get or create flavor for cloudify manager vm ...") flavor_settings = FlavorConfig( name="{}-{}".format( self.orchestrator['requirements']['flavor']['name'], self.uuid), ram=self.orchestrator['requirements']['flavor']['ram_min'], disk=50, vcpus=2) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) self.__logger.info("Creating a second user to bypass issues ...") user_creator = OpenStackUser( self.snaps_creds, UserConfig( name='cloudify_network_bug-{}'.format(self.uuid), password=str(uuid.uuid4()), project_name=self.tenant_name, domain_name=self.snaps_creds.user_domain_name, roles={'_member_': self.tenant_name})) user_creator.create() self.created_object.append(user_creator) snaps_creds = user_creator.get_os_creds(self.snaps_creds.project_name) self.__logger.debug("snaps creds: %s", snaps_creds) self.__logger.info("Creating keypair ...") kp_file = os.path.join(self.data_dir, "cloudify_ims.pem") keypair_settings = KeypairConfig( name='cloudify_ims_kp-{}'.format(self.uuid), private_filepath=kp_file) keypair_creator = OpenStackKeypair(snaps_creds, keypair_settings) keypair_creator.create() self.created_object.append(keypair_creator) # needs some images self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( snaps_creds, ImageConfig( name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator) # network creation self.__logger.info("Creating full network ...") subnet_settings = SubnetConfig( name='cloudify_ims_subnet-{}'.format(self.uuid), cidr='10.67.79.0/24', dns_nameservers=[env.get('NAMESERVER')]) network_settings = NetworkConfig( name='cloudify_ims_network-{}'.format(self.uuid), subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(snaps_creds, network_settings) network_creator.create() self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(snaps_creds) router_creator = OpenStackRouter( snaps_creds, RouterConfig( name='cloudify_ims_router-{}'.format(self.uuid), external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) # security group creation self.__logger.info("Creating security group for cloudify manager vm") sg_rules = list() sg_rules.append( SecurityGroupRuleConfig( sec_grp_name="sg-cloudify-manager-{}".format(self.uuid), direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleConfig( sec_grp_name="sg-cloudify-manager-{}".format(self.uuid), direction=Direction.ingress, protocol=Protocol.udp, port_range_min=1, port_range_max=65535)) security_group_creator = OpenStackSecurityGroup( snaps_creds, SecurityGroupConfig( name="sg-cloudify-manager-{}".format(self.uuid), rule_settings=sg_rules)) security_group_creator.create() self.created_object.append(security_group_creator) image_settings = ImageConfig( name=self.orchestrator['requirements']['os_image'], image_user='******', exists=True) port_settings = PortConfig( name='cloudify_manager_port-{}'.format(self.uuid), network_name=network_settings.name) manager_settings = VmInstanceConfig( name='cloudify_manager-{}'.format(self.uuid), flavor=flavor_settings.name, port_settings=[port_settings], security_group_names=[ security_group_creator.sec_grp_settings.name], floating_ip_settings=[FloatingIpConfig( name='cloudify_manager_fip-{}'.format(self.uuid), port_name=port_settings.name, router_name=router_creator.router_settings.name)]) manager_creator = OpenStackVmInstance( snaps_creds, manager_settings, image_settings, keypair_settings) self.__logger.info("Creating cloudify manager VM") manager_creator.create() self.created_object.append(manager_creator) public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity') cfy_creds = dict( keystone_username=snaps_creds.username, keystone_password=snaps_creds.password, keystone_tenant_name=snaps_creds.project_name, keystone_url=public_auth_url, region=snaps_creds.region_name, user_domain_name=snaps_creds.user_domain_name, project_domain_name=snaps_creds.project_domain_name) self.__logger.info("Set creds for cloudify manager %s", cfy_creds) cfy_client = CloudifyClient( host=manager_creator.get_floating_ip().ip, username='******', password='******', tenant='default_tenant') self.orchestrator['object'] = cfy_client self.__logger.info("Attemps running status of the Manager") for loop in range(10): try: self.__logger.debug( "status %s", cfy_client.manager.get_status()) cfy_status = cfy_client.manager.get_status()['status'] self.__logger.info( "The current manager status is %s", cfy_status) if str(cfy_status) != 'running': raise Exception("Cloudify Manager isn't up and running") self.__logger.info("Put OpenStack creds in manager") secrets_list = cfy_client.secrets.list() for k, val in cfy_creds.iteritems(): if not any(d.get('key', None) == k for d in secrets_list): cfy_client.secrets.create(k, val) else: cfy_client.secrets.update(k, val) break except Exception: # pylint: disable=broad-except self.logger.info( "try %s: Cloudify Manager isn't up and running", loop + 1) time.sleep(30) else: self.logger.error("Cloudify Manager isn't up and running") return False duration = time.time() - start_time if manager_creator.vm_ssh_active(block=True): self.__logger.info("Put private keypair in manager") ssh = manager_creator.ssh_client() scp = SCPClient(ssh.get_transport(), socket_timeout=15.0) scp.put(kp_file, '~/') cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/" self.run_blocking_ssh_command(ssh, cmd) cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem" self.run_blocking_ssh_command(ssh, cmd) # cmd2 is badly unpinned by Cloudify cmd = "sudo yum install -y gcc python-devel python-cmd2" self.run_blocking_ssh_command( ssh, cmd, "Unable to install packages on manager") self.run_blocking_ssh_command(ssh, 'cfy status') else: self.__logger.error("Cannot connect to manager") return False self.details['orchestrator'].update(status='PASS', duration=duration) self.vnf['inputs'].update(dict( external_network_name=ext_net_name, network_name=network_settings.name, key_pair_name=keypair_settings.name )) self.result = 1/3 * 100 return True
def deploy_orchestrator(self): # pylint: disable=too-many-locals """ Create network, subnet, router Bootstrap juju """ self.__logger.info("Deployed Orchestrator") private_net_name = CONST.__getattribute__( 'vnf_{}_private_net_name'.format(self.case_name)) private_subnet_name = CONST.__getattribute__( 'vnf_{}_private_subnet_name'.format(self.case_name)) private_subnet_cidr = CONST.__getattribute__( 'vnf_{}_private_subnet_cidr'.format(self.case_name)) abot_router = CONST.__getattribute__( 'vnf_{}_external_router'.format(self.case_name)) dns_nameserver = CONST.__getattribute__( 'vnf_{}_dns_nameserver'.format(self.case_name)) ext_net_name = CONST.__getattribute__( 'vnf_{}_external_network_name'.format(self.case_name)) self.__logger.info("Creating full network ...") subnet_settings = SubnetSettings(name=private_subnet_name, cidr=private_subnet_cidr, dns_nameservers=dns_nameserver) network_settings = NetworkSettings(name=private_net_name, subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) network_creator.create() self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) self.__logger.info("Creating network Router ....") router_creator = OpenStackRouter( self.snaps_creds, RouterSettings( name=abot_router, external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) self.__logger.info("Creating Flavor ....") flavor_settings = FlavorSettings( name=self.orchestrator['requirements']['flavor']['name'], ram=self.orchestrator['requirements']['flavor']['ram_min'], disk=10, vcpus=1) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) self.__logger.info("Juju Bootstrap: Skip creation of flavors") flavor_creator.create() self.created_object.append(flavor_creator) self.__logger.info("Installing Dependency Packages .......") source_dir = "/src/epc-requirements/juju_bin_build" if os.path.exists(source_dir): shutil.rmtree(source_dir) os.makedirs(source_dir) os.environ['GOPATH'] = str(source_dir) os.environ['GOBIN'] = str(source_dir) + "/bin" os.environ['PATH'] = ((os.path.expandvars('$GOPATH')) + ":" + (os.path.expandvars('$GOBIN')) + ":" + (os.path.expandvars('$PATH'))) os.system('go get -d -v github.com/juju/juju/...') os.chdir(source_dir + "/src" + "/github.com" + "/juju" + "/juju") os.system('git checkout tags/juju-2.2.5') os.system('go get github.com/rogpeppe/godeps') os.system('godeps -u dependencies.tsv') os.system('go install -v github.com/juju/juju/...') self.__logger.info("Creating Cloud for Abot-epc .....") os.system('juju add-cloud abot-epc -f {}'.format(self.filename)) os.system('juju add-credential abot-epc -f {}'.format(self.filename)) for image_name in self.images.keys(): self.__logger.info("Generating Metadata for %s", image_name) image_id = os_utils.get_image_id(self.glance_client, image_name) os.system( 'juju metadata generate-image -d ~ -i {} -s {} -r ' '{} -u {}'.format( image_id, image_name, os.environ.get("OS_REGION_NAME", self.default_region_name), self.public_auth_url)) net_id = os_utils.get_network_id(self.neutron_client, private_net_name) self.__logger.info("Credential information : %s", net_id) juju_bootstrap_command = ('juju bootstrap abot-epc abot-controller ' '--config network={} --metadata-source ~ ' '--config ssl-hostname-verification=false ' '--constraints mem=2G --bootstrap-series ' 'xenial ' '--config use-floating-ip=true --debug'. format(net_id)) os.system(juju_bootstrap_command) return True
def _prepare_env(self): """Create resources needed by test scenarios.""" LOGGER.debug('Validating the test name...') if self.test_name not in self.TESTS: raise Exception("Test name '%s' is invalid" % self.test_name) network_name = self.RALLY_PRIVATE_NET_NAME + self.guid subnet_name = self.RALLY_PRIVATE_SUBNET_NAME + self.guid router_name = self.RALLY_ROUTER_NAME + self.guid self.image_name = self.GLANCE_IMAGE_NAME + self.guid self.flavor_name = self.FLAVOR_NAME + self.guid self.flavor_alt_name = self.FLAVOR_ALT_NAME + self.guid self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) self.compute_cnt = snaps_utils.get_active_compute_cnt(self.os_creds) LOGGER.debug("Creating image '%s'...", self.image_name) image_creator = deploy_utils.create_image( self.os_creds, ImageConfig( name=self.image_name, image_file=self.GLANCE_IMAGE_PATH, img_format=self.GLANCE_IMAGE_FORMAT, image_user=self.GLANCE_IMAGE_USERNAME, public=True, extra_properties=self.GLANCE_IMAGE_EXTRA_PROPERTIES)) if image_creator is None: raise Exception("Failed to create image") self.creators.append(image_creator) LOGGER.debug("Creating network '%s'...", network_name) rally_network_type = None rally_physical_network = None rally_segmentation_id = None if hasattr(CONST, 'rally_network_type'): rally_network_type = CONST.__getattribute__( 'rally_network_type') if hasattr(CONST, 'rally_physical_network'): rally_physical_network = CONST.__getattribute__( 'rally_physical_network') if hasattr(CONST, 'rally_segmentation_id'): rally_segmentation_id = CONST.__getattribute__( 'rally_segmentation_id') network_creator = deploy_utils.create_network( self.os_creds, NetworkConfig( name=network_name, shared=True, network_type=rally_network_type, physical_network=rally_physical_network, segmentation_id=rally_segmentation_id, subnet_settings=[SubnetConfig( name=subnet_name, cidr=self.RALLY_PRIVATE_SUBNET_CIDR)])) if network_creator is None: raise Exception("Failed to create private network") self.priv_net_id = network_creator.get_network().id self.creators.append(network_creator) LOGGER.debug("Creating router '%s'...", router_name) router_creator = deploy_utils.create_router( self.os_creds, RouterConfig( name=router_name, external_gateway=self.ext_net_name, internal_subnets=[subnet_name])) if router_creator is None: raise Exception("Failed to create router") self.creators.append(router_creator) LOGGER.debug("Creating flavor '%s'...", self.flavor_name) flavor_creator = OpenStackFlavor( self.os_creds, FlavorConfig( name=self.flavor_name, ram=self.FLAVOR_RAM, disk=1, vcpus=1, metadata=self.FLAVOR_EXTRA_SPECS)) if flavor_creator is None or flavor_creator.create() is None: raise Exception("Failed to create flavor") self.creators.append(flavor_creator) LOGGER.debug("Creating flavor '%s'...", self.flavor_alt_name) flavor_alt_creator = OpenStackFlavor( self.os_creds, FlavorConfig( name=self.flavor_alt_name, ram=self.FLAVOR_RAM_ALT, disk=1, vcpus=1, metadata=self.FLAVOR_EXTRA_SPECS)) if flavor_alt_creator is None or flavor_alt_creator.create() is None: raise Exception("Failed to create flavor") self.creators.append(flavor_alt_creator)