def __init__(self, **kwargs):
"""Initialize HeatIms testcase object."""
if "case_name" not in kwargs:
kwargs["case_name"] = "heat_ims"
super(HeatIms, self).__init__(**kwargs)
# Retrieve the configuration
try:
self.config = getattr(config.CONF,
'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/ims')
config_file = os.path.join(self.case_dir, self.config)
self.vnf = dict(descriptor=functest_utils.get_parameter_from_yaml(
"vnf.descriptor", config_file),
parameters=functest_utils.get_parameter_from_yaml(
"vnf.inputs", config_file))
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=functest_utils.get_parameter_from_yaml(
"vnf.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf.version", config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.keypair = None
self.stack = None
self.clearwater = None
self.role = None
(_, self.key_filename) = tempfile.mkstemp()
def __init__(self, **kwargs):
if "case_name" not in kwargs:
kwargs["case_name"] = "juju_epc"
super(JujuEpc, self).__init__(**kwargs)
# Retrieve the configuration
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/epc')
try:
self.config = getattr(config.CONF,
'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
requirements=functest_utils.get_parameter_from_yaml(
"orchestrator.requirements", self.config_file))
self.created_object = []
self.details['orchestrator'] = dict(
name=functest_utils.get_parameter_from_yaml(
"orchestrator.name", self.config_file),
version=functest_utils.get_parameter_from_yaml(
"orchestrator.version", self.config_file),
status='ERROR',
result='')
self.vnf = dict(descriptor=functest_utils.get_parameter_from_yaml(
"vnf.descriptor", self.config_file),
requirements=functest_utils.get_parameter_from_yaml(
"vnf.requirements", self.config_file))
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=functest_utils.get_parameter_from_yaml(
"vnf.name", self.config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf.version", self.config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.details['test_vnf'] = dict(
name=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.name", self.config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.version", self.config_file),
tag_name=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.tag_name", self.config_file))
self.res_dir = os.path.join(getattr(config.CONF, 'dir_results'),
self.case_name)
try:
self.public_auth_url = self.get_public_auth_url(self.orig_cloud)
if not self.public_auth_url.endswith(('v3', 'v3/')):
self.public_auth_url = "{}/v3".format(self.public_auth_url)
except Exception: # pylint: disable=broad-except
self.public_auth_url = None
self.sec = None
self.image_alt = None
self.flavor_alt = None
def test_get_parameter_from_yaml_failed(self):
self.file_yaml['general'] = None
with mock.patch('six.moves.builtins.open', mock.mock_open()), \
mock.patch('functest.utils.functest_utils.yaml.safe_load') \
as mock_yaml, \
self.assertRaises(ValueError) as excep:
mock_yaml.return_value = self.file_yaml
functest_utils.get_parameter_from_yaml(self.parameter,
self.test_file)
self.assertTrue(("The parameter %s is not"
" defined in config_functest.yaml" %
self.parameter) in excep.exception)
def __init__(self):
self.config_file = pkg_resources.resource_filename(
'sdnvpn', 'test/functest/config.yaml')
self.keyfile_path = pkg_resources.resource_filename(
'sdnvpn', 'artifacts/id_rsa')
self.test_db = CONST.results_test_db_url
self.quagga_setup_script_path = pkg_resources.resource_filename(
'sdnvpn', 'artifacts/quagga_setup.sh')
self.line_length = 90 # length for the summary table
self.vm_boot_timeout = 180
self.default_flavor = ft_utils.get_parameter_from_yaml(
"defaults.flavor", self.config_file)
self.image_filename = CONST.openstack_image_file_name
self.image_format = CONST.openstack_image_disk_format
self.image_path = '{0}/{1}'.format(CONST.dir_functest_images,
self.image_filename)
# This is the ubuntu image used by sfc
# Basically vanilla ubuntu + some scripts in there
# We can use it to setup a quagga instance
# TODO does functest have an ubuntu image somewhere?
self.ubuntu_image_name = "sdnvpn-ubuntu"
self.ubuntu_image_path = '{0}/{1}'.format(
CONST.dir_functest_images,
"ubuntu-16.04-server-cloudimg-amd64-disk1.img")
self.custom_flavor_name = 'm1.custom'
self.custom_flavor_ram = 1024
self.custom_flavor_disk = 10
self.custom_flavor_vcpus = 1
self.neutron_nw_quota = -1
self.neutron_subnet_quota = -1
self.neutron_port_quota = -1
self.neutron_router_quota = -1
self.nova_instances_quota_class = -1
def get_deployment_handler():
global handler
global pod_arch
installer_params_yaml = os.path.join(CONST.dir_repo_functest,
'functest/ci/installer_params.yaml')
if (CONST.INSTALLER_IP and CONST.INSTALLER_TYPE
and CONST.INSTALLER_TYPE in opnfv_constants.INSTALLERS):
try:
installer_params = ft_utils.get_parameter_from_yaml(
CONST.INSTALLER_TYPE, installer_params_yaml)
except ValueError as e:
logger.debug('Printing deployment info is not supported for %s' %
CONST.INSTALLER_TYPE)
logger.debug(e)
else:
user = installer_params.get('user', None)
password = installer_params.get('password', None)
pkey = installer_params.get('pkey', None)
try:
handler = factory.Factory.get_handler(
installer=CONST.INSTALLER_TYPE,
installer_ip=CONST.INSTALLER_IP,
installer_user=user,
installer_pwd=password,
pkey_file=pkey)
if handler:
pod_arch = handler.get_arch()
except Exception as e:
logger.debug("Cannot get deployment information. %s" % e)
def __init__(self):
self.repo_path = CONST.dir_repo_sdnvpn
self.config_file = os.path.join(self.repo_path,
'sdnvpn/test/functest/config.yaml')
self.keyfile_path = os.path.join(self.repo_path,
'sdnvpn/artifacts/id_rsa')
self.test_db = CONST.results_test_db_url
self.quagga_setup_script_path = os.path.join(
self.repo_path, "sdnvpn/artifacts/quagga_setup.sh")
self.line_length = 90 # length for the summary table
self.vm_boot_timeout = 180
self.default_flavor = ft_utils.get_parameter_from_yaml(
"defaults.flavor", self.config_file)
self.image_filename = CONST.openstack_image_file_name
self.image_format = CONST.openstack_image_disk_format
self.image_path = '{0}/{1}'.format(CONST.dir_functest_data,
self.image_filename)
# This is the ubuntu image used by sfc
# Basically vanilla ubuntu + some scripts in there
# We can use it to setup a quagga instance
# TODO does functest have an ubuntu image somewhere?
self.ubuntu_image_name = "sdnvpn-ubuntu"
self.ubuntu_image_path = '{0}/{1}'.format(
CONST.dir_functest_data,
"ubuntu-16.04-server-cloudimg-amd64-disk1.img")
def get_deployment_handler():
global handler
global pod_arch
installer_params_yaml = pkg_resources.resource_filename(
'functest', 'ci/installer_params.yaml')
if (CONST.__getattribute__('INSTALLER_IP')
and CONST.__getattribute__('INSTALLER_TYPE')
and CONST.__getattribute__('INSTALLER_TYPE')
in opnfv_constants.INSTALLERS):
try:
installer_params = ft_utils.get_parameter_from_yaml(
CONST.__getattribute__('INSTALLER_TYPE'),
installer_params_yaml)
except ValueError as e:
logger.debug('Printing deployment info is not supported for %s' %
CONST.__getattribute__('INSTALLER_TYPE'))
logger.debug(e)
else:
user = installer_params.get('user', None)
password = installer_params.get('password', None)
pkey = installer_params.get('pkey', None)
try:
handler = factory.Factory.get_handler(
installer=CONST.__getattribute__('INSTALLER_TYPE'),
installer_ip=CONST.__getattribute__('INSTALLER_IP'),
installer_user=user,
installer_pwd=password,
pkey_file=pkey)
if handler:
pod_arch = handler.get_arch()
except Exception as e:
logger.debug("Cannot get deployment information. %s" % e)
def test_get_parameter_from_yaml_default(self):
with mock.patch('six.moves.builtins.open', mock.mock_open()), \
mock.patch('functest.utils.functest_utils.yaml.safe_load') \
as mock_yaml:
mock_yaml.return_value = self.file_yaml
self.assertEqual(
functest_utils.get_parameter_from_yaml(self.parameter,
self.test_file),
'test_image_name')
def __init__(self, **kwargs):
"""Initialize CloudifyIms testcase object."""
if "case_name" not in kwargs:
kwargs["case_name"] = "cloudify_ims"
super(CloudifyIms, self).__init__(**kwargs)
# Retrieve the configuration
try:
self.config = getattr(config.CONF,
'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/ims')
config_file = os.path.join(self.case_dir, self.config)
self.details['orchestrator'] = dict(
name=functest_utils.get_parameter_from_yaml(
"orchestrator.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"orchestrator.version", config_file),
status='ERROR',
result='')
self.vnf = dict(descriptor=functest_utils.get_parameter_from_yaml(
"vnf.descriptor", config_file),
inputs=functest_utils.get_parameter_from_yaml(
"vnf.inputs", config_file))
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=functest_utils.get_parameter_from_yaml(
"vnf.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf.version", config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.details['test_vnf'] = dict(
name=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.version", config_file))
self.image_alt = None
self.flavor_alt = None
self.clearwater = None
def __init__(self):
self.repo_path = ft_constants.SDNVPN_REPO_DIR
self.config_file = os.path.join(self.repo_path,
'sdnvpn/test/functest/config.yaml')
self.keyfile_path = os.path.join(self.repo_path,
'sdnvpn/artifacts/id_rsa')
self.test_db = ft_utils.get_functest_config("results.test_db_url")
self.line_length = 90 # length for the summary table
self.vm_boot_timeout = 180
self.default_flavor = ft_utils.get_parameter_from_yaml(
"defaults.flavor", self.config_file)
self.image_filename = ft_utils.get_functest_config(
"general.openstack.image_file_name")
self.image_format = ft_utils.get_functest_config(
"general.openstack.image_disk_format")
self.image_path = '{0}/{1}'.format(
ft_utils.get_functest_config(
"general.directories.dir_functest_data"), self.image_filename)
def __init__(self):
self.line_length = 35
self.functest_repo_path = os.path.dirname(functest.__file__)
self.functest_logging_api = os.path.join(self.functest_repo_path, "ci",
"logging.ini")
self.sfc_repo_path = os.path.dirname(sfc.__file__)
self.sfc_test_dir = os.path.join(self.sfc_repo_path, "tests",
"functest")
self.vnfd_dir = os.path.join(self.sfc_test_dir, "vnfd-templates")
self.vnfd_default_params_file = os.path.join(
self.sfc_test_dir, "vnfd-default-params-file")
self.vnffgd_dir = os.path.join(self.sfc_test_dir, "vnffgd-templates")
self.functest_results_dir = os.path.join(
getattr(config.CONF, 'dir_results'), "odl-sfc")
self.config_file = os.path.join(self.sfc_test_dir, "config.yaml")
self.vim_file = os.path.join(self.sfc_test_dir, "register-vim.json")
self.installer_type = env.get('INSTALLER_TYPE')
self.installer_fields = test_utils.fill_installer_dict(
self.installer_type)
self.installer_ip = env.get('INSTALLER_IP')
self.installer_user = ft_utils.get_parameter_from_yaml(
self.installer_fields['user'], self.config_file)
try:
self.installer_password = ft_utils.get_parameter_from_yaml(
self.installer_fields['password'], self.config_file)
except Exception:
self.installer_password = None
try:
self.installer_key_file = ft_utils.get_parameter_from_yaml(
self.installer_fields['pkey_file'], self.config_file)
except Exception:
self.installer_key_file = None
try:
self.installer_cluster = ft_utils.get_parameter_from_yaml(
self.installer_fields['cluster'], self.config_file)
except Exception:
self.installer_cluster = None
self.flavor = ft_utils.get_parameter_from_yaml("defaults.flavor",
self.config_file)
self.ram_size_in_mb = ft_utils.get_parameter_from_yaml(
"defaults.ram_size_in_mb", self.config_file)
self.disk_size_in_gb = ft_utils.get_parameter_from_yaml(
"defaults.disk_size_in_gb", self.config_file)
self.vcpu_count = ft_utils.get_parameter_from_yaml(
"defaults.vcpu_count", self.config_file)
self.image_name = ft_utils.get_parameter_from_yaml(
"defaults.image_name", self.config_file)
self.image_format = ft_utils.get_parameter_from_yaml(
"defaults.image_format", self.config_file)
self.image_url = ft_utils.get_parameter_from_yaml(
"defaults.image_url", self.config_file)
try:
self.vnf_image_name = ft_utils.get_parameter_from_yaml(
"defaults.vnf_image_name", self.config_file)
self.vnf_image_url = ft_utils.get_parameter_from_yaml(
"defaults.vnf_image_url", self.config_file)
self.vnf_image_format = ft_utils.get_parameter_from_yaml(
"defaults.vnf_image_format", self.config_file)
except ValueError:
# If the parameter does not exist we use the default
self.vnf_image_name = self.image_name
self.vnf_image_url = self.image_url
self.vnf_image_format = self.image_format
self.dir_functest_data = getattr(config.CONF, 'dir_functest_data')
def __init__(self, **kwargs):
if "case_name" not in kwargs:
kwargs["case_name"] = "vyos_vrouter"
super(CloudifyVrouter, self).__init__(**kwargs)
# Retrieve the configuration
try:
self.config = getattr(
config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/router')
config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
requirements=functest_utils.get_parameter_from_yaml(
"orchestrator.requirements", config_file),
)
self.details['orchestrator'] = dict(
name=functest_utils.get_parameter_from_yaml(
"orchestrator.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"orchestrator.version", config_file),
status='ERROR',
result=''
)
self.__logger.debug("Orchestrator configuration %s", self.orchestrator)
self.__logger.debug("name = %s", __name__)
self.vnf = dict(
descriptor=functest_utils.get_parameter_from_yaml(
"vnf.descriptor", config_file),
inputs=functest_utils.get_parameter_from_yaml(
"vnf.inputs", config_file),
requirements=functest_utils.get_parameter_from_yaml(
"vnf.requirements", config_file)
)
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=functest_utils.get_parameter_from_yaml(
"vnf.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf.version", config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.util = Utilvnf()
self.util.set_credentials(self.cloud)
credentials = {"cloud": self.cloud}
self.util_info = {"credentials": credentials,
"vnf_data_dir": self.util.vnf_data_dir}
self.details['test_vnf'] = dict(
name=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.version", config_file)
)
self.images = functest_utils.get_parameter_from_yaml(
"tenant_images", config_file)
self.__logger.info("Images needed for vrouter: %s", self.images)
self.image_alt = None
self.flavor_alt = None
import functest.utils.openstack_utils as os_utils
from keystoneclient.v2_0 import client as keystoneclient
from neutronclient.v2_0 import client as neutronclient
from novaclient import client as novaclient
import yaml
logger = ft_logger.Logger("openstack_snapshot").getLogger()
REPO_PATH = os.environ['repos_dir'] + '/functest/'
if not os.path.exists(REPO_PATH):
logger.error("Functest repository directory not found '%s'" % REPO_PATH)
exit(-1)
OS_SNAPSHOT_FILE = ft_utils.get_parameter_from_yaml(
"general.openstack.snapshot_file")
def separator():
logger.info("-------------------------------------------")
def get_instances(nova_client):
logger.debug("Getting instances...")
dic_instances = {}
instances = os_utils.get_instances(nova_client)
if not (instances is None or len(instances) == 0):
for instance in instances:
dic_instances.update({getattr(instance, 'id'): getattr(instance,
'name')})
return {'instances': dic_instances}
def __init__(self, **kwargs):
if "case_name" not in kwargs:
kwargs["case_name"] = "vyos_vrouter"
super(CloudifyVrouter, self).__init__(**kwargs)
# Retrieve the configuration
try:
self.config = getattr(config.CONF,
'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.cfy_manager_ip = ''
self.deployment_name = ''
config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
requirements=functest_utils.get_parameter_from_yaml(
"orchestrator.requirements", config_file), )
self.details['orchestrator'] = dict(
name=functest_utils.get_parameter_from_yaml(
"orchestrator.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"orchestrator.version", config_file),
status='ERROR',
result='')
self.__logger.debug("Orchestrator configuration %s", self.orchestrator)
self.__logger.debug("name = %s", self.name)
self.vnf = dict(descriptor=functest_utils.get_parameter_from_yaml(
"vnf.descriptor", config_file),
inputs=functest_utils.get_parameter_from_yaml(
"vnf.inputs", config_file),
requirements=functest_utils.get_parameter_from_yaml(
"vnf.requirements", config_file))
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=functest_utils.get_parameter_from_yaml(
"vnf.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf.version", config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.util = Utilvnf()
self.details['test_vnf'] = dict(
name=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.name", config_file),
version=functest_utils.get_parameter_from_yaml(
"vnf_test_suite.version", config_file))
self.images = functest_utils.get_parameter_from_yaml(
"tenant_images", config_file)
self.__logger.info("Images needed for vrouter: %s", self.images)
def __init__(self):
self.line_length = 30
self.test_db = ft_utils.get_functest_config("results.test_db_url")
self.repo_path = CONST.dir_repo_sfc
self.sfc_test_dir = os.path.join(self.repo_path, "sfc", "tests",
"functest")
self.vnfd_dir = os.path.join(self.sfc_test_dir, "vnfd-templates")
self.vnfd_default_params_file = os.path.join(
self.sfc_test_dir, "vnfd-default-params-file")
self.functest_results_dir = os.path.join(CONST.dir_results, "odl-sfc")
self.config_file = os.path.join(self.sfc_test_dir, "config.yaml")
self.installer_type = ft_utils.get_parameter_from_yaml(
"defaults.installer.type", self.config_file)
self.installer_ip = ft_utils.get_parameter_from_yaml(
"defaults.installer.ip", self.config_file)
self.installer_user = ft_utils.get_parameter_from_yaml(
"defaults.installer.user", self.config_file)
try:
self.installer_password = ft_utils.get_parameter_from_yaml(
"defaults.installer.password", self.config_file)
except:
self.installer_password = None
try:
self.installer_key_file = ft_utils.get_parameter_from_yaml(
"defaults.installer.key_file", self.config_file)
except:
self.installer_key_file = None
try:
self.installer_cluster = ft_utils.get_parameter_from_yaml(
"defaults.installer.cluster", self.config_file)
except:
self.installer_cluster = None
self.flavor = ft_utils.get_parameter_from_yaml("defaults.flavor",
self.config_file)
self.ram_size_in_mb = ft_utils.get_parameter_from_yaml(
"defaults.ram_size_in_mb", self.config_file)
self.disk_size_in_gb = ft_utils.get_parameter_from_yaml(
"defaults.disk_size_in_gb", self.config_file)
self.vcpu_count = ft_utils.get_parameter_from_yaml(
"defaults.vcpu_count", self.config_file)
self.image_name = ft_utils.get_parameter_from_yaml(
"defaults.image_name", self.config_file)
self.image_file_name = ft_utils.get_parameter_from_yaml(
"defaults.image_file_name", self.config_file)
self.image_format = ft_utils.get_parameter_from_yaml(
"defaults.image_format", self.config_file)
self.url = ft_utils.get_parameter_from_yaml("defaults.url",
self.config_file)
self.dir_functest_data = ft_utils.get_functest_config(
"general.dir.functest_data")
self.image_path = os.path.join(self.dir_functest_data,
self.image_file_name)
#
#
import ConfigParser
import os
import re
import shutil
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from sdnvpn.lib import config as sdnvpn_config
logger = ft_logger.Logger("sdnvpn-tempest").getLogger()
COMMON_CONFIG = sdnvpn_config.CommonConfig()
SUCCESS_CRITERIA = ft_utils.get_parameter_from_yaml(
"testcases.testcase_1.succes_criteria", COMMON_CONFIG.config_file)
def main():
src_tempest_dir = ft_utils.get_deployment_dir()
if not src_tempest_dir:
logger.error("Rally deployment not found.")
exit(-1)
src_tempest_conf = src_tempest_dir + '/tempest.conf'
bgpvpn_tempest_conf = src_tempest_dir + '/bgpvpn_tempest.conf'
if not os.path.isfile(src_tempest_conf):
logger.error("tempest.conf not found in %s." % src_tempest_conf)
exit(-1)
shutil.copy(src_tempest_conf, bgpvpn_tempest_conf)
parser.add_argument("-r", "--report",
help="Create json result file",
action="store_true")
args = parser.parse_args()
""" logging configuration """
logger = ft_logger.Logger("create_instance_and_ip").getLogger()
REPO_PATH = os.environ['repos_dir'] + '/functest/'
HOME = os.environ['HOME'] + "/"
VM_BOOT_TIMEOUT = 180
INSTANCE_NAME = ft_utils.get_parameter_from_yaml("example.example_vm_name")
FLAVOR = ft_utils.get_parameter_from_yaml("example.example_flavor")
IMAGE_NAME = ft_utils.get_parameter_from_yaml("example.example_image_name")
IMAGE_FILENAME = ft_utils.get_parameter_from_yaml(
"general.openstack.image_file_name")
IMAGE_FORMAT = ft_utils.get_parameter_from_yaml(
"general.openstack.image_disk_format")
IMAGE_PATH = ft_utils.get_parameter_from_yaml(
"general.directories.dir_functest_data") + "/" + IMAGE_FILENAME
# NEUTRON Private Network parameters
NET_NAME = ft_utils.get_parameter_from_yaml(
"example.example_private_net_name")
SUBNET_NAME = ft_utils.get_parameter_from_yaml(
"example.example_private_subnet_name")
import datetime
import os
import re
import time
from neutronclient.v2_0 import client as neutronclient
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as functest_utils
import functest.utils.openstack_utils as openstack_utils
""" logging configuration """
logger = ft_logger.Logger("onos").getLogger()
# onos parameters
TEST_DB = functest_utils.get_parameter_from_yaml(
"results.test_db_url")
ONOS_REPO_PATH = functest_utils.get_parameter_from_yaml(
"general.directories.dir_repos")
ONOS_CONF_DIR = functest_utils.get_parameter_from_yaml(
"general.directories.dir_functest_conf")
REPO_PATH = ONOS_REPO_PATH + '/functest/'
if not os.path.exists(REPO_PATH):
logger.error("Functest repository directory not found '%s'" % REPO_PATH)
exit(-1)
ONOSCI_PATH = ONOS_REPO_PATH + "/"
starttime = datetime.datetime.now()
HOME = os.environ['HOME'] + "/"
INSTALLER_TYPE = os.environ['INSTALLER_TYPE']
DEPLOY_SCENARIO = os.environ['DEPLOY_SCENARIO']
