def test_create_admin_user(self):
"""
Tests the creation of an OpenStack user.
"""
self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
created_user = self.user_creator.create()
self.assertIsNotNone(created_user)
retrieved_user = keystone_utils.get_user(self.keystone,
self.user_settings.name)
self.assertIsNotNone(retrieved_user)
self.assertEqual(created_user, retrieved_user)
role = keystone_utils.get_role_by_name(self.keystone, 'admin')
if not role:
role = keystone_utils.get_role_by_name(self.keystone, 'Admin')
self.assertIsNotNone(role)
os_proj = keystone_utils.get_project(
keystone=self.keystone, project_name=self.os_creds.project_name)
user_roles = keystone_utils.get_roles_by_user(self.keystone,
retrieved_user, os_proj)
self.assertIsNotNone(user_roles)
self.assertEqual(1, len(user_roles))
self.assertEqual(role.id, user_roles[0].id)
def dict_for_neutron(self, keystone):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
TODO - expand automated testing to exercise all parameters
:param keystone: the Keystone client
:return: the dictionary object
"""
out = dict()
if self.name:
out['name'] = self.name
if self.description:
out['description'] = self.description
if self.project_name:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
project_id = None
if project:
project_id = project.id
if project_id:
out['tenant_id'] = project_id
else:
raise SecurityGroupConfigError(
'Could not find project ID for project named - ' +
self.project_name)
return {'security_group': out}
def create_volume(cinder, keystone, volume_settings):
"""
Creates and returns OpenStack volume object with an external URL
:param cinder: the cinder client
:param keystone: the keystone client
:param volume_settings: the volume settings object
:return: the OpenStack volume object
:raise Exception if using a file and it cannot be found
"""
project_id = None
if volume_settings.project_name:
project = keystone_utils.get_project(
keystone, project_name=volume_settings.project_name)
if project:
project_id = project.id
else:
raise KeystoneUtilsException(
'Project cannot be found with name - ' +
volume_settings.project_name)
os_volume = cinder.volumes.create(
name=volume_settings.name,
project_id=project_id,
description=volume_settings.description,
size=volume_settings.size,
imageRef=volume_settings.image_name,
volume_type=volume_settings.type_name,
availability_zone=volume_settings.availability_zone,
multiattach=volume_settings.multi_attach)
return __map_os_volume_to_domain(os_volume)
def test_update_quotas(self):
"""
Tests the creation of an OpenStack project where the quotas get
updated.
"""
self.project_creator = OpenStackProject(self.os_creds,
self.project_settings)
created_project = self.project_creator.create()
self.assertIsNotNone(created_project)
retrieved_project = keystone_utils.get_project(
keystone=self.keystone, project_settings=self.project_settings)
self.assertIsNotNone(retrieved_project)
self.assertEqual(created_project, retrieved_project)
self.assertTrue(
validate_project(self.keystone, self.project_settings,
created_project))
update_compute_quotas = ComputeQuotas(
**{
'metadata_items': 64,
'cores': 5,
'instances': 5,
'injected_files': 3,
'injected_file_content_bytes': 5120,
'ram': 25600,
'fixed_ips': 100,
'key_pairs': 50
})
self.project_creator.update_compute_quotas(update_compute_quotas)
update_network_quotas = NetworkQuotas(
**{
'security_group': 5,
'security_group_rule': 50,
'floatingip': 25,
'network': 5,
'port': 25,
'router': 6,
'subnet': 7
})
self.project_creator.update_network_quotas(update_network_quotas)
self.assertEqual(update_compute_quotas,
self.project_creator.get_compute_quotas())
self.assertEqual(update_network_quotas,
self.project_creator.get_network_quotas())
nova = nova_utils.nova_client(self.os_creds, self.os_session)
new_compute_quotas = nova_utils.get_compute_quotas(
nova,
self.project_creator.get_project().id)
self.assertEqual(update_compute_quotas, new_compute_quotas)
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
new_network_quotas = neutron_utils.get_network_quotas(
neutron,
self.project_creator.get_project().id)
self.assertEqual(update_network_quotas, new_network_quotas)
def dict_for_neutron(self, os_creds, network=None):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
:param os_creds: the OpenStack credentials
:param network: The network object on which the subnet will be created
(optional)
:return: the dictionary object
"""
out = {
'cidr': self.cidr,
'ip_version': self.ip_version,
}
if network:
out['network_id'] = network.id
if self.name:
out['name'] = self.name
if self.project_name:
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
try:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
finally:
keystone_utils.close_session(session)
project_id = None
if project:
project_id = project.id
if project_id:
out['tenant_id'] = project_id
else:
raise SubnetConfigError(
'Could not find project ID for project named - ' +
self.project_name)
if self.start and self.end:
out['allocation_pools'] = [{'start': self.start, 'end': self.end}]
if self.gateway_ip:
if self.gateway_ip == 'none':
out['gateway_ip'] = None
else:
out['gateway_ip'] = self.gateway_ip
if self.enable_dhcp is not None:
out['enable_dhcp'] = self.enable_dhcp
if self.dns_nameservers and len(self.dns_nameservers) > 0:
out['dns_nameservers'] = self.dns_nameservers
if self.host_routes and len(self.host_routes) > 0:
out['host_routes'] = self.host_routes
if self.destination:
out['destination'] = self.destination
if self.nexthop:
out['nexthop'] = self.nexthop
if self.ipv6_ra_mode:
out['ipv6_ra_mode'] = self.ipv6_ra_mode.value
if self.ipv6_address_mode:
out['ipv6_address_mode'] = self.ipv6_address_mode.value
return out
def initialize(self):
"""
Loads the existing Project object if it exists
:return: The Project domain object
"""
super(self.__class__, self).initialize()
self.__project = keystone_utils.get_project(
keystone=self._keystone, project_settings=self.project_settings)
return self.__project
def test_create_project(self):
"""
Tests the creation of an OpenStack project.
"""
self.project_creator = OpenStackProject(self.os_creds,
self.project_settings)
created_project = self.project_creator.create()
self.assertIsNotNone(created_project)
retrieved_project = keystone_utils.get_project(
keystone=self.keystone, project_settings=self.project_settings)
self.assertIsNotNone(retrieved_project)
self.assertEqual(created_project, retrieved_project)
self.assertTrue(
validate_project(self.keystone, self.project_settings,
created_project))
def dict_for_neutron(self, neutron, os_creds):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
TODO - expand automated testing to exercise all parameters
:param neutron: The neutron client to retrieve external network
information if necessary
:param os_creds: The OpenStack credentials for retrieving the keystone
client for looking up the project ID when the
self.project_name is not None
:return: the dictionary object
"""
out = dict()
ext_gw = dict()
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
try:
if self.name:
out['name'] = self.name
if self.project_name:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
if project:
out['tenant_id'] = project.id
else:
raise RouterConfigError(
'Could not find project ID for project named - ' +
self.project_name)
if self.admin_state_up is not None:
out['admin_state_up'] = self.admin_state_up
if self.external_gateway:
ext_net = neutron_utils.get_network(
neutron, keystone, network_name=self.external_gateway)
if ext_net:
ext_gw['network_id'] = ext_net.id
out['external_gateway_info'] = ext_gw
else:
raise RouterConfigError(
'Could not find the external network named - ' +
self.external_gateway)
finally:
keystone_utils.close_session(session)
return {'router': out}
def test_create_two_vol_same_name_diff_proj(self):
"""
Creates a volume as admin to the project of os_creds then instantiates
a creator object with the os_creds project to ensure it initializes
without creation
"""
vol_name = self.guid + '-vol'
self.volume_creators.append(
OpenStackVolume(self.admin_os_creds, VolumeConfig(name=vol_name)))
admin_vol = self.volume_creators[0].create(block=True)
self.assertIsNotNone(admin_vol)
admin_key = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
admin_proj = keystone_utils.get_project(
admin_key, project_name=self.admin_os_creds.project_name)
self.assertEqual(admin_vol.project_id, admin_proj.id)
admin_cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
admin_vol_get = cinder_utils.get_volume(
admin_cinder,
admin_key,
volume_name=vol_name,
project_name=self.admin_os_creds.project_name)
self.assertIsNotNone(admin_vol_get)
self.assertEqual(admin_vol, admin_vol_get)
self.volume_creators.append(
OpenStackVolume(self.os_creds, VolumeConfig(name=vol_name)))
proj_vol = self.volume_creators[1].create(block=True)
self.assertIsNotNone(proj_vol)
self.assertNotEqual(admin_vol, proj_vol)
proj_key = keystone_utils.keystone_client(self.os_creds,
self.os_session)
proj_cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
proj_vol_get = cinder_utils.get_volume(
proj_cinder,
proj_key,
volume_name=vol_name,
project_name=self.os_creds.project_name)
self.assertIsNotNone(proj_vol_get)
self.assertEqual(proj_vol, proj_vol_get)
def get_project_id(self, os_creds):
"""
Returns the project ID for a given project_name or None
:param os_creds: the credentials required for keystone client retrieval
:return: the ID or None
"""
if self.project_id:
return self.project_id
else:
if self.project_name:
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
try:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
if project:
return project.id
finally:
keystone_utils.close_session(session)
return None
def test_create_project_minimal(self):
"""
Tests the keyston_utils.create_project() funtion
"""
project_settings = ProjectConfig(
name=self.project_name, domain=self.os_creds.project_domain_name)
self.project = keystone_utils.create_project(self.keystone,
project_settings)
self.assertEqual(self.project_name, self.project.name)
project = keystone_utils.get_project(keystone=self.keystone,
project_settings=project_settings)
self.assertIsNotNone(project)
self.assertEqual(self.project_name, self.project.name)
domain = keystone_utils.get_domain_by_id(self.keystone,
project.domain_id)
if self.keystone.version == keystone_utils.V2_VERSION_STR:
self.assertIsNone(domain)
else:
self.assertIsNotNone(domain)
self.assertEqual(domain.id, project.domain_id)
def test_create_project_quota_override(self):
"""
Tests the creation of an OpenStack project with new quotas.
"""
quotas = {
'cores': 4,
'instances': 5,
'injected_files': 6,
'injected_file_content_bytes': 60000,
'ram': 70000,
'fixed_ips': 7,
'key_pairs': 8
}
self.project_settings.quotas = quotas
self.project_creator = OpenStackProject(self.os_creds,
self.project_settings)
created_project = self.project_creator.create()
self.assertIsNotNone(created_project)
retrieved_project = keystone_utils.get_project(
keystone=self.keystone, project_settings=self.project_settings)
self.assertIsNotNone(retrieved_project)
self.assertEqual(created_project, retrieved_project)
self.assertTrue(
validate_project(self.keystone, self.project_settings,
created_project))
nova = nova_utils.nova_client(self.os_creds, self.os_session)
new_quotas = nova_utils.get_compute_quotas(nova, created_project.id)
self.assertEqual(4, new_quotas.cores)
self.assertEqual(5, new_quotas.instances)
self.assertEqual(6, new_quotas.injected_files)
self.assertEqual(60000, new_quotas.injected_file_content_bytes)
self.assertEqual(70000, new_quotas.ram)
self.assertEqual(7, new_quotas.fixed_ips)
self.assertEqual(8, new_quotas.key_pairs)
def dict_for_neutron(self, neutron, os_creds):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
TODO - expand automated testing to exercise all parameters
:param neutron: the Neutron client
:param os_creds: the OpenStack credentials
:return: the dictionary object
"""
out = dict()
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
project_name = os_creds.project_name
if self.project_name:
project_name = project_name
try:
network = neutron_utils.get_network(neutron,
keystone,
network_name=self.network_name)
if network and not (network.shared or network.external):
network = neutron_utils.get_network(
neutron,
keystone,
network_name=self.network_name,
project_name=project_name)
finally:
if session:
keystone_utils.close_session(session)
if not network:
raise PortConfigError('Cannot locate network with name - ' +
self.network_name + ' in project - ' +
str(project_name))
out['network_id'] = network.id
if self.admin_state_up is not None:
out['admin_state_up'] = self.admin_state_up
if self.name:
out['name'] = self.name
if self.project_name:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
project_id = None
if project:
project_id = project.id
if project_id:
out['tenant_id'] = project_id
else:
raise PortConfigError(
'Could not find project ID for project named - ' +
self.project_name)
if self.mac_address:
out['mac_address'] = self.mac_address
fixed_ips = self.__get_fixed_ips(neutron, network)
if fixed_ips and len(fixed_ips) > 0:
out['fixed_ips'] = fixed_ips
if self.security_groups:
sec_grp_ids = list()
for sec_grp_name in self.security_groups:
sec_grp = neutron_utils.get_security_group(
neutron,
keystone,
sec_grp_name=sec_grp_name,
project_name=self.project_name)
if sec_grp:
sec_grp_ids.append(sec_grp.id)
out['security_groups'] = sec_grp_ids
if self.port_security_enabled is not None:
out['port_security_enabled'] = self.port_security_enabled
if self.allowed_address_pairs and len(self.allowed_address_pairs) > 0:
out['allowed_address_pairs'] = self.allowed_address_pairs
if self.opt_value:
out['opt_value'] = self.opt_value
if self.opt_name:
out['opt_name'] = self.opt_name
if self.device_owner:
out['device_owner'] = self.device_owner
if self.device_id:
out['device_id'] = self.device_id
if self.extra_dhcp_opts:
out['extra_dhcp_opts'] = self.extra_dhcp_opts
return {'port': out}