def test_name_priv_only(self):
settings = KeypairConfig(name='foo', private_filepath='/foo/bar')
self.assertEqual('foo', settings.name)
self.assertEqual(1024, settings.key_size)
self.assertIsNone(settings.public_filepath)
self.assertEqual('/foo/bar', settings.private_filepath)
self.assertIsNone(settings.delete_on_clean)
def test_config_with_name_only(self):
settings = KeypairConfig(**{'name': 'foo'})
self.assertEqual('foo', settings.name)
self.assertEqual(1024, settings.key_size)
self.assertIsNone(settings.public_filepath)
self.assertIsNone(settings.private_filepath)
self.assertIsNone(settings.delete_on_clean)
def test_create_keypair_from_file(self):
"""
Tests the creation of an existing public keypair from a file
:return:
"""
keys = nova_utils.create_keys()
file_utils.save_keys_to_files(keys=keys,
pub_file_path=self.pub_file_path)
self.keypair_creator = OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.pub_file_path))
self.keypair_creator.create()
keypair = nova_utils.keypair_exists(self.nova,
self.keypair_creator.get_keypair())
self.assertEqual(self.keypair_creator.get_keypair(), keypair)
pub_file = None
try:
pub_file = open(os.path.expanduser(self.pub_file_path))
file_key = pub_file.read()
self.assertEqual(self.keypair_creator.get_keypair().public_key,
file_key)
finally:
if pub_file:
pub_file.close()
self.assertEqual(self.keypair_creator.get_keypair().public_key,
file_key)
def test_create_keypair_save_both(self):
"""
Tests the creation of a generated keypair and saves both private and
public key files[
:return:
"""
self.keypair_creator = OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.pub_file_path,
private_filepath=self.priv_file_path))
self.keypair_creator.create()
keypair = nova_utils.keypair_exists(self.nova,
self.keypair_creator.get_keypair())
self.assertEqual(self.keypair_creator.get_keypair(), keypair)
pub_file = None
try:
pub_file = open(os.path.expanduser(self.pub_file_path))
file_key = pub_file.read()
self.assertEqual(self.keypair_creator.get_keypair().public_key,
file_key)
finally:
if pub_file:
pub_file.close()
self.assertEqual(self.keypair_creator.get_keypair().public_key,
file_key)
self.assertTrue(os.path.isfile(self.priv_file_path))
def setUp(self):
"""
Instantiates the CreateClusterTemplate object that is responsible for
downloading and creating an OS template config file within OpenStack
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.cluster_type_name = self.guid + '-cluster-type'
self.magnum = magnum_utils.magnum_client(self.os_creds,
self.os_session)
metadata = self.image_metadata
if not metadata:
metadata = dict()
if 'extra_properties' not in metadata:
metadata['extra_properties'] = dict()
metadata['extra_properties']['os_distro'] = 'cirros'
os_image_settings = openstack_tests.cirros_image_settings(
name=self.guid + '-image', image_metadata=metadata)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
flavor_config = openstack_tests.get_flavor_config(
name=self.guid + '-flavor',
ram=512,
disk=10,
vcpus=1,
metadata=self.flavor_metadata)
self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config)
keypair_priv_filepath = 'tmp/' + self.guid
keypair_pub_filepath = keypair_priv_filepath + '.pub'
self.keypair_creator = OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.guid + '-keypair',
public_filepath=keypair_pub_filepath,
private_filepath=keypair_priv_filepath))
self.cluster_template_creator = None
self.cluster_template_config = ClusterTemplateConfig(
name=self.cluster_type_name,
image=self.image_creator.image_settings.name,
keypair=self.keypair_creator.keypair_settings.name,
external_net=self.ext_net_name,
flavor=self.flavor_creator.flavor_settings.name)
try:
self.image_creator.create()
self.flavor_creator.create()
self.keypair_creator.create()
except:
self.tearDown()
raise
def test_all_delete_str_false_cap(self):
settings = KeypairConfig(name='foo',
public_filepath='/foo/bar.pub',
private_filepath='/foo/bar',
delete_on_clean='False')
self.assertEqual('foo', settings.name)
self.assertEqual(1024, settings.key_size)
self.assertEqual('/foo/bar.pub', settings.public_filepath)
self.assertEqual('/foo/bar', settings.private_filepath)
self.assertFalse(settings.delete_on_clean)
def test_all_delete_bool(self):
settings = KeypairConfig(name='foo',
public_filepath='/foo/bar.pub',
private_filepath='/foo/bar',
delete_on_clean=True,
key_size=999)
self.assertEqual('foo', settings.name)
self.assertEqual(999, settings.key_size)
self.assertEqual('/foo/bar.pub', settings.public_filepath)
self.assertEqual('/foo/bar', settings.private_filepath)
self.assertTrue(settings.delete_on_clean)
def test_create_keypair_only(self):
"""
Tests the creation of a generated keypair without saving to file
:return:
"""
self.keypair_creator = OpenStackKeypair(
self.os_creds, KeypairConfig(name=self.keypair_name))
self.keypair_creator.create()
keypair = nova_utils.keypair_exists(self.nova,
self.keypair_creator.get_keypair())
self.assertEqual(self.keypair_creator.get_keypair(), keypair)
def test_config_all_delete_false_str_lc(self):
settings = KeypairConfig(
**{
'name': 'foo',
'public_filepath': '/foo/bar.pub',
'private_filepath': '/foo/bar',
'delete_on_clean': 'false'
})
self.assertEqual('foo', settings.name)
self.assertEqual(1024, settings.key_size)
self.assertEqual('/foo/bar.pub', settings.public_filepath)
self.assertEqual('/foo/bar', settings.private_filepath)
self.assertFalse(settings.delete_on_clean)
def create_keypair_config(heat_cli, stack, keypair, pk_output_key):
"""
Instantiates a KeypairConfig object from a Keypair domain objects
:param heat_cli: the heat client
:param stack: the Stack domain object
:param keypair: the Keypair SNAPS domain object
:param pk_output_key: the key to the heat template's outputs for retrieval
of the private key file
:return: a KeypairConfig object
"""
if pk_output_key:
outputs = heat_utils.get_outputs(heat_cli, stack)
for output in outputs:
if output.key == pk_output_key:
# Save to file
guid = uuid.uuid4()
key_file = file_utils.save_string_to_file(
output.value, str(guid), 0o400)
# Use outputs, file and resources for the KeypairConfig
return KeypairConfig(name=keypair.name,
private_filepath=key_file.name)
return KeypairConfig(name=keypair.name)
def test_vping_ssh(self, create_vm, path_exists, flavor_create,
get_port_ip, vm_active, ssh_active, ssh_client,
scp_client, trans_script, do_vping_ssh, ext_net_name):
os_vm_inst = mock.MagicMock(name='get_console_output')
os_vm_inst.get_console_output.return_value = 'vPing OK'
ssh_client = mock.MagicMock(name='get_transport')
ssh_client.get_transport.return_value = None
scp_client = mock.MagicMock(name='put')
scp_client.put.return_value = None
with mock.patch('snaps.openstack.utils.deploy_utils.create_image',
return_value=OpenStackImage(self.os_creds, None)), \
mock.patch('snaps.openstack.utils.deploy_utils.create_network',
return_value=OpenStackNetwork(
self.os_creds,
NetworkConfig(
name='foo',
subnet_settings=[
SubnetConfig(
name='bar',
cidr='10.0.0.1/24')]))), \
mock.patch('snaps.openstack.utils.deploy_utils.'
'create_vm_instance',
return_value=OpenStackVmInstance(
self.os_creds,
VmInstanceConfig(
name='foo', flavor='bar',
port_settings=[PortConfig(
name='foo', network_name='bar')]),
None)), \
mock.patch('snaps.openstack.utils.deploy_utils.create_keypair',
return_value=OpenStackKeypair(
self.os_creds, KeypairConfig(name='foo'))), \
mock.patch('snaps.openstack.utils.deploy_utils.create_router',
return_value=OpenStackRouter(
self.os_creds, RouterConfig(name='foo'))), \
mock.patch('snaps.openstack.utils.deploy_utils.'
'create_security_group',
return_value=OpenStackSecurityGroup(
self.os_creds,
SecurityGroupConfig(name='foo'))), \
mock.patch('snaps.openstack.create_instance.'
'OpenStackVmInstance.'
'get_vm_inst', return_value=os_vm_inst), \
mock.patch('snaps.openstack.create_instance.'
'OpenStackVmInstance.'
'ssh_client', return_value=ssh_client):
self.assertEquals(TestCase.EX_OK, self.vping_ssh.run())
def test_create_keypair_gen_files_delete_1(self):
"""
Tests the creation of a generated keypair and ensures that the files
are deleted on clean()
:return:
"""
self.keypair_creator = OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.pub_file_path,
private_filepath=self.priv_file_path))
self.keypair_creator.create()
self.keypair_creator.clean()
self.assertFalse(file_utils.file_exists(self.pub_file_path))
self.assertFalse(file_utils.file_exists(self.priv_file_path))
def test_create_keypair_exist_files_delete(self):
"""
Tests the creation of an existing public keypair and ensures the files
are deleted on clean
:return:
"""
keys = nova_utils.create_keys()
file_utils.save_keys_to_files(keys=keys,
pub_file_path=self.pub_file_path,
priv_file_path=self.priv_file_path)
self.keypair_creator = OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.pub_file_path,
private_filepath=self.priv_file_path,
delete_on_clean=True))
self.keypair_creator.create()
self.keypair_creator.clean()
self.assertFalse(file_utils.file_exists(self.pub_file_path))
self.assertFalse(file_utils.file_exists(self.priv_file_path))
def test_create_delete_keypair(self):
"""
Tests the creation then deletion of an OpenStack keypair to ensure
clean() does not raise an Exception.
"""
# Create Image
self.keypair_creator = OpenStackKeypair(
self.os_creds, KeypairConfig(name=self.keypair_name))
created_keypair = self.keypair_creator.create()
self.assertIsNotNone(created_keypair)
# Delete Image manually
nova_utils.delete_keypair(self.nova, created_keypair)
self.assertIsNone(
nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
# Must not throw an exception when attempting to cleanup non-existent
# image
self.keypair_creator.clean()
self.assertIsNone(self.keypair_creator.get_keypair())
def setUp(self):
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.cluster_type_name = self.guid + '-cluster-type'
self.magnum = magnum_utils.magnum_client(
self.os_creds, self.os_session)
metadata = self.image_metadata
if not metadata:
metadata = dict()
if 'extra_properties' not in metadata:
metadata['extra_properties'] = dict()
metadata['extra_properties']['os_distro'] = 'cirros'
os_image_settings = openstack_tests.cirros_image_settings(
name=self.guid + '-image', image_metadata=metadata)
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.flavor_creator = OpenStackFlavor(
self.os_creds, FlavorConfig(
name=self.guid + '-flavor', ram=512, disk=10, vcpus=1))
keypair_priv_filepath = 'tmp/' + self.guid
keypair_pub_filepath = keypair_priv_filepath + '.pub'
self.keypair_creator = OpenStackKeypair(
self.os_creds, KeypairConfig(
name=self.guid + '-keypair',
public_filepath=keypair_pub_filepath,
private_filepath=keypair_priv_filepath))
self.cluster_template = None
try:
self.image_creator.create()
self.flavor_creator.create()
self.keypair_creator.create()
except:
self.tearDown()
raise
def determine_keypair_config(heat_cli,
stack,
server,
keypair_settings=None,
priv_key_key=None):
"""
Returns a KeypairConfig object from the list that matches the
server.keypair_name value in the keypair_settings parameter if not None,
else if the output_key is not None, the output's value when contains the
string 'BEGIN RSA PRIVATE KEY', this value will be stored into a file and
encoded into the KeypairConfig object returned
:param heat_cli: the OpenStack heat client
:param stack: a SNAPS-OO Stack domain object
:param server: a SNAPS-OO VmInst domain object
:param keypair_settings: list of KeypairConfig objects
:param priv_key_key: the stack options that holds the private key value
:return: KeypairConfig or None
"""
# Existing keypair being used by Heat Template
if keypair_settings:
for keypair_setting in keypair_settings:
if server.keypair_name == keypair_setting.name:
return keypair_setting
# Keypair created by Heat template
if priv_key_key:
outputs = heat_utils.get_outputs(heat_cli, stack)
for output in outputs:
if output.key == priv_key_key:
# Save to file
guid = uuid.uuid4()
key_file = file_utils.save_string_to_file(
output.value, str(guid), 0o400)
# Use outputs, file and resources for the KeypairConfig
return KeypairConfig(name=server.keypair_name,
private_filepath=key_file.name)
def test_empty_config(self):
with self.assertRaises(KeypairConfigError):
KeypairConfig(**dict())
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.keypair_priv_filepath = 'tmp/' + guid
self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
self.keypair_name = guid + '-kp'
self.vm_inst_name = guid + '-inst'
self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
self.port_1_name = guid + '-port-1'
self.port_2_name = guid + '-port-2'
self.floating_ip_name = guid + 'fip1'
# Setup members to cleanup just in case they don't get created
self.inst_creator = None
self.keypair_creator = None
self.sec_grp_creator = None
self.flavor_creator = None
self.router_creator = None
self.network_creator = None
self.image_creator = None
try:
# Create Image
os_image_settings = openstack_tests.ubuntu_image_settings(
name=guid + '-' + '-image', image_metadata=self.image_metadata)
self.image_creator = create_image.OpenStackImage(
self.os_creds, os_image_settings)
self.image_creator.create()
# First network is public
self.pub_net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name=guid + '-pub-net',
mtu=1442,
subnet_name=guid + '-pub-subnet',
router_name=guid + '-pub-router',
external_net=self.ext_net_name)
self.network_creator = create_network.OpenStackNetwork(
self.os_creds, self.pub_net_config.network_settings)
self.network_creator.create()
# Create routers
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.pub_net_config.router_settings)
self.router_creator.create()
# Create Flavor
flavor_config = openstack_tests.get_flavor_config(
name=guid + '-flavor-name',
ram=2048,
disk=10,
vcpus=2,
metadata=self.flavor_metadata)
self.flavor_creator = create_flavor.OpenStackFlavor(
self.admin_os_creds, flavor_config)
self.flavor_creator.create()
# Create Key/Pair
self.keypair_creator = create_keypairs.OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.keypair_pub_filepath,
private_filepath=self.keypair_priv_filepath))
self.keypair_creator.create()
# Create Security Group
sec_grp_name = guid + '-sec-grp'
rule1 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.icmp)
rule2 = SecurityGroupRuleConfig(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,
SecurityGroupConfig(name=sec_grp_name,
rule_settings=[rule1, rule2]))
self.sec_grp_creator.create()
# Create instance
ports_settings = list()
ports_settings.append(
PortConfig(
name=self.port_1_name,
network_name=self.pub_net_config.network_settings.name))
instance_settings = VmInstanceConfig(
name=self.vm_inst_name,
flavor=self.flavor_creator.flavor_settings.name,
port_settings=ports_settings,
floating_ip_settings=[
FloatingIpConfig(
name=self.floating_ip_name,
port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)
])
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds,
instance_settings,
self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
except:
self.tearDown()
raise
def deploy_orchestrator(self):
"""
Deploy Cloudify Manager.
network, security group, fip, VM creation
"""
# network creation
start_time = time.time()
self.__logger.info("Creating keypair ...")
kp_file = os.path.join(self.data_dir, "cloudify_ims.pem")
keypair_settings = KeypairConfig(name='cloudify_ims_kp',
private_filepath=kp_file)
keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings)
keypair_creator.create()
self.created_object.append(keypair_creator)
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(name='cloudify_ims_subnet',
cidr='10.67.79.0/24')
network_settings = NetworkConfig(name='cloudify_ims_network',
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
router_creator = OpenStackRouter(
self.snaps_creds,
RouterConfig(name='cloudify_ims_router',
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
# security group creation
self.__logger.info("Creating security group for cloudify manager vm")
sg_rules = list()
sg_rules.append(
SecurityGroupRuleConfig(sec_grp_name="sg-cloudify-manager",
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=1,
port_range_max=65535))
sg_rules.append(
SecurityGroupRuleConfig(sec_grp_name="sg-cloudify-manager",
direction=Direction.ingress,
protocol=Protocol.udp,
port_range_min=1,
port_range_max=65535))
securit_group_creator = OpenStackSecurityGroup(
self.snaps_creds,
SecurityGroupConfig(name="sg-cloudify-manager",
rule_settings=sg_rules))
securit_group_creator.create()
self.created_object.append(securit_group_creator)
# orchestrator VM flavor
self.__logger.info("Get or create flavor for cloudify manager vm ...")
flavor_settings = FlavorConfig(
name=self.orchestrator['requirements']['flavor']['name'],
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=50,
vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
image_settings = ImageConfig(
name=self.orchestrator['requirements']['os_image'],
image_user='******',
exists=True)
port_settings = PortConfig(name='cloudify_manager_port',
network_name=network_settings.name)
manager_settings = VmInstanceConfig(
name='cloudify_manager',
flavor=flavor_settings.name,
port_settings=[port_settings],
security_group_names=[securit_group_creator.sec_grp_settings.name],
floating_ip_settings=[
FloatingIpConfig(
name='cloudify_manager_fip',
port_name=port_settings.name,
router_name=router_creator.router_settings.name)
])
manager_creator = OpenStackVmInstance(self.snaps_creds,
manager_settings, image_settings,
keypair_settings)
self.__logger.info("Creating cloudify manager VM")
manager_creator.create()
self.created_object.append(manager_creator)
public_auth_url = keystone_utils.get_endpoint(self.snaps_creds,
'identity')
self.__logger.info("Set creds for cloudify manager")
cfy_creds = dict(keystone_username=self.snaps_creds.username,
keystone_password=self.snaps_creds.password,
keystone_tenant_name=self.snaps_creds.project_name,
keystone_url=public_auth_url)
cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip,
username='******',
password='******',
tenant='default_tenant')
self.orchestrator['object'] = cfy_client
self.__logger.info("Attemps running status of the Manager")
cfy_status = None
retry = 10
while str(cfy_status) != 'running' and retry:
try:
cfy_status = cfy_client.manager.get_status()['status']
self.__logger.debug("The current manager status is %s",
cfy_status)
except Exception: # pylint: disable=broad-except
self.__logger.warning("Cloudify Manager isn't " +
"up and running. Retrying ...")
retry = retry - 1
time.sleep(30)
if str(cfy_status) == 'running':
self.__logger.info("Cloudify Manager is up and running")
else:
raise Exception("Cloudify Manager isn't up and running")
self.__logger.info("Put OpenStack creds in manager")
secrets_list = cfy_client.secrets.list()
for k, val in cfy_creds.iteritems():
if not any(d.get('key', None) == k for d in secrets_list):
cfy_client.secrets.create(k, val)
else:
cfy_client.secrets.update(k, val)
duration = time.time() - start_time
self.__logger.info("Put private keypair in manager")
if manager_creator.vm_ssh_active(block=True):
ssh = manager_creator.ssh_client()
scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
scp.put(kp_file, '~/')
cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/"
run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
run_blocking_ssh_command(ssh, cmd)
cmd = "sudo yum install -y gcc python-devel"
run_blocking_ssh_command(
ssh, cmd, "Unable to install packages \
on manager")
self.details['orchestrator'].update(status='PASS', duration=duration)
self.vnf['inputs'].update(
dict(external_network_name=ext_net_name,
network_name=network_settings.name))
self.result = 1 / 3 * 100
return True
def deploy_orchestrator(self):
# pylint: disable=too-many-locals,too-many-statements
"""
Deploy Cloudify Manager.
network, security group, fip, VM creation
"""
start_time = time.time()
# orchestrator VM flavor
self.__logger.info("Get or create flavor for cloudify manager vm ...")
flavor_settings = FlavorConfig(
name="{}-{}".format(
self.orchestrator['requirements']['flavor']['name'],
self.uuid),
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=50,
vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
self.__logger.info("Creating a second user to bypass issues ...")
user_creator = OpenStackUser(
self.snaps_creds,
UserConfig(
name='cloudify_network_bug-{}'.format(self.uuid),
password=str(uuid.uuid4()),
project_name=self.tenant_name,
domain_name=self.snaps_creds.user_domain_name,
roles={'_member_': self.tenant_name}))
user_creator.create()
self.created_object.append(user_creator)
snaps_creds = user_creator.get_os_creds(self.snaps_creds.project_name)
self.__logger.debug("snaps creds: %s", snaps_creds)
self.__logger.info("Creating keypair ...")
kp_file = os.path.join(self.data_dir, "cloudify_ims.pem")
keypair_settings = KeypairConfig(
name='cloudify_ims_kp-{}'.format(self.uuid),
private_filepath=kp_file)
keypair_creator = OpenStackKeypair(snaps_creds, keypair_settings)
keypair_creator.create()
self.created_object.append(keypair_creator)
# needs some images
self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_file in self.images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(
snaps_creds,
ImageConfig(
name=image_name, image_user='******',
img_format='qcow2', image_file=image_file))
image_creator.create()
self.created_object.append(image_creator)
# network creation
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(
name='cloudify_ims_subnet-{}'.format(self.uuid),
cidr='10.67.79.0/24',
dns_nameservers=[env.get('NAMESERVER')])
network_settings = NetworkConfig(
name='cloudify_ims_network-{}'.format(self.uuid),
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(snaps_creds)
router_creator = OpenStackRouter(
snaps_creds,
RouterConfig(
name='cloudify_ims_router-{}'.format(self.uuid),
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
# security group creation
self.__logger.info("Creating security group for cloudify manager vm")
sg_rules = list()
sg_rules.append(
SecurityGroupRuleConfig(
sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
direction=Direction.ingress, protocol=Protocol.tcp,
port_range_min=1, port_range_max=65535))
sg_rules.append(
SecurityGroupRuleConfig(
sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
direction=Direction.ingress, protocol=Protocol.udp,
port_range_min=1, port_range_max=65535))
security_group_creator = OpenStackSecurityGroup(
snaps_creds,
SecurityGroupConfig(
name="sg-cloudify-manager-{}".format(self.uuid),
rule_settings=sg_rules))
security_group_creator.create()
self.created_object.append(security_group_creator)
image_settings = ImageConfig(
name=self.orchestrator['requirements']['os_image'],
image_user='******',
exists=True)
port_settings = PortConfig(
name='cloudify_manager_port-{}'.format(self.uuid),
network_name=network_settings.name)
manager_settings = VmInstanceConfig(
name='cloudify_manager-{}'.format(self.uuid),
flavor=flavor_settings.name,
port_settings=[port_settings],
security_group_names=[
security_group_creator.sec_grp_settings.name],
floating_ip_settings=[FloatingIpConfig(
name='cloudify_manager_fip-{}'.format(self.uuid),
port_name=port_settings.name,
router_name=router_creator.router_settings.name)])
manager_creator = OpenStackVmInstance(
snaps_creds, manager_settings, image_settings,
keypair_settings)
self.__logger.info("Creating cloudify manager VM")
manager_creator.create()
self.created_object.append(manager_creator)
public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity')
cfy_creds = dict(
keystone_username=snaps_creds.username,
keystone_password=snaps_creds.password,
keystone_tenant_name=snaps_creds.project_name,
keystone_url=public_auth_url,
region=snaps_creds.region_name,
user_domain_name=snaps_creds.user_domain_name,
project_domain_name=snaps_creds.project_domain_name)
self.__logger.info("Set creds for cloudify manager %s", cfy_creds)
cfy_client = CloudifyClient(
host=manager_creator.get_floating_ip().ip,
username='******', password='******', tenant='default_tenant')
self.orchestrator['object'] = cfy_client
self.__logger.info("Attemps running status of the Manager")
for loop in range(10):
try:
self.__logger.debug(
"status %s", cfy_client.manager.get_status())
cfy_status = cfy_client.manager.get_status()['status']
self.__logger.info(
"The current manager status is %s", cfy_status)
if str(cfy_status) != 'running':
raise Exception("Cloudify Manager isn't up and running")
self.__logger.info("Put OpenStack creds in manager")
secrets_list = cfy_client.secrets.list()
for k, val in cfy_creds.iteritems():
if not any(d.get('key', None) == k for d in secrets_list):
cfy_client.secrets.create(k, val)
else:
cfy_client.secrets.update(k, val)
break
except Exception: # pylint: disable=broad-except
self.logger.info(
"try %s: Cloudify Manager isn't up and running", loop + 1)
time.sleep(30)
else:
self.logger.error("Cloudify Manager isn't up and running")
return False
duration = time.time() - start_time
if manager_creator.vm_ssh_active(block=True):
self.__logger.info("Put private keypair in manager")
ssh = manager_creator.ssh_client()
scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
scp.put(kp_file, '~/')
cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/"
self.run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
self.run_blocking_ssh_command(ssh, cmd)
# cmd2 is badly unpinned by Cloudify
cmd = "sudo yum install -y gcc python-devel python-cmd2"
self.run_blocking_ssh_command(
ssh, cmd, "Unable to install packages on manager")
self.run_blocking_ssh_command(ssh, 'cfy status')
else:
self.__logger.error("Cannot connect to manager")
return False
self.details['orchestrator'].update(status='PASS', duration=duration)
self.vnf['inputs'].update(dict(
external_network_name=ext_net_name,
network_name=network_settings.name,
key_pair_name=keypair_settings.name
))
self.result = 1/3 * 100
return True
def run(self):
"""
Excecute VPingSSH testcase.
Sets up the OpenStack keypair, router, security group, and VM instance
objects then validates the ping.
:return: the exit code from the super.execute() method
"""
try:
super(VPingSSH, self).run()
log = "Creating keypair with name: '%s'" % self.kp_name
self.logger.info(log)
kp_creator = deploy_utils.create_keypair(
self.os_creds,
KeypairConfig(name=self.kp_name,
private_filepath=self.kp_priv_file,
public_filepath=self.kp_pub_file))
self.creators.append(kp_creator)
# Creating Instance 1
port1_settings = PortConfig(
name=self.vm1_name + '-vPingPort',
network_name=self.network_creator.network_settings.name)
instance1_settings = VmInstanceConfig(
name=self.vm1_name,
flavor=self.flavor_name,
vm_boot_timeout=self.vm_boot_timeout,
vm_delete_timeout=self.vm_delete_timeout,
ssh_connect_timeout=self.vm_ssh_connect_timeout,
port_settings=[port1_settings])
log = ("Creating VM 1 instance with name: '%s'" %
instance1_settings.name)
self.logger.info(log)
self.vm1_creator = deploy_utils.create_vm_instance(
self.os_creds,
instance1_settings,
self.image_creator.image_settings,
keypair_creator=kp_creator)
self.creators.append(self.vm1_creator)
# Creating Instance 2
sg_creator = self.__create_security_group()
self.creators.append(sg_creator)
port2_settings = PortConfig(
name=self.vm2_name + '-vPingPort',
network_name=self.network_creator.network_settings.name)
instance2_settings = VmInstanceConfig(
name=self.vm2_name,
flavor=self.flavor_name,
vm_boot_timeout=self.vm_boot_timeout,
vm_delete_timeout=self.vm_delete_timeout,
ssh_connect_timeout=self.vm_ssh_connect_timeout,
port_settings=[port2_settings],
security_group_names=[sg_creator.sec_grp_settings.name],
floating_ip_settings=[
FloatingIpConfig(
name=self.vm2_name + '-FIPName',
port_name=port2_settings.name,
router_name=self.router_creator.router_settings.name)
])
log = ("Creating VM 2 instance with name: '%s'" %
instance2_settings.name)
self.logger.info(log)
self.vm2_creator = deploy_utils.create_vm_instance(
self.os_creds,
instance2_settings,
self.image_creator.image_settings,
keypair_creator=kp_creator)
self.creators.append(self.vm2_creator)
return self._execute()
except Exception as exc: # pylint: disable=broad-except
self.logger.error('Unexpected error running test - ' + exc.message)
return TestCase.EX_RUN_ERROR
finally:
self._cleanup()
def test_small_key_size(self):
with self.assertRaises(KeypairConfigError):
KeypairConfig(name='foo', key_size=511)
def test_no_params(self):
with self.assertRaises(KeypairConfigError):
KeypairConfig()