from scp import SCPClient
import yaml
-from functest.energy import energy
-from functest.opnfv_tests.openstack.snaps import snaps_utils
-import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base
-from functest.utils.constants import CONST
-
from snaps.config.flavor import FlavorConfig
from snaps.config.image import ImageConfig
from snaps.config.keypair import KeypairConfig
from snaps.config.security_group import (
Direction, Protocol, SecurityGroupConfig, SecurityGroupRuleConfig)
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_instance import OpenStackVmInstance
from snaps.openstack.create_router import OpenStackRouter
from snaps.openstack.create_security_group import OpenStackSecurityGroup
from snaps.openstack.utils import keystone_utils
+from xtesting.energy import energy
+from functest.opnfv_tests.openstack.snaps import snaps_utils
+import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base
+from functest.utils import config
+from functest.utils import env
__author__ = "Valentin Boucher <valentin.boucher@orange.com>"
# Retrieve the configuration
try:
- self.config = CONST.__getattribute__(
- 'vnf_{}_config'.format(self.case_name))
+ self.config = getattr(
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
- self.snaps_creds = ''
-
config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
requirements=get_config("orchestrator.requirements", config_file),
name=image_name, image_user='cloud',
img_format='qcow2', image_file=image_file))
image_creator.create()
- # self.created_object.append(image_creator)
+ self.created_object.append(image_creator)
def deploy_orchestrator(self):
"""
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_settings = KeypairConfig(
+ name='cloudify_ims_kp-{}'.format(self.uuid),
+ 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])
+ 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(self.snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
router_creator = OpenStackRouter(
self.snaps_creds,
RouterConfig(
- name='cloudify_ims_router',
+ name='cloudify_ims_router-{}'.format(self.uuid),
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
sg_rules = list()
sg_rules.append(
SecurityGroupRuleConfig(
- sec_grp_name="sg-cloudify-manager",
+ 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",
+ sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
direction=Direction.ingress, protocol=Protocol.udp,
port_range_min=1, port_range_max=65535))
- securit_group_creator = OpenStackSecurityGroup(
+ security_group_creator = OpenStackSecurityGroup(
self.snaps_creds,
SecurityGroupConfig(
- name="sg-cloudify-manager",
+ name="sg-cloudify-manager-{}".format(self.uuid),
rule_settings=sg_rules))
- securit_group_creator.create()
- self.created_object.append(securit_group_creator)
+ 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 ...")
image_user='centos',
exists=True)
- port_settings = PortConfig(name='cloudify_manager_port',
- network_name=network_settings.name)
+ port_settings = PortConfig(
+ name='cloudify_manager_port-{}'.format(self.uuid),
+ network_name=network_settings.name)
manager_settings = VmInstanceConfig(
- name='cloudify_manager',
+ name='cloudify_manager-{}'.format(self.uuid),
flavor=flavor_settings.name,
port_settings=[port_settings],
- security_group_names=[securit_group_creator.sec_grp_settings.name],
+ security_group_names=[
+ security_group_creator.sec_grp_settings.name],
floating_ip_settings=[FloatingIpConfig(
- name='cloudify_manager_fip',
+ 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,
- keypair_settings)
+ manager_creator = OpenStackVmInstance(
+ self.snaps_creds, manager_settings, image_settings,
+ keypair_settings)
self.__logger.info("Creating cloudify manager VM")
manager_creator.create()
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.tenant_name,
- keystone_password=self.tenant_name,
- keystone_tenant_name=self.tenant_name,
- keystone_url=public_auth_url)
+ 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,
+ region=self.snaps_creds.region_name,
+ user_domain_name=self.snaps_creds.user_domain_name,
+ project_domain_name=self.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='admin',
- password='admin',
- tenant='default_tenant')
+ cfy_client = CloudifyClient(
+ host=manager_creator.get_floating_ip().ip,
+ username='admin', password='admin', tenant='default_tenant')
self.orchestrator['object'] = cfy_client
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)
+ self.__logger.info(
+ "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 ...")
+ self.__logger.info(
+ "Cloudify Manager isn't up and running. Retrying ...")
retry = retry - 1
time.sleep(30)
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)
+ self.run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
- run_blocking_ssh_command(ssh, cmd)
+ self.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.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
+ network_name=network_settings.name,
+ key_pair_name=keypair_settings.name
))
self.result = 1/3 * 100
return True
_get_deployment_environment_creation_execution(
cfy_client, descriptor.get('name')),
self.__logger,
- timeout=600)
+ timeout=300)
self.__logger.info("Start the VNF Instance deployment")
execution = cfy_client.executions.start(descriptor.get('name'),
try:
cfy_client.executions.cancel(execution['id'],
force=True)
- except: # pylint: disable=broad-except
+ except Exception: # pylint: disable=broad-except
self.__logger.warn("Can't cancel the current exec")
execution = cfy_client.executions.start(
wait_for_execution(cfy_client, execution, self.__logger)
cfy_client.deployments.delete(self.vnf['descriptor'].get('name'))
cfy_client.blueprints.delete(self.vnf['descriptor'].get('name'))
- except: # pylint: disable=broad-except
- self.__logger.warn("Some issue during the undeployment ..")
- self.__logger.warn("Tenant clean continue ..")
+ except Exception: # pylint: disable=broad-except
+ self.__logger.exception("Some issue during the undeployment ..")
super(CloudifyIms, self).clean()
+ @staticmethod
+ def run_blocking_ssh_command(ssh, cmd,
+ error_msg="Unable to run this command"):
+ """Command to run ssh command with the exit status."""
+ _, stdout, stderr = ssh.exec_command(cmd)
+ CloudifyIms.__logger.debug("SSH %s stdout: %s", cmd, stdout.read())
+ if stdout.channel.recv_exit_status() != 0:
+ CloudifyIms.__logger.error("SSH %s stderr: %s", cmd, stderr.read())
+ raise Exception(error_msg)
+
@energy.enable_recording
def run(self, **kwargs):
"""Execute CloudifyIms test case."""
return value
-def wait_for_execution(client, execution, logger, timeout=2400, ):
+def wait_for_execution(client, execution, logger, timeout=1500, ):
"""Wait for a workflow execution on Cloudify Manager."""
# if execution already ended - return without waiting
if execution.status in Execution.END_STATES:
short_sig_test_result['skipped'] = nb_skipped
nb_test = nb_passed + nb_skipped
return (short_sig_test_result, nb_test)
-
-
-def run_blocking_ssh_command(ssh, cmd, error_msg="Unable to run this command"):
- """Command to run ssh command with the exit status."""
- stdin, stdout, stderr = ssh.exec_command(cmd)
- if stdout.channel.recv_exit_status() != 0:
- raise Exception(error_msg)
Code Review / functest.git / blobdiff