def test_create_loadbalancer(self): """Create load balancer.""" # Prepare payload instances # First we allow communication to port 80 by adding a security group # rule project_id = openstack_utils.get_project_id(self.keystone_client, 'admin', domain_name='admin_domain') openstack_utils.add_neutron_secgroup_rules(self.neutron_client, project_id, [{ 'protocol': 'tcp', 'port_range_min': '80', 'port_range_max': '80', 'direction': 'ingress' }]) # Then we request two Ubuntu instances with the Apache web server # installed instance_1, instance_2 = self.launch_guests( userdata='#cloud-config\npackages:\n - apache2\n') # Get IP of the prepared payload instances payload_ips = [] for server in (instance_1, instance_2): payload_ips.append(server.networks['private'][0]) self.assertTrue(len(payload_ips) > 0) resp = self.neutron_client.list_networks(name='private') subnet_id = resp['networks'][0]['subnets'][0] if openstack_utils.dvr_enabled(): resp = self.neutron_client.list_networks( name='private_lb_fip_network') vip_subnet_id = resp['networks'][0]['subnets'][0] else: vip_subnet_id = subnet_id for provider in self.get_lb_providers(self.octavia_client).keys(): logging.info( 'Creating loadbalancer with provider {}'.format(provider)) lb = self._create_lb_resources(self.octavia_client, provider, vip_subnet_id, subnet_id, payload_ips) self.loadbalancers.append(lb) lb_fp = openstack_utils.create_floating_ip( self.neutron_client, 'ext_net', port={'id': lb['vip_port_id']}) snippet = 'This is the default welcome page' assert snippet in self._get_payload(lb_fp['floating_ip_address']) logging.info('Found "{}" in page retrieved through load balancer ' ' (provider="{}") at "http://{}/"'.format( snippet, provider, lb_fp['floating_ip_address'])) # If we get here, it means the tests passed self.run_resource_cleanup = True
def setup_sdn_provider_vlan(network_config, keystone_session=None): """Perform setup for Software Defined Network, specifically a provider VLAN. :param network_config: Network configuration settings dictionary :type network_config: dict :param keystone_session: Keystone session object for overcloud :type keystone_session: keystoneauth1.session.Session object :returns: None :rtype: None """ # If a session has not been provided, acquire one if not keystone_session: keystone_session = openstack_utils.get_overcloud_keystone_session() # Get authenticated clients keystone_client = openstack_utils.get_keystone_session_client( keystone_session) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) admin_domain = None if openstack_utils.get_keystone_api_version() > 2: admin_domain = "admin_domain" # Resolve the project name from the overcloud openrc into a project id project_id = openstack_utils.get_project_id( keystone_client, "admin", domain_name=admin_domain, ) logging.info("Configuring VLAN provider network") # Create the external network provider_vlan_network = openstack_utils.create_provider_network( neutron_client, project_id, net_name=network_config["provider_vlan_net_name"], external=False, shared=True, network_type='vlan', vlan_id=network_config["provider_vlan_id"]) provider_vlan_subnet = openstack_utils.create_provider_subnet( neutron_client, project_id, provider_vlan_network, network_config["provider_vlan_subnet_name"], cidr=network_config["provider_vlan_cidr"], dhcp=True) openstack_utils.plug_subnet_into_router(neutron_client, network_config["router_name"], provider_vlan_network, provider_vlan_subnet) openstack_utils.add_neutron_secgroup_rules(neutron_client, project_id)
def prepare_payload_instance(): """Prepare a instance we can use as payload test.""" session = openstack.get_overcloud_keystone_session() keystone = openstack.get_keystone_session_client(session) neutron = openstack.get_neutron_session_client(session) project_id = openstack.get_project_id(keystone, 'admin', domain_name='admin_domain') openstack.add_neutron_secgroup_rules(neutron, project_id, [{ 'protocol': 'tcp', 'port_range_min': '80', 'port_range_max': '80', 'direction': 'ingress' }]) zaza.openstack.configure.guest.launch_instance( glance_setup.LTS_IMAGE_NAME, userdata='#cloud-config\npackages:\n - apache2\n')
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() default_machines = ["cirros:m1.tiny:1"] parser.add_argument("machines", default=default_machines, nargs="*") parser.add_argument("--active_wait", default=600) parser.add_argument("--cloudinit_wait", default=600) parser.add_argument("--ping_wait", default=600) options = parser.parse_args() machines = cli_utils.parse_arg(options, 'machines', multiargs=True) active_wait = int(cli_utils.parse_arg(options, 'active_wait')) cloudinit_wait = int(cli_utils.parse_arg(options, 'cloudinit_wait')) ping_wait = int(cli_utils.parse_arg(options, 'ping_wait')) overcloud_novarc = openstack_utils.get_overcloud_auth() try: cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'), 'cacert.pem') os.stat(cacert) logging.info("Using cacert file: {}".format(cacert)) except FileNotFoundError: logging.info("Not using a cacert pem file") cacert = None logging.info("Initializing client sessions") keystone_session = openstack_utils.get_overcloud_keystone_session( verify=cacert) keystonec = openstack_utils.get_keystone_session_client(keystone_session) domain = overcloud_novarc.get('OS_PROJECT_DOMAIN_NAME') project_id = openstack_utils.get_project_id( keystonec, 'admin', api_version=overcloud_novarc['API_VERSION'], domain_name=domain) novac = openstack_utils.get_nova_session_client(keystone_session) neutronc = openstack_utils.get_neutron_session_client(keystone_session) init_flavors(novac) priv_key = mojo_os_utils.create_keypair(novac, 'mojo') openstack_utils.add_neutron_secgroup_rules(neutronc, project_id) for server in novac.servers.list(search_opts={'all_tenants': 1}): if server.name.startswith('mojo'): logging.info("Deleting nova instance {}".format(server.id)) novac.servers.delete(server.id) for instanceset in machines: image_name, flavor_name, count = instanceset.split(":") # when instance count allows boot instances off both regular instance # storage and volume storage # # account for count=1 and odd numbers # NOTE(fnordahl) temporarilly disable test while tests settle # regular_boot_count = int(int(count) / 2) + (int(count) % 2) # volume_boot_count = int(int(count) / 2) regular_boot_count = int(count) volume_boot_count = 0 mojo_os_utils.boot_and_test( novac, neutronc, image_name=image_name, flavor_name=flavor_name, number=regular_boot_count, privkey=priv_key, active_wait=active_wait, cloudinit_wait=cloudinit_wait, ping_wait=ping_wait, ) mojo_os_utils.boot_and_test( novac, neutronc, image_name=image_name, flavor_name=flavor_name, number=volume_boot_count, privkey=priv_key, active_wait=active_wait, cloudinit_wait=cloudinit_wait, ping_wait=ping_wait, boot_from_volume=True, )
def setup_sdn(network_config, keystone_session=None): """Perform setup for Software Defined Network. :param network_config: Network configuration settings dictionary :type network_config: dict :param keystone_session: Keystone session object for overcloud :type keystone_session: keystoneauth1.session.Session object :returns: None :rtype: None """ # If a session has not been provided, acquire one if not keystone_session: keystone_session = openstack_utils.get_overcloud_keystone_session() # Get authenticated clients keystone_client = openstack_utils.get_keystone_session_client( keystone_session) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) admin_domain = None if openstack_utils.get_keystone_api_version() > 2: admin_domain = "admin_domain" # Resolve the project name from the overcloud openrc into a project id project_id = openstack_utils.get_project_id( keystone_client, "admin", domain_name=admin_domain, ) # Network Setup subnetpools = False if network_config.get("subnetpool_prefix"): subnetpools = True logging.info("Configuring overcloud network") # Create the external network ext_network = openstack_utils.create_provider_network( neutron_client, project_id, network_config["external_net_name"]) openstack_utils.create_provider_subnet( neutron_client, project_id, ext_network, network_config["external_subnet_name"], network_config["default_gateway"], network_config["external_net_cidr"], network_config["start_floating_ip"], network_config["end_floating_ip"]) provider_router = (openstack_utils.create_provider_router( neutron_client, project_id)) openstack_utils.plug_extnet_into_router(neutron_client, provider_router, ext_network) ip_version = network_config.get("ip_version") or 4 subnetpool = None if subnetpools: address_scope = openstack_utils.create_address_scope( neutron_client, project_id, network_config.get("address_scope"), ip_version=ip_version) subnetpool = openstack_utils.create_subnetpool( neutron_client, project_id, network_config.get("subnetpool_name"), network_config.get("subnetpool_prefix"), address_scope) project_network = openstack_utils.create_project_network( neutron_client, project_id, shared=False, network_type=network_config["network_type"]) project_subnet = openstack_utils.create_project_subnet( neutron_client, project_id, project_network, network_config.get("private_net_cidr"), subnetpool=subnetpool, ip_version=ip_version) openstack_utils.update_subnet_dns(neutron_client, project_subnet, network_config["external_dns"]) openstack_utils.plug_subnet_into_router(neutron_client, network_config["router_name"], project_network, project_subnet) openstack_utils.add_neutron_secgroup_rules(neutron_client, project_id)