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)