"""Base class form Rally testcases implementation."""
# pylint: disable=too-many-instance-attributes, too-many-public-methods
- TESTS = ['authenticate', 'glance', 'cinder', 'gnocchi', 'heat',
- 'keystone', 'neutron', 'nova', 'quotas']
+ stests = ['authenticate', 'glance', 'cinder', 'gnocchi', 'heat',
+ 'keystone', 'neutron', 'nova', 'quotas', 'swift', 'barbican']
- RALLY_CONF_PATH = "/etc/rally/rally.conf"
- RALLY_AARCH64_PATCH_PATH = pkg_resources.resource_filename(
+ rally_conf_path = "/etc/rally/rally.conf"
+ rally_aar4_patch_path = pkg_resources.resource_filename(
'functest', 'ci/rally_aarch64_patch.conf')
- RALLY_DIR = pkg_resources.resource_filename(
+ rally_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/openstack/rally')
- RALLY_SCENARIO_DIR = pkg_resources.resource_filename(
+ rally_scenario_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/openstack/rally/scenario')
- TEMPLATE_DIR = pkg_resources.resource_filename(
+ template_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/openstack/rally/scenario/templates')
- SUPPORT_DIR = pkg_resources.resource_filename(
+ support_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/openstack/rally/scenario/support')
- USERS_AMOUNT = 2
- TENANTS_AMOUNT = 3
- ITERATIONS_AMOUNT = 10
- CONCURRENCY = 4
- VOLUME_VERSION = 3
- VOLUME_SERVICE_TYPE = "volumev3"
- BLACKLIST_FILE = os.path.join(RALLY_DIR, "blacklist.yaml")
- TASK_DIR = os.path.join(getattr(config.CONF, 'dir_rally_data'), 'task')
- TEMP_DIR = os.path.join(TASK_DIR, 'var')
+ users_amount = 2
+ tenants_amount = 3
+ iterations_amount = 10
+ concurrency = 4
+ volume_version = 3
+ volume_service_type = "volumev3"
+ blacklist_file = os.path.join(rally_dir, "blacklist.yaml")
+ task_dir = os.path.join(getattr(config.CONF, 'dir_rally_data'), 'task')
+ temp_dir = os.path.join(task_dir, 'var')
visibility = 'public'
shared_network = True
+ allow_no_fip = True
+ task_timeout = '3600'
def __init__(self, **kwargs):
"""Initialize RallyBase object."""
task_args['flavor_alt_name'] = str(self.flavor_alt.name)
task_args['glance_image_location'] = str(self.filename)
task_args['glance_image_format'] = str(self.image_format)
- task_args['tmpl_dir'] = str(self.TEMPLATE_DIR)
- task_args['sup_dir'] = str(self.SUPPORT_DIR)
- task_args['users_amount'] = self.USERS_AMOUNT
- task_args['tenants_amount'] = self.TENANTS_AMOUNT
+ task_args['tmpl_dir'] = str(self.template_dir)
+ task_args['sup_dir'] = str(self.support_dir)
+ task_args['users_amount'] = self.users_amount
+ task_args['tenants_amount'] = self.tenants_amount
task_args['use_existing_users'] = False
- task_args['iterations'] = self.ITERATIONS_AMOUNT
- task_args['concurrency'] = self.CONCURRENCY
+ task_args['iterations'] = self.iterations_amount
+ task_args['concurrency'] = self.concurrency
task_args['smoke'] = self.smoke
- task_args['volume_version'] = self.VOLUME_VERSION
- task_args['volume_service_type'] = self.VOLUME_SERVICE_TYPE
+ task_args['volume_version'] = self.volume_version
+ task_args['volume_service_type'] = self.volume_service_type
+ task_args['block_migration'] = env.get("BLOCK_MIGRATION").lower()
if self.ext_net:
task_args['floating_network'] = str(self.ext_net.name)
def _prepare_test_list(self, test_name):
"""Build the list of test cases to be executed."""
test_yaml_file_name = 'opnfv-{}.yaml'.format(test_name)
- scenario_file_name = os.path.join(self.RALLY_SCENARIO_DIR,
+ scenario_file_name = os.path.join(self.rally_scenario_dir,
test_yaml_file_name)
if not os.path.exists(scenario_file_name):
% scenario_file_name)
LOGGER.debug('Scenario fetched from : %s', scenario_file_name)
- test_file_name = os.path.join(self.TEMP_DIR, test_yaml_file_name)
+ test_file_name = os.path.join(self.temp_dir, test_yaml_file_name)
- if not os.path.exists(self.TEMP_DIR):
- os.makedirs(self.TEMP_DIR)
+ if not os.path.exists(self.temp_dir):
+ os.makedirs(self.temp_dir)
self.apply_blacklist(scenario_file_name, test_file_name)
return test_file_name
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
deployment_uuid = proc.stdout.readline().rstrip()
- return deployment_uuid
+ return deployment_uuid.decode("utf-8")
@staticmethod
def create_rally_deployment(environ=None):
if pod_arch and pod_arch in arch_filter:
LOGGER.info("Apply aarch64 specific to rally config...")
- with open(RallyBase.RALLY_AARCH64_PATCH_PATH, "r") as pfile:
+ with open(RallyBase.rally_aar4_patch_path, "r") as pfile:
rally_patch_conf = pfile.read()
- for line in fileinput.input(RallyBase.RALLY_CONF_PATH):
+ for line in fileinput.input(RallyBase.rally_conf_path):
print(line, end=' ')
if "cirros|testvm" in line:
print(rally_patch_conf)
'--deployment',
str(getattr(config.CONF, 'rally_deployment_name'))]
output = subprocess.check_output(cmd)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
except subprocess.CalledProcessError:
pass
cmd = ['rally', 'deployment', 'create', '--fromenv',
'--name', str(getattr(config.CONF, 'rally_deployment_name'))]
output = subprocess.check_output(cmd, env=environ)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
cmd = ['rally', 'deployment', 'check']
output = subprocess.check_output(cmd)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
return RallyBase.get_verifier_deployment_id()
@staticmethod
rconfig.add_section('openstack')
rconfig.set(
'openstack', 'keystone_default_role', env.get("NEW_USER_ROLE"))
- with open(rally_conf, 'wb') as config_file:
+ with open(rally_conf, 'w') as config_file:
rconfig.write(config_file)
@staticmethod
rconfig.read(rally_conf)
if rconfig.has_option('openstack', 'keystone_default_role'):
rconfig.remove_option('openstack', 'keystone_default_role')
- with open(rally_conf, 'wb') as config_file:
+ with open(rally_conf, 'w') as config_file:
rconfig.write(config_file)
@staticmethod
taskid_re = re.compile('^Task +(.*): started$')
for line in cmd_raw.splitlines(True):
line = line.strip()
- match = taskid_re.match(line)
+ match = taskid_re.match(line.decode("utf-8"))
if match:
return match.group(1)
return None
"""Exclude scenario."""
black_tests = []
try:
- with open(RallyBase.BLACKLIST_FILE, 'r') as black_list_file:
+ with open(RallyBase.blacklist_file, 'r') as black_list_file:
black_list_yaml = yaml.safe_load(black_list_file)
deploy_scenario = env.get('DEPLOY_SCENARIO')
func_list = []
try:
- with open(RallyBase.BLACKLIST_FILE, 'r') as black_list_file:
+ with open(RallyBase.blacklist_file, 'r') as black_list_file:
black_list_yaml = yaml.safe_load(black_list_file)
+ if env.get('BLOCK_MIGRATION').lower() == 'true':
+ func_list.append("block_migration")
if not self._migration_supported():
func_list.append("no_migration")
if not self._network_trunk_supported():
func_list.append("no_net_trunk_service")
+ if not self.ext_net:
+ func_list.append("no_floating_ip")
if 'functionality' in black_list_yaml.keys():
for item in black_list_yaml['functionality']:
cmd = (["rally", "task", "detailed", "--uuid", task_id])
LOGGER.debug('running command: %s', cmd)
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
# save report as JSON
report_json_name = '{}.json'.format(test_name)
"--out", report_json_dir])
LOGGER.debug('running command: %s', cmd)
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
json_results = open(report_json_dir).read()
self._append_summary(json_results, test_name)
LOGGER.debug('task_id : %s', task_id)
if task_id is None:
LOGGER.error("Failed to retrieve task_id")
- LOGGER.error("Result:\n%s", output)
+ LOGGER.error("Result:\n%s", output.decode("utf-8"))
raise Exception("Failed to retrieve task id")
self._save_results(test_name, task_id)
def _append_summary(self, json_raw, test_name):
+ # pylint: disable=too-many-locals
"""Update statistics summary info."""
nb_tests = 0
nb_success = 0
"""Prepare resources needed by test scenarios."""
assert self.cloud
LOGGER.debug('Validating run tests...')
- for test in kwargs.get('tests', self.TESTS):
- if test in self.TESTS:
+ for test in kwargs.get('tests', self.stests):
+ if test in self.stests:
self.tests.append(test)
else:
raise Exception("Test name '%s' is invalid" % test)
- if not os.path.exists(self.TASK_DIR):
- os.makedirs(self.TASK_DIR)
+ if not os.path.exists(self.task_dir):
+ os.makedirs(self.task_dir)
- task = os.path.join(self.RALLY_DIR, 'task.yaml')
+ task = os.path.join(self.rally_dir, 'task.yaml')
if not os.path.exists(task):
LOGGER.error("Task file '%s' does not exist.", task)
raise Exception("Task file '{}' does not exist.".
format(task))
- self.task_file = os.path.join(self.TASK_DIR, 'task.yaml')
+ self.task_file = os.path.join(self.task_dir, 'task.yaml')
shutil.copyfile(task, self.task_file)
- task_macro = os.path.join(self.RALLY_DIR, 'macro')
+ task_macro = os.path.join(self.rally_dir, 'macro')
if not os.path.exists(task_macro):
LOGGER.error("Task macro dir '%s' does not exist.", task_macro)
raise Exception("Task macro dir '{}' does not exist.".
format(task_macro))
- macro_dir = os.path.join(self.TASK_DIR, 'macro')
+ macro_dir = os.path.join(self.task_dir, 'macro')
if os.path.exists(macro_dir):
shutil.rmtree(macro_dir)
shutil.copytree(task_macro, macro_dir)
if self.file_is_empty(file_name):
LOGGER.info('No tests for scenario "%s"', test_name)
return False
- self.run_cmd = (["rally", "task", "start", "--abort-on-sla-failure",
+ self.run_cmd = (["timeout", self.task_timeout,
+ "rally", "task", "start", "--abort-on-sla-failure",
"--task", self.task_file, "--task-args",
str(self.build_task_args(test_name))])
return True
"--to", file_name]
LOGGER.debug('running command: %s', cmd)
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
@staticmethod
def verify_report(file_name, uuid, export_type="html"):
"--uuid", uuid, "--to", file_name]
LOGGER.debug('running command: %s', cmd)
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
- LOGGER.info("%s\n%s", " ".join(cmd), output)
+ LOGGER.info("%s\n%s", " ".join(cmd), output.decode("utf-8"))
def clean(self):
"""Cleanup of OpenStack resources. Should be called on completion."""
self.clean_rally_conf()
+ self.clean_rally_logs()
if self.flavor_alt:
self.orig_cloud.delete_flavor(self.flavor_alt.id)
super(RallyBase, self).clean()
return super(RallyBase, self).is_successful()
+ @staticmethod
+ def update_rally_logs(res_dir, rally_conf='/etc/rally/rally.conf'):
+ """Print rally logs in res dir"""
+ if not os.path.exists(res_dir):
+ os.makedirs(res_dir)
+ rconfig = configparser.RawConfigParser()
+ rconfig.read(rally_conf)
+ rconfig.set('DEFAULT', 'debug', True)
+ rconfig.set('DEFAULT', 'use_stderr', False)
+ rconfig.set('DEFAULT', 'log-file', 'rally.log')
+ rconfig.set('DEFAULT', 'log_dir', res_dir)
+ with open(rally_conf, 'w') as config_file:
+ rconfig.write(config_file)
+
+ @staticmethod
+ def clean_rally_logs(rally_conf='/etc/rally/rally.conf'):
+ """Clean Rally config"""
+ rconfig = configparser.RawConfigParser()
+ rconfig.read(rally_conf)
+ if rconfig.has_option('DEFAULT', 'use_stderr'):
+ rconfig.remove_option('DEFAULT', 'use_stderr')
+ if rconfig.has_option('DEFAULT', 'debug'):
+ rconfig.remove_option('DEFAULT', 'debug')
+ if rconfig.has_option('DEFAULT', 'log-file'):
+ rconfig.remove_option('DEFAULT', 'log-file')
+ if rconfig.has_option('DEFAULT', 'log_dir'):
+ rconfig.remove_option('DEFAULT', 'log_dir')
+ with open(rally_conf, 'w') as config_file:
+ rconfig.write(config_file)
+
def run(self, **kwargs):
"""Run testcase."""
self.start_time = time.time()
try:
assert super(RallyBase, self).run(
**kwargs) == testcase.TestCase.EX_OK
+ self.update_rally_logs(self.res_dir)
self.create_rally_deployment(environ=self.project.get_environ())
self.prepare_run(**kwargs)
self.run_tests(**kwargs)
"{}/{}.xml".format(self.results_dir, self.case_name),
export_type="junit-xml")
res = testcase.TestCase.EX_OK
- except Exception as exc: # pylint: disable=broad-except
- LOGGER.error('Error with run: %s', exc)
+ except Exception: # pylint: disable=broad-except
+ LOGGER.exception('Error with run:')
self.result = 0
res = testcase.TestCase.EX_RUN_ERROR
self.stop_time = time.time()
kwargs["case_name"] = "rally_sanity"
super(RallySanity, self).__init__(**kwargs)
self.smoke = True
- self.scenario_dir = os.path.join(self.RALLY_SCENARIO_DIR, 'sanity')
+ self.scenario_dir = os.path.join(self.rally_scenario_dir, 'sanity')
class RallyFull(RallyBase):
kwargs["case_name"] = "rally_full"
super(RallyFull, self).__init__(**kwargs)
self.smoke = False
- self.scenario_dir = os.path.join(self.RALLY_SCENARIO_DIR, 'full')
+ self.scenario_dir = os.path.join(self.rally_scenario_dir, 'full')
class RallyJobs(RallyBase):
"""Rally OpenStack CI testcase implementation."""
- TESTS = ["neutron"]
+ stests = ["neutron"]
+ task_timeout = '7200'
def __init__(self, **kwargs):
"""Initialize RallyJobs object."""
if "case_name" not in kwargs:
kwargs["case_name"] = "rally_jobs"
super(RallyJobs, self).__init__(**kwargs)
- self.task_file = os.path.join(self.RALLY_DIR, 'rally_jobs.yaml')
+ self.task_file = os.path.join(self.rally_dir, 'rally_jobs.yaml')
self.task_yaml = None
def prepare_run(self, **kwargs):
"""Create resources needed by test scenarios."""
super(RallyJobs, self).prepare_run(**kwargs)
- with open(os.path.join(self.RALLY_DIR,
+ with open(os.path.join(self.rally_dir,
'rally_jobs.yaml'), 'r') as task_file:
self.task_yaml = yaml.safe_load(task_file)
cases.pop(name)
else:
# workloads in subtasks
- for sind, subtask in enumerate(cases.get('subtasks', [])):
- idx = []
- for wind, workload in enumerate(subtask.get('workloads', [])):
+ for sind, subtask in reversed(list(
+ enumerate(cases.get('subtasks', [])))):
+ for wind, workload in reversed(list(
+ enumerate(subtask.get('workloads', [])))):
scenario = workload.get('scenario', {})
for name in scenario.keys():
if self.in_iterable_re(name, black_tests):
- idx.append(wind)
+ cases['subtasks'][sind]['workloads'].pop(wind)
break
- for wind in reversed(idx):
- cases['subtasks'][sind]['workloads'].pop(wind)
+ if 'workloads' in cases['subtasks'][sind]:
+ if not cases['subtasks'][sind]['workloads']:
+ cases['subtasks'].pop(sind)
# scenarios in subtasks
- idx = []
- for sind, subtask in enumerate(cases.get('subtasks', [])):
+ for sind, subtask in reversed(list(
+ enumerate(cases.get('subtasks', [])))):
scenario = subtask.get('scenario', {})
for name in scenario.keys():
if self.in_iterable_re(name, black_tests):
- idx.append(sind)
+ cases['subtasks'].pop(sind)
break
- for sind in reversed(idx):
- cases['subtasks'].pop(sind)
with open(result_file_name, 'w') as fname:
template.dump(cases, fname)
task_args['floating_network'] = str(self.ext_net.name)
else:
task_args['floating_network'] = ''
+ task_args['image_name'] = str(self.image.name)
+ task_args['flavor_name'] = str(self.flavor.name)
return task_args
@staticmethod
raise Exception("The scenario '%s' does not exist." % task)
LOGGER.debug('Scenario fetched from : %s', task)
- if not os.path.exists(self.TEMP_DIR):
- os.makedirs(self.TEMP_DIR)
- task_file_name = os.path.join(self.TEMP_DIR, task_name)
+ if not os.path.exists(self.temp_dir):
+ os.makedirs(self.temp_dir)
+ task_file_name = os.path.join(self.temp_dir, task_name)
self.apply_blacklist(task, task_file_name)
- self.run_cmd = (["rally", "task", "start", "--task", task_file_name,
+ self.run_cmd = (["timeout", self.task_timeout,
+ "rally", "task", "start", "--task", task_file_name,
"--task-args", str(self.build_task_args(test_name))])
return True