def generate_creator(os_creds,
vm_inst,
image_config,
project_name,
keypair_config=None):
"""
Initializes an OpenStackVmInstance object
:param os_creds: the OpenStack credentials
:param vm_inst: the SNAPS-OO VmInst domain object
:param image_config: the associated ImageConfig object
:param project_name: the associated project ID
:param keypair_config: the associated KeypairConfig object (optional)
:return: an initialized OpenStackVmInstance object
"""
session = keystone_utils.keystone_session(os_creds)
nova = nova_utils.nova_client(os_creds, session)
keystone = keystone_utils.keystone_client(os_creds, session)
neutron = neutron_utils.neutron_client(os_creds, session)
try:
derived_inst_config = settings_utils.create_vm_inst_config(
nova, keystone, neutron, vm_inst, project_name)
derived_inst_creator = OpenStackVmInstance(os_creds,
derived_inst_config,
image_config,
keypair_config)
derived_inst_creator.initialize()
return derived_inst_creator
finally:
keystone_utils.close_session(session)
def __reboot_openstack_node(vm_info):
creds_dict = vm_info.get('os_creds')
os_creds = OSCreds(**creds_dict)
logger.debug('Retrieving keystone session %s', creds_dict)
os_sess = keystone_utils.keystone_session(os_creds)
try:
logger.debug('Retrieving OpenStack clients with %s', creds_dict)
nova = nova_utils.nova_client(os_creds, os_sess)
neutron = neutron_utils.neutron_client(os_creds, os_sess)
keystone = keystone_utils.keystone_client(os_creds, os_sess)
logger.info('Retrieved OpenStack clients')
vm_inst = nova_utils.get_server_object_by_id(nova, neutron, keystone,
vm_info['id'])
logger.info('Looking up VM named [%s]', vm_inst.name)
if vm_inst:
logger.debug('Generating VM SNAPS creator with creds [%s]',
creds_dict)
snaps_vm = create_instance.generate_creator(
os_creds, vm_inst, None, os_creds.project_name)
if snaps_vm:
logger.info('Rebooting VM with name %s', vm_inst.name)
snaps_vm.reboot(RebootType.hard)
else:
logger.warn('Unable to obtain a SNAPS-OO VM creator [%s]',
vm_inst.name)
else:
logger.warn('Unable to locate VM with name %s', vm_inst.name)
finally:
logger.info('Closing keystone session')
keystone_utils.close_session(os_sess)
def get_auth_token(os_creds):
""" Get auth token """
sess = keystone_utils.keystone_session(os_creds)
try:
return sess.get_token()
except Exception as error:
LOGGER.error("Got token ...FAILED")
raise error
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 magnum_client(os_creds, session=None):
"""
Retrieves the Magnum client
:param os_creds: the OpenStack credentialsf
:param session: the keystone session object (optional)
:return: the client
"""
logger.debug('Retrieving Magnum Client')
if not session:
session = keystone_utils.keystone_session(os_creds)
return Client(str(os_creds.magnum_api_version), session=session)
def heat_client(os_creds, session=None):
"""
Retrieves the Heat client
:param os_creds: the OpenStack credentials
:return: the client
"""
logger.debug('Retrieving Heat Client')
if not session:
session = keystone_utils.keystone_session(os_creds)
return Client(os_creds.heat_api_version,
session=session,
region_name=os_creds.region_name)
def neutron_client(os_creds, session=None):
"""
Instantiates and returns a client for communications with OpenStack's
Neutron server
:param os_creds: the credentials for connecting to the OpenStack remote API
:param session: the keystone session object (optional)
:return: the client object
"""
if not session:
session = keystone_utils.keystone_session(os_creds)
return Client(api_version=os_creds.network_api_version,
session=session,
region_name=os_creds.region_name)
def glance_client(os_creds, session=None):
"""
Creates and returns a glance client object
:param os_creds: the credentials for connecting to the OpenStack remote API
:param session: the keystone session object (optional)
:return: the glance client
"""
if not session:
session = keystone_utils.keystone_session(os_creds)
return Client(version=os_creds.image_api_version,
session=session,
region_name=os_creds.region_name)
def __init__(self,
method_name='runTest',
os_creds=None,
ext_net_name=None,
flavor_metadata=None,
image_metadata=None,
log_level=logging.DEBUG):
"""
Super for test classes requiring a connection to OpenStack
:param method_name: default 'runTest'
:param os_creds: the OSCreds object, when null it searches for the file
in the package snaps.openstack.tests.conf.os_env.yaml
:param ext_net_name: the name of the external network that is used for
creating routers for floating IPs
:param flavor_metadata: dict() to be sent directly into the Nova client
generally used for page sizes
:param image_metadata: ability to override images being used in the
tests (see examples/image-metadata)
:param log_level: the logging level of your test run (default DEBUG)
"""
super(OSComponentTestCase, self).__init__(method_name)
logging.basicConfig(level=log_level)
self.ext_net_name = None
self.flavor_metadata = None
if os_creds:
self.os_creds = os_creds
else:
if file_utils.file_exists(dev_os_env_file):
self.os_creds = openstack_tests.get_credentials(
dev_os_env_file=dev_os_env_file)
test_conf = file_utils.read_yaml(dev_os_env_file)
self.ext_net_name = test_conf.get('ext_net')
os_env_dict = file_utils.read_yaml(dev_os_env_file)
flavor_metadata = os_env_dict.get('flavor_metadata')
if flavor_metadata:
self.flavor_metadata = {'metadata': flavor_metadata}
else:
raise Exception('Unable to obtain OSCreds')
self.os_session = keystone_utils.keystone_session(self.os_creds)
self.image_metadata = image_metadata
if not self.ext_net_name:
self.ext_net_name = ext_net_name
if not self.flavor_metadata:
self.flavor_metadata = flavor_metadata
def nova_client(os_creds, session=None):
"""
Instantiates and returns a client for communications with OpenStack's Nova
server
:param os_creds: The connection credentials to the OpenStack API
:param session: the keystone session object (optional)
:return: the client object
"""
logger.debug('Retrieving Nova Client')
if not session:
session = keystone_utils.keystone_session(os_creds)
return Client(os_creds.compute_api_version,
session=session,
region_name=os_creds.region_name)
def __start__(self):
"""
Creates a project and user to be leveraged by subclass test methods. If
implementing class uses this method, it must call __clean__() else you
will be left with unwanted users and tenants
"""
self.project_creator = None
self.user_creator = None
self.admin_os_creds = self.os_creds
self.admin_os_session = self.os_session
self.keystone = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
if self.use_keystone:
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())[:-19]
project_name = guid + '-proj'
self.project_creator = deploy_utils.create_project(
self.admin_os_creds,
ProjectConfig(name=project_name,
domain=self.admin_os_creds.project_domain_name))
# Set by implementing class for setting the user's roles
roles = dict()
if self.user_roles and isinstance(self.user_roles, list):
for user_role in self.user_roles:
roles[user_role] = project_name
self.user_creator = deploy_utils.create_user(
self.admin_os_creds,
UserConfig(name=guid + '-user',
password=guid,
project_name=project_name,
roles=roles,
domain_name=self.admin_os_creds.user_domain_name))
self.os_creds = self.user_creator.get_os_creds(
self.project_creator.project_settings.name)
self.os_session = keystone_utils.keystone_session(self.os_creds)
# add user to project
self.project_creator.assoc_user(self.user_creator.get_user())
if self.proj_users and isinstance(self.proj_users, list):
for user_name in self.proj_users:
user = keystone_utils.get_user(self.keystone, user_name)
if user:
self.project_creator.assoc_user(user)
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 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 __get_router_variable_value(var_config_values, routers_dict,
os_creds_dict):
"""
Returns the associated network value
:param var_config_values: the configuration dictionary
:param routers_dict: the dictionary containing all networks where the key
is the network name
:param os_creds_dict: dict of OpenStack credentials where the key is the
name
:return: the value
"""
if 'creds_name' in var_config_values:
os_creds = os_creds_dict.get[var_config_values['creds_name']]
else:
os_creds = os_creds_dict.get('admin-creds')
router_name = var_config_values.get('router_name')
router_creator = routers_dict[router_name]
if router_creator:
if 'external_fixed_ip' == var_config_values.get('attr'):
session = keystone_utils.keystone_session(os_creds)
neutron = neutron_utils.neutron_client(os_creds, session)
try:
ext_nets = neutron_utils.get_external_networks(neutron)
subnet_name = var_config_values.get('subnet_name')
for ext_net in ext_nets:
for subnet in ext_net.subnets:
if subnet_name == subnet.name:
router = router_creator.get_router()
for fixed_ips in router.external_fixed_ips:
if subnet.id == fixed_ips['subnet_id']:
return fixed_ips['ip_address']
finally:
keystone_utils.close_session(session)
def get_tacker_client(other_creds={}):
creds_override = None
os_creds = openstack_tests.get_credentials(os_env_file=constants.ENV_FILE,
overrides=creds_override)
sess = keystone_utils.keystone_session(os_creds)
return tackerclient.Client(get_tacker_client_version(), session=sess)
def initialize(self):
self._os_session = keystone_utils.keystone_session(self._os_creds)
self._keystone = keystone_utils.keystone_client(
self._os_creds, session=self._os_session)
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}
