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') 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')
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument('-d', '--domain_name', help='DNS Domain Name. ' 'Must end in a .', default='mojo.serverstack.') options = parser.parse_args() domain_name = cli_utils.parse_arg(options, 'domain_name') os_version = openstack_utils.get_current_os_versions( 'keystone')['keystone'] if os_version >= 'queens': designate_api = '2' else: designate_api = '1' keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client(keystone_session) des_client = mojo_os_utils.get_designate_session_client( keystone_session, all_tenants=True, client_version=designate_api) for server in nova_client.servers.list(): for addr_info in server.addresses['private']: if addr_info['OS-EXT-IPS:type'] == 'floating': mojo_os_utils.check_dns_entry( des_client, addr_info['addr'], domain_name, '{}.{}'.format(server.name, domain_name))
def setUpClass(cls): """Run class setup for running tests.""" super(MasakariTest, cls).setUpClass() cls.keystone_session = openstack_utils.get_overcloud_keystone_session() cls.model_name = zaza.model.get_juju_model() cls.nova_client = openstack_utils.get_nova_session_client( cls.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 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)
def setUpClass(cls): """Run class setup for running glance tests.""" cls.keystone_session = openstack_utils.get_overcloud_keystone_session() cls.model_name = model.get_juju_model() cls.nova_client = openstack_utils.get_nova_session_client( cls.keystone_session) cls.neutron_client = openstack_utils.get_neutron_session_client( cls.keystone_session)
def main(argv): cli_utils.setup_logging() keystone_session = openstack_utils.get_overcloud_keystone_session() aodhc = mojo_os_utils.get_aodh_session_client(keystone_session) nova_client = openstack_utils.get_nova_session_client(keystone_session) servers = nova_client.servers.list() assert servers, "No servers available for AODH testing" if servers: alarm_name = 'mojo_instance_off' server = servers[0] assert server.status == 'ACTIVE', "Server {} not active".format( server.name) logging.info('Using server {} for aodh test'.format(server.name)) server = nova_client.servers.find(name=server.name) logging.info('Deleting alarm {} if it exists'.format(alarm_name)) mojo_os_utils.delete_alarm(aodhc, alarm_name, cache_wait=True) logging.info('Creating alarm {}'.format(alarm_name)) alarm_def = { 'type': 'event', 'name': alarm_name, 'description': 'Instance powered OFF', 'alarm_actions': ['log://'], 'ok_actions': ['log://'], 'insufficient_data_actions': ['log://'], 'event_rule': { 'event_type': 'compute.instance.power_off.*', 'query': [{ 'field': 'traits.instance_id', 'op': 'eq', 'type': 'string', 'value': server.id }] } } alarm_info = aodhc.alarm.create(alarm_def) logging.info('Stopping server {}'.format(server.name)) server.stop() for i in range(10): alarm_state = mojo_os_utils.get_alarm_state( aodhc, alarm_info['alarm_id']) if alarm_state == 'alarm': logging.info('Alarm triggered') break else: time.sleep(5) else: raise Exception("Alarm failed to trigger")
def manage_ssh_key(nova_client=None): """Create basic flavors. :param nova_client: Authenticated nova client :type nova_client: novaclient.v2.client.Client """ if not nova_client: keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client( keystone_session) cli_utils.setup_logging() if not openstack_utils.valid_key_exists(nova_client, nova_utils.KEYPAIR_NAME): key = openstack_utils.create_ssh_key( nova_client, nova_utils.KEYPAIR_NAME, replace=True) openstack_utils.write_private_key( nova_utils.KEYPAIR_NAME, key.private_key)
def create_flavors(nova_client=None): """Create basic flavors. :param nova_client: Authenticated nova client :type nova_client: novaclient.v2.client.Client """ if not nova_client: keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client( keystone_session) cli_utils.setup_logging() names = [flavor.name for flavor in nova_client.flavors.list()] for flavor in nova_utils.FLAVORS.keys(): if flavor not in names: nova_client.flavors.create( name=flavor, ram=nova_utils.FLAVORS[flavor]['ram'], vcpus=nova_utils.FLAVORS[flavor]['vcpus'], disk=nova_utils.FLAVORS[flavor]['disk'], flavorid=nova_utils.FLAVORS[flavor]['flavorid'])
def create_segments(segment_number=1, host_assignment_method=None): """Create a masakari segment and populate it with hypervisors. :param segment_number: Number of segments to create :type segment_number: int :param host_assignment_method: Method to use to assign hypervisors to segments :type host_assignment_method: f() """ host_assignment_method = host_assignment_method or ROUND_ROBIN keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client(keystone_session) masakari_client = openstack_utils.get_masakari_session_client( keystone_session) for segment_number in range(0, segment_number): segment_name = 'seg{}'.format(segment_number) logging.info('Creating segment {}'.format(segment_name)) masakari_client.create_segment(name=segment_name, recovery_method='auto', service_type='COMPUTE') HOST_ASSIGNMENT_METHODS[host_assignment_method](nova_client, masakari_client)
def main(): """Cleanup after test run.""" args = parse_args(sys.argv[1:]) keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client(keystone_session) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) instance = nova_client.servers.find(name=args.vm_name) logger.debug("Found vm {} with instance is {}".format( args.vm_name, instance.id)) wait(nova_client, instance.id, args.vm_name) ip = assign_ip(neutron_client, instance.id) logger.debug("Checking ping to {}".format(ip)) openstack_utils.ping_response(ip) logger.debug("Checking ssh to {}".format(ip)) openstack_utils.ssh_test(username='******', ip=ip, vm_name=args.vm_name, password=None, privkey=get_priv_key(args.key_file))
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=180) parser.add_argument("--cloudinit_wait", default=180) parser.add_argument("--ping_wait", default=180) 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) except FileNotFoundError: cacert = None 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(): 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 launch_instance(instance_key, use_boot_volume=False, vm_name=None, private_network_name=None, image_name=None, flavor_name=None, external_network_name=None, meta=None): """Launch an instance. :param instance_key: Key to collect associated config data with. :type instance_key: str :param use_boot_volume: Whether to boot guest from a shared volume. :type use_boot_volume: boolean :param vm_name: Name to give guest. :type vm_name: str :param private_network_name: Name of private network to attach guest to. :type private_network_name: str :param image_name: Image name to use with guest. :type image_name: str :param flavor_name: Flavor name to use with guest. :type flavor_name: str :param external_network_name: External network to create floating ip from for guest. :type external_network_name: str :param meta: A dict of arbitrary key/value metadata to store for this server. Both keys and values must be <=255 characters. :type meta: dict """ keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client(keystone_session) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) # Collect resource information. vm_name = vm_name or time.strftime("%Y%m%d%H%M%S") image_name = image_name or boot_tests[instance_key]['image_name'] image = nova_client.glance.find_image(image_name) flavor_name = flavor_name or boot_tests[instance_key]['flavor_name'] flavor = nova_client.flavors.find(name=flavor_name) private_network_name = private_network_name or "private" net = neutron_client.find_resource("network", private_network_name) nics = [{'net-id': net.get('id')}] meta = meta or {} external_network_name = external_network_name or "ext_net" if use_boot_volume: bdmv2 = [{ 'boot_index': '0', 'uuid': image.id, 'source_type': 'image', 'volume_size': flavor.disk, 'destination_type': 'volume', 'delete_on_termination': True}] image = None else: bdmv2 = None # Launch instance. logging.info('Launching instance {}'.format(vm_name)) instance = nova_client.servers.create( name=vm_name, image=image, block_device_mapping_v2=bdmv2, flavor=flavor, key_name=nova_utils.KEYPAIR_NAME, meta=meta, nics=nics) # Test Instance is ready. logging.info('Checking instance is active') openstack_utils.resource_reaches_status( nova_client.servers, instance.id, expected_status='ACTIVE', stop_after_attempt=16) logging.info('Checking cloud init is complete') openstack_utils.cloud_init_complete( nova_client, instance.id, boot_tests[instance_key]['bootstring']) port = openstack_utils.get_ports_from_device_id( neutron_client, instance.id)[0] logging.info('Assigning floating ip.') ip = openstack_utils.create_floating_ip( neutron_client, external_network_name, port=port)['floating_ip_address'] logging.info('Assigned floating IP {} to {}'.format(ip, vm_name)) openstack_utils.ping_response(ip) # Check ssh'ing to instance. logging.info('Testing ssh access.') openstack_utils.ssh_test( username=boot_tests[instance_key]['username'], ip=ip, vm_name=vm_name, password=boot_tests[instance_key].get('password'), privkey=openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME))
def main(argv): cli_utils.setup_logging() keystone_session = openstack_utils.get_overcloud_keystone_session() novac = openstack_utils.get_nova_session_client(keystone_session) mojo_os_utils.check_guest_connectivity(novac)
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()