return '%s:%s' % (dt_cfg.dovetail_config[type]['image_name'],
dt_cfg.dovetail_config[type]['docker_tag'])
except KeyError as e:
- cls.logger.error('There is no %s in %s config file.', e, type)
+ cls.logger.exception(
+ 'There is no key {} in {} config file.'.format(e, type))
return None
# get the openrc_volume for creating the container
dovetail_config[type]['openrc'])
return openrc
else:
- cls.logger.error("File %s is not exist", dovetail_config['openrc'])
+ cls.logger.error(
+ "File {} doesn't exist.".format(dovetail_config['openrc']))
return None
# set functest envs and TEST_DB_URL for creating functest container
pod_file = os.path.join(dovetail_config['config_dir'],
dovetail_config['pod_file'])
if not os.path.isfile(pod_file):
- cls.logger.error("File %s doesn't exist.", pod_file)
+ cls.logger.error("File {} doesn't exist.".format(pod_file))
return None
key_file = os.path.join(dovetail_config['config_dir'],
dovetail_config['pri_key'])
key_container_path = dovetail_config["yardstick"]['result']['key_path']
if not os.path.isfile(key_file):
- cls.logger.debug("Key file %s is not found, maybe can use passwd "
- "method in %s to do HA test.", key_file, pod_file)
+ cls.logger.debug("Key file {} is not found, must use password in "
+ "{} to do HA test.".format(key_file, pod_file))
key_vol = ''
else:
key_vol = '-v %s:%s ' % (key_file, key_container_path)
for host in hosts_info['hosts_info']:
hosts_config += " --add-host "
hosts_config += str(host)
- cls.logger.info('get hosts info %s', hosts_config)
+ cls.logger.info('Get hosts info {}.'.format(hosts_config))
except Exception:
- cls.logger.warn('fail to get hosts info in %s/hosts.yaml, \
- maybe some issue with domain name resolution',
- hosts_config_path)
+ cls.logger.warn('Failed to get hosts info in {}/hosts.yaml, '
+ 'maybe some issues with domain name resolution.'
+ .format(hosts_config_path))
cacert_volume = ""
https_enabled = dt_utils.check_https_enabled(cls.logger)
cls.logger.info("https enabled...")
if cacert is not None:
if not os.path.isfile(cacert):
- cls.logger.error("env variable 'OS_CACERT' is set to %s"
- "but the file does not exist", cacert)
+ cls.logger.error("Env variable 'OS_CACERT' is set to {}"
+ "but the file does not exist."
+ .format(cacert))
return None
elif not dovetail_config['config_dir'] in cacert:
- cls.logger.error("credential file has to be put in %s,"
- "which can be mount into container",
- dovetail_config['config_dir'])
+ cls.logger.error("Credential file has to be put in {},"
+ "which can be mount into container."
+ .format(dovetail_config['config_dir']))
return None
cacert_volume = ' -v %s:%s ' % (cacert, cacert)
else:
cmd = "sudo docker ps -aq -f 'ancestor=%s'" % (image_id)
ret, msg = dt_utils.exec_cmd(cmd, cls.logger)
if msg and ret == 0:
- cls.logger.debug('image %s has containers, skip.', image_id)
+ cls.logger.debug('Image {} has containers, skip.'.format(image_id))
return True
cmd = 'sudo docker rmi %s' % (image_id)
- cls.logger.debug('remove image %s', image_id)
+ cls.logger.debug('Remove image {}.'.format(image_id))
ret, msg = dt_utils.exec_cmd(cmd, cls.logger)
if ret == 0:
- cls.logger.debug('remove image %s successfully', image_id)
+ cls.logger.debug('Remove image {} successfully.'.format(image_id))
return True
- cls.logger.error('fail to remove image %s.', image_id)
+ cls.logger.error('Failed to remove image {}.'.format(image_id))
return False
@classmethod
cmd = 'sudo docker pull %s' % (image_name)
ret, msg = dt_utils.exec_cmd(cmd, cls.logger)
if ret != 0:
- cls.logger.error('fail to pull docker image %s!', image_name)
+ cls.logger.error(
+ 'Failed to pull docker image {}!'.format(image_name))
return False
- cls.logger.debug('success to pull docker image %s!', image_name)
+ cls.logger.debug('Success to pull docker image {}!'.format(image_name))
return True
@classmethod
if not docker_image:
return None
if cls.has_pull_latest_image[validate_type] is True:
- cls.logger.debug('%s is already the newest version.', docker_image)
+ cls.logger.debug(
+ '{} is already the newest version.'.format(docker_image))
return docker_image
old_image_id = cls.get_image_id(docker_image)
if not cls.pull_image_only(docker_image):
cls.has_pull_latest_image[validate_type] = True
new_image_id = cls.get_image_id(docker_image)
if not new_image_id:
- cls.logger.error("fail to get the new image's id %s", docker_image)
+ cls.logger.error(
+ "Failed to get the id of image {}.".format(docker_image))
return None
if not old_image_id:
return docker_image
if new_image_id == old_image_id:
- cls.logger.debug('image %s has no changes, no need to remove.',
- docker_image)
+ cls.logger.debug('Image {} has no changes, no need to remove.'
+ .format(docker_image))
else:
cls.remove_image(old_image_id)
return docker_image
kwargs = {}
for arg in dt_cfg.dovetail_config['parameters']:
path = eval(arg['path'])
- cls.logger.debug('name: %s, eval path: %s ',
- arg['name'], path)
+ cls.logger.debug(
+ 'name: {}, eval path: {}'.format(arg['name'], path))
kwargs[arg['name']] = \
dt_utils.get_obj_by_path(testcase.testcase, path)
- cls.logger.debug('kwargs: %s', kwargs)
+ cls.logger.debug('kwargs: {}'.format(kwargs))
cmd_lines = template.render(**kwargs)
except Exception as e:
- cls.logger.error('failed to parse cmd %s, exception:%s', cmd, e)
+ cls.logger.exception(
+ 'Failed to parse cmd {}, exception: {}'.format(cmd, e))
return None
return cmd_lines
'|'.join(dt_cfg.dovetail_config['testarea_supported']))
area = pattern.findall(testcase['name'])
if not area:
- cls.logger.error("testcase %s not in supported testarea",
- testcase['name'])
+ cls.logger.error("Test case {} not in supported testarea."
+ .format(testcase['name']))
return None
area = area[0]
testarea_scope.append(area)
with open(os.path.join(dt_cfg.dovetail_config['result_dir'],
report_file_name), 'w') as report_file:
report_file.write(report)
- cls.logger.info('save report to %s', report_file_name)
+ cls.logger.info('Save report to {}'.format(report_file_name))
except Exception:
- cls.logger.error('Failed to save: %s', report_file_name)
+ cls.logger.exception('Failed to save: {}'.format(report_file_name))
@classmethod
def get_result(cls, testcase):
type = testcase.validate_type()
crawler = CrawlerFactory.create(type)
if crawler is None:
- cls.logger.error('crawler is None:%s', testcase.name())
+ cls.logger.error('Crawler is None: {}'.format(testcase.name()))
return None
# if validate_testcase in cls.results[type]:
if result is not None:
cls.results[type][validate_testcase] = result
# testcase.script_result_acquired(True)
- cls.logger.debug('testcase: %s -> result acquired',
- validate_testcase)
+ cls.logger.debug(
+ 'Test case: {} -> result acquired'.format(validate_testcase))
else:
retry = testcase.increase_retry()
- cls.logger.debug('testcase: %s -> result acquired retry:%d',
- validate_testcase, retry)
+ cls.logger.debug('Test case: {} -> result acquired retry: {}'
+ .format(validate_testcase, retry))
return result
def __init__(self):
self.type = 'functest'
- self.logger.debug('create crawler:%s', self.type)
+ self.logger.debug('Create crawler: {}'.format(self.type))
@classmethod
def create_log(cls):
os.path.join(dovetail_config['result_dir'],
dovetail_config[self.type]['result']['file_path'])
if not os.path.exists(file_path):
- self.logger.info('result file not found: %s', file_path)
+ self.logger.error('Result file not found: {}'.format(file_path))
return None
if testcase_name in dt_cfg.dovetail_config['functest_testcase']:
complex_testcase = False
elif testcase_name in dt_cfg.dovetail_config['functest_testsuite']:
complex_testcase = True
else:
- self.logger.error("Wrong Functest test case %s.", testcase_name)
+ self.logger.error(
+ "Wrong Functest test case {}.".format(testcase_name))
return None
with open(file_path, 'r') as f:
for jsonfile in f:
"errors": error_case,
"skipped": skipped_case}
except KeyError as e:
- self.logger.error("Result data don't have key %s.", e)
+ self.logger.exception(
+ "Result data don't have key {}.".format(e))
return None
except ValueError:
continue
'timestop': timestop, 'duration': duration,
'details': details}
- self.logger.debug('Results: %s', str(json_results))
+ self.logger.debug('Results: {}'.format(str(json_results)))
return json_results
def crawl_from_url(self, testcase=None):
url = "%s?case=%s&last=1" % \
(dt_cfg.dovetail_config['report_dest'],
testcase.validate_testcase())
- self.logger.debug("Query to rest api: %s", url)
+ self.logger.debug("Query to rest api: {}".format(url))
try:
data = json.load(urllib2.urlopen(url))
return data['results'][0]
except Exception as e:
- self.logger.error("Cannot read content from the url: %s, "
- "exception: %s", url, e)
+ self.logger.exception("Cannot read content from the url: {}, "
+ "exception: {}".format(url, e))
return None
def __init__(self):
self.type = 'yardstick'
- self.logger.debug('create crawler:%s', self.type)
+ self.logger.debug('Create crawler: {}'.format(self.type))
@classmethod
def create_log(cls):
file_path = os.path.join(dt_cfg.dovetail_config['result_dir'],
testcase.name() + '.out')
if not os.path.exists(file_path):
- self.logger.info('result file not found: %s', file_path)
+ self.logger.error('Result file not found: {}'.format(file_path))
return None
criteria = 'FAIL'
with open(file_path, 'r') as f:
if 1 == v:
criteria = 'PASS'
except KeyError as e:
- self.logger.error('pass flag not found %s', e)
+ self.logger.exception(
+ 'Pass flag not found {}'.format(e))
json_results = {'criteria': criteria}
- self.logger.debug('Results: %s', str(json_results))
+ self.logger.debug('Results: {}'.format(str(json_results)))
return json_results
def crawl_from_url(self, testcase=None):
testcase_passed = 'SKIP'
for sub_testcase in sub_testcase_list:
- self.logger.debug('check sub_testcase:%s', sub_testcase)
+ self.logger.debug('Check sub_testcase: {}'.format(sub_testcase))
try:
if self.get_sub_testcase(sub_testcase,
db_result['details']['errors']):
duration = 0
start_time = time.time()
for testcase_name in testarea_list:
- logger.info('>>[testcase]: %s', testcase_name)
+ logger.info('>>[testcase]: {}'.format(testcase_name))
testcase = Testcase.get(testcase_name)
if testcase is None:
- logger.error('test case %s is not defined in testcase folder, \
- skipping', testcase_name)
+ logger.error('Test case {} is not defined in testcase folder, '
+ 'skipping.'.format(testcase_name))
continue
run_testcase = True
testcase.name(), dovetail_result,
logger):
logger.info("Results have been pushed to database and stored "
- "with local file %s.", dovetail_result)
+ "with local file {}.".format(dovetail_result))
else:
- logger.error("Fail to push results to database.")
+ logger.error("Failed to push results to database.")
if dt_cfg.dovetail_config['report_dest'] == "file":
if validate_type.lower() == 'yardstick':
result_file = os.path.join(result_dir, testcase.name() + '.out')
elif validate_type.lower() == 'functest':
result_file = os.path.join(result_dir, functest_result)
else:
- logger.error("Don't support %s now.", validate_type)
+ logger.error("Don't support {} now.".format(validate_type))
return
if os.path.isfile(result_file):
- logger.info("Results have been stored with file %s.", result_file)
+ logger.info(
+ "Results have been stored with file {}.".format(result_file))
else:
- logger.error("Fail to store results with file %s.", result_file)
+ logger.error(
+ "Failed to store results with file {}.".format(result_file))
result = Report.get_result(testcase)
Report.check_result(testcase, result)
yard_tag = input_dict['yard_tag']
valid_tag = check_dict['valid_docker_tag']
if func_tag is not None and func_tag not in valid_tag:
- logger.error("func_tag can't be %s, valid in %s", func_tag, valid_tag)
+ logger.error("The input option 'func_tag' can't be {}, "
+ "valid values are {}.".format(func_tag, valid_tag))
raise SystemExit(1)
if yard_tag is not None and yard_tag not in valid_tag:
- logger.error("yard_tag can't be %s, valid in %s", yard_tag, valid_tag)
+ logger.error("The input option 'yard_tag' can't be {}, "
+ "valid values are {}.".format(yard_tag, valid_tag))
raise SystemExit(1)
# for 'report' option
report = input_dict['report']
if report:
if not (report.startswith("http") or report == "file"):
- logger.error("report can't be %s", input_dict['report'])
- logger.info("valid report types are 'file' and 'http'")
+ logger.error("Report type can't be {}, valid types are 'file' "
+ "and 'http'.".format(input_dict['report']))
raise SystemExit(1)
configs[key.upper()] = value_dict
break
except KeyError as e:
- logger.exception('%s lacks subsection %s', config_key, e)
+ logger.exception('KeyError {}.'.format(e))
raise SystemExit(1)
if not configs:
return None
openrc = os.path.join(dt_cfg.dovetail_config['config_dir'],
dt_cfg.dovetail_config['env_file'])
if not os.path.isfile(openrc):
- logger.error("openrc file %s does not exist", openrc)
+ logger.error("File {} does not exist.".format(openrc))
dt_utils.source_env(openrc)
create_logs()
logger = dt_logger.Logger('run').getLogger()
logger.info('================================================')
- logger.info('Dovetail compliance: %s!', (kwargs['testsuite']))
+ logger.info('Dovetail compliance: {}!'.format(kwargs['testsuite']))
logger.info('================================================')
- logger.info('Build tag: %s', dt_cfg.dovetail_config['build_tag'])
+ logger.info('Build tag: {}'.format(dt_cfg.dovetail_config['build_tag']))
env_init(logger)
copy_userconfig_files(logger)
dt_utils.check_docker_version(logger)
if dt_cfg.dovetail_config['report_dest'] == "file":
Report.generate(testsuite_yaml, testarea, duration)
else:
- logger.error('invalid input commands, testsuite %s testarea %s',
- kwargs['testsuite'], testarea)
+ logger.error('Invalid input commands, testsuite {} testarea {}'
+ .format(kwargs['testsuite'], testarea))
dt_cfg.load_config_files()
def __init__(self, testcase):
self.testcase = testcase
- self.logger.debug('create runner: %s', self.type)
+ self.logger.debug('Create runner: {}'.format(self.type))
@classmethod
def create_log(cls):
def pre_copy(self, container_id=None, dest_path=None,
src_file=None, exist_file=None):
if not dest_path:
- self.logger.error("There has no dest_path in %s config file.",
- self.testcase.name())
+ self.logger.error("There has no dest_path in {} config file."
+ .format(self.testcase.name()))
return None
if src_file:
self.testcase.mk_src_file()
if dt_cfg.dovetail_config['offline']:
exist = Container.check_image_exist(self.testcase.validate_type())
if not exist:
- self.logger.error('%s image not exist when running offline',
- self.testcase.validate_type())
+ self.logger.error("{} image doesn't exist, can't run offline."
+ .format(self.testcase.validate_type()))
return
else:
if not Container.pull_image(self.testcase.validate_type()):
img_file = os.path.join(dt_cfg.dovetail_config['config_dir'],
img_name)
if not os.path.isfile(img_file):
- self.logger.error('image %s not found', img_name)
+ self.logger.error('Image {} not found.'.format(img_name))
return
container_id = Container.create(self.testcase.validate_type(),
self.testcase.name())
if not container_id:
- self.logger.error('failed to create container')
+ self.logger.error('Failed to create container.')
return
- self.logger.debug('container id:%s', container_id)
+ self.logger.debug('container id: {}'.format(container_id))
dest_path = self.testcase.pre_copy_path("dest_path")
src_file_name = self.testcase.pre_copy_path("src_file")
self.testcase.prepared(True)
if not self.testcase.prepare_cmd(self.type):
- self.logger.error('failed to prepare testcase:%s',
- self.testcase.name())
+ self.logger.error(
+ 'Failed to prepare test case: {}'.format(self.testcase.name()))
else:
for cmd in self.testcase.cmds:
ret, msg = Container.exec_cmd(container_id, cmd)
if ret != 0:
- self.logger.error('Failed to exec %s, ret:%d, msg:%s',
- cmd, ret, msg)
+ self.logger.error('Failed to exec {}, ret: {}, msg: {}'
+ .format(cmd, ret, msg))
break
cmds = self.testcase.post_condition()
super(ShellRunner, self).__init__()
self.testcase = testcase
self.type = 'shell'
- self.logger.debug('create runner:%s', self.type)
+ self.logger.debug('Create runner: {}'.format(self.type))
def run(self):
testcase_passed = 'PASS'
self.testcase.prepared(True)
if not self.testcase.prepare_cmd(self.type):
- self.logger.error('failed to prepare cmd:%s',
- self.testcase.name())
+ self.logger.error(
+ 'Failed to prepare cmd: {}'.format(self.testcase.name()))
else:
for cmd in self.testcase.cmds:
ret, msg = dt_utils.exec_cmd(cmd, self.logger)
result_filename = os.path.join(dt_cfg.dovetail_config['result_dir'],
self.testcase.name()) + '.out'
- self.logger.debug('save result:%s', result_filename)
+ self.logger.debug('Save result: {}'.format(result_filename))
try:
with open(result_filename, 'w') as f:
f.write(json.dumps(result))
except Exception as e:
- self.logger.exception('Failed to write result into file:%s, \
- except:%s', result_filename, e)
+ self.logger.exception('Failed to write result into file: {}, '
+ 'exception: {}'.format(result_filename, e))
class TestRunnerFactory(object):
return False
# self.logger.debug('cmd_lines:%s', cmd_lines)
self.cmds.append(cmd_lines)
- self.logger.debug('cmds:%s', self.cmds)
+ self.logger.debug('cmds: {}'.format(self.cmds))
return True
def prepare_cmd(self, test_type):
return self.parse_cmd(testcase_cmds)
if config_cmds:
return self.parse_cmd(config_cmds)
- self.logger.error('testcase %s has no cmds', self.name())
+ self.logger.error('Test case {} has no cmds.'.format(self.name()))
return False
def __str__(self):
def sub_testcase_passed(self, name, passed=None):
if passed is not None:
- self.logger.debug('sub_testcase_passed:%s %s', name, passed)
+ self.logger.debug(
+ 'sub_testcase_passed: {} {}'.format(name, passed))
self.sub_testcase_status[name] = passed
return self.sub_testcase_status[name]
return pre_condition
pre_condition = self.pre_condition_cls(self.validate_type())
if not pre_condition:
- self.logger.debug('testcase:%s pre_condition is empty',
- self.name())
+ self.logger.debug(
+ 'Test case: {} pre_condition is empty.'.format(self.name()))
return pre_condition
def pre_copy_path(self, key_name):
return post_condition
post_condition = self.post_condition_cls(self.validate_type())
if not post_condition:
- self.logger.debug('testcae:%s post_condition is empty',
- self.name())
+ self.logger.debug(
+ 'Test case: {} post_condition is empty.'.format(self.name()))
return post_condition
def mk_src_file(self):
with open(file_path, 'w+') as src_file:
if self.sub_testcase() is not None:
for sub_test in self.sub_testcase():
- self.logger.debug('save testcases %s', sub_test)
+ self.logger.debug(
+ 'Save test cases {}'.format(sub_test))
src_file.write(sub_test + '\n')
- self.logger.debug('save testcases to %s', file_path)
+ self.logger.debug('Save test cases to {}'.format(file_path))
return file_path
except Exception:
- self.logger.error('Failed to save: %s', file_path)
+ self.logger.exception('Failed to save: {}'.format(file_path))
return None
def run(self):
try:
runner.run()
except AttributeError as e:
- self.logger.exception('testcase:%s except:%s', self.name, e)
+ self.logger.exception(
+ 'Test case: {} Exception: {}'.format(self.name, e))
# testcase in upstream testing project
# validate_testcase_list = {'functest': {}, 'yardstick': {}, 'shell': {}}
cls.testcase_list[next(testcase_yaml.iterkeys())] = \
testcase
else:
- cls.logger.error('failed to create testcase: %s',
- testcase_file)
+ cls.logger.error('Failed to create test case: {}'
+ .format(testcase_file))
@classmethod
def get(cls, testcase_name):
def check_https_enabled(logger=None):
- logger.info("checking if https enabled or not...")
+ logger.debug("Checking if https enabled or not...")
cmd = "openstack catalog show identity |awk '/public/ {print $4}'| \
grep 'https'"
ret, msg = exec_cmd(cmd, logger)
if insecure.lower() == "true":
insecure_option = ' --insecure '
else:
- logger.warn("env variable OS_INSECURE is %s, if https + no"
- "credential used, should be set as True" % insecure)
+ logger.warn("Env variable OS_INSECURE is {}, if https + no "
+ "credential used, should be set as True."
+ .format(insecure))
cmd_check = "openstack %s network list" % insecure_option
ret, msg = exec_cmd(cmd_check, logger)
if ret:
- logger.error("The credentials info in %s is invalid." % env_file)
+ logger.error("The credentials info in {} is invalid.".format(env_file))
return None
cmd = "openstack %s network list --long | grep 'External' | head -1 | \
awk '{print $4}'" % insecure_option
def store_db_results(db_url, build_tag, testcase, dest_file, logger):
url = "%s?build_tag=%s-%s" % (db_url, build_tag, testcase)
- logger.debug("Query to rest api: %s", url)
+ logger.debug("Query to rest api: {}".format(url))
try:
data = json.load(urllib2.urlopen(url))
if data['results']:
else:
return False
except Exception as e:
- logger.error("Cannot read content from %s, exception: %s", url, e)
+ logger.exception(
+ "Cannot read content from {}, exception: {}".format(url, e))
return False
res = "%sm%ss" % (delta / 60, delta % 60)
return res
except ValueError as e:
- logger.error("ValueError: %s", e)
+ logger.exception("ValueError: {}".format(e))
return None
client_ret, client_ver = \
exec_cmd("sudo docker version -f'{{.Client.Version}}'", logger=logger)
if server_ret == 0:
- logger.debug("docker server version: %s", server_ver)
+ logger.debug("docker server version: {}".format(server_ver))
if server_ret != 0 or (LooseVersion(server_ver) < LooseVersion('1.12.3')):
logger.error("Don't support this Docker server version. "
"Docker server should be updated to at least 1.12.3.")
if client_ret == 0:
- logger.debug("docker client version: %s", client_ver)
+ logger.debug("docker client version: {}".format(client_ver))
if client_ret != 0 or (LooseVersion(client_ver) < LooseVersion('1.12.3')):
logger.error("Don't support this Docker client version. "
"Docker client should be updated to at least 1.12.3.")
Code Review / dovetail.git / commitdiff