def test_single_port_static(self):
"""
Tests the creation of an OpenStack instance with a single port with a static IP.
"""
port_settings = create_network.PortSettings(name='test-port-1',
ip_address=ip_1)
ports = [
neutron_utils.create_port(self.network_creator.neutron,
port_settings,
self.network_creator.network)
]
floating_ip_conf = {
'port_name': 'test-port-1',
'ext_net': pub_net_config.router_settings.external_gateway
}
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds,
vm_inst_name,
flavor,
self.image_creator,
ports,
self.os_image_settings.image_user,
floating_ip_conf=floating_ip_conf)
vm_inst = self.inst_creator.create()
self.assertEquals(
ip_1, self.inst_creator.ports[0]['port']['dns_assignment'][0]
['ip_address'])
self.assertTrue(self.inst_creator.vm_active(block=True))
# TODO - add check to ensure can ssh with timout. Commented line below will almost always return False on the
# first several attempts
# self.assertTrue(self.inst_creator._ssh_active())
self.assertEquals(vm_inst, self.inst_creator.vm)
def create_vm_instance(os_conn_config, instance_config, image, network_dict,
keypair_creator):
"""
Creates a VM instance
:param os_conn_config: The OpenStack credentials
:param instance_config: The VM instance configuration
:param image: The VM image
:param network_dict: A dictionary of network objects returned by OpenStack where the key contains the network name.
:param keypair_creator: The object responsible for creating the keypair associated with this VM instance.
:return: A reference to the VM instance object
"""
from openstack.create_network import PortSettings
from openstack.create_instance import OpenStackVmInstance
os_creds = get_os_credentials(os_conn_config)
neutron = neutron_utils.neutron_client(os_creds)
config = instance_config['instance']
ports_config = config['ports']
existing_ports = neutron.list_ports()['ports']
ports = list()
for port_config in ports_config:
network_name = port_config['port']['network_name']
port_name = port_config['port']['name']
found = False
for existing_port in existing_ports:
if existing_port['name'] == port_name:
existing_port_dict = {'port': existing_port}
ports.append(existing_port_dict)
found = True
if not found:
os_network_obj = network_dict.get(network_name)
if os_network_obj:
logger.info('Creating port [' + port_config['port']['name'] +
'] for network name - ' + network_name)
port_setting = PortSettings(port_config)
ports.append(
neutron_utils.create_port(neutron, port_setting,
os_network_obj.network,
os_network_obj.subnet))
else:
logger.warn(
'Cannot create port as associated network name of [' +
network_name + '] not configured.')
raise Exception
from openstack.create_image import OpenStackImage
# TODO - need to configure in the image username
image_creator = OpenStackImage(image=image, image_user='******')
vm_inst = OpenStackVmInstance(os_creds, config['name'], config['flavor'],
image_creator, ports, config['sudo_user'],
keypair_creator, config.get('floating_ip'))
vm_inst.create()
return vm_inst
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
within OpenStack
"""
# Create Image
self.os_image_settings = openstack_tests.get_instance_image_settings()
self.image_creator = create_image.OpenStackImage(self.os_creds, self.os_image_settings.image_user,
self.os_image_settings.format,
self.os_image_settings.url,
self.os_image_settings.name,
self.os_image_settings.download_file_path)
self.image_creator.create()
# Create Network
self.network_creators = list()
# First network is public
self.network_creators.append(create_network.OpenStackNetwork(self.os_creds, pub_net_config.network_settings,
pub_net_config.subnet_settings,
pub_net_config.router_settings))
# Second network is private
self.network_creators.append(create_network.OpenStackNetwork(self.os_creds, priv_net_config.network_settings,
priv_net_config.subnet_settings,
priv_net_config.router_settings))
for network_creator in self.network_creators:
network_creator.create()
self.keypair_creator = create_keypairs.OpenStackKeypair(self.os_creds,
create_keypairs.KeypairSettings(name=keypair_name,
public_filepath=keypair_pub_filepath,
private_filepath=keypair_priv_filepath))
self.keypair_creator.create()
floating_ip_conf = dict()
ports = []
for network_creator in self.network_creators:
idx = self.network_creators.index(network_creator)
# port_name = 'test-port-' + `idx`
port_name = 'test-port-' + repr(idx)
if idx == 0:
floating_ip_conf = {'port_name': port_name, 'ext_net': pub_net_config.router_settings.external_gateway}
port_settings = create_network.PortSettings(name=port_name)
ports.append(neutron_utils.create_port(network_creator.neutron, port_settings, network_creator.network))
# Create instance
self.inst_creator = create_instance.OpenStackVmInstance(self.os_creds, vm_inst_name, flavor,
self.image_creator, ports,
self.os_image_settings.image_user,
keypair_creator=self.keypair_creator,
floating_ip_conf=floating_ip_conf)
self.inst_creator.create()
self.test_file_local_path = '/tmp/hello.txt'
def test_create_port_invalid_ip_to_subnet(self):
"""
Tests the neutron_utils.create_port() function for an Exception when the IP value is None
"""
self.network = neutron_utils.create_network(self.neutron, self.net_config.network_settings)
self.assertEqual(self.net_config.net_name, self.network['network']['name'])
self.assertTrue(validate_network(self.neutron, self.net_config.net_name, True))
self.subnet = neutron_utils.create_subnet(self.neutron, self.net_config.subnet_settings, self.network)
validate_subnet(self.neutron, self.net_config.subnet_name, self.net_config.subnet_cidr, True)
with self.assertRaises(Exception):
self.port = neutron_utils.create_port(self.neutron, port_name, self.network, '10.197.123.100')
def test_create_port_null_network_object(self):
"""
Tests the neutron_utils.create_port() function for an Exception when the network object is None
"""
self.network = neutron_utils.create_network(self.neutron, self.net_config.network_settings)
self.assertEqual(self.net_config.net_name, self.network['network']['name'])
self.assertTrue(validate_network(self.neutron, self.net_config.net_name, True))
self.subnet = neutron_utils.create_subnet(self.neutron, self.net_config.subnet_settings, self.network)
validate_subnet(self.neutron, self.net_config.subnet_name, self.net_config.subnet_cidr, True)
with self.assertRaises(Exception):
self.port = neutron_utils.create_port(self.neutron, port_name, None, ip_1)
def test_create_port_empty_name(self):
"""
Tests the neutron_utils.create_port() function
"""
self.network = neutron_utils.create_network(self.neutron, self.net_config.network_settings)
self.assertEqual(self.net_config.net_name, self.network['network']['name'])
self.assertTrue(validate_network(self.neutron, self.net_config.net_name, True))
self.subnet = neutron_utils.create_subnet(self.neutron, self.net_config.subnet_settings, self.network)
validate_subnet(self.neutron, self.net_config.subnet_name, self.net_config.subnet_cidr, True)
self.port = neutron_utils.create_port(self.neutron, create_network.PortSettings(ip_address=ip_1), self.network)
validate_port(self.neutron, port_name, True)
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.
"""
floating_ip_conf = dict()
# Create ports/NICs for instance
ports = []
for network_creator in self.network_creators:
idx = self.network_creators.index(network_creator)
# port_name = 'test-port-' + `idx`
port_name = 'test-port-' + repr(idx)
if idx == 0:
floating_ip_conf = {
'port_name': port_name,
'ext_net': pub_net_config.router_settings.external_gateway
}
port_settings = create_network.PortSettings(name=port_name)
ports.append(
neutron_utils.create_port(network_creator.neutron,
port_settings,
network_creator.network))
# Create instance
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds,
vm_inst_name,
flavor,
self.image_creator,
ports,
self.os_image_settings.image_user,
keypair_creator=self.keypair_creator,
floating_ip_conf=floating_ip_conf)
vm_inst = self.inst_creator.create()
self.assertEquals(vm_inst, self.inst_creator.vm)
# Effectively blocks until VM has been properly activated
self.assertTrue(self.inst_creator.vm_active(block=True))
# Effectively blocks until VM's ssh port has been opened
self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
self.inst_creator.config_rpm_nics()
def test_single_port_dhcp(self):
"""
Tests the creation of an OpenStack instance with a single port with a DHCP assigned IP.
"""
port_settings = create_network.PortSettings(name='test-port-1')
ports = [neutron_utils.create_port(self.network_creator.neutron, port_settings, self.network_creator.network)]
self.inst_creator = create_instance.OpenStackVmInstance(self.os_creds, vm_inst_name, flavor,
self.image_creator, ports,
self.os_image_settings.image_user)
vm_inst = self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
# TODO - add check to ensure can ssh with timout. Commented line below will almost always return False on the
# first several attempts
# self.assertTrue(self.inst_creator._ssh_active())
self.assertEquals(vm_inst, self.inst_creator.vm)
def test_single_port_static(self):
"""
Tests the creation of an OpenStack instance with a single port with a static IP.
"""
port_settings = create_network.PortSettings(name='test-port-1', ip_address=ip_1)
ports = [neutron_utils.create_port(self.network_creator.neutron, port_settings, self.network_creator.network)]
floating_ip_conf = {'port_name': 'test-port-1', 'ext_net': pub_net_config.router_settings.external_gateway}
self.inst_creator = create_instance.OpenStackVmInstance(self.os_creds, vm_inst_name, flavor,
self.image_creator, ports,
self.os_image_settings.image_user,
floating_ip_conf=floating_ip_conf)
vm_inst = self.inst_creator.create()
self.assertEquals(ip_1, self.inst_creator.ports[0]['port']['dns_assignment'][0]['ip_address'])
self.assertTrue(self.inst_creator.vm_active(block=True))
# TODO - add check to ensure can ssh with timout. Commented line below will almost always return False on the
# first several attempts
# self.assertTrue(self.inst_creator._ssh_active())
self.assertEquals(vm_inst, self.inst_creator.vm)
def test_single_port_dhcp(self):
"""
Tests the creation of an OpenStack instance with a single port with a DHCP assigned IP.
"""
port_settings = create_network.PortSettings(name='test-port-1')
ports = [
neutron_utils.create_port(self.network_creator.neutron,
port_settings,
self.network_creator.network)
]
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds, vm_inst_name, flavor, self.image_creator, ports,
self.os_image_settings.image_user)
vm_inst = self.inst_creator.create()
self.assertTrue(self.inst_creator.vm_active(block=True))
# TODO - add check to ensure can ssh with timout. Commented line below will almost always return False on the
# first several attempts
# self.assertTrue(self.inst_creator._ssh_active())
self.assertEquals(vm_inst, self.inst_creator.vm)
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.
"""
floating_ip_conf = dict()
# Create ports/NICs for instance
ports = []
for network_creator in self.network_creators:
idx = self.network_creators.index(network_creator)
# port_name = 'test-port-' + `idx`
port_name = 'test-port-' + repr(idx)
if idx == 0:
floating_ip_conf = {'port_name': port_name, 'ext_net': pub_net_config.router_settings.external_gateway}
port_settings = create_network.PortSettings(name=port_name)
ports.append(neutron_utils.create_port(network_creator.neutron, port_settings, network_creator.network))
# Create instance
self.inst_creator = create_instance.OpenStackVmInstance(self.os_creds, vm_inst_name, flavor,
self.image_creator, ports,
self.os_image_settings.image_user,
keypair_creator=self.keypair_creator,
floating_ip_conf=floating_ip_conf)
vm_inst = self.inst_creator.create()
self.assertEquals(vm_inst, self.inst_creator.vm)
# Effectively blocks until VM has been properly activated
self.assertTrue(self.inst_creator.vm_active(block=True))
# Effectively blocks until VM's ssh port has been opened
self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
self.inst_creator.config_rpm_nics()
