import logging
import os
import time
+import uuid
from cloudify_rest_client import CloudifyClient
from cloudify_rest_client.executions import Execution
from functest.opnfv_tests.openstack.snaps import snaps_utils
import functest.opnfv_tests.vnf.router.vrouter_base as vrouter_base
from functest.opnfv_tests.vnf.router.utilvnf import Utilvnf
-from functest.utils.constants import CONST
+from functest.utils import config
+from functest.utils import env
from functest.utils import functest_utils
-from git import Repo
-
from snaps.config.flavor import FlavorConfig
from snaps.config.image import ImageConfig
from snaps.config.keypair import KeypairConfig
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_network import OpenStackNetwork
from snaps.openstack.create_security_group import OpenStackSecurityGroup
from snaps.openstack.create_router import OpenStackRouter
+from snaps.openstack.create_user import OpenStackUser
import snaps.openstack.utils.glance_utils as glance_utils
from snaps.openstack.utils import keystone_utils
# Retrieve the configuration
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.cfy_manager_ip = ''
- self.util_info = {}
self.deployment_name = ''
config_file = os.path.join(self.case_dir, self.config)
"tenant_images", config_file)
self.__logger.info("Images needed for vrouter: %s", self.images)
+ @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)
+ CloudifyVrouter.__logger.debug("SSH %s stdout: %s", cmd, stdout.read())
+ if stdout.channel.recv_exit_status() != 0:
+ CloudifyVrouter.__logger.error(
+ "SSH %s stderr: %s", cmd, stderr.read())
+ raise Exception(error_msg)
+
def prepare(self):
super(CloudifyVrouter, self).prepare()
self.__logger.info("Additional pre-configuration steps")
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(
name='cloudify_vrouter_subnet-{}'.format(self.uuid),
- cidr='10.67.79.0/24')
+ cidr='10.67.79.0/24',
+ dns_nameservers=[env.get('NAMESERVER')])
network_settings = NetworkConfig(
name='cloudify_vrouter_network-{}'.format(self.uuid),
subnet_settings=[subnet_settings])
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.exception(
+ 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_vrouter.pem /etc/cloudify/"
- run_blocking_ssh_command(ssh, cmd)
+ self.run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_vrouter.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(
+ self.run_blocking_ssh_command(
ssh, cmd, "Unable to install packages on manager")
self.details['orchestrator'].update(status='PASS', duration=duration)
descriptor = self.vnf['descriptor']
self.deployment_name = descriptor.get('name')
- vrouter_blueprint_dir = os.path.join(
- self.data_dir, self.util.blueprint_dir)
- if not os.path.exists(vrouter_blueprint_dir):
- Repo.clone_from(
- descriptor.get('url'), vrouter_blueprint_dir,
- branch=descriptor.get('version'))
-
cfy_client.blueprints.upload(
- vrouter_blueprint_dir + self.util.blueprint_file_name,
- descriptor.get('name'))
+ descriptor.get('file_name'), descriptor.get('name'))
self.__logger.info("Get or create flavor for vrouter")
flavor_settings = FlavorConfig(
glance = glance_utils.glance_client(self.snaps_creds)
image = glance_utils.get_image(glance, "vyos1.1.7")
+ user_creator = OpenStackUser(
+ self.snaps_creds,
+ UserConfig(
+ name='cloudify_network_bug-{}'.format(self.uuid),
+ password=str(uuid.uuid4()),
+ project_name=self.tenant_name,
+ domain=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.vnf['inputs'].update(dict(target_vnf_image_id=image.id))
self.vnf['inputs'].update(dict(reference_vnf_image_id=image.id))
self.vnf['inputs'].update(dict(target_vnf_flavor_id=flavor.id))
self.vnf['inputs'].update(dict(reference_vnf_flavor_id=flavor.id))
self.vnf['inputs'].update(dict(
- keystone_username=self.snaps_creds.username))
+ keystone_username=snaps_creds.username))
self.vnf['inputs'].update(dict(
- keystone_password=self.snaps_creds.password))
+ keystone_password=snaps_creds.password))
self.vnf['inputs'].update(dict(
- keystone_tenant_name=self.snaps_creds.project_name))
+ keystone_tenant_name=snaps_creds.project_name))
self.vnf['inputs'].update(dict(
- region=self.snaps_creds.region_name))
+ keystone_user_domain_name=snaps_creds.user_domain_name))
+ self.vnf['inputs'].update(dict(
+ keystone_project_domain_name=snaps_creds.project_domain_name))
+ self.vnf['inputs'].update(dict(
+ region=snaps_creds.region_name))
self.vnf['inputs'].update(dict(
keystone_url=keystone_utils.get_endpoint(
- self.snaps_creds, 'identity')))
+ snaps_creds, 'identity')))
self.__logger.info("Create VNF Instance")
cfy_client.deployments.create(
def test_vnf(self):
cfy_client = self.orchestrator['object']
- credentials = {"snaps_creds": self.snaps_creds,
- "username": self.snaps_creds.username,
- "password": self.snaps_creds.password,
- "auth_url": self.snaps_creds.auth_url,
- "tenant_name": self.snaps_creds.project_name}
+ credentials = {"snaps_creds": self.snaps_creds}
self.util_info = {"credentials": credentials,
"cfy": cfy_client,
cfy_client.deployments.delete(self.vnf['descriptor'].get('name'))
cfy_client.blueprints.delete(self.vnf['descriptor'].get('name'))
except Exception: # pylint: disable=broad-except
- self.__logger.warn("Some issue during the undeployment ..")
- self.__logger.warn("Tenant clean continue ..")
+ self.__logger.exception("Some issue during the undeployment ..")
+
super(CloudifyVrouter, self).clean()
def get_vnf_info_list(self, target_vnf_name):
raise RuntimeError('Failed to get create_deployment_environment '
'workflow execution.'
'Available executions: {0}'.format(executions))
-
-
-def run_blocking_ssh_command(ssh, cmd, error_msg="Unable to run this command"):
- """Command to run ssh command with the exit status."""
- (_, stdout, _) = ssh.exec_command(cmd)
- if stdout.channel.recv_exit_status() != 0:
- raise Exception(error_msg)