def main(): args = parse_args(sys.argv[1:]) cli_utils.setup_logging(log_level=args.loglevel.upper()) #session = zaza_os.get_undercloud_keystone_session() #neutron_client = zaza_os.get_neutron_session_client(session) #nova_client = zaza_os.get_nova_session_client(session, version=2.56) if args.vnic_binding_type == 'dummy': logging.warn('Running in dummy mode') binding_type = None else: binding_type = args.vnic_binding_type if args.action == 'summary': logging.info('Running Summary') summary( zaza_os.get_nova_session_client( zaza_os.get_undercloud_keystone_session(), version=2.56), args.application_name) elif args.action == 'balance': logging.info('Running balance') balance( zaza_os.get_nova_session_client( zaza_os.get_undercloud_keystone_session(), version=2.56), args.application_name) elif args.action == 'advertise': logging.info('Running advertise') advertise( args.application_name) elif args.action == 'listen': logging.info('Running listen') listen( args.application_name, args.cidr, int(args.listener_count))
def test_get_undercloud_keystone_session(self): self.patch_object(openstack_utils, "get_keystone_session") self.patch_object(openstack_utils, "get_undercloud_auth") _auth = "FAKE_AUTH" self.get_undercloud_auth.return_value = _auth openstack_utils.get_undercloud_keystone_session() self.get_keystone_session.assert_called_once_with(_auth, verify=None)
def setUpClass(cls): """Run class setup for running percona-cluster cold start tests.""" super(PerconaClusterColdStartTest, cls).setUpClass() cls.overcloud_keystone_session = ( openstack_utils.get_undercloud_keystone_session()) cls.nova_client = openstack_utils.get_nova_session_client( cls.overcloud_keystone_session)
def __init__(self, prov_net_id=None): try: cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'), 'cacert.pem') os.stat(cacert) except FileNotFoundError: cacert = None keystone_session = openstack_utils.get_undercloud_keystone_session( verify=cacert) neutronc = openstack_utils.get_neutron_session_client( keystone_session) if prov_net_id: net = neutronc.list_networks(id=prov_net_id)['networks'][0] else: net = openstack_utils.get_admin_net(neutronc) subnet_id = net['subnets'][0] subnet = neutronc.list_subnets(id=subnet_id)['subnets'][0] allocation_pools = subnet['allocation_pools'] self.cidr = subnet['cidr'] self.highest_assigned = netaddr.IPAddress(allocation_pools[0]['end']) # XXX look away now, nothing to see here, move along. # If there is less than 30 free ips in the network after the top # dhcp ip then eat into the top of the dhcp range available_ips = [] for element in list(netaddr.IPNetwork(self.cidr)): if element == netaddr.IPAddress(self.highest_assigned) or \ available_ips: available_ips.append(element) if len(available_ips) < 30: self.highest_assigned = self.highest_assigned - 30
def basic_overcloud_network(): """Run setup for neutron networking. Configure the following: The overcloud network using subnet pools """ cli_utils.setup_logging() # Get network configuration settings network_config = {} # Declared overcloud settings network_config.update(OVERCLOUD_NETWORK_CONFIG) # Default undercloud settings network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG) # Environment specific settings network_config.update(generic_utils.get_undercloud_env_vars()) # Deployed model settings if (model.get_application_config('neutron-api').get('enable-dvr').get( 'value')): network_config.update({"dvr_enabled": True}) # Get keystone session keystone_session = openstack_utils.get_overcloud_keystone_session() # Handle network for Openstack-on-Openstack scenarios if juju_utils.get_provider_type() == "openstack": undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session() network.setup_gateway_ext_port(network_config, keystone_session=undercloud_ks_sess) # Confugre the overcloud network network.setup_sdn(network_config, keystone_session=keystone_session)
def basic_overcloud_network(limit_gws=None): """Run setup for neutron networking. Configure the following: The overcloud network using subnet pools :param limit_gws: Limit the number of gateways that get a port attached :type limit_gws: int """ cli_utils.setup_logging() # Get network configuration settings network_config = {} # Declared overcloud settings network_config.update(OVERCLOUD_NETWORK_CONFIG) # Default undercloud settings network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG) # Environment specific settings network_config.update(generic_utils.get_undercloud_env_vars()) # Get keystone session keystone_session = openstack_utils.get_overcloud_keystone_session() # Handle network for Openstack-on-Openstack scenarios if juju_utils.get_provider_type() == "openstack": undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session() network.setup_gateway_ext_port(network_config, keystone_session=undercloud_ks_sess, limit_gws=None) # Confugre the overcloud network network.setup_sdn(network_config, keystone_session=keystone_session)
def setUpClass(cls): """Run class setup for running percona-cluster cold start tests.""" super().setUpClass() cls.application = "mysql-innodb-cluster" cls.overcloud_keystone_session = ( openstack_utils.get_undercloud_keystone_session()) cls.nova_client = openstack_utils.get_nova_session_client( cls.overcloud_keystone_session)
def setup_gateway_ext_port(network_config, keystone_session=None, limit_gws=None, use_juju_wait=True): """Perform setup external port on Neutron Gateway. For OpenStack on OpenStack scenarios. :param network_config: Network configuration dictionary :type network_config: dict :param keystone_session: Keystone session object for undercloud :type keystone_session: keystoneauth1.session.Session object :param limit_gws: Limit the number of gateways that get a port attached :type limit_gws: Optional[int] :param use_juju_wait: Use juju wait (default True) for model to settle :type use_juju_wait: boolean :returns: None :rtype: None """ # If a session has not been provided, acquire one if not keystone_session: keystone_session = openstack_utils.get_undercloud_keystone_session() # Get authenticated clients nova_client = openstack_utils.get_nova_session_client(keystone_session) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) # Add an interface to the neutron-gateway units and tell juju to use it # as the external port. if "net_id" in network_config.keys(): net_id = network_config["net_id"] else: net_id = None try: # If we're using netplan, we need to add the new interface to the guest current_release = openstack_utils.get_os_release() bionic_queens = openstack_utils.get_os_release('bionic_queens') if current_release >= bionic_queens: logging.warn("Adding second interface for dataport to guest " "netplan for bionic-queens and later") add_dataport_to_netplan = True else: add_dataport_to_netplan = False except zaza.openstack.utilities.exceptions.ApplicationNotFound: # The setup_gateway_ext_port helper may be used with non-OpenStack # workloads. add_dataport_to_netplan = False logging.info("Configuring network for OpenStack undercloud/provider") openstack_utils.configure_gateway_ext_port( nova_client, neutron_client, net_id=net_id, add_dataport_to_netplan=add_dataport_to_netplan, limit_gws=limit_gws, use_juju_wait=use_juju_wait)
def main(argv): cli_utils.setup_logging() logging.getLogger("urllib3").setLevel(logging.WARNING) keystone_session_uc = openstack_utils.get_undercloud_keystone_session() under_novac = openstack_utils.get_nova_session_client(keystone_session_uc) keystone_session_oc = openstack_utils.get_overcloud_keystone_session() clients = { 'neutron': openstack_utils.get_neutron_session_client(keystone_session_oc), 'nova': openstack_utils.get_nova_session_client(keystone_session_oc), 'glance': mojo_os_utils.get_glance_session_client(keystone_session_oc), } image_file = mojo_utils.get_mojo_file('images.yaml') image_config = generic_utils.get_yaml_config(image_file) image_password = image_config['cirros']['password'] # Look for existing Cirros guest server, ip = get_cirros_server(clients, image_password) router = (clients['neutron'].list_routers( name='provider-router')['routers'][0]) l3_agents = clients['neutron'].list_l3_agent_hosting_routers( router=router['id'])['agents'] logging.info('Checking there are multiple L3 agents running tenant router') if len(l3_agents) != 2: raise Exception('Unexpected number of l3 agents') series = os.environ.get("MOJO_SERIES") for agent in l3_agents: gateway_hostname = agent['host'] gateway_server = under_novac.servers.find(name=gateway_hostname) logging.info('Shutting down neutron gateway {} ({})'.format( gateway_hostname, gateway_server.id)) gateway_server.stop() if not check_server_state( under_novac, 'SHUTOFF', server_name=gateway_hostname): raise Exception('Server failed to reach SHUTOFF state') logging.info('Neutron gateway %s has shutdown' % (gateway_hostname)) logging.info('Checking connectivity to cirros guest') if not mojo_os_utils.wait_for_ping(ip, 90): raise Exception('Cirros guest not responding to ping') if not mojo_os_utils.ssh_test( 'cirros', ip, server.name, password=image_password): raise Exception('Cirros guest issh connection failed') logging.info('Starting neutron gateway: ' + gateway_hostname) gateway_server.start() if not check_server_state( under_novac, 'ACTIVE', server_name=gateway_hostname): raise Exception('Server failed to reach SHUTOFF state') if not check_neutron_agent_states(clients['neutron'], gateway_hostname): raise Exception('Server agents failed to reach active state') if series == "xenial": logging.info( "Concluding tests as rebooting a xenial guest can cause " "network interfaces to be renamed which breaks the " "gateway") return
def basic_overcloud_network(limit_gws=None): """Run setup for neutron networking. Configure the following: The overcloud network using subnet pools :param limit_gws: Limit the number of gateways that get a port attached :type limit_gws: int """ cli_utils.setup_logging() # Get network configuration settings network_config = {} # Declared overcloud settings network_config.update(OVERCLOUD_NETWORK_CONFIG) # Default undercloud settings network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG) # Environment specific settings network_config.update(generic_utils.get_undercloud_env_vars()) # Get keystone session keystone_session = openstack_utils.get_overcloud_keystone_session() # Get optional use_juju_wait for netw ork option options = (lifecycle_utils .get_charm_config(fatal=False) .get('configure_options', {})) use_juju_wait = options.get( 'configure_gateway_ext_port_use_juju_wait', True) # Handle network for OpenStack-on-OpenStack scenarios provider_type = juju_utils.get_provider_type() if provider_type == "openstack": undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session() network.setup_gateway_ext_port(network_config, keystone_session=undercloud_ks_sess, limit_gws=limit_gws, use_juju_wait=use_juju_wait) elif provider_type == "maas": # NOTE(fnordahl): After validation of the MAAS+Netplan Open vSwitch # integration support, we would most likely want to add multiple modes # of operation with MAAS. # # Perform charm based OVS configuration openstack_utils.configure_charmed_openstack_on_maas( network_config, limit_gws=limit_gws) else: logging.warning('Unknown Juju provider type, "{}", will not perform' ' charm network configuration.' .format(provider_type)) # Confugre the overcloud network network.setup_sdn(network_config, keystone_session=keystone_session)
def setup_gateway_ext_port(network_config, keystone_session=None): """Perform setup external port on Neutron Gateway. For OpenStack on OpenStack scenarios. :param network_config: Network configuration dictionary :type network_config: dict :param keystone_session: Keystone session object for undercloud :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_undercloud_keystone_session() # Get authenticated clients nova_client = openstack_utils.get_nova_session_client(keystone_session) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) # Add an interface to the neutron-gateway units and tell juju to use it # as the external port. if "net_id" in network_config.keys(): net_id = network_config["net_id"] else: net_id = None # If we're using netplan, we need to add the new interface to the guest current_release = openstack_utils.get_os_release() bionic_queens = openstack_utils.get_os_release('bionic_queens') if current_release >= bionic_queens: logging.warn("Adding second interface for dataport to guest netplan " "for bionic-queens and later") add_dataport_to_netplan = True else: add_dataport_to_netplan = False logging.info("Configuring network for OpenStack undercloud/provider") openstack_utils.configure_gateway_ext_port( nova_client, neutron_client, dvr_mode=network_config.get("dvr_enabled", False), net_id=net_id, add_dataport_to_netplan=add_dataport_to_netplan)
def test_gateway_failure(self): """Validate networking in the case of a gateway failure.""" instance_1, instance_2 = self.retrieve_guests() if not all([instance_1, instance_2]): self.launch_guests() instance_1, instance_2 = self.retrieve_guests() self.check_connectivity(instance_1, instance_2) routers = self.neutron_client.list_routers( name='provider-router')['routers'] assert len(routers) == 1, "Unexpected router count {}".format( len(routers)) provider_router = routers[0] l3_agents = self.neutron_client.list_l3_agent_hosting_routers( router=provider_router['id'])['agents'] logging.info( 'Checking there are multiple L3 agents running tenant router') assert len(l3_agents) == 2, "Unexpected l3 agent count {}".format( len(l3_agents)) uc_ks_session = openstack_utils.get_undercloud_keystone_session() uc_nova_client = openstack_utils.get_nova_session_client(uc_ks_session) uc_neutron_client = openstack_utils.get_neutron_session_client( uc_ks_session) for agent in l3_agents: gateway_hostname = agent['host'] gateway_server = uc_nova_client.servers.find(name=gateway_hostname) logging.info("Shutting down {}".format(gateway_hostname)) gateway_server.stop() self.check_server_state( uc_nova_client, 'SHUTOFF', server_name=gateway_hostname) self.check_connectivity(instance_1, instance_2) gateway_server.start() self.check_server_state( uc_nova_client, 'ACTIVE', server_name=gateway_hostname) self.check_neutron_agent_up( uc_neutron_client, gateway_hostname) self.check_connectivity(instance_1, instance_2)
def main(): args = parse_args(sys.argv[1:]) cli_utils.setup_logging(log_level=args.loglevel.upper()) session = zaza_os.get_undercloud_keystone_session() neutron_client = zaza_os.get_neutron_session_client(session) nova_client = zaza_os.get_nova_session_client(session) if args.vnic_binding_type == 'dummy': logging.warning('Running in dummy mode') binding_type = None else: binding_type = args.vnic_binding_type if args.action == 'cleanup': logging.info('Running cleanup') cleanup(nova_client, neutron_client, args.network_name, args.application_name) elif args.action == 'add-ports': logging.info('Adding ports') create_ports(nova_client, neutron_client, args.network_name, args.application_name, binding_type, shutdown_move=True) logging.info('Adding to netplan') add_port_to_netplan(neutron_client, args.network_name, args.application_name) elif args.action == 'add-servers': add_servers(nova_client, neutron_client, args.network_name, args.number_of_units, args.flavor, args.image_name, vnic_type=binding_type, port_security_enabled=args.enable_port_security) elif args.action == 'add-manual-cloud': add_cloud(nova_client) elif args.action == 'add-machines': add_machines(nova_client)
def run_from_cli(**kwargs): """Run network configurations from CLI. Use a YAML file of network configuration settings to configure the overcloud network. YAML file of the form: topology_name: network_type: gre router_name: provider-router private_net_cidr: 192.168.21.0/24 external_dns: 10.5.0.2 external_net_cidr: 10.5.0.0/16 external_net_name: ext_net external_subnet_name: ext_net_subnet default_gateway: 10.5.0.1 start_floating_ip: 10.5.150.0 end_floating_ip: 10.5.200.254 :param kwargs: Allow for override of argparse options :returns: None :rtype: None """ cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("net_topology", help="network topology type, default is GRE", default="gre", nargs="?") parser.add_argument("--ignore_env_vars", "-i", help="do not override using environment variables", action="store_true", default=False) parser.add_argument("--net_topology_file", "-f", help="Network topology file location", default="network.yaml") parser.add_argument("--cacert", help="Path to CA certificate bundle file", default=None) parser.add_argument("--no-use-juju-wait", help=("don't use juju wait for the model to settle " "(default true)"), action="store_false", default=True) # Handle CLI options options = parser.parse_args() net_topology = (kwargs.get('net_toplogoy') or cli_utils.parse_arg(options, "net_topology")) net_topology_file = (kwargs.get('net_topology_file') or cli_utils.parse_arg(options, "net_topology_file")) ignore_env_vars = (kwargs.get('ignore_env_vars') or cli_utils.parse_arg(options, "ignore_env_vars")) cacert = (kwargs.get('cacert') or cli_utils.parse_arg(options, "cacert")) logging.info("Setting up %s network" % (net_topology)) network_config = generic_utils.get_network_config(net_topology, ignore_env_vars, net_topology_file) # Handle network for OpenStack-on-OpenStack scenarios if juju_utils.get_provider_type() == "openstack": undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session( verify=cacert) setup_gateway_ext_port(network_config, keystone_session=undercloud_ks_sess, use_juju_wait=cli_utils.parse_arg( options, 'no_use_juju_wait')) overcloud_ks_sess = openstack_utils.get_overcloud_keystone_session( verify=cacert) setup_sdn(network_config, keystone_session=overcloud_ks_sess)
def delete_unit_openstack(unit): keystone_session = openstack_utils.get_undercloud_keystone_session() nc = openstack_utils.get_nova_session_client(keystone_session) server_id = convert_unit_to_machineno(unit) server = nc.servers.find(id=server_id) server.delete()