def clean(cls, container_id, valid_type):
cmd = ('sudo docker rm -f {}'.format(container_id))
dt_utils.exec_cmd(cmd, cls.logger)
if valid_type.lower() == 'bottlenecks':
containers = dt_cfg.dovetail_config[valid_type]['extra_container']
for container in containers:
if cls.check_container_exist(container):
cmd = ('sudo docker rm -f {}'.format(container))
dt_utils.exec_cmd(cmd, cls.logger)
def clean_results_dir():
result_path = dt_cfg.dovetail_config['result_dir']
if os.path.exists(result_path):
if os.path.isdir(result_path):
cmd = 'rm -rf %s/*' % (result_path)
dt_utils.exec_cmd(cmd, exit_on_error=False, exec_msg_on=False)
else:
print('result_dir in dovetail_config.yml is not a directory.')
raise SystemExit(EXIT_RUN_FAILED)
def remove_image(cls, image_id):
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 {} has containers, skip.'.format(image_id))
return True
cmd = 'sudo docker rmi %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 {} successfully.'.format(image_id))
return True
cls.logger.error('Failed to remove image {}.'.format(image_id))
return False
def get_image_id(cls, image_name):
cmd = 'sudo docker images -q %s' % (image_name)
ret, image_id = dt_utils.exec_cmd(cmd, cls.logger)
if ret == 0:
return image_id
else:
return None
def pull_image_only(cls, image_name):
cmd = 'sudo docker pull %s' % (image_name)
ret, msg = dt_utils.exec_cmd(cmd, cls.logger)
if ret != 0:
cls.logger.error(
'Failed to pull docker image {}!'.format(image_name))
return False
cls.logger.debug('Success to pull docker image {}!'.format(image_name))
return True
def run(self):
testcase_passed = 'PASS'
prepare_failed = False
result = {'pass': '******', 'results': []}
if not self.testcase.prepared():
cmds = self.testcase.pre_condition()
for cmd in cmds:
ret, msg = dt_utils.exec_cmd(cmd, self.logger)
result['results'].append((cmd, ret, msg))
if ret != 0:
prepare_failed = True
break
if not prepare_failed:
self.testcase.prepared(True)
if not self.testcase.prepare_cmd(self.type):
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['results'].append((cmd, ret, msg))
if ret != 0:
testcase_passed = 'FAIL'
result['pass'] = testcase_passed
cmds = self.testcase.post_condition()
for cmd in cmds:
ret, msg = dt_utils.exec_cmd(cmd, self.logger)
result['results'].append((cmd, ret, msg))
result_filename = os.path.join(dt_cfg.dovetail_config['result_dir'],
self.testcase.name()) + '.out'
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: {}, '
'exception: {}'.format(result_filename, e))
def copy_patch_files(logger):
patch_set_path = dt_cfg.dovetail_config['patch_dir']
if not os.path.isdir(patch_set_path):
os.makedirs(patch_set_path)
cmd = 'cp -a -r %s/* %s' % (constants.PATCH_PATH, patch_set_path)
dt_utils.exec_cmd(cmd, logger, exit_on_error=False)
def copy_userconfig_files(logger):
userconfig_path = dt_cfg.dovetail_config['userconfig_dir']
if not os.path.isdir(userconfig_path):
os.makedirs(userconfig_path)
cmd = 'cp -r %s/* %s' % (constants.USERCONF_PATH, userconfig_path)
dt_utils.exec_cmd(cmd, logger, exit_on_error=False)
def create(cls, valid_type, testcase_name, docker_image):
dovetail_config = dt_cfg.dovetail_config
project_cfg = dovetail_config[valid_type]
# credentials file openrc.sh is neccessary
openrc = cls.openrc_volume(valid_type)
if not openrc:
return None
opts = dt_utils.get_value_from_dict('opts', project_cfg)
envs = dt_utils.get_value_from_dict('envs', project_cfg)
volumes = dt_utils.get_value_from_dict('volumes', project_cfg)
opts = ' ' if not opts else opts
envs = ' ' if not envs else envs
volumes = ' ' if not volumes else ' '.join(volumes)
# CI_DEBUG is used for showing the debug logs of the upstream projects
# BUILD_TAG is the unique id for this test
DEBUG = os.getenv('DEBUG')
if DEBUG is not None and DEBUG.lower() == "true":
envs = envs + ' -e CI_DEBUG=true'
else:
envs = envs + ' -e CI_DEBUG=false'
envs = envs + ' -e BUILD_TAG=%s-%s' % (dovetail_config['build_tag'],
testcase_name)
hosts_config = dt_utils.get_hosts_info(cls.logger)
# This part will be totally removed after remove the 4 functions
# set_functest_config has been removed
# set_yardstick_config has been removed
# set_bottlenecks_config has been removed
# set_vnftest_config
config = " "
if valid_type.lower() == "vnftest":
config = cls.set_vnftest_config()
if not config:
return None
# for refstack, support user self_defined configuration
config_volume = \
' -v %s:%s ' % (os.getenv("DOVETAIL_HOME"),
project_cfg['config']['dir'])
cacert_volume = ""
https_enabled = dt_utils.check_https_enabled(cls.logger)
cacert = os.getenv('OS_CACERT')
insecure = os.getenv('OS_INSECURE')
if cacert is not None:
if dt_utils.check_cacert_file(cacert, cls.logger):
cacert_volume = ' -v %s:%s ' % (cacert, cacert)
else:
return None
elif https_enabled:
if insecure and insecure.lower() == 'true':
cls.logger.debug("Use the insecure mode...")
else:
cls.logger.error("https enabled, please set OS_CACERT or "
"insecure mode...")
return None
images_volume = ''
if project_cfg['config'].get('images', None):
images_volume = '-v {}:{}'.format(dovetail_config['images_dir'],
project_cfg['config']['images'])
result_volume = ' -v %s:%s ' % (dovetail_config['result_dir'],
project_cfg['result']['dir'])
cmd = 'sudo docker run {opts} {envs} {volumes} {config} ' \
'{hosts_config} {openrc} {cacert_volume} {config_volume} ' \
'{result_volume} {images_volume} {docker_image} /bin/bash' \
.format(**locals())
dt_utils.exec_cmd(cmd, cls.logger)
ret, container_id = \
dt_utils.exec_cmd("sudo docker ps | grep " + docker_image +
" | awk '{print $1}' | head -1", cls.logger)
cls.container_list[valid_type] = container_id
if valid_type.lower() == 'vnftest':
cls.set_vnftest_conf_file(container_id)
return container_id
def docker_copy(cls, container_id, src_path, dest_path):
if not src_path or not dest_path:
return (1, 'src_path or dest_path is empty')
cmd = 'docker cp %s %s:%s' % (src_path, container_id, dest_path)
return dt_utils.exec_cmd(cmd, cls.logger)
def exec_cmd(cls, container_id, sub_cmd, exit_on_error=False):
if sub_cmd == "":
return (1, 'sub_cmd is empty')
cmd = 'sudo docker exec %s /bin/bash -c "%s"' % (container_id, sub_cmd)
return dt_utils.exec_cmd(cmd, cls.logger, exit_on_error)
def check_container_exist(cls, container_name):
cmd = ('sudo docker ps -aq -f name={}'.format(container_name))
ret, msg = dt_utils.exec_cmd(cmd, cls.logger)
if ret == 0 and msg:
return True
return False