def test_get_project_id(self): # No domain self.patch_object(openstack_utils, "get_keystone_api_version") self.get_keystone_api_version.return_value = 2 ksclient = mock.MagicMock() project_id = "project-uuid" project_name = "myproject" project = mock.MagicMock() project._info = {"name": project_name, "id": project_id} ksclient.projects.list.return_value = [project] self.assertEqual( openstack_utils.get_project_id(ksclient, project_name), project_id) ksclient.projects.list.assert_called_once_with(domain=None) ksclient.domains.list.assert_not_called() # With domain ksclient.reset_mock() domain_name = "mydomain" domain_id = "domain-uuid" domain = mock.MagicMock() domain.id = domain_id ksclient.domains.list.return_value = [domain] self.assertEqual( openstack_utils.get_project_id(ksclient, project_name, domain_name=domain_name), project_id) ksclient.domains.list.assert_called_once_with(name=domain_name) ksclient.projects.list.assert_called_once_with(domain=domain_id)
def user_create_v2(kclient, users): current_users = [user.name for user in kclient.users.list()] for user in users: if user['username'] in current_users: logging.warning('Not creating user %s it already' 'exists' % (user['username'])) else: logging.info('Creating user %s' % (user['username'])) project_id = openstack_utils.get_project_id( kclient, user['project']) kclient.users.create(name=user['username'], password=user['password'], email=user['email'], tenant_id=project_id)
def user_create_v3(kclient, users): for user in users: project = user.get('project') or user.get('tenant') if kclient.users.find(username=user['username']): logging.warning('Not creating user %s it already' 'exists' % (user['username'])) else: if user['scope'] == 'project': logging.info('Creating user %s' % (user['username'])) project_id = openstack_utils.get_project_id(kclient, project, api_version=3) kclient.users.create(name=user['username'], password=user['password'], email=user['email'], project_id=project_id)
def add_users_to_roles(kclient, users): for user_details in users: tenant_id = openstack_utils.get_project_id(kclient, user_details['project']) for role_name in user_details['roles']: role = kclient.roles.find(name=role_name) user = kclient.users.find(name=user_details['username']) users_roles = get_roles_for_user(kclient, user, tenant_id) if role.id in users_roles: logging.warning('Not adding role %s to %s it already has ' 'it' % (user_details['username'], role_name)) else: logging.info('Adding %s to role %s for tenant' '%s' % (user_details['username'], role_name, tenant_id)) kclient.roles.add_user_role(user_details['username'], role, tenant_id)
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 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 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_external_network( neutron_client, project_id, network_config.get("dvr_enabled", False), network_config["external_net_name"]) openstack_utils.create_external_subnet( neutron_client, project_id, ext_network, network_config["default_gateway"], network_config["external_net_cidr"], network_config["start_floating_ip"], network_config["end_floating_ip"], network_config["external_subnet_name"]) 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)