"""CloudifyIms testcase implementation."""
+from __future__ import division
+
import logging
import os
import time
+import uuid
from cloudify_rest_client import CloudifyClient
from cloudify_rest_client.executions import Execution
from snaps.config.router import RouterConfig
from snaps.config.security_group import (
Direction, Protocol, SecurityGroupConfig, SecurityGroupRuleConfig)
+from snaps.config.user import UserConfig
from snaps.config.vm_inst import FloatingIpConfig, VmInstanceConfig
from snaps.openstack.create_flavor import OpenStackFlavor
from snaps.openstack.create_image import OpenStackImage
from snaps.openstack.create_network import OpenStackNetwork
from snaps.openstack.create_router import OpenStackRouter
from snaps.openstack.create_security_group import OpenStackSecurityGroup
+from snaps.openstack.create_user import OpenStackUser
from snaps.openstack.utils import keystone_utils
from xtesting.energy import energy
compute_quotas = self.os_project.update_compute_quotas(compute_quotas)
network_quotas = self.os_project.update_network_quotas(network_quotas)
- # 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(
- self.snaps_creds,
- ImageConfig(
- name=image_name, image_user='cloud',
- img_format='qcow2', image_file=image_file))
- image_creator.create()
- self.created_object.append(image_creator)
-
def deploy_orchestrator(self):
# pylint: disable=too-many-locals,too-many-statements
"""
network, security group, fip, VM creation
"""
- # network 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(self.snaps_creds, keypair_settings)
+ 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='cloud',
+ 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),
network_settings = NetworkConfig(
name='cloudify_ims_network-{}'.format(self.uuid),
subnet_settings=[subnet_settings])
- network_creator = OpenStackNetwork(self.snaps_creds, network_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(self.snaps_creds)
+ ext_net_name = snaps_utils.get_ext_net_name(snaps_creds)
router_creator = OpenStackRouter(
- self.snaps_creds,
+ snaps_creds,
RouterConfig(
name='cloudify_ims_router-{}'.format(self.uuid),
external_gateway=ext_net_name,
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(
- self.snaps_creds,
+ 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)
- # 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='centos',
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,
name='cloudify_manager_fip-{}'.format(self.uuid),
port_name=port_settings.name,
router_name=router_creator.router_settings.name)])
-
manager_creator = OpenStackVmInstance(
- self.snaps_creds, manager_settings, image_settings,
+ 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')
+ public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity')
cfy_creds = dict(
- keystone_username=self.snaps_creds.username,
- keystone_password=self.snaps_creds.password,
- keystone_tenant_name=self.snaps_creds.project_name,
+ keystone_username=snaps_creds.username,
+ keystone_password=snaps_creds.password,
+ keystone_tenant_name=snaps_creds.project_name,
keystone_url=public_auth_url,
- region=self.snaps_creds.region_name,
- user_domain_name=self.snaps_creds.user_domain_name,
- project_domain_name=self.snaps_creds.project_domain_name)
+ 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(
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:
+ 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(
- "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")
+ self.logger.info(
+ "try %s: Cloudify Manager isn't up and running", loop + 1)
+ time.sleep(30)
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)
+ self.logger.error("Cloudify Manager isn't up and running")
+ return False
duration = time.time() - start_time
- self.__logger.info("Put private keypair in manager")
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, '~/')
self.run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
self.run_blocking_ssh_command(ssh, cmd)
- cmd = "sudo yum install -y gcc python-devel"
+ # 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)
descriptor.get('file_name'), descriptor.get('name'))
self.__logger.info("Get or create flavor for all clearwater vm")
flavor_settings = FlavorConfig(
- name=self.vnf['requirements']['flavor']['name'],
+ name="{}-{}".format(
+ self.vnf['requirements']['flavor']['name'],
+ self.uuid),
ram=self.vnf['requirements']['flavor']['ram_min'],
disk=25,
- vcpus=1)
+ vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
self.vnf['inputs'].update(dict(
- flavor_id=self.vnf['requirements']['flavor']['name'],
+ flavor_id=flavor_settings.name,
))
self.__logger.info("Create VNF Instance")
execution = cfy_client.executions.start(descriptor.get('name'),
'install')
# Show execution log
- execution = wait_for_execution(cfy_client, execution, self.__logger)
+ execution = wait_for_execution(
+ cfy_client, execution, self.__logger, timeout=3600)
duration = time.time() - start_time
self.details['test_vnf'].update(status='FAIL')
return False
- return True
+ return True if vnf_test_rate > 0 else False
def clean(self):
"""Clean created objects/functions."""
return value
-def wait_for_execution(client, execution, logger, timeout=1500, ):
+def wait_for_execution(client, execution, logger, timeout=3600, ):
"""Wait for a workflow execution on Cloudify Manager."""
# if execution already ended - return without waiting
if execution.status in Execution.END_STATES:
execution_id=execution.id,
_offset=offset,
_size=batch_size,
- include_logs=False,
+ include_logs=True,
sort='@timestamp').items
offset = offset + len(event_list)