from neutronclient.common.exceptions import PortNotFoundClient
from novaclient.exceptions import NotFound
+from snaps.openstack.create_network import PortSettings
from snaps.openstack.utils import glance_utils
from snaps.openstack.utils import neutron_utils
-from snaps.openstack.create_network import PortSettings
-from snaps.provisioning import ansible_utils
from snaps.openstack.utils import nova_utils
+from snaps.provisioning import ansible_utils
__author__ = 'spisarski'
Class responsible for creating a VM instance in OpenStack
"""
- def __init__(self, os_creds, instance_settings, image_settings, keypair_settings=None):
+ def __init__(self, os_creds, instance_settings, image_settings,
+ keypair_settings=None):
"""
Constructor
:param os_creds: The connection credentials to the OpenStack API
self.image_settings = image_settings
self.keypair_settings = keypair_settings
- # TODO - get rid of FIP list and only use the dict(). Need to fix populating this object when already exists
+ # TODO - get rid of FIP list and only use the dict(). Need to fix
+ # populating this object when already exists
self.__floating_ips = list()
self.__floating_ip_dict = dict()
"""
Creates a VM instance
:param cleanup: When true, only perform lookups for OpenStack objects.
- :param block: Thread will block until instance has either become active, error, or timeout waiting.
- Additionally, when True, floating IPs will not be applied until VM is active.
+ :param block: Thread will block until instance has either become
+ active, error, or timeout waiting.
+ Additionally, when True, floating IPs will not be applied
+ until VM is active.
:return: The VM reference object
"""
self.__nova = nova_utils.nova_client(self.__os_creds)
self.__neutron = neutron_utils.neutron_client(self.__os_creds)
- self.__ports = self.__setup_ports(self.instance_settings.port_settings, cleanup)
+ self.__ports = self.__setup_ports(self.instance_settings.port_settings,
+ cleanup)
self.__lookup_existing_vm_by_name()
if not self.__vm and not cleanup:
self.__create_vm(block)
def __lookup_existing_vm_by_name(self):
"""
- Populates the member variables 'self.vm' and 'self.floating_ips' if a VM with the same name already exists
+ Populates the member variables 'self.vm' and 'self.floating_ips' if a
+ VM with the same name already exists
within the project
"""
- servers = nova_utils.get_servers_by_name(self.__nova, self.instance_settings.name)
+ servers = nova_utils.get_servers_by_name(self.__nova,
+ self.instance_settings.name)
for server in servers:
if server.name == self.instance_settings.name:
self.__vm = server
- logger.info('Found existing machine with name - ' + self.instance_settings.name)
+ logger.info(
+ 'Found existing machine with name - %s',
+ self.instance_settings.name)
fips = self.__nova.floating_ips.list()
for fip in fips:
if fip.instance_id == server.id:
self.__floating_ips.append(fip)
- # TODO - Determine a means to associate to the FIP configuration and add to FIP map
+ # TODO - Determine a means to associate to the FIP
+ # configuration and add to FIP map
def __create_vm(self, block=False):
"""
Responsible for creating the VM instance
- :param block: Thread will block until instance has either become active, error, or timeout waiting.
- Floating IPs will be assigned after active when block=True
+ :param block: Thread will block until instance has either become
+ active, error, or timeout waiting. Floating IPs will be
+ assigned after active when block=True
"""
nics = []
for key, port in self.__ports:
if self.keypair_settings:
keypair_name = self.keypair_settings.name
- flavor = nova_utils.get_flavor_by_name(self.__nova, self.instance_settings.flavor)
+ flavor = nova_utils.get_flavor_by_name(self.__nova,
+ self.instance_settings.flavor)
if not flavor:
- raise Exception('Flavor not found with name - ' + self.instance_settings.flavor)
+ raise Exception(
+ 'Flavor not found with name - %s',
+ self.instance_settings.flavor)
- image = glance_utils.get_image(glance_utils.glance_client(self.__os_creds),
- self.image_settings.name)
+ image = glance_utils.get_image(
+ glance_utils.glance_client(self.__os_creds),
+ self.image_settings.name)
if image:
self.__vm = self.__nova.servers.create(
name=self.instance_settings.name,
availability_zone=self.instance_settings.availability_zone)
else:
- raise Exception('Cannot create instance, image cannot be located with name ' + self.image_settings.name)
+ raise Exception(
+ 'Cannot create instance, image cannot be located with name %s',
+ self.image_settings.name)
- logger.info('Created instance with name - ' + self.instance_settings.name)
+ logger.info(
+ 'Created instance with name - %s', self.instance_settings.name)
if block:
if not self.vm_active(block=True):
- raise Exception('Fatal error, VM did not become ACTIVE within the alloted time')
+ raise Exception(
+ 'Fatal error, VM did not become ACTIVE within the alloted '
+ 'time')
- # TODO - the call above should add security groups. The return object shows they exist but the association
- # had never been made by OpenStack. This call is here to ensure they have been added
+ # TODO - the call above should add security groups. The return object
+ # shows they exist but the association had never been made by
+ # OpenStack. This call is here to ensure they have been added
for sec_grp_name in self.instance_settings.security_group_names:
if self.vm_active(block=True):
- nova_utils.add_security_group(self.__nova, self.__vm, sec_grp_name)
+ nova_utils.add_security_group(self.__nova, self.__vm,
+ sec_grp_name)
else:
- raise Exception('Cannot applying security group with name ' + sec_grp_name +
- ' to VM that did not activate with name - ' + self.instance_settings.name)
+ raise Exception(
+ 'Cannot applying security group with name ' +
+ sec_grp_name +
+ ' to VM that did not activate with name - ' +
+ self.instance_settings.name)
self.__apply_floating_ips()
port = port_dict.get(floating_ip_setting.port_name)
if not port:
- raise Exception('Cannot find port object with name - ' + floating_ip_setting.port_name)
-
- # Setup Floating IP only if there is a router with an external gateway
- ext_gateway = self.__ext_gateway_by_router(floating_ip_setting.router_name)
+ raise Exception(
+ 'Cannot find port object with name - ' +
+ floating_ip_setting.port_name)
+
+ # Setup Floating IP only if there is a router with an external
+ # gateway
+ ext_gateway = self.__ext_gateway_by_router(
+ floating_ip_setting.router_name)
if ext_gateway:
- subnet = neutron_utils.get_subnet_by_name(self.__neutron, floating_ip_setting.subnet_name)
- floating_ip = nova_utils.create_floating_ip(self.__nova, ext_gateway)
+ subnet = neutron_utils.get_subnet_by_name(
+ self.__neutron, floating_ip_setting.subnet_name)
+ floating_ip = nova_utils.create_floating_ip(self.__nova,
+ ext_gateway)
self.__floating_ips.append(floating_ip)
self.__floating_ip_dict[floating_ip_setting.name] = floating_ip
- logger.info('Created floating IP ' + floating_ip.ip + ' via router - ' +
- floating_ip_setting.router_name)
+ logger.info(
+ 'Created floating IP %s via router - %s', floating_ip.ip,
+ floating_ip_setting.router_name)
self.__add_floating_ip(floating_ip, port, subnet)
else:
- raise Exception('Unable to add floating IP to port,' +
- ' cannot locate router with an external gateway ')
+ raise Exception('Unable to add floating IP to port,'
+ ' cannot locate router with an external '
+ 'gateway ')
def __ext_gateway_by_router(self, router_name):
"""
- Returns network name for the external network attached to a router or None if not found
+ Returns network name for the external network attached to a router or
+ None if not found
:param router_name: The name of the router to lookup
:return: the external network name or None
"""
router = neutron_utils.get_router_by_name(self.__neutron, router_name)
if router and router['router'].get('external_gateway_info'):
- network = neutron_utils.get_network_by_id(self.__neutron,
- router['router']['external_gateway_info']['network_id'])
+ network = neutron_utils.get_network_by_id(
+ self.__neutron,
+ router['router']['external_gateway_info']['network_id'])
if network:
return network['network']['name']
return None
try:
neutron_utils.delete_port(self.__neutron, port)
except PortNotFoundClient as e:
- logger.warning('Unexpected error deleting port - ' + str(e))
+ logger.warning('Unexpected error deleting port - %s', e)
pass
self.__ports = list()
# Cleanup VM
if self.__vm:
try:
- logger.info('Deleting VM instance - ' + self.instance_settings.name)
+ logger.info(
+ 'Deleting VM instance - ' + self.instance_settings.name)
nova_utils.delete_vm_instance(self.__nova, self.__vm)
except Exception as e:
- logger.error('Error deleting VM - ' + str(e))
+ logger.error('Error deleting VM - %s', e)
- # Block until instance cannot be found or returns the status of DELETED
+ # Block until instance cannot be found or returns the status of
+ # DELETED
logger.info('Checking deletion status')
try:
if self.vm_deleted(block=True):
- logger.info('VM has been properly deleted VM with name - ' + self.instance_settings.name)
+ logger.info(
+ 'VM has been properly deleted VM with name - %s',
+ self.instance_settings.name)
self.__vm = None
else:
- logger.error('VM not deleted within the timeout period of ' +
- str(self.instance_settings.vm_delete_timeout) + ' seconds')
+ logger.error(
+ 'VM not deleted within the timeout period of %s '
+ 'seconds', self.instance_settings.vm_delete_timeout)
except Exception as e:
- logger.error('Unexpected error while checking VM instance status - ' + str(e))
+ logger.error(
+ 'Unexpected error while checking VM instance status - %s',
+ e)
def __setup_ports(self, port_settings, cleanup):
"""
- Returns the previously configured ports or creates them if they do not exist
+ Returns the previously configured ports or creates them if they do not
+ exist
:param port_settings: A list of PortSetting objects
:param cleanup: When true, only perform lookups for OpenStack objects.
- :return: a list of OpenStack port tuples where the first member is the port name and the second is the port
- object
+ :return: a list of OpenStack port tuples where the first member is the
+ port name and the second is the port object
"""
ports = list()
for port_setting in port_settings:
# First check to see if network already has this port
- # TODO/FIXME - this could potentially cause problems if another port with the same name exists
+ # TODO/FIXME - this could potentially cause problems if another
+ # port with the same name exists
# VM has the same network/port name pair
found = False
- # TODO/FIXME - should we not be iterating on ports for the specific network in question as unique port names
+ # TODO/FIXME - should we not be iterating on ports for the specific
+ # network in question as unique port names
# seem to only be important by network
existing_ports = self.__neutron.list_ports()['ports']
for existing_port in existing_ports:
break
if not found and not cleanup:
- ports.append((port_setting.name, neutron_utils.create_port(self.__neutron, self.__os_creds,
- port_setting)))
+ ports.append((port_setting.name,
+ neutron_utils.create_port(self.__neutron,
+ self.__os_creds,
+ port_setting)))
return ports
- def __add_floating_ip(self, floating_ip, port, subnet, timeout=30, poll_interval=POLL_INTERVAL):
+ def __add_floating_ip(self, floating_ip, port, subnet, timeout=30,
+ poll_interval=POLL_INTERVAL):
"""
Returns True when active else False
TODO - Make timeout and poll_interval configurable...
ip = None
if subnet:
- # Take IP of subnet if there is one configured on which to place the floating IP
+ # Take IP of subnet if there is one configured on which to place
+ # the floating IP
for fixed_ip in port['port']['fixed_ips']:
if fixed_ip['subnet_id'] == subnet['subnet']['id']:
ip = fixed_ip['ip_address']
logger.debug('Attempting to add floating IP to instance')
try:
self.__vm.add_floating_ip(floating_ip, ip)
- logger.info('Added floating IP ' + floating_ip.ip + ' to port IP - ' + ip +
- ' on instance - ' + self.instance_settings.name)
+ logger.info(
+ 'Added floating IP %s to port IP %s on instance %s',
+ floating_ip.ip, ip, self.instance_settings.name)
return
except Exception as e:
- logger.debug('Retry adding floating IP to instance. Last attempt failed with - ' + str(e))
+ logger.debug(
+ 'Retry adding floating IP to instance. Last attempt '
+ 'failed with - %s', e)
time.sleep(poll_interval)
count -= 1
pass
else:
- raise Exception('Unable find IP address on which to place the floating IP')
+ raise Exception(
+ 'Unable find IP address on which to place the floating IP')
logger.error('Timeout attempting to add the floating IP to instance.')
raise Exception('Timeout while attempting add floating IP to instance')
def get_port_ip(self, port_name, subnet_name=None):
"""
- Returns the first IP for the port corresponding with the port_name parameter when subnet_name is None
- else returns the IP address that corresponds to the subnet_name parameter
+ Returns the first IP for the port corresponding with the port_name
+ parameter when subnet_name is None else returns the IP address that
+ corresponds to the subnet_name parameter
:param port_name: the name of the port from which to return the IP
:param subnet_name: the name of the subnet attached to this IP
:return: the IP or None if not found
if port:
port_dict = port['port']
if subnet_name:
- subnet = neutron_utils.get_subnet_by_name(self.__neutron, subnet_name)
+ subnet = neutron_utils.get_subnet_by_name(self.__neutron,
+ subnet_name)
if not subnet:
- logger.warning('Cannot retrieve port IP as subnet could not be located with name - ' + subnet_name)
+ logger.warning('Cannot retrieve port IP as subnet could '
+ 'not be located with name - %s',
+ subnet_name)
return None
for fixed_ip in port_dict['fixed_ips']:
if fixed_ip['subnet_id'] == subnet['subnet']['id']:
def get_port_mac(self, port_name):
"""
- Returns the first IP for the port corresponding with the port_name parameter
- TODO - Add in the subnet as an additional parameter as a port may have multiple fixed_ips
+ Returns the first IP for the port corresponding with the port_name
+ parameter
+ TODO - Add in the subnet as an additional parameter as a port may have
+ multiple fixed_ips
:param port_name: the name of the port from which to return the IP
:return: the IP or None if not found
"""
def config_nics(self):
"""
- Responsible for configuring NICs on RPM systems where the instance has more than one configured port
+ Responsible for configuring NICs on RPM systems where the instance has
+ more than one configured port
:return: None
"""
if len(self.__ports) > 1 and len(self.__floating_ips) > 0:
port_index = self.__ports.index((key, port))
if port_index > 0:
nic_name = 'eth' + repr(port_index)
- self.__config_nic(nic_name, port, self.__get_first_provisioning_floating_ip().ip)
- logger.info('Configured NIC - ' + nic_name + ' on VM - ' + self.instance_settings.name)
+ self.__config_nic(
+ nic_name, port,
+ self.__get_first_provisioning_floating_ip().ip)
+ logger.info('Configured NIC - %s on VM - %s',
+ nic_name, self.instance_settings.name)
def __get_first_provisioning_floating_ip(self):
"""
- Returns the first floating IP tagged with the Floating IP name if exists else the first one found
+ Returns the first floating IP tagged with the Floating IP name if
+ exists else the first one found
:return:
"""
for floating_ip_setting in self.instance_settings.floating_ip_settings:
def __config_nic(self, nic_name, port, floating_ip):
"""
- Although ports/NICs can contain multiple IPs, this code currently only supports the first.
-
- Your CWD at this point must be the <repo dir>/python directory.
- TODO - fix this restriction.
+ Although ports/NICs can contain multiple IPs, this code currently only
+ supports the first.
:param nic_name: Name of the interface
:param port: The port information containing the expected IP values.
}
if self.image_settings.nic_config_pb_loc and self.keypair_settings:
- return self.apply_ansible_playbook(self.image_settings.nic_config_pb_loc, variables)
+ return self.apply_ansible_playbook(
+ self.image_settings.nic_config_pb_loc, variables)
else:
- logger.warning('VM ' + self.instance_settings.name + ' cannot self configure NICs eth1++. ' +
- 'No playbook or keypairs found.')
+ logger.warning(
+ 'VM %s cannot self configure NICs eth1++. No playbook or '
+ 'keypairs found.', self.instance_settings.name)
- def apply_ansible_playbook(self, pb_file_loc, variables=None, fip_name=None):
+ def apply_ansible_playbook(self, pb_file_loc, variables=None,
+ fip_name=None):
"""
Applies a playbook to a VM
:param pb_file_loc: the file location of the playbook to be applied
- :param variables: a dict() of substitution values required by the playbook
- :param fip_name: the name of the floating IP to use for applying the playbook (default - will take the first)
+ :param variables: a dict() of substitution values required by the
+ playbook
+ :param fip_name: the name of the floating IP to use for applying the
+ playbook (default - will take the first)
:return: the return value from ansible
"""
- return ansible_utils.apply_playbook(pb_file_loc, [self.get_floating_ip(fip_name=fip_name).ip],
- self.get_image_user(), self.keypair_settings.private_filepath,
- variables, self.__os_creds.proxy_settings)
+ return ansible_utils.apply_playbook(
+ pb_file_loc, [self.get_floating_ip(fip_name=fip_name).ip],
+ self.get_image_user(), self.keypair_settings.private_filepath,
+ variables, self.__os_creds.proxy_settings)
def get_image_user(self):
"""
- Returns the instance sudo_user if it has been configured in the instance_settings else it returns the
- image_settings.image_user value
+ Returns the instance sudo_user if it has been configured in the
+ instance_settings else it returns the image_settings.image_user value
"""
if self.instance_settings.sudo_user:
return self.instance_settings.sudo_user
def vm_deleted(self, block=False, poll_interval=POLL_INTERVAL):
"""
- Returns true when the VM status returns the value of expected_status_code or instance retrieval throws
- a NotFound exception.
- :param block: When true, thread will block until active or timeout value in seconds has been exceeded (False)
+ Returns true when the VM status returns the value of
+ expected_status_code or instance retrieval throws a NotFound exception.
+ :param block: When true, thread will block until active or timeout
+ value in seconds has been exceeded (False)
:param poll_interval: The polling interval in seconds
:return: T/F
"""
try:
- return self.__vm_status_check(STATUS_DELETED, block, self.instance_settings.vm_delete_timeout,
- poll_interval)
+ return self.__vm_status_check(
+ STATUS_DELETED, block,
+ self.instance_settings.vm_delete_timeout, poll_interval)
except NotFound as e:
- logger.debug("Instance not found when querying status for " + STATUS_DELETED + ' with message ' + str(e))
+ logger.debug(
+ "Instance not found when querying status for %s with message "
+ "%s", STATUS_DELETED, e)
return True
def vm_active(self, block=False, poll_interval=POLL_INTERVAL):
"""
- Returns true when the VM status returns the value of expected_status_code
- :param block: When true, thread will block until active or timeout value in seconds has been exceeded (False)
+ Returns true when the VM status returns the value of
+ expected_status_code
+ :param block: When true, thread will block until active or timeout
+ value in seconds has been exceeded (False)
:param poll_interval: The polling interval in seconds
:return: T/F
"""
- return self.__vm_status_check(STATUS_ACTIVE, block, self.instance_settings.vm_boot_timeout, poll_interval)
+ return self.__vm_status_check(STATUS_ACTIVE, block,
+ self.instance_settings.vm_boot_timeout,
+ poll_interval)
- def __vm_status_check(self, expected_status_code, block, timeout, poll_interval):
+ def __vm_status_check(self, expected_status_code, block, timeout,
+ poll_interval):
"""
- Returns true when the VM status returns the value of expected_status_code
- :param expected_status_code: instance status evaluated with this string value
- :param block: When true, thread will block until active or timeout value in seconds has been exceeded (False)
+ Returns true when the VM status returns the value of
+ expected_status_code
+ :param expected_status_code: instance status evaluated with this
+ string value
+ :param block: When true, thread will block until active or timeout
+ value in seconds has been exceeded (False)
:param timeout: The timeout value
:param poll_interval: The polling interval in seconds
:return: T/F
logger.info('VM is - ' + expected_status_code)
return True
- logger.debug('Retry querying VM status in ' + str(poll_interval) + ' seconds')
+ logger.debug('Retry querying VM status in ' + str(
+ poll_interval) + ' seconds')
time.sleep(poll_interval)
- logger.debug('VM status query timeout in ' + str(timeout - (time.time() - start)))
+ logger.debug('VM status query timeout in ' + str(
+ timeout - (time.time() - start)))
- logger.error('Timeout checking for VM status for ' + expected_status_code)
+ logger.error(
+ 'Timeout checking for VM status for ' + expected_status_code)
return False
def __status(self, expected_status_code):
"""
Returns True when active else False
- :param expected_status_code: instance status evaluated with this string value
+ :param expected_status_code: instance status evaluated with this string
+ value
:return: T/F
"""
if not self.__vm:
if instance.status == 'ERROR':
raise Exception('Instance had an error during deployment')
- logger.debug('Instance status [' + self.instance_settings.name + '] is - ' + instance.status)
+ logger.debug(
+ 'Instance status [%s] is - %s', self.instance_settings.name,
+ instance.status)
return instance.status == expected_status_code
def vm_ssh_active(self, block=False, poll_interval=POLL_INTERVAL):
"""
Returns true when the VM can be accessed via SSH
- :param block: When true, thread will block until active or timeout value in seconds has been exceeded (False)
+ :param block: When true, thread will block until active or timeout
+ value in seconds has been exceeded (False)
:param poll_interval: The polling interval
:return: T/F
"""
logger.info('SSH is active for VM instance')
return True
- logger.debug('Retry SSH connection in ' + str(poll_interval) + ' seconds')
+ logger.debug('Retry SSH connection in ' + str(
+ poll_interval) + ' seconds')
time.sleep(poll_interval)
- logger.debug('SSH connection timeout in ' + str(timeout - (time.time() - start)))
+ logger.debug('SSH connection timeout in ' + str(
+ timeout - (time.time() - start)))
logger.error('Timeout attempting to connect with VM via SSH')
return False
def get_floating_ip(self, fip_name=None):
"""
- Returns the floating IP object byt name if found, else the first known, else None
+ Returns the floating IP object byt name if found, else the first known,
+ else None
:param fip_name: the name of the floating IP to return
:return: the SSH client or None
"""
def ssh_client(self, fip_name=None):
"""
- Returns an SSH client using the name or the first known floating IP if exists, else None
+ Returns an SSH client using the name or the first known floating IP if
+ exists, else None
:param fip_name: the name of the floating IP to return
:return: the SSH client or None
"""
fip = self.get_floating_ip(fip_name)
if fip:
- return ansible_utils.ssh_client(self.__floating_ips[0].ip, self.get_image_user(),
- self.keypair_settings.private_filepath,
- proxy_settings=self.__os_creds.proxy_settings)
+ return ansible_utils.ssh_client(
+ self.__floating_ips[0].ip, self.get_image_user(),
+ self.keypair_settings.private_filepath,
+ proxy_settings=self.__os_creds.proxy_settings)
else:
- logger.warning('Cannot return an SSH client. No Floating IP configured')
+ logger.warning(
+ 'Cannot return an SSH client. No Floating IP configured')
def add_security_group(self, security_group):
"""
return False
try:
- nova_utils.add_security_group(self.__nova, self.get_vm_inst(), security_group['security_group']['name'])
+ nova_utils.add_security_group(self.__nova, self.get_vm_inst(),
+ security_group['security_group'][
+ 'name'])
return True
except NotFound as e:
logger.warning('Security group not added - ' + str(e))
def remove_security_group(self, security_group):
"""
- Removes a security group to this VM. Call will block until VM is active.
+ Removes a security group to this VM. Call will block until VM is active
:param security_group: the OpenStack security group object
:return True if successful else False
"""
return False
try:
- nova_utils.remove_security_group(self.__nova, self.get_vm_inst(), security_group)
+ nova_utils.remove_security_group(self.__nova, self.get_vm_inst(),
+ security_group)
return True
except NotFound as e:
logger.warning('Security group not removed - ' + str(e))
"""
Class responsible for holding configuration setting for a VM Instance
"""
- def __init__(self, config=None, name=None, flavor=None, port_settings=list(), security_group_names=set(),
- floating_ip_settings=list(), sudo_user=None, vm_boot_timeout=900,
- vm_delete_timeout=300, ssh_connect_timeout=180, availability_zone=None, userdata=None):
+
+ def __init__(self, **kwargs):
"""
Constructor
- :param config: dict() object containing the configuration settings using the attribute names below as each
- member's the key and overrides any of the other parameters.
:param name: the name of the VM
:param flavor: the VM's flavor
:param port_settings: the port configuration settings (required)
- :param security_group_names: a set of names of the security groups to add to the VM
+ :param security_group_names: a set of names of the security groups to
+ add to the VM
:param floating_ip_settings: the floating IP configuration settings
- :param sudo_user: the sudo user of the VM that will override the instance_settings.image_user when trying to
+ :param sudo_user: the sudo user of the VM that will override the
+ instance_settings.image_user when trying to
connect to the VM
- :param vm_boot_timeout: the amount of time a thread will sleep waiting for an instance to boot
- :param vm_delete_timeout: the amount of time a thread will sleep waiting for an instance to be deleted
- :param ssh_connect_timeout: the amount of time a thread will sleep waiting obtaining an SSH connection to a VM
- :param availability_zone: the name of the compute server on which to deploy the VM (optional)
- :param userdata: the cloud-init script to run after the VM has been started
- """
- if config:
- self.name = config.get('name')
- self.flavor = config.get('flavor')
- self.sudo_user = config.get('sudo_user')
- self.userdata = config.get('userdata')
-
- self.port_settings = list()
- if config.get('ports'):
- for port_config in config['ports']:
- if isinstance(port_config, PortSettings):
- self.port_settings.append(port_config)
- else:
- self.port_settings.append(PortSettings(config=port_config['port']))
-
- if config.get('security_group_names'):
- if isinstance(config['security_group_names'], list):
- self.security_group_names = set(config['security_group_names'])
- elif isinstance(config['security_group_names'], set):
- self.security_group_names = config['security_group_names']
- elif isinstance(config['security_group_names'], str):
- self.security_group_names = [config['security_group_names']]
- else:
- raise Exception('Invalid data type for security_group_names attribute')
+ :param vm_boot_timeout: the amount of time a thread will sleep waiting
+ for an instance to boot
+ :param vm_delete_timeout: the amount of time a thread will sleep
+ waiting for an instance to be deleted
+ :param ssh_connect_timeout: the amount of time a thread will sleep
+ waiting obtaining an SSH connection to a VM
+ :param availability_zone: the name of the compute server on which to
+ deploy the VM (optional)
+ :param userdata: the cloud-init script to run after the VM has been
+ started
+ """
+ self.name = kwargs.get('name')
+ self.flavor = kwargs.get('flavor')
+ self.sudo_user = kwargs.get('sudo_user')
+ self.userdata = kwargs.get('userdata')
+
+ self.port_settings = list()
+ port_settings = kwargs.get('ports')
+ if not port_settings:
+ port_settings = kwargs.get('port_settings')
+ if port_settings:
+ for port_setting in port_settings:
+ if isinstance(port_setting, dict):
+ self.port_settings.append(PortSettings(**port_setting))
+ elif isinstance(port_setting, PortSettings):
+ self.port_settings.append(port_setting)
+
+ if kwargs.get('security_group_names'):
+ if isinstance(kwargs['security_group_names'], list):
+ self.security_group_names = kwargs['security_group_names']
+ elif isinstance(kwargs['security_group_names'], set):
+ self.security_group_names = kwargs['security_group_names']
+ elif isinstance(kwargs['security_group_names'], str):
+ self.security_group_names = [kwargs['security_group_names']]
else:
- self.security_group_names = set()
-
- self.floating_ip_settings = list()
- if config.get('floating_ips'):
- for floating_ip_config in config['floating_ips']:
- if isinstance(floating_ip_config, FloatingIpSettings):
- self.floating_ip_settings.append(floating_ip_config)
- else:
- self.floating_ip_settings.append(FloatingIpSettings(config=floating_ip_config['floating_ip']))
-
- if config.get('vm_boot_timeout'):
- self.vm_boot_timeout = config['vm_boot_timeout']
- else:
- self.vm_boot_timeout = vm_boot_timeout
+ raise Exception(
+ 'Invalid data type for security_group_names attribute')
+ else:
+ self.security_group_names = set()
+
+ self.floating_ip_settings = list()
+ floating_ip_settings = kwargs.get('floating_ips')
+ if not floating_ip_settings:
+ floating_ip_settings = kwargs.get('floating_ip_settings')
+ if floating_ip_settings:
+ for floating_ip_config in floating_ip_settings:
+ if isinstance(floating_ip_config, FloatingIpSettings):
+ self.floating_ip_settings.append(floating_ip_config)
+ else:
+ self.floating_ip_settings.append(FloatingIpSettings(
+ **floating_ip_config['floating_ip']))
- if config.get('vm_delete_timeout'):
- self.vm_delete_timeout = config['vm_delete_timeout']
- else:
- self.vm_delete_timeout = vm_delete_timeout
+ if kwargs.get('vm_boot_timeout'):
+ self.vm_boot_timeout = kwargs['vm_boot_timeout']
+ else:
+ self.vm_boot_timeout = 900
- if config.get('ssh_connect_timeout'):
- self.ssh_connect_timeout = config['ssh_connect_timeout']
- else:
- self.ssh_connect_timeout = ssh_connect_timeout
+ if kwargs.get('vm_delete_timeout'):
+ self.vm_delete_timeout = kwargs['vm_delete_timeout']
+ else:
+ self.vm_delete_timeout = 300
- if config.get('availability_zone'):
- self.availability_zone = config['availability_zone']
- else:
- self.availability_zone = None
+ if kwargs.get('ssh_connect_timeout'):
+ self.ssh_connect_timeout = kwargs['ssh_connect_timeout']
+ else:
+ self.ssh_connect_timeout = 180
+
+ if kwargs.get('availability_zone'):
+ self.availability_zone = kwargs['availability_zone']
else:
- self.name = name
- self.flavor = flavor
- self.port_settings = port_settings
- self.security_group_names = security_group_names
- self.floating_ip_settings = floating_ip_settings
- self.sudo_user = sudo_user
- self.vm_boot_timeout = vm_boot_timeout
- self.vm_delete_timeout = vm_delete_timeout
- self.ssh_connect_timeout = ssh_connect_timeout
- self.availability_zone = availability_zone
- self.userdata = userdata
+ self.availability_zone = None
if not self.name or not self.flavor:
- raise Exception('Instance configuration requires the attributes: name, flavor')
+ raise Exception(
+ 'Instance configuration requires the attributes: name, flavor')
if len(self.port_settings) == 0:
- raise Exception('Instance configuration requires port settings (aka. NICS)')
+ raise Exception(
+ 'Instance configuration requires port settings (aka. NICS)')
class FloatingIpSettings:
"""
Class responsible for holding configuration settings for a floating IP
"""
- def __init__(self, config=None, name=None, port_name=None, router_name=None, subnet_name=None, provisioning=True):
+
+ def __init__(self, **kwargs):
"""
Constructor
- :param config: dict() object containing the configuration settings using the attribute names below as each
- member's the key and overrides any of the other parameters.
:param name: the name of the floating IP
:param port_name: the name of the router to the external network
:param router_name: the name of the router to the external network
- :param subnet_name: the name of the subnet on which to attach the floating IP
- :param provisioning: when true, this floating IP can be used for provisioning
-
- TODO - provisioning flag is a hack as I have only observed a single Floating IPs that actually works on
- an instance. Multiple floating IPs placed on different subnets from the same port are especially troublesome
- as you cannot predict which one will actually connect. For now, it is recommended not to setup multiple
- floating IPs on an instance unless absolutely necessary.
- """
- if config:
- self.name = config.get('name')
- self.port_name = config.get('port_name')
- self.router_name = config.get('router_name')
- self.subnet_name = config.get('subnet_name')
- if config.get('provisioning') is not None:
- self.provisioning = config['provisioning']
- else:
- self.provisioning = provisioning
+ :param subnet_name: the name of the subnet on which to attach the
+ floating IP
+ :param provisioning: when true, this floating IP can be used for
+ provisioning
+
+ TODO - provisioning flag is a hack as I have only observed a single
+ Floating IPs that actually works on an instance. Multiple floating IPs
+ placed on different subnets from the same port are especially
+ troublesome as you cannot predict which one will actually connect.
+ For now, it is recommended not to setup multiple floating IPs on an
+ instance unless absolutely necessary.
+ """
+ self.name = kwargs.get('name')
+ self.port_name = kwargs.get('port_name')
+ self.router_name = kwargs.get('router_name')
+ self.subnet_name = kwargs.get('subnet_name')
+ if kwargs.get('provisioning') is not None:
+ self.provisioning = kwargs['provisioning']
else:
- self.name = name
- self.port_name = port_name
- self.router_name = router_name
- self.subnet_name = subnet_name
- self.provisioning = provisioning
+ self.provisioning = True
if not self.name or not self.port_name or not self.router_name:
- raise Exception('The attributes name, port_name and router_name are required for FloatingIPSettings')
+ raise Exception(
+ 'The attributes name, port_name and router_name are required '
+ 'for FloatingIPSettings')
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
-import os
import re
+import shutil
import time
import unittest
import uuid
-import shutil
+import os
+
from snaps import file_utils
-from snaps.openstack.create_instance import VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings
from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
+from snaps.openstack.create_image import OpenStackImage, ImageSettings
+from snaps.openstack.create_instance import (
+ VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings)
from snaps.openstack.create_keypairs import OpenStackKeypair, KeypairSettings
from snaps.openstack.create_network import OpenStackNetwork, PortSettings
from snaps.openstack.create_router import OpenStackRouter
-from snaps.openstack.create_image import OpenStackImage, ImageSettings
-from snaps.openstack.create_security_group import SecurityGroupSettings, OpenStackSecurityGroup, \
- SecurityGroupRuleSettings, Direction, Protocol
+from snaps.openstack.create_security_group import (
+ SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
+ Direction, Protocol)
from snaps.openstack.tests import openstack_tests, validation_utils
+from snaps.openstack.tests.os_source_file_test import (
+ OSIntegrationTestCase, OSComponentTestCase)
from snaps.openstack.utils import nova_utils
-from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase, OSComponentTestCase
__author__ = 'spisarski'
def test_name_flavor_port_only(self):
port_settings = PortSettings(name='foo-port', network_name='bar-net')
- settings = VmInstanceSettings(name='foo', flavor='bar', port_settings=[port_settings])
+ settings = VmInstanceSettings(name='foo', flavor='bar',
+ port_settings=[port_settings])
self.assertEqual('foo', settings.name)
self.assertEqual('bar', settings.flavor)
self.assertEqual(1, len(settings.port_settings))
def test_config_with_name_flavor_port_only(self):
port_settings = PortSettings(name='foo-port', network_name='bar-net')
- settings = VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
+ settings = VmInstanceSettings(
+ **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
self.assertEqual('foo', settings.name)
self.assertEqual('bar', settings.flavor)
self.assertEqual(1, len(settings.port_settings))
def test_all(self):
port_settings = PortSettings(name='foo-port', network_name='bar-net')
- fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port', router_name='foo-bar-router')
-
- settings = VmInstanceSettings(name='foo', flavor='bar', port_settings=[port_settings],
- security_group_names=['sec_grp_1'], floating_ip_settings=[fip_settings],
- sudo_user='joe', vm_boot_timeout=999, vm_delete_timeout=333,
- ssh_connect_timeout=111, availability_zone='server name')
+ fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
+ router_name='foo-bar-router')
+
+ settings = VmInstanceSettings(name='foo', flavor='bar',
+ port_settings=[port_settings],
+ security_group_names=['sec_grp_1'],
+ floating_ip_settings=[fip_settings],
+ sudo_user='joe', vm_boot_timeout=999,
+ vm_delete_timeout=333,
+ ssh_connect_timeout=111,
+ availability_zone='server name')
self.assertEqual('foo', settings.name)
self.assertEqual('bar', settings.flavor)
self.assertEqual(1, len(settings.port_settings))
self.assertEqual('sec_grp_1', settings.security_group_names[0])
self.assertEqual(1, len(settings.floating_ip_settings))
self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
- self.assertEqual('bar-port', settings.floating_ip_settings[0].port_name)
- self.assertEqual('foo-bar-router', settings.floating_ip_settings[0].router_name)
+ self.assertEqual('bar-port',
+ settings.floating_ip_settings[0].port_name)
+ self.assertEqual('foo-bar-router',
+ settings.floating_ip_settings[0].router_name)
self.assertEqual('joe', settings.sudo_user)
self.assertEqual(999, settings.vm_boot_timeout)
self.assertEqual(333, settings.vm_delete_timeout)
def test_config_all(self):
port_settings = PortSettings(name='foo-port', network_name='bar-net')
- fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port', router_name='foo-bar-router')
-
- settings = VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
- 'security_group_names': ['sec_grp_1'],
- 'floating_ips': [fip_settings], 'sudo_user': 'joe',
- 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
- 'ssh_connect_timeout': 111, 'availability_zone': 'server name'})
+ fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
+ router_name='foo-bar-router')
+
+ settings = VmInstanceSettings(
+ **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
+ 'security_group_names': ['sec_grp_1'],
+ 'floating_ips': [fip_settings], 'sudo_user': 'joe',
+ 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
+ 'ssh_connect_timeout': 111, 'availability_zone': 'server name'})
self.assertEqual('foo', settings.name)
self.assertEqual('bar', settings.flavor)
self.assertEqual(1, len(settings.port_settings))
self.assertEqual(1, len(settings.security_group_names))
self.assertEqual(1, len(settings.floating_ip_settings))
self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
- self.assertEqual('bar-port', settings.floating_ip_settings[0].port_name)
- self.assertEqual('foo-bar-router', settings.floating_ip_settings[0].router_name)
+ self.assertEqual('bar-port',
+ settings.floating_ip_settings[0].port_name)
+ self.assertEqual('foo-bar-router',
+ settings.floating_ip_settings[0].router_name)
self.assertEqual('joe', settings.sudo_user)
self.assertEqual(999, settings.vm_boot_timeout)
self.assertEqual(333, settings.vm_delete_timeout)
def test_empty_config(self):
with self.assertRaises(Exception):
- FloatingIpSettings(config=dict())
+ FloatingIpSettings(**dict())
def test_name_only(self):
with self.assertRaises(Exception):
def test_config_with_name_only(self):
with self.assertRaises(Exception):
- FloatingIpSettings(config={'name': 'foo'})
+ FloatingIpSettings(**{'name': 'foo'})
def test_name_port_only(self):
with self.assertRaises(Exception):
def test_config_with_name_port_only(self):
with self.assertRaises(Exception):
- FloatingIpSettings(config={'name': 'foo', 'port_name': 'bar'})
+ FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
def test_name_router_only(self):
with self.assertRaises(Exception):
def test_config_with_name_router_only(self):
with self.assertRaises(Exception):
- FloatingIpSettings(config={'name': 'foo', 'router_name': 'bar'})
+ FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
def test_name_port_router_only(self):
- settings = FloatingIpSettings(name='foo', port_name='foo-port', router_name='bar-router')
+ settings = FloatingIpSettings(name='foo', port_name='foo-port',
+ router_name='bar-router')
self.assertEqual('foo', settings.name)
self.assertEqual('foo-port', settings.port_name)
self.assertEqual('bar-router', settings.router_name)
self.assertTrue(settings.provisioning)
def test_config_with_name_port_router_only(self):
- settings = FloatingIpSettings(config={'name': 'foo', 'port_name': 'foo-port', 'router_name': 'bar-router'})
+ settings = FloatingIpSettings(
+ **{'name': 'foo', 'port_name': 'foo-port',
+ 'router_name': 'bar-router'})
self.assertEqual('foo', settings.name)
self.assertEqual('foo-port', settings.port_name)
self.assertEqual('bar-router', settings.router_name)
self.assertTrue(settings.provisioning)
def test_all(self):
- settings = FloatingIpSettings(name='foo', port_name='foo-port', router_name='bar-router',
- subnet_name='bar-subnet', provisioning=False)
+ settings = FloatingIpSettings(name='foo', port_name='foo-port',
+ router_name='bar-router',
+ subnet_name='bar-subnet',
+ provisioning=False)
self.assertEqual('foo', settings.name)
self.assertEqual('foo-port', settings.port_name)
self.assertEqual('bar-router', settings.router_name)
self.assertFalse(settings.provisioning)
def test_config_all(self):
- settings = FloatingIpSettings(config={'name': 'foo', 'port_name': 'foo-port', 'router_name': 'bar-router',
- 'subnet_name': 'bar-subnet', 'provisioning': False})
+ settings = FloatingIpSettings(
+ **{'name': 'foo', 'port_name': 'foo-port',
+ 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
+ 'provisioning': False})
self.assertEqual('foo', settings.name)
self.assertEqual('foo-port', settings.port_name)
self.assertEqual('bar-router', settings.router_name)
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file
within OpenStack
"""
super(self.__class__, self).__start__()
self.priv_net_config = openstack_tests.get_priv_net_config(
net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
self.port_settings = PortSettings(
- name=self.port_1_name, network_name=self.priv_net_config.network_settings.name)
+ name=self.port_1_name,
+ network_name=self.priv_net_config.network_settings.name)
# Create Image
- # Set the default image settings, then set any custom parameters sent from the app
+ # Set the default image settings, then set any custom parameters sent
+ # from the app
os_image_settings = openstack_tests.cirros_image_settings(
name=guid + '-image', image_metadata=self.image_metadata)
try:
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, self.priv_net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, self.priv_net_config.network_settings)
self.network_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10, vcpus=1, metadata=self.flavor_metadata))
+ FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
+ vcpus=1, metadata=self.flavor_metadata))
self.flavor_creator.create()
except Exception as e:
self.tearDown()
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message'
+ ' - %s', e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s',
+ e)
super(self.__class__, self).__clean__()
def test_check_vm_ip_dhcp(self):
"""
- Tests the creation of an OpenStack instance with a single port and ensures that it's assigned IP address is
- the actual.
+ Tests the creation of an OpenStack instance with a single port and
+ ensures that it's assigned IP address is the actual.
"""
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm = self.inst_creator.create()
ip = self.inst_creator.get_port_ip(self.port_settings.name)
"""
Simple instance creation tests without any other objects
"""
+
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file
within OpenStack
"""
super(self.__class__, self).__start__()
try:
# Create Image
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10, vcpus=2, metadata=self.flavor_metadata))
+ FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
+ vcpus=2, metadata=self.flavor_metadata))
self.flavor_creator.create()
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, net_config.network_settings)
self.network_creator.create()
- self.port_settings = PortSettings(name=guid + '-port',
- network_name=net_config.network_settings.name)
+ self.port_settings = PortSettings(
+ name=guid + '-port',
+ network_name=net_config.network_settings.name)
except Exception as e:
self.tearDown()
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message '
+ '- %s', e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
def test_create_delete_instance(self):
"""
- Tests the creation of an OpenStack instance with a single port with a static IP without a Floating IP.
+ Tests the creation of an OpenStack instance with a single port with a
+ static IP without a Floating IP.
"""
- instance_settings = VmInstanceSettings(name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name,
- port_settings=[self.port_settings])
+ instance_settings = VmInstanceSettings(
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
self.inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings)
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create()
- self.assertEqual(1, len(nova_utils.get_servers_by_name(self.nova, instance_settings.name)))
+ self.assertEqual(1, len(
+ nova_utils.get_servers_by_name(self.nova, instance_settings.name)))
# Delete instance
nova_utils.delete_vm_instance(self.nova, vm_inst)
self.assertTrue(self.inst_creator.vm_deleted(block=True))
- self.assertEqual(0, len(nova_utils.get_servers_by_name(self.nova, instance_settings.name)))
+ self.assertEqual(0, len(
+ nova_utils.get_servers_by_name(self.nova, instance_settings.name)))
# Exception should not be thrown
self.inst_creator.clean()
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
name=guid + '-image', image_metadata=self.image_metadata)
try:
# Create Image
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, self.pub_net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, self.pub_net_config.network_settings)
self.network_creator.create()
# Create Router
- self.router_creator = OpenStackRouter(self.os_creds, self.pub_net_config.router_settings)
+ self.router_creator = OpenStackRouter(
+ self.os_creds, self.pub_net_config.router_settings)
self.router_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10, vcpus=2, metadata=self.flavor_metadata))
+ FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
+ vcpus=2, metadata=self.flavor_metadata))
self.flavor_creator.create()
self.keypair_creator = OpenStackKeypair(
self.os_creds, KeypairSettings(
- name=self.keypair_name, public_filepath=self.keypair_pub_filepath,
+ name=self.keypair_name,
+ public_filepath=self.keypair_pub_filepath,
private_filepath=self.keypair_priv_filepath))
self.keypair_creator.create()
sec_grp_name = guid + '-sec-grp'
- rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name, direction=Direction.ingress,
+ rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
+ direction=Direction.ingress,
protocol=Protocol.icmp)
- rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name, direction=Direction.ingress,
- protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
+ rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
+ direction=Direction.ingress,
+ protocol=Protocol.tcp,
+ port_range_min=22,
+ port_range_max=22)
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds,
- SecurityGroupSettings(name=sec_grp_name, rule_settings=[rule1, rule2]))
+ SecurityGroupSettings(name=sec_grp_name,
+ rule_settings=[rule1, rule2]))
self.sec_grp_creator.create()
except Exception as e:
self.tearDown()
try:
inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message '
+ '- %s', e)
if self.keypair_creator:
try:
self.keypair_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning keypair with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning keypair with message - %s',
+ e)
if os.path.isfile(self.keypair_pub_filepath):
os.remove(self.keypair_pub_filepath)
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.sec_grp_creator:
try:
self.sec_grp_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning security group with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning security group with message'
+ ' - %s', e)
if self.router_creator:
try:
self.router_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning router with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning router with message - %s',
+ e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
def test_single_port_static(self):
"""
- Tests the creation of an OpenStack instance with a single port with a static IP without a Floating IP.
+ Tests the creation of an OpenStack instance with a single port with a
+ static IP without a Floating IP.
"""
ip_1 = '10.55.1.100'
-
+ sub_settings = self.pub_net_config.network_settings.subnet_settings
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.pub_net_config.network_settings.name,
- ip_addrs=[{'subnet_name': self.pub_net_config.network_settings.subnet_settings[0].name, 'ip': ip_1}])
+ name=self.port_1_name,
+ network_name=self.pub_net_config.network_settings.name,
+ ip_addrs=[
+ {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings],
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings],
floating_ip_settings=[FloatingIpSettings(
name=self.floating_ip_name, port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)])
inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings,
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
self.inst_creators.append(inst_creator)
vm_inst = inst_creator.create()
def test_ssh_client_fip_before_active(self):
"""
- Tests the ability to access a VM via SSH and a floating IP when it has been assigned prior to being active.
+ Tests the ability to access a VM via SSH and a floating IP when it has
+ been assigned prior to being active.
"""
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.pub_net_config.network_settings.name)
+ name=self.port_1_name,
+ network_name=self.pub_net_config.network_settings.name)
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings],
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings],
floating_ip_settings=[FloatingIpSettings(
name=self.floating_ip_name, port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)])
inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings,
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
self.inst_creators.append(inst_creator)
vm_inst = inst_creator.create()
ip = inst_creator.get_port_ip(port_settings.name)
self.assertTrue(check_dhcp_lease(vm_inst, ip))
- inst_creator.add_security_group(self.sec_grp_creator.get_security_group())
+ inst_creator.add_security_group(
+ self.sec_grp_creator.get_security_group())
self.assertEqual(vm_inst, inst_creator.get_vm_inst())
self.assertTrue(validate_ssh_client(inst_creator))
def test_ssh_client_fip_after_active(self):
"""
- Tests the ability to access a VM via SSH and a floating IP when it has been assigned prior to being active.
+ Tests the ability to access a VM via SSH and a floating IP when it has
+ been assigned prior to being active.
"""
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.pub_net_config.network_settings.name)
+ name=self.port_1_name,
+ network_name=self.pub_net_config.network_settings.name)
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings],
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings],
floating_ip_settings=[FloatingIpSettings(
name=self.floating_ip_name, port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)])
inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings,
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
self.inst_creators.append(inst_creator)
ip = inst_creator.get_port_ip(port_settings.name)
self.assertTrue(check_dhcp_lease(vm_inst, ip))
- inst_creator.add_security_group(self.sec_grp_creator.get_security_group())
+ inst_creator.add_security_group(
+ self.sec_grp_creator.get_security_group())
self.assertEqual(vm_inst, inst_creator.get_vm_inst())
self.assertTrue(validate_ssh_client(inst_creator))
class CreateInstancePortManipulationTests(OSIntegrationTestCase):
"""
- Test for the CreateInstance class with a single NIC/Port where mac and IP values are manually set
+ Test for the CreateInstance class with a single NIC/Port where mac and IP
+ values are manually set
"""
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
try:
# Create Image
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, self.net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, self.net_config.network_settings)
self.network_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10, vcpus=2, metadata=self.flavor_metadata))
+ FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
+ vcpus=2, metadata=self.flavor_metadata))
self.flavor_creator.create()
except Exception as e:
self.tearDown()
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message '
+ '- %s', e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
def test_set_custom_valid_ip_one_subnet(self):
"""
- Tests the creation of an OpenStack instance with a single port with a static IP on a network with one subnet.
+ Tests the creation of an OpenStack instance with a single port with a
+ static IP on a network with one subnet.
"""
ip = '10.55.0.101'
+ sub_settings = self.net_config.network_settings.subnet_settings
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name,
- ip_addrs=[{'subnet_name': self.net_config.network_settings.subnet_settings[0].name, 'ip': ip}])
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create(block=True)
self.assertEqual(ip, self.inst_creator.get_port_ip(
- self.port_1_name, subnet_name=self.net_config.network_settings.subnet_settings[0].name))
+ self.port_1_name,
+ subnet_name=self.net_config.network_settings.subnet_settings[
+ 0].name))
def test_set_custom_invalid_ip_one_subnet(self):
"""
- Tests the creation of an OpenStack instance with a single port with a static IP on a network with one subnet.
+ Tests the creation of an OpenStack instance with a single port with a
+ static IP on a network with one subnet.
"""
ip = '10.66.0.101'
+ sub_settings = self.net_config.network_settings.subnet_settings
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name,
- ip_addrs=[{'subnet_name': self.net_config.network_settings.subnet_settings[0].name, 'ip': ip}])
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
with self.assertRaises(Exception):
self.inst_creator.create()
def test_set_custom_valid_mac(self):
"""
- Tests the creation of an OpenStack instance with a single port where the MAC address is assigned.
+ Tests the creation of an OpenStack instance with a single port where
+ the MAC address is assigned.
"""
mac_addr = '0a:1b:2c:3d:4e:5f'
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name, mac_address=mac_addr)
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ mac_address=mac_addr)
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create(block=True)
- self.assertEqual(mac_addr, self.inst_creator.get_port_mac(self.port_1_name))
+ self.assertEqual(mac_addr,
+ self.inst_creator.get_port_mac(self.port_1_name))
def test_set_custom_invalid_mac(self):
"""
- Tests the creation of an OpenStack instance with a single port where an invalid MAC address value is being
+ Tests the creation of an OpenStack instance with a single port where an
+ invalid MAC address value is being
assigned. This should raise an Exception
"""
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name, mac_address='foo')
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ mac_address='foo')
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
self.inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings)
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
with self.assertRaises(Exception):
self.inst_creator.create()
def test_set_custom_mac_and_ip(self):
"""
- Tests the creation of an OpenStack instance with a single port where the IP and MAC address is assigned.
+ Tests the creation of an OpenStack instance with a single port where
+ the IP and MAC address is assigned.
"""
ip = '10.55.0.101'
mac_addr = '0a:1b:2c:3d:4e:5f'
+ sub_settings = self.net_config.network_settings.subnet_settings
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name, mac_address=mac_addr,
- ip_addrs=[{'subnet_name': self.net_config.network_settings.subnet_settings[0].name, 'ip': ip}])
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ mac_address=mac_addr,
+ ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create(block=True)
self.assertEqual(ip, self.inst_creator.get_port_ip(
- self.port_1_name, subnet_name=self.net_config.network_settings.subnet_settings[0].name))
- self.assertEqual(mac_addr, self.inst_creator.get_port_mac(self.port_1_name))
+ self.port_1_name,
+ subnet_name=self.net_config.network_settings.subnet_settings[
+ 0].name))
+ self.assertEqual(mac_addr,
+ self.inst_creator.get_port_mac(self.port_1_name))
def test_set_allowed_address_pairs(self):
"""
- Tests the creation of an OpenStack instance with a single port where max_allowed_address_pair is set.
+ Tests the creation of an OpenStack instance with a single port where
+ max_allowed_address_pair is set.
"""
ip = '10.55.0.101'
mac_addr = '0a:1b:2c:3d:4e:5f'
pair = {'ip_address': ip, 'mac_address': mac_addr}
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name, allowed_address_pairs=[pair])
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ allowed_address_pairs=[pair])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create(block=True)
port = self.inst_creator.get_port_by_name(port_settings.name)
self.assertIsNotNone(port)
self.assertIsNotNone(port['port'].get('allowed_address_pairs'))
self.assertEqual(1, len(port['port']['allowed_address_pairs']))
- validation_utils.objects_equivalent(pair, port['port']['allowed_address_pairs'][0])
+ validation_utils.objects_equivalent(pair, port['port'][
+ 'allowed_address_pairs'][0])
def test_set_allowed_address_pairs_bad_mac(self):
"""
- Tests the creation of an OpenStack instance with a single port where max_allowed_address_pair is set with an
- invalid MAC address.
+ Tests the creation of an OpenStack instance with a single port where
+ max_allowed_address_pair is set with an invalid MAC address.
"""
ip = '10.55.0.101'
mac_addr = 'foo'
pairs = set()
pairs.add((ip, mac_addr))
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name, allowed_address_pairs=[pair])
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ allowed_address_pairs=[pair])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
with self.assertRaises(Exception):
self.inst_creator.create()
def test_set_allowed_address_pairs_bad_ip(self):
"""
- Tests the creation of an OpenStack instance with a single port where max_allowed_address_pair is set with an
- invalid MAC address.
+ Tests the creation of an OpenStack instance with a single port where
+ max_allowed_address_pair is set with an invalid MAC address.
"""
ip = 'foo'
mac_addr = '0a:1b:2c:3d:4e:5f'
pairs = set()
pairs.add((ip, mac_addr))
port_settings = PortSettings(
- name=self.port_1_name, network_name=self.net_config.network_settings.name, allowed_address_pairs=[pair])
+ name=self.port_1_name,
+ network_name=self.net_config.network_settings.name,
+ allowed_address_pairs=[pair])
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings])
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
with self.assertRaises(Exception):
self.inst_creator.create()
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
try:
# Create Network
- self.network_creator = OpenStackNetwork(self.admin_os_creds, self.priv_net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.admin_os_creds, self.priv_net_config.network_settings)
self.network_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=guid + '-flavor-name', ram=512, disk=1, vcpus=1, metadata=self.flavor_metadata))
+ FlavorSettings(name=guid + '-flavor-name', ram=512, disk=1,
+ vcpus=1, metadata=self.flavor_metadata))
self.flavor_creator.create()
# Create Image
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
except Exception as e:
try:
inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message '
+ '- %s', e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
for zone in zones:
inst_name = self.vm_inst_name + '-' + zone
ctr += 1
- port_settings = PortSettings(name=self.port_base_name + '-' + str(ctr),
- network_name=self.priv_net_config.network_settings.name)
+ port_settings = PortSettings(
+ name=self.port_base_name + '-' + str(ctr),
+ network_name=self.priv_net_config.network_settings.name)
instance_settings = VmInstanceSettings(
- name=inst_name, flavor=self.flavor_creator.flavor_settings.name, availability_zone=zone,
+ name=inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ availability_zone=zone,
port_settings=[port_settings])
inst_creator = OpenStackVmInstance(
- self.admin_os_creds, instance_settings, self.image_creator.image_settings)
+ self.admin_os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creators.append(inst_creator)
inst_creator.create()
- # Validate instances to ensure they've been deployed to the correct server
+ # Validate instances to ensure they've been deployed to the correct
+ # server
index = 0
for zone in zones:
creator = self.inst_creators[index]
class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
"""
- Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP and eth1 w/o
+ Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
+ and eth1 w/o.
These tests require a Centos image
"""
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
self.port_2_name = self.guid + '-port-2'
self.floating_ip_name = self.guid + 'fip1'
self.priv_net_config = openstack_tests.get_priv_net_config(
- net_name=self.guid + '-priv-net', subnet_name=self.guid + '-priv-subnet',
- router_name=self.guid + '-priv-router', external_net=self.ext_net_name)
+ net_name=self.guid + '-priv-net',
+ subnet_name=self.guid + '-priv-subnet',
+ router_name=self.guid + '-priv-router',
+ external_net=self.ext_net_name)
self.pub_net_config = openstack_tests.get_pub_net_config(
- net_name=self.guid + '-pub-net', subnet_name=self.guid + '-pub-subnet',
- router_name=self.guid + '-pub-router', external_net=self.ext_net_name)
+ net_name=self.guid + '-pub-net',
+ subnet_name=self.guid + '-pub-subnet',
+ router_name=self.guid + '-pub-router',
+ external_net=self.ext_net_name)
image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
- os_image_settings = openstack_tests.centos_image_settings(name=image_name, image_metadata=self.image_metadata)
+ os_image_settings = openstack_tests.centos_image_settings(
+ name=image_name, image_metadata=self.image_metadata)
try:
# Create Image
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
# First network is public
- self.network_creators.append(OpenStackNetwork(self.os_creds, self.pub_net_config.network_settings))
+ self.network_creators.append(OpenStackNetwork(
+ self.os_creds, self.pub_net_config.network_settings))
# Second network is private
- self.network_creators.append(OpenStackNetwork(self.os_creds, self.priv_net_config.network_settings))
+ self.network_creators.append(OpenStackNetwork(
+ self.os_creds, self.priv_net_config.network_settings))
for network_creator in self.network_creators:
network_creator.create()
- self.router_creators.append(OpenStackRouter(self.os_creds, self.pub_net_config.router_settings))
- self.router_creators.append(OpenStackRouter(self.os_creds, self.priv_net_config.router_settings))
+ self.router_creators.append(OpenStackRouter(
+ self.os_creds, self.pub_net_config.router_settings))
+ self.router_creators.append(OpenStackRouter(
+ self.os_creds, self.priv_net_config.router_settings))
# Create Routers
for router_creator in self.router_creators:
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=self.guid + '-flavor-name', ram=512, disk=10, vcpus=2,
+ FlavorSettings(name=self.guid + '-flavor-name', ram=512,
+ disk=10, vcpus=2,
metadata=self.flavor_metadata))
self.flavor_creator.create()
# Create Keypair
self.keypair_creator = OpenStackKeypair(
self.os_creds, KeypairSettings(
- name=self.keypair_name, public_filepath=self.keypair_pub_filepath,
+ name=self.keypair_name,
+ public_filepath=self.keypair_pub_filepath,
private_filepath=self.keypair_priv_filepath))
self.keypair_creator.create()
sec_grp_name = self.guid + '-sec-grp'
- rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name, direction=Direction.ingress,
+ rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
+ direction=Direction.ingress,
protocol=Protocol.icmp)
- rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name, direction=Direction.ingress,
- protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
+ rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
+ direction=Direction.ingress,
+ protocol=Protocol.tcp,
+ port_range_min=22,
+ port_range_max=22)
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds,
- SecurityGroupSettings(name=sec_grp_name, rule_settings=[rule1, rule2]))
+ SecurityGroupSettings(name=sec_grp_name,
+ rule_settings=[rule1, rule2]))
self.sec_grp_creator.create()
except Exception as e:
self.tearDown()
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message '
+ '- %s', e)
if self.keypair_creator:
try:
self.keypair_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning keypair with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning keypair with message - %s',
+ e)
if os.path.isfile(self.keypair_pub_filepath):
os.remove(self.keypair_pub_filepath)
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
for router_creator in self.router_creators:
try:
router_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning router with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning router with message - %s',
+ e)
for network_creator in self.network_creators:
try:
network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.sec_grp_creator:
try:
self.sec_grp_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning security group with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning security group with message'
+ ' - %s', e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
def test_dual_ports_dhcp(self):
"""
- Tests the creation of an OpenStack instance with a dual ports/NICs with a DHCP assigned IP.
- NOTE: This test and any others that call ansible will most likely fail unless you do one of
- two things:
- 1. Have a ~/.ansible.cfg (or alternate means) to set host_key_checking = False
- 2. Set the following environment variable in your executing shell: ANSIBLE_HOST_KEY_CHECKING=False
- Should this not be performed, the creation of the host ssh key will cause your ansible calls to fail.
+ Tests the creation of an OpenStack instance with a dual ports/NICs with
+ a DHCP assigned IP.
+ NOTE: This test and any others that call ansible will most likely fail
+ unless you do one of two things:
+ 1. Have a ~/.ansible.cfg (or alternate means) to
+ set host_key_checking = False
+ 2. Set the following environment variable in your executing shell:
+ ANSIBLE_HOST_KEY_CHECKING=False
+ Should this not be performed, the creation of the host ssh key will
+ cause your ansible calls to fail.
"""
# Create ports/NICs for instance
ports_settings = []
# Create instance
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=ports_settings,
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=ports_settings,
floating_ip_settings=[FloatingIpSettings(
name=self.floating_ip_name, port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)])
self.inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings,
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
vm_inst = self.inst_creator.create(block=True)
self.assertTrue(check_dhcp_lease(vm_inst, ip))
# Add security group to VM
- self.inst_creator.add_security_group(self.sec_grp_creator.get_security_group())
+ self.inst_creator.add_security_group(
+ self.sec_grp_creator.get_security_group())
# Effectively blocks until VM's ssh port has been opened
self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
- # TODO - Refactor config_nics() to return a status that can be validated here.
+ # TODO - Refactor config_nics() to return a status that can be
+ # validated here.
self.inst_creator.config_nics()
# TODO - *** ADD VALIDATION HERE ***
# TODO - Add validation that both floating IPs work
# TODO - Add tests where only one NIC has a floating IP
- # TODO - Add tests where one attempts to place a floating IP on a network/router without an external gateway
+ # TODO - Add tests where one attempts to place a floating IP on a
+ # network/router without an external gateway
class InstanceSecurityGroupTests(OSIntegrationTestCase):
"""
Tests that include, add, and remove security groups from VM instances
"""
+
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
self.floating_ip_name = self.guid + 'fip1'
net_config = openstack_tests.get_priv_net_config(
- net_name=self.guid + '-pub-net', subnet_name=self.guid + '-pub-subnet',
- router_name=self.guid + '-pub-router', external_net=self.ext_net_name)
+ net_name=self.guid + '-pub-net',
+ subnet_name=self.guid + '-pub-subnet',
+ router_name=self.guid + '-pub-router',
+ external_net=self.ext_net_name)
# Initialize for tearDown()
self.image_creator = None
try:
# Create Image
- self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
+ self.image_creator = OpenStackImage(self.os_creds,
+ os_image_settings)
self.image_creator.create()
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, net_config.network_settings)
self.network_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=self.guid + '-flavor-name', ram=128, disk=10, vcpus=2,
+ FlavorSettings(name=self.guid + '-flavor-name', ram=128,
+ disk=10, vcpus=2,
metadata=self.flavor_metadata))
self.flavor_creator.create()
- self.port_settings = PortSettings(name=self.guid + '-port',
- network_name=net_config.network_settings.name)
+ self.port_settings = PortSettings(
+ name=self.guid + '-port',
+ network_name=net_config.network_settings.name)
except Exception as e:
self.tearDown()
raise e
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message -'
+ ' %s', e)
for sec_grp_creator in self.sec_grp_creators:
try:
sec_grp_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning security group with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning security group with message'
+ ' - %s', e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
"""
# Create instance
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create(block=True)
self.assertIsNotNone(vm_inst)
# Create security group object to add to instance
- sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name', description='hello group')
- sec_grp_creator = OpenStackSecurityGroup(self.os_creds, sec_grp_settings)
+ sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
+ description='hello group')
+ sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
+ sec_grp_settings)
sec_grp = sec_grp_creator.create()
self.sec_grp_creators.append(sec_grp_creator)
# Check that group has not been added
- self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
# Add security group to instance after activated
self.inst_creator.add_security_group(sec_grp)
# Validate that security group has been added
- self.assertTrue(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertTrue(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
def test_add_invalid_security_group(self):
"""
"""
# Create instance
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create(block=True)
self.assertIsNotNone(vm_inst)
# Create security group object to add to instance
- sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name', description='hello group')
- sec_grp_creator = OpenStackSecurityGroup(self.os_creds, sec_grp_settings)
+ sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
+ description='hello group')
+ sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
+ sec_grp_settings)
sec_grp = sec_grp_creator.create()
sec_grp_creator.clean()
self.sec_grp_creators.append(sec_grp_creator)
# Check that group has not been added
- self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
# Add security group to instance after activated
self.assertFalse(self.inst_creator.add_security_group(sec_grp))
# Validate that security group has been added
- self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
def test_remove_security_group(self):
"""
- Tests the removal of a security group created before and added to the instance.
+ Tests the removal of a security group created before and added to the
+ instance.
"""
# Create security group object to add to instance
- sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name', description='hello group')
- sec_grp_creator = OpenStackSecurityGroup(self.os_creds, sec_grp_settings)
+ sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
+ description='hello group')
+ sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
+ sec_grp_settings)
sec_grp = sec_grp_creator.create()
self.sec_grp_creators.append(sec_grp_creator)
# Create instance
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name,
- security_group_names=[sec_grp_settings.name], port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ security_group_names=[sec_grp_settings.name],
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create(block=True)
self.assertIsNotNone(vm_inst)
self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
# Validate that security group has been added
- self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
def test_remove_security_group_never_added(self):
"""
- Tests the removal of a security group that was never added in the first place.
+ Tests the removal of a security group that was never added in the first
+ place.
"""
# Create security group object to add to instance
- sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name', description='hello group')
- sec_grp_creator = OpenStackSecurityGroup(self.os_creds, sec_grp_settings)
+ sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
+ description='hello group')
+ sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
+ sec_grp_settings)
sec_grp = sec_grp_creator.create()
self.sec_grp_creators.append(sec_grp_creator)
# Create instance
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create(block=True)
self.assertIsNotNone(vm_inst)
# Check that group has been added
- self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
# Add security group to instance after activated
self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
# Validate that security group has been added
- self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertFalse(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
def test_add_same_security_group(self):
"""
- Tests the addition of a security group created before add added to the instance.
+ Tests the addition of a security group created before add added to the
+ instance.
"""
# Create security group object to add to instance
- sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name', description='hello group')
- sec_grp_creator = OpenStackSecurityGroup(self.os_creds, sec_grp_settings)
+ sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
+ description='hello group')
+ sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
+ sec_grp_settings)
sec_grp = sec_grp_creator.create()
self.sec_grp_creators.append(sec_grp_creator)
# Create instance
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name,
- security_group_names=[sec_grp_settings.name], port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ security_group_names=[sec_grp_settings.name],
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create(block=True)
self.assertIsNotNone(vm_inst)
# Check that group has been added
- self.assertTrue(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertTrue(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
# Add security group to instance after activated
self.assertTrue(self.inst_creator.add_security_group(sec_grp))
# Validate that security group has been added
- self.assertTrue(inst_has_sec_grp(self.inst_creator.get_vm_inst(), sec_grp_settings.name))
+ self.assertTrue(inst_has_sec_grp(self.inst_creator.get_vm_inst(),
+ sec_grp_settings.name))
def inst_has_sec_grp(vm_inst, sec_grp_name):
def validate_ssh_client(instance_creator):
"""
Returns True if instance_creator returns an SSH client that is valid
- :param instance_creator: the object responsible for creating the VM instance
+ :param instance_creator: the object responsible for creating the VM
+ instance
:return: T/F
"""
ssh_active = instance_creator.vm_ssh_active(block=True)
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
and 'disk_file' in self.image_metadata['cirros']:
metadata = self.image_metadata['cirros']
else:
- metadata = {'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
- 'kernel_url': openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
- 'ramdisk_url': openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
+ metadata = {
+ 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
+ 'kernel_url':
+ openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
+ 'ramdisk_url':
+ openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
image_settings = openstack_tests.cirros_image_settings(
name=self.image_name,
image_metadata=metadata)
- if not image_settings.ramdisk_image_settings or not image_settings.kernel_image_settings:
- logger.warn('3 Part image will not be tested. Image metadata has overridden this functionality')
+ if not image_settings.ramdisk_image_settings or not \
+ image_settings.kernel_image_settings:
+ logger.warn(
+ '3 Part image will not be tested. Image metadata has '
+ 'overridden this functionality')
self.image_creator = OpenStackImage(self.os_creds, image_settings)
self.image_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.admin_os_creds,
- FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10, vcpus=2, metadata=self.flavor_metadata))
+ FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
+ vcpus=2, metadata=self.flavor_metadata))
self.flavor_creator.create()
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, net_config.network_settings)
self.network_creator.create()
- self.port_settings = PortSettings(name=guid + '-port',
- network_name=net_config.network_settings.name)
+ self.port_settings = PortSettings(
+ name=guid + '-port',
+ network_name=net_config.network_settings.name)
except Exception as e:
self.tearDown()
raise e
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message -'
+ ' %s', e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.image_creator and not self.image_creator.image_settings.exists:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
super(self.__class__, self).__clean__()
"""
Tests the creation of an OpenStack instance from a 3-part image.
"""
- instance_settings = VmInstanceSettings(name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name,
- port_settings=[self.port_settings])
+ instance_settings = VmInstanceSettings(
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
- # The last created image is the main image from which we create the instance
+ # The last created image is the main image from which we create the
+ # instance
self.inst_creator = OpenStackVmInstance(
- self.os_creds, instance_settings, self.image_creator.image_settings)
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
vm_inst = self.inst_creator.create()
self.assertIsNotNone(vm_inst)
class CreateInstanceMockOfflineTests(OSComponentTestCase):
"""
- Tests the custom image_metadata that can be set by clients for handling images differently than the
- default behavior of the existing tests primarily for offline testing
+ Tests the custom image_metadata that can be set by clients for handling
+ images differently than the default behavior of the existing tests
+ primarily for offline testing
"""
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.inst_creator = None
self.priv_net_config = openstack_tests.get_priv_net_config(
- net_name=self.guid + '-priv-net', subnet_name=self.guid + '-priv-subnet')
+ net_name=self.guid + '-priv-net',
+ subnet_name=self.guid + '-priv-subnet')
self.port_settings = PortSettings(
- name=self.port_1_name, network_name=self.priv_net_config.network_settings.name)
+ name=self.port_1_name,
+ network_name=self.priv_net_config.network_settings.name)
try:
# Download image file
- self.image_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
+ self.image_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
# Create Network
- self.network_creator = OpenStackNetwork(self.os_creds, self.priv_net_config.network_settings)
+ self.network_creator = OpenStackNetwork(
+ self.os_creds, self.priv_net_config.network_settings)
self.network_creator.create()
# Create Flavor
self.flavor_creator = OpenStackFlavor(
self.os_creds,
FlavorSettings(
- name=self.guid + '-flavor-name', ram=128, disk=10, vcpus=1))
+ name=self.guid + '-flavor-name', ram=128, disk=10,
+ vcpus=1))
self.flavor_creator.create()
except Exception as e:
self.tearDown()
try:
self.inst_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning VM instance with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning VM instance with message - '
+ '%s', e)
if self.network_creator:
try:
self.network_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning network with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning network with message - %s',
+ e)
if self.flavor_creator:
try:
self.flavor_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning flavor with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning flavor with message - %s',
+ e)
if self.image_creator:
try:
self.image_creator.clean()
except Exception as e:
- logger.error('Unexpected exception cleaning image with message - ' + str(e))
+ logger.error(
+ 'Unexpected exception cleaning image with message - %s', e)
if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
shutil.rmtree(self.tmpDir)
def test_inst_from_file_image_simple_flat(self):
"""
- Creates a VM instance from a locally sourced file image using simply the 'disk_file' attribute vs.
- using the 'config' option which completely overrides all image settings
+ Creates a VM instance from a locally sourced file image using simply
+ the 'disk_file' attribute vs. using the 'config' option which
+ completely overrides all image settings
:return:
"""
metadata = {'disk_file': self.image_file.name}
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name, image_metadata=metadata)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=metadata)
self.assertEqual(self.image_file.name, os_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.image_user)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.image_user)
self.assertIsNone(os_image_settings.url)
self.assertFalse(os_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.format)
self.assertIsNone(os_image_settings.kernel_image_settings)
self.assertIsNone(os_image_settings.ramdisk_image_settings)
self.image_creator.create()
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
def test_inst_from_file_image_simple_nested(self):
"""
- Creates a VM instance from a locally sourced file image using simply the 'disk_file' attribute under 'cirros'
- vs. using the 'config' option which completely overrides all image settings
+ Creates a VM instance from a locally sourced file image using simply
+ the 'disk_file' attribute under 'cirros' vs. using the 'config' option
+ which completely overrides all image settings
:return:
"""
metadata = {'cirros': {'disk_file': self.image_file.name}}
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name, image_metadata=metadata)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=metadata)
self.assertEqual(self.image_file.name, os_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.image_user)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.image_user)
self.assertIsNone(os_image_settings.url)
self.assertFalse(os_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.format)
self.assertIsNone(os_image_settings.kernel_image_settings)
self.assertIsNone(os_image_settings.ramdisk_image_settings)
self.image_creator.create()
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
def test_inst_from_existing(self):
"""
- Creates a VM instance from a image creator that has been configured to use an existing image
+ Creates a VM instance from a image creator that has been configured to
+ use an existing image
:return:
"""
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
+ image_settings = self.image_creator.image_settings
test_image_creator = OpenStackImage(
- self.os_creds, ImageSettings(name=self.image_creator.image_settings.name,
- image_user=self.image_creator.image_settings.image_user, exists=True))
+ self.os_creds,
+ ImageSettings(name=image_settings.name,
+ image_user=image_settings.image_user,
+ exists=True))
test_image_creator.create()
- self.assertEqual(self.image_creator.get_image().id, test_image_creator.get_image().id)
+ self.assertEqual(self.image_creator.get_image().id,
+ test_image_creator.get_image().id)
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- test_image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ test_image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
def test_inst_from_file_image_complex(self):
"""
- Creates a VM instance from a locally sourced file image by overriding the default settings by using a dict()
- that can be read in by ImageSettings
+ Creates a VM instance from a locally sourced file image by overriding
+ the default settings by using a dict() that can be read in by
+ ImageSettings
:return:
"""
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
- metadata = {'cirros': {'config':
- {'name': os_image_settings.name, 'image_user': os_image_settings.image_user,
- 'exists': True}}}
- test_image_settings = openstack_tests.cirros_image_settings(image_metadata=metadata)
+ metadata = {
+ 'cirros':
+ {'config':
+ {'name': os_image_settings.name,
+ 'image_user': os_image_settings.image_user,
+ 'exists': True}}}
+ test_image_settings = openstack_tests.cirros_image_settings(
+ image_metadata=metadata)
test_image = OpenStackImage(self.os_creds, test_image_settings)
test_image.create()
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(self.os_creds,
+ instance_settings,
test_image_settings)
self.inst_creator.create()
def test_inst_from_file_3part_image_complex(self):
"""
- Creates a VM instance from a locally sourced file image by overriding the default settings by using a dict()
- that can be read in by ImageSettings
+ Creates a VM instance from a locally sourced file image by overriding
+ the default settings by using a dict() that can be read in by
+ ImageSettings
:return:
"""
- kernel_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
- ramdisk_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
-
- metadata = {'cirros':
- {'config':
- {'name': self.image_name,
- 'image_user': openstack_tests.CIRROS_USER,
- 'image_file': self.image_file.name,
- 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
- 'kernel_image_settings':
- {'name': self.image_name + '-kernel',
- 'image_user': openstack_tests.CIRROS_USER,
- 'image_file': kernel_file.name,
- 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
- 'ramdisk_image_settings':
- {'name': self.image_name + '-ramdisk',
- 'image_user': openstack_tests.CIRROS_USER,
- 'image_file': ramdisk_file.name,
- 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
-
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name, image_metadata=metadata)
+ kernel_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
+ ramdisk_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
+
+ metadata = {
+ 'cirros':
+ {'config':
+ {'name': self.image_name,
+ 'image_user': openstack_tests.CIRROS_USER,
+ 'image_file': self.image_file.name,
+ 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
+ 'kernel_image_settings':
+ {'name': self.image_name + '-kernel',
+ 'image_user': openstack_tests.CIRROS_USER,
+ 'image_file': kernel_file.name,
+ 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
+ 'ramdisk_image_settings':
+ {'name': self.image_name + '-ramdisk',
+ 'image_user': openstack_tests.CIRROS_USER,
+ 'image_file': ramdisk_file.name,
+ 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
+
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=metadata)
self.assertEqual(self.image_name, os_image_settings.name)
self.assertEqual(self.image_file.name, os_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.image_user)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.image_user)
self.assertIsNone(os_image_settings.url)
self.assertFalse(os_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.format)
self.assertIsNotNone(os_image_settings.kernel_image_settings)
- self.assertEqual(self.image_name + '-kernel', os_image_settings.kernel_image_settings.name)
- self.assertEqual(kernel_file.name, os_image_settings.kernel_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.kernel_image_settings.image_user)
+ self.assertEqual(self.image_name + '-kernel',
+ os_image_settings.kernel_image_settings.name)
+ self.assertEqual(kernel_file.name,
+ os_image_settings.kernel_image_settings.image_file)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.kernel_image_settings.image_user)
self.assertIsNone(os_image_settings.kernel_image_settings.url)
self.assertFalse(os_image_settings.kernel_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.kernel_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.kernel_image_settings.format)
self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
- self.assertEqual(self.image_name + '-ramdisk', os_image_settings.ramdisk_image_settings.name)
- self.assertEqual(ramdisk_file.name, os_image_settings.ramdisk_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.ramdisk_image_settings.image_user)
+ self.assertEqual(self.image_name + '-ramdisk',
+ os_image_settings.ramdisk_image_settings.name)
+ self.assertEqual(ramdisk_file.name,
+ os_image_settings.ramdisk_image_settings.image_file)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.ramdisk_image_settings.image_user)
self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.ramdisk_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.ramdisk_image_settings.format)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings, self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
def test_inst_from_file_3part_image_simple_flat(self):
"""
- Creates a VM instance from a 3-part image locally sourced from file images using simply the 'disk_file',
- 'kernel_file', and 'ramdisk_file' attributes vs. using the 'config' option which completely overrides all
+ Creates a VM instance from a 3-part image locally sourced from file
+ images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
+ attributes vs. using the 'config' option which completely overrides all
image settings
:return:
"""
- kernel_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
- ramdisk_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
+ kernel_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
+ ramdisk_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
- metadata = {'disk_file': self.image_file.name, 'kernel_file': kernel_file.name,
+ metadata = {'disk_file': self.image_file.name,
+ 'kernel_file': kernel_file.name,
'ramdisk_file': ramdisk_file.name}
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name, image_metadata=metadata)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=metadata)
self.assertEqual(self.image_name, os_image_settings.name)
self.assertEqual(self.image_file.name, os_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.image_user)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.image_user)
self.assertIsNone(os_image_settings.url)
self.assertFalse(os_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.format)
self.assertIsNotNone(os_image_settings.kernel_image_settings)
- self.assertEqual(self.image_name + '-kernel', os_image_settings.kernel_image_settings.name)
- self.assertEqual(kernel_file.name, os_image_settings.kernel_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.kernel_image_settings.image_user)
+ self.assertEqual(self.image_name + '-kernel',
+ os_image_settings.kernel_image_settings.name)
+ self.assertEqual(kernel_file.name,
+ os_image_settings.kernel_image_settings.image_file)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.kernel_image_settings.image_user)
self.assertIsNone(os_image_settings.kernel_image_settings.url)
self.assertFalse(os_image_settings.kernel_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.kernel_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.kernel_image_settings.format)
self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
- self.assertEqual(self.image_name + '-ramdisk', os_image_settings.ramdisk_image_settings.name)
- self.assertEqual(ramdisk_file.name, os_image_settings.ramdisk_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.ramdisk_image_settings.image_user)
+ self.assertEqual(self.image_name + '-ramdisk',
+ os_image_settings.ramdisk_image_settings.name)
+ self.assertEqual(ramdisk_file.name,
+ os_image_settings.ramdisk_image_settings.image_file)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.ramdisk_image_settings.image_user)
self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.ramdisk_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.ramdisk_image_settings.format)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
self.assertIsNotNone(self.image_creator.get_ramdisk_image())
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
def test_inst_from_file_3part_image_simple_nested(self):
"""
- Creates a VM instance from a 3-part image locally sourced from file images using simply the 'disk_file',
- 'kernel_file', and 'ramdisk_file' attributes under 'cirros' vs. using the 'config' option which completely
- overrides all image settings
+ Creates a VM instance from a 3-part image locally sourced from file
+ images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
+ attributes under 'cirros' vs. using the 'config' option which
+ completely overrides all image settings
:return:
"""
- kernel_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
- ramdisk_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
+ kernel_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
+ ramdisk_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
- metadata = {'cirros': {'disk_file': self.image_file.name, 'kernel_file': kernel_file.name,
+ metadata = {'cirros': {'disk_file': self.image_file.name,
+ 'kernel_file': kernel_file.name,
'ramdisk_file': ramdisk_file.name}}
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name, image_metadata=metadata)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=metadata)
self.assertEqual(self.image_name, os_image_settings.name)
self.assertEqual(self.image_file.name, os_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.image_user)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.image_user)
self.assertIsNone(os_image_settings.url)
self.assertFalse(os_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.format)
self.assertIsNotNone(os_image_settings.kernel_image_settings)
- self.assertEqual(self.image_name + '-kernel', os_image_settings.kernel_image_settings.name)
- self.assertEqual(kernel_file.name, os_image_settings.kernel_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.kernel_image_settings.image_user)
+ self.assertEqual(self.image_name + '-kernel',
+ os_image_settings.kernel_image_settings.name)
+ self.assertEqual(kernel_file.name,
+ os_image_settings.kernel_image_settings.image_file)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.kernel_image_settings.image_user)
self.assertIsNone(os_image_settings.kernel_image_settings.url)
self.assertFalse(os_image_settings.kernel_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.kernel_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.kernel_image_settings.format)
self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
- self.assertEqual(self.image_name + '-ramdisk', os_image_settings.ramdisk_image_settings.name)
- self.assertEqual(ramdisk_file.name, os_image_settings.ramdisk_image_settings.image_file)
- self.assertEqual(openstack_tests.CIRROS_USER, os_image_settings.ramdisk_image_settings.image_user)
+ self.assertEqual(self.image_name + '-ramdisk',
+ os_image_settings.ramdisk_image_settings.name)
+ self.assertEqual(ramdisk_file.name,
+ os_image_settings.ramdisk_image_settings.image_file)
+ self.assertEqual(openstack_tests.CIRROS_USER,
+ os_image_settings.ramdisk_image_settings.image_user)
self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
- self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT, os_image_settings.ramdisk_image_settings.format)
+ self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
+ os_image_settings.ramdisk_image_settings.format)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
self.assertIsNotNone(self.image_creator.get_ramdisk_image())
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- self.image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ self.image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
Creates a VM instance from a 3-part image that is existing
:return:
"""
- kernel_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
- ramdisk_file = file_utils.download(openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
+ kernel_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
+ ramdisk_file = file_utils.download(
+ openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
- metadata = {'cirros': {'disk_file': self.image_file.name, 'kernel_file': kernel_file.name,
+ metadata = {'cirros': {'disk_file': self.image_file.name,
+ 'kernel_file': kernel_file.name,
'ramdisk_file': ramdisk_file.name}}
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name, image_metadata=metadata)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=metadata)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
+ image_settings = self.image_creator.image_settings
test_image_creator = OpenStackImage(
- self.os_creds, ImageSettings(name=self.image_creator.image_settings.name,
- image_user=self.image_creator.image_settings.image_user, exists=True))
+ self.os_creds,
+ ImageSettings(name=image_settings.name,
+ image_user=image_settings.image_user,
+ exists=True))
test_image_creator.create()
- self.assertEqual(self.image_creator.get_image().id, test_image_creator.get_image().id)
+ self.assertEqual(self.image_creator.get_image().id,
+ test_image_creator.get_image().id)
instance_settings = VmInstanceSettings(
- name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=[self.port_settings])
- self.inst_creator = OpenStackVmInstance(self.os_creds, instance_settings,
- test_image_creator.image_settings)
+ name=self.vm_inst_name,
+ flavor=self.flavor_creator.flavor_settings.name,
+ port_settings=[self.port_settings])
+ self.inst_creator = OpenStackVmInstance(
+ self.os_creds, instance_settings,
+ test_image_creator.image_settings)
self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
def check_dhcp_lease(vm, ip, timeout=160):
"""
Returns true if the expected DHCP lease has been acquired
- :param vm:
- :param ip:
+ :param vm: the OpenStack VM instance object
+ :param ip: the IP address to look for
+ :param timeout: how long to query for IP address
:return:
"""
found = False
Code Review / snaps.git / commitdiff