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 setup_network():
cli_utils.setup_logging()
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Retrieve necessary clients
keystone_client = openstack_utils.get_keystone_session_client(
keystone_session)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Retrieve necessary variables
admin_domain = None
if openstack_utils.get_keystone_api_version() > 2:
admin_domain = "admin_domain"
project_id = openstack_utils.get_project_id(
keystone_client,
"admin",
domain_name=admin_domain,
)
# Create simple private network
project_network = openstack_utils.create_project_network(
neutron_client, project_id, shared=False, network_type="gre")
openstack_utils.create_project_subnet(neutron_client,
project_id,
project_network,
private_subnet,
ip_version=4)
def test_create_loadbalancer(self):
"""Create load balancer."""
# Prepare payload instances
# First we allow communication to port 80 by adding a security group
# rule
project_id = openstack_utils.get_project_id(self.keystone_client,
'admin',
domain_name='admin_domain')
openstack_utils.add_neutron_secgroup_rules(self.neutron_client,
project_id,
[{
'protocol': 'tcp',
'port_range_min': '80',
'port_range_max': '80',
'direction': 'ingress'
}])
# Then we request two Ubuntu instances with the Apache web server
# installed
instance_1, instance_2 = self.launch_guests(
userdata='#cloud-config\npackages:\n - apache2\n')
# Get IP of the prepared payload instances
payload_ips = []
for server in (instance_1, instance_2):
payload_ips.append(server.networks['private'][0])
self.assertTrue(len(payload_ips) > 0)
resp = self.neutron_client.list_networks(name='private')
subnet_id = resp['networks'][0]['subnets'][0]
if openstack_utils.dvr_enabled():
resp = self.neutron_client.list_networks(
name='private_lb_fip_network')
vip_subnet_id = resp['networks'][0]['subnets'][0]
else:
vip_subnet_id = subnet_id
for provider in self.get_lb_providers(self.octavia_client).keys():
logging.info(
'Creating loadbalancer with provider {}'.format(provider))
lb = self._create_lb_resources(self.octavia_client, provider,
vip_subnet_id, subnet_id,
payload_ips)
self.loadbalancers.append(lb)
lb_fp = openstack_utils.create_floating_ip(
self.neutron_client, 'ext_net', port={'id': lb['vip_port_id']})
snippet = 'This is the default welcome page'
assert snippet in self._get_payload(lb_fp['floating_ip_address'])
logging.info('Found "{}" in page retrieved through load balancer '
' (provider="{}") at "http://{}/"'.format(
snippet, provider, lb_fp['floating_ip_address']))
# If we get here, it means the tests passed
self.run_resource_cleanup = True
def setup_sdn_provider_vlan(network_config, keystone_session=None):
"""Perform setup for Software Defined Network, specifically a provider VLAN.
: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,
)
logging.info("Configuring VLAN provider network")
# Create the external network
provider_vlan_network = openstack_utils.create_provider_network(
neutron_client,
project_id,
net_name=network_config["provider_vlan_net_name"],
external=False,
shared=True,
network_type='vlan',
vlan_id=network_config["provider_vlan_id"])
provider_vlan_subnet = openstack_utils.create_provider_subnet(
neutron_client,
project_id,
provider_vlan_network,
network_config["provider_vlan_subnet_name"],
cidr=network_config["provider_vlan_cidr"],
dhcp=True)
openstack_utils.plug_subnet_into_router(neutron_client,
network_config["router_name"],
provider_vlan_network,
provider_vlan_subnet)
openstack_utils.add_neutron_secgroup_rules(neutron_client, project_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 prepare_payload_instance():
"""Prepare a instance we can use as payload test."""
session = openstack.get_overcloud_keystone_session()
keystone = openstack.get_keystone_session_client(session)
neutron = openstack.get_neutron_session_client(session)
project_id = openstack.get_project_id(keystone,
'admin',
domain_name='admin_domain')
openstack.add_neutron_secgroup_rules(neutron, project_id,
[{
'protocol': 'tcp',
'port_range_min': '80',
'port_range_max': '80',
'direction': 'ingress'
}])
zaza.openstack.configure.guest.launch_instance(
glance_setup.LTS_IMAGE_NAME,
userdata='#cloud-config\npackages:\n - apache2\n')
def _auth_arguments(cls, keystone_client):
"""Generate workloadmgrcli arguments for cloud authentication.
:returns: string of required cli arguments for authentication
:rtype: str
"""
overcloud_auth = openstack_utils.get_overcloud_auth()
overcloud_auth.update({
"OS_DOMAIN_ID":
openstack_utils.get_domain_id(keystone_client,
domain_name="admin_domain"),
"OS_TENANT_ID":
openstack_utils.get_project_id(
keystone_client,
project_name="admin",
domain_name="admin_domain",
),
"OS_TENANT_NAME":
"admin",
})
_required_keys = [
"OS_AUTH_URL",
"OS_USERNAME",
"OS_PASSWORD",
"OS_REGION_NAME",
"OS_DOMAIN_ID",
"OS_TENANT_ID",
"OS_TENANT_NAME",
]
params = []
for os_key in _required_keys:
params.append("--{}={}".format(
os_key.lower().replace("_", "-"),
overcloud_auth[os_key],
))
return " ".join(params)
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=600)
parser.add_argument("--cloudinit_wait", default=600)
parser.add_argument("--ping_wait", default=600)
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)
logging.info("Using cacert file: {}".format(cacert))
except FileNotFoundError:
logging.info("Not using a cacert pem file")
cacert = None
logging.info("Initializing client sessions")
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(search_opts={'all_tenants': 1}):
if server.name.startswith('mojo'):
logging.info("Deleting nova instance {}".format(server.id))
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_provider_network(
neutron_client, project_id, network_config["external_net_name"])
openstack_utils.create_provider_subnet(
neutron_client, project_id, ext_network,
network_config["external_subnet_name"],
network_config["default_gateway"], network_config["external_net_cidr"],
network_config["start_floating_ip"], network_config["end_floating_ip"])
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)
