def add_lts_image(glance_client=None, image_name=None, release=None): """Add an Ubuntu LTS image to the current deployment. :param glance: Authenticated glanceclient :type glance: glanceclient.Client :param image_name: Label for the image in glance :type image_name: str :param release: Name of ubuntu release. :type release: str """ image_name = image_name or LTS_IMAGE_NAME release = release or LTS_RELEASE if not glance_client: keystone_session = openstack_utils.get_overcloud_keystone_session() glance_client = openstack_utils.get_glance_session_client( keystone_session) if openstack_utils.get_images_by_name(glance_client, image_name): logging.warning('Using existing glance image') else: image_url = openstack_utils.find_ubuntu_image( release=release, arch='amd64') openstack_utils.create_image( glance_client, image_url, image_name)
def add_image(image_url, glance_client=None, image_name=None, tags=[]): """Retrieve image from ``image_url`` and add it to glance. :param image_url: Retrievable URL with image data :type image_url: str :param glance: Authenticated glanceclient :type glance: glanceclient.Client :param image_name: Label for the image in glance :type image_name: str :param tags: List of tags to add to image :type tags: list of str """ if not glance_client: keystone_session = openstack_utils.get_overcloud_keystone_session() glance_client = openstack_utils.get_glance_session_client( keystone_session) if image_name: image = openstack_utils.get_images_by_name(glance_client, image_name) if image: logging.warning('Using existing glance image "{}" ({})'.format( image_name, image[0].id)) else: logging.info('Downloading image {}'.format(image_name or image_url)) openstack_utils.create_image(glance_client, image_url, image_name, tags=tags)
def setUpClass(cls): """Run class setup for running tests.""" super(Cinder{{ cookiecutter.driver_name }}Test, cls).setUpClass() cls.keystone_session = openstack_utils.get_overcloud_keystone_session() cls.model_name = zaza.model.get_juju_model() cls.cinder_client = openstack_utils.get_cinder_session_client( cls.keystone_session)
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 setUpClass(cls): """Run setup for test class to create common resourcea.""" cls.keystone_session = openstack_utils.get_overcloud_keystone_session() cls.model_name = model.get_juju_model() cls.test_config = lifecycle_utils.get_charm_config() cls.application_name = cls.test_config['charm_name'] cls.lead_unit = model.get_lead_unit_name(cls.application_name, model_name=cls.model_name) logging.debug('Leader unit is {}'.format(cls.lead_unit))
def _v2(): keystone_session = openstack_utils.get_overcloud_keystone_session() keystone_client = openstack_utils.get_keystone_session_client( keystone_session, client_api_version=2) tenant = keystone_client.tenants.create(tenant_name=DEMO_TENANT, description='Demo Tenant', enabled=True) keystone_client.users.create(name=DEMO_USER, password=DEMO_PASSWORD, tenant_id=tenant.id)
def main(argv): cli_utils.setup_logging() # Setup client keystone_session = openstack_utils.get_overcloud_keystone_session() os_version = openstack_utils.get_current_os_versions( 'keystone')['keystone'] if os_version >= 'queens': designate_api_version = '2' else: designate_api_version = '1' client = mojo_os_utils.get_designate_session_client( keystone_session, client_version=designate_api_version) designate_api_version = 2 zone = mojo_os_utils.create_or_return_zone( client, TEST_DOMAIN, TEST_DOMAIN_EMAIL) mojo_os_utils.create_or_return_recordset( client, zone['id'], 'www', 'A', [TEST_RECORD[TEST_WWW_RECORD]]) # Test record is in bind and designate mojo_os_utils.check_dns_entry( client, TEST_RECORD[TEST_WWW_RECORD], TEST_DOMAIN, record_name=TEST_WWW_RECORD, designate_api=designate_api_version) mojo_utils.add_unit('designate-bind') mojo_os_utils.check_dns_entry( client, TEST_RECORD[TEST_WWW_RECORD], TEST_DOMAIN, record_name=TEST_WWW_RECORD, designate_api=designate_api_version) mojo_utils.delete_oldest('designate-bind') mojo_os_utils.check_dns_entry( client, TEST_RECORD[TEST_WWW_RECORD], TEST_DOMAIN, record_name=TEST_WWW_RECORD, designate_api=designate_api_version)
def _v3(): keystone_session = openstack_utils.get_overcloud_keystone_session() keystone_client = openstack_utils.get_keystone_session_client( keystone_session) domain = keystone_client.domains.create( DEMO_DOMAIN, description='Demo Domain', enabled=True) project = keystone_client.projects.create( DEMO_PROJECT, domain, description='Demo Project', enabled=True) demo_user = keystone_client.users.create( DEMO_USER, domain=domain, project=project, password=DEMO_PASSWORD, email='*****@*****.**', description='Demo User', enabled=True) member_role = keystone_client.roles.find(name='Member') keystone_client.roles.grant( member_role, user=demo_user, project_domain=domain, project=project) demo_admin_user = keystone_client.users.create( DEMO_ADMIN_USER, domain=domain, project=project, password=DEMO_ADMIN_USER_PASSWORD, email='*****@*****.**', description='Demo Admin User', enabled=True) admin_role = keystone_client.roles.find(name='Admin') keystone_client.roles.grant( admin_role, user=demo_admin_user, domain=domain) keystone_client.roles.grant( member_role, user=demo_admin_user, project_domain=domain, project=project) keystone_client.roles.grant( admin_role, user=demo_admin_user, project_domain=domain, project=project)
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 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 test_bgp_routes(peer_application_name="quagga", keystone_session=None): """Test BGP routes. :param peer_application_name: String name of BGP peer application :type peer_application_name: string :param keystone_session: Keystone session object for overcloud :type keystone_session: keystoneauth1.session.Session object :raises: AssertionError if expected BGP routes are not found :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 neutron_client = openstack_utils.get_neutron_session_client( keystone_session) # Get the peer unit peer_unit = model.get_units(peer_application_name)[0].entity_id # Get expected advertised routes private_cidr = neutron_client.list_subnets( name="private_subnet")["subnets"][0]["cidr"] floating_ip_cidr = "{}/32".format( neutron_client.list_floatingips()["floatingips"][0] ["floating_ip_address"]) # This test may run immediately after configuration. It may take time for # routes to propogate via BGP. Do a binary backoff. @tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60), reraise=True, stop=tenacity.stop_after_attempt(8)) def _assert_cidr_in_peer_routing_table(peer_unit, cidr): logging.debug("Checking for {} on BGP peer {}".format(cidr, peer_unit)) # Run show ip route bgp on BGP peer routes = juju_utils.remote_run( peer_unit, remote_cmd='vtysh -c "show ip route bgp"') logging.debug(routes) assert cidr in routes, ( "CIDR, {}, not found in BGP peer's routing table".format(cidr)) _assert_cidr_in_peer_routing_table(peer_unit, private_cidr) logging.info( "Private subnet CIDR, {}, found in routing table".format(private_cidr)) _assert_cidr_in_peer_routing_table(peer_unit, floating_ip_cidr) logging.info("Floating IP CIDR, {}, found in routing table".format( floating_ip_cidr))
def setUpClass(cls): """Run class setup for running Keystone charm operation tests.""" super(BaseKeystoneTest, cls).setUpClass() cls.keystone_ips = zaza.model.get_app_ips('keystone') if (openstack_utils.get_os_release() < openstack_utils.get_os_release('xenial_queens')): cls.default_api_version = '2' else: cls.default_api_version = '3' cls.admin_keystone_session = ( openstack_utils.get_overcloud_keystone_session()) cls.admin_keystone_client = ( openstack_utils.get_keystone_session_client( cls.admin_keystone_session, client_api_version=cls.default_api_version))
def test_tunnel_datapath(self): """From ports list, connect to unit in one end, ping other end(s).""" keystone_session = openstack_utils.get_overcloud_keystone_session() neutron_client = openstack_utils.get_neutron_session_client( keystone_session) resp = neutron_client.list_ports() ports = resp['ports'] host_port = {} for port in ports: if (port['device_owner'].startswith('network:') or port['device_owner'].startswith('compute:')): continue host_port[port['binding:host_id']] = port for unit in zaza.model.get_units('neutron-openvswitch'): result = zaza.model.run_on_unit(unit.entity_id, 'hostname') hostname = result['Stdout'].rstrip() if hostname not in host_port: # no port bound to this host, skip continue # get interface name from unit OVS data ovs_interface = json.loads( zaza.model.run_on_unit( unit.entity_id, 'ovs-vsctl -f json find Interface ' 'external_ids:iface-id={}'.format( host_port[hostname]['id']))['Stdout']) for (idx, heading) in enumerate(ovs_interface['headings']): if heading == 'name': break else: raise Exception('Unable to find interface name from OVS') interface_name = ovs_interface['data'][0][idx] ip_unit = zaza.model.run_on_unit( unit.entity_id, 'ip addr show dev {}'.format(interface_name)) for other_host in (set(host_port) - set([hostname])): for ip_info in host_port[other_host]['fixed_ips']: logging.info('Local IP info: "{}"'.format(ip_unit)) logging.info('PING "{}" --> "{}"...'.format( hostname, other_host)) result = zaza.model.run_on_unit( unit.entity_id, 'ping -c 3 {}'.format(ip_info['ip_address'])) logging.info(result['Stdout']) if result['Code'] == '1': raise Exception('FAILED')
def keystone_federation_setup(): """Configure Keystone Federation.""" cli_utils.setup_logging() keystone_session = openstack_utils.get_overcloud_keystone_session() keystone_client = openstack_utils.get_keystone_session_client( keystone_session) try: domain = keystone_client.domains.find(name=FEDERATED_DOMAIN) except keystoneauth1.exceptions.http.NotFound: domain = keystone_client.domains.create(FEDERATED_DOMAIN, description="Federated Domain", enabled=True) try: group = keystone_client.groups.find(name=FEDERATED_GROUP, domain=domain) except keystoneauth1.exceptions.http.NotFound: group = keystone_client.groups.create(FEDERATED_GROUP, domain=domain, enabled=True) role = keystone_client.roles.find(name=MEMBER) keystone_client.roles.grant(role, group=group, domain=domain) try: idp = keystone_client.federation.identity_providers.find( name=IDP, domain_id=domain.id) except keystoneauth1.exceptions.http.NotFound: idp = keystone_client.federation.identity_providers.create( IDP, remote_ids=[REMOTE_ID], domain_id=domain.id, enabled=True) JSON_RULES = json.loads(MAP_TEMPLATE.format(domain_id=domain.id)) try: keystone_client.federation.mappings.find(name=MAP_NAME) except keystoneauth1.exceptions.http.NotFound: keystone_client.federation.mappings.create(MAP_NAME, rules=JSON_RULES) try: keystone_client.federation.protocols.get(IDP, PROTOCOL_NAME) except keystoneauth1.exceptions.http.NotFound: keystone_client.federation.protocols.create(PROTOCOL_NAME, mapping=MAP_NAME, identity_provider=idp)
def test_multisite_failover(self): """Verify object storage failover/failback. Verify that the slave radosgw can be promoted to master status """ if not self.multisite: raise unittest.SkipTest('Skipping multisite failover test') logging.info('Checking multisite failover/failback') keystone_session = zaza_openstack.get_overcloud_keystone_session() source_client = zaza_openstack.get_swift_session_client( keystone_session, region_name='east-1') target_client = zaza_openstack.get_swift_session_client( keystone_session, region_name='west-1') zaza_model.run_action_on_leader( 'slave-ceph-radosgw', 'promote', action_params={}, ) _container = 'demo-container-for-failover' _test_data = 'Test data from Zaza on Slave' target_client.put_container(_container) target_client.put_object(_container, 'testfile', contents=_test_data, content_type='text/plain') _, target_content = target_client.get_object(_container, 'testfile') zaza_model.run_action_on_leader( 'ceph-radosgw', 'promote', action_params={}, ) @tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60), reraise=True, stop=tenacity.stop_after_attempt(12)) def _source_get_object(): return source_client.get_object(_container, 'testfile') _, source_content = _source_get_object() self.assertEqual(target_content.decode('UTF-8'), source_content.decode('UTF-8'))
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("router", nargs="?") options = parser.parse_args() router_name = cli_utils.parse_arg(options, 'router') 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) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) router = neutron_client.list_routers(name=router_name)['routers'][0]['id'] l3_agent = neutron_client.list_l3_agent_hosting_routers(router=router) hosting_machine = l3_agent['agents'][0]['host'] mojo_utils.delete_machine(hosting_machine)
def test_object_storage_multisite(self): """Verify object storage replication. Verify that the object storage replication works as expected. """ if not self.multisite: raise unittest.SkipTest('Skipping multisite replication test') logging.info('Checking multisite replication') keystone_session = zaza_openstack.get_overcloud_keystone_session() source_client = zaza_openstack.get_swift_session_client( keystone_session, region_name='east-1') _container = 'demo-container' _test_data = 'Test data from Zaza' source_client.put_container(_container) source_client.put_object(_container, 'testfile', contents=_test_data, content_type='text/plain') _, source_content = source_client.get_object(_container, 'testfile') self.assertEqual(source_content.decode('UTF-8'), _test_data) target_client = zaza_openstack.get_swift_session_client( keystone_session, region_name='east-1') @tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60), reraise=True, stop=tenacity.stop_after_attempt(12)) def _target_get_object(): return target_client.get_object(_container, 'testfile') _, target_content = _target_get_object() self.assertEqual(target_content.decode('UTF-8'), source_content.decode('UTF-8')) target_client.delete_object(_container, 'testfile') try: source_client.head_object(_container, 'testfile') except ClientException as e: self.assertEqual(e.http_status, 404) else: self.fail('object not deleted on source radosgw')
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 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 add_cirros_image(glance_client=None, image_name=None): """Add a cirros image to the current deployment. :param glance: Authenticated glanceclient :type glance: glanceclient.Client :param image_name: Label for the image in glance :type image_name: str """ image_name = image_name or CIRROS_IMAGE_NAME if not glance_client: keystone_session = openstack_utils.get_overcloud_keystone_session() glance_client = openstack_utils.get_glance_session_client( keystone_session) if openstack_utils.get_images_by_name(glance_client, image_name): logging.warning('Using existing glance image') else: image_url = openstack_utils.find_cirros_image(arch='x86_64') openstack_utils.create_image( glance_client, image_url, image_name)
def enable_hosts(masakari_client=None): """Enable all hypervisors within masakari. Enable all hosts across all segments within masakari. This does not enable the hypervisor from a nova POV. :param masakari_client: Authenticated masakari client :type masakari_client: openstack.instance_ha.v1._proxy.Proxy """ if not masakari_client: keystone_session = openstack_utils.get_overcloud_keystone_session() masakari_client = openstack_utils.get_masakari_session_client( keystone_session) for segment in masakari_client.segments(): for host in masakari_client.hosts(segment_id=segment.uuid): if host.on_maintenance: logging.info("Removing maintenance mode from masakari " "host {}".format(host.uuid)) masakari_client.update_host(host.uuid, segment_id=segment.uuid, **{'on_maintenance': False})
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 test_object_storage(self): """Verify object storage API. Verify that the object storage API works as expected. """ if self.multisite: raise unittest.SkipTest('Skipping REST API test, ' 'multisite configuration') logging.info('Checking Swift REST API') keystone_session = zaza_openstack.get_overcloud_keystone_session() region_name = 'RegionOne' swift_client = zaza_openstack.get_swift_session_client( keystone_session, region_name) _container = 'demo-container' _test_data = 'Test data from Zaza' swift_client.put_container(_container) swift_client.put_object(_container, 'testfile', contents=_test_data, content_type='text/plain') _, content = swift_client.get_object(_container, 'testfile') self.assertEqual(content.decode('UTF-8'), _test_data)
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 keystone_v3_domain_setup(): overcloud_novarc = openstack_utils.get_overcloud_auth() if overcloud_novarc.get('API_VERSION', 2) == 3: 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) keystone_client = openstack_utils.get_keystone_session_client( keystone_session) mojo_os_utils.project_create(keystone_client, ['admin'], 'admin_domain') admin_project_id = openstack_utils.get_project_id( keystone_client, 'admin', api_version=3, domain_name='admin_domain') role = keystone_client.roles.find(name='admin') user = keystone_client.users.find(name='admin') keystone_client.roles.grant(role, user=user, project=admin_project_id)
def overlay_network(): """Create network with subnets, add OVS port per unit. Useful for testing that the `neutron-openvswitch` charm configures the system, LXD profiles etc in such a way that the Neutron OpenvSwitch agent is able to perform the required OVS configuration. """ keystone_session = openstack_utils.get_overcloud_keystone_session() neutron_client = openstack_utils.get_neutron_session_client( keystone_session) resp = neutron_client.create_network( {'network': { 'name': 'zaza-neutron-openvswitch-network' }}) network = resp['network'] logging.info('created network {}'.format(pprint.pformat(network))) # make rfc4193 Unique Local IPv6 Unicast Addresses from network UUID rfc4193_addr = 'fc00' for n in [0, 4, 8]: rfc4193_addr += ':' + network['id'].split('-')[4][n:n + 4] rfc4193_addr += '::/64' resp = neutron_client.create_subnet({ 'subnets': [ { 'name': 'zaza-neutron-openvswitch-subnet', 'ip_version': 4, 'cidr': '10.42.42.0/24', 'network_id': network['id'], }, { 'name': 'zaza-neutron-openvswitch-subnetv6', 'ip_version': 6, 'ipv6_address_mode': 'slaac', 'ipv6_ra_mode': 'slaac', 'cidr': rfc4193_addr, 'network_id': network['id'], }, ], }) logging.info('created subnets {}'.format(pprint.pformat(resp['subnets']))) for unit in zaza.model.get_units('neutron-openvswitch'): result = zaza.model.run_on_unit(unit.entity_id, 'hostname') hostname = result['Stdout'].rstrip() logging.info('hostname: "{}"'.format(hostname)) resp = neutron_client.create_port({ 'port': { 'binding:host_id': hostname, 'device_owner': 'Zaza:neutron-openvswitch-test', 'name': hostname, 'network_id': network['id'], }, }) port = resp['port'] logging.info('created port {}'.format(pprint.pformat(port))) result = zaza.model.run_on_unit( unit.entity_id, 'ovs-vsctl -- --may-exist add-port br-int zaza0 ' '-- set Interface zaza0 type=internal ' '-- set Interface zaza0 external-ids:iface-status=active ' '-- set Interface zaza0 external-ids:attached-mac={} ' '-- set Interface zaza0 external-ids:iface-id={} ' '-- set Interface zaza0 external-ids:skip_cleanup=true '.format( port['mac_address'], port['id'])) logging.info('do ovs configuration {}'.format(pprint.pformat(result))) result = zaza.model.run_on_unit( unit.entity_id, 'ip link set dev zaza0 address {} up'.format(port['mac_address'])) logging.info('ip link {}'.format(pprint.pformat(result))) for ip_info in port['fixed_ips']: # NOTE(fnordahl) overly simplified but is sufficient for test if ':' in ip_info['ip_address']: bits = '64' else: bits = '24' result = zaza.model.run_on_unit( unit.entity_id, 'ip addr add {}/{} dev zaza0'.format(ip_info['ip_address'], bits)) logging.info('ip addr add {}'.format(pprint.pformat(result)))
def setup_bgp_speaker(peer_application_name, keystone_session=None): """Perform BGP Speaker setup. :param peer_application_name: String name of BGP peer application :type peer_application_name: string :param keystone_session: Keystone session object for overcloud :type keystone_session: keystoneauth1.session.Session object :returns: None :rtype: None """ # Get ASNs from deployment dr_relation = juju_utils.get_relation_from_unit( 'neutron-dynamic-routing', peer_application_name, 'bgpclient') peer_asn = dr_relation.get('asn') logging.debug('peer ASn: "{}"'.format(peer_asn)) peer_relation = juju_utils.get_relation_from_unit( peer_application_name, 'neutron-dynamic-routing', 'bgp-speaker') dr_asn = peer_relation.get('asn') logging.debug('our ASn: "{}"'.format(dr_asn)) # If a session has not been provided, acquire one if not keystone_session: keystone_session = openstack_utils.get_overcloud_keystone_session() # Get authenticated clients neutron_client = openstack_utils.get_neutron_session_client( keystone_session) # Create BGP speaker logging.info("Setting up BGP speaker") bgp_speaker = openstack_utils.create_bgp_speaker( neutron_client, local_as=dr_asn) # Add networks to bgp speaker logging.info("Advertising BGP routes") openstack_utils.add_network_to_bgp_speaker( neutron_client, bgp_speaker, EXT_NET) openstack_utils.add_network_to_bgp_speaker( neutron_client, bgp_speaker, PRIVATE_NET) logging.debug("Advertised routes: {}" .format( neutron_client.list_route_advertised_from_bgp_speaker( bgp_speaker["id"]))) # Create peer logging.info("Setting up BGP peer") bgp_peer = openstack_utils.create_bgp_peer(neutron_client, peer_application_name, remote_as=peer_asn) # Add peer to bgp speaker logging.info("Adding BGP peer to BGP speaker") openstack_utils.add_peer_to_bgp_speaker( neutron_client, bgp_speaker, bgp_peer) # Create Floating IP to advertise logging.info("Creating floating IP to advertise") port = openstack_utils.create_port(neutron_client, FIP_TEST, PRIVATE_NET) floating_ip = openstack_utils.create_floating_ip(neutron_client, EXT_NET, port=port) logging.info( "Advertised floating IP: {}".format( floating_ip["floating_ip_address"])) # NOTE(fnordahl): As a workaround for LP: #1784083 remove BGP speaker from # dragent and add it back. logging.info( "Waiting for Neutron agent 'neutron-bgp-dragent' to appear...") keystone_session = openstack_utils.get_overcloud_keystone_session() neutron_client = openstack_utils.get_neutron_session_client( keystone_session) agents = openstack_utils.neutron_agent_appears(neutron_client, 'neutron-bgp-dragent') agent_id = None for agent in agents.get('agents', []): agent_id = agent.get('id', None) if agent_id is not None: break logging.info( 'Waiting for BGP speaker to appear on agent "{}"...'.format(agent_id)) bgp_speakers = openstack_utils.neutron_bgp_speaker_appears_on_agent( neutron_client, agent_id) logging.info( "Removing and adding back bgp-speakers to agent (LP: #1784083)...") while True: try: for bgp_speaker in bgp_speakers.get('bgp_speakers', []): bgp_speaker_id = bgp_speaker.get('id', None) logging.info('removing "{}" from "{}"' ''.format(bgp_speaker_id, agent_id)) neutron_client.remove_bgp_speaker_from_dragent( agent_id, bgp_speaker_id) except neutronclient.common.exceptions.NotFound as e: logging.info('Exception: "{}"'.format(e)) break neutron_client.add_bgp_speaker_to_dragent( agent_id, {'bgp_speaker_id': bgp_speaker_id})
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument('-r', '--resolver', help='Resolver address. ' 'Usually designate-bind address.', required=False) parser.add_argument('-d', '--domain_name', help='DNS Domain Name. ' 'Must end in a .', default='mojo.serverstack.') parser.add_argument('-e', '--email', help='Email address', default='*****@*****.**') parser.add_argument('-b', '--bind-service', help='Bind Service Name', default='designate-bind') options = parser.parse_args() bind_service_name = cli_utils.parse_arg(options, 'bind_service') resolver = cli_utils.parse_arg(options, 'resolver') bind_unit = mojo_utils.get_juju_units(bind_service_name)[0] if not resolver: resolver = mojo_utils.get_juju_unit_ip(bind_unit) domain_name = cli_utils.parse_arg(options, 'domain_name') email = cli_utils.parse_arg(options, 'email') nameserver = 'ns1.{}'.format(domain_name) logging.info('Setting up designate {} {}'.format(nameserver, resolver)) os_version = openstack_utils.get_current_os_versions( 'keystone')['keystone'] 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) neutronc = openstack_utils.get_neutron_session_client(keystone_session) if os_version >= 'queens': designatec = mojo_os_utils.get_designate_session_client( keystone_session, client_version='2') zone = mojo_os_utils.create_or_return_zone(designatec, domain_name, email) mojo_os_utils.create_or_return_recordset(designatec, zone['id'], 'www', 'A', [resolver]) else: designatec = mojo_os_utils.get_designate_session_client( keystone_session, client_version='1') if not mojo_os_utils.get_designate_server_id(designatec, nameserver): logging.info('Creating server {}'.format(nameserver)) server = Server(name=nameserver) server_id = designatec.servers.create(server) assert (server_id is not None) else: logging.info('{} server already exists.'.format(nameserver)) domain_id = mojo_os_utils.get_designate_domain_id( designatec, domain_name) if not domain_id: logging.info('Creating domain {}'.format(domain_name)) domain = Domain(name=domain_name, email=email) domain_id = designatec.domains.create(domain) assert (domain_id is not None) else: logging.info('{} domain already exists.'.format(domain_name)) if not mojo_os_utils.get_designate_record_id(designatec, domain_id, nameserver): logging.info('Creating NS record {}'.format(nameserver)) ns_record = Record(name=nameserver, type="A", data=resolver) record_id = designatec.records.create(domain_id, ns_record) assert (record_id is not None) else: logging.info('{} record already exists.'.format(nameserver)) logging.info('Update network to use domain {}'.format(domain_name)) net_uuid = openstack_utils.get_net_uuid(neutronc, 'private') mojo_os_utils.update_network_dns(neutronc, net_uuid, domain_name)
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 get_swiftclient(self): keystone_session = openstack_utils.get_overcloud_keystone_session() swift_client = mojo_os_utils.get_swift_session_client(keystone_session) return swift_client