def UpdateFile(self, request, context):
container_id = request.container_id
path = request.path
file_name = request.file_name
old_version = request.old_version
exit_code, old_file_stat = ContainerUtils.ExecCommand(\
container_id=container_id,
exec_cmd = ["stat", "-c", "%Y", path+"/"+file_name]
)
if exit_code == 0:
if old_version == old_file_stat or request.force:
# generate_data = GenerateData(request)
if not ContainerUtils.PutArchive(container_id, path,
request.data):
return Manager.UpdateFile_Response(
exit_code=Manager.UpdateFile_Response.ExitCode.
UNKNOWN_ERROR)
else:
exit_code, new_version = ContainerUtils.ExecCommand(\
container_id=container_id,
exec_cmd = ["stat", "-c", "%Y", path]
)
return Manager.UpdateFile_Response(\
exit_code = Manager.UpdateFile_Response.ExitCode.SUCCESS,
new_version = new_version
)
else:
return Manager.UpdateFile_Response(\
exit_code=Manager.UpdateFile_Response.ExitCode.MTIME_SYNC_ERROR)
elif exit_code == 1:
return Manager.UpdateFile_Response(\
exit_code=Manager.UpdateFile_Response.ExitCode.FILE_IS_NOT_EXIST)
def ListFile(self, request, context):
cmd = ["ls", "-Al", request.path]
exit_code, output = ContainerUtils.ExecCommand(request.container_id,
cmd)
response = Manager.ListFile_Response()
if exit_code == 0:
response.exit_code = Manager.ListFile_Response.ExitCode.SUCCESS
List = output.strip().split('\n')[1:]
for file in List:
temp = file.split(' ')
stat = temp[0]
filename = temp[-1]
temp = response.files.add()
temp.file_name = filename
if stat[0] == '-':
temp.file_type = Manager.FileStat.FileType.FILE
elif stat[0] == 'd':
temp.file_type = Manager.FileStat.FileType.FOLDER
elif stat[0] == 'i':
temp.file_type = Manager.FileStat.FileType.LINK
elif exit_code == 1:
response.exit_code = Manager.ListFile_Response.ExitCode.MINOR_PROBLEMS
elif exit_code == 2:
response.exit_code = Manager.ListFile_Response.ExitCode.SERIOUS_TROUBLE
return response
def CreateContainer(self, request, context):
container_id = ContainerUtils.CreateContainer(
image_id=request.image_id,
mount_path="/workplace/{username}/mount".format(
username=request.username),
hostname=request.username,
container_name=request.container_name)
return Manager.CreateContainer_Response(container_id=container_id)
def ListContainers(self, request, context):
containers = ContainerUtils.ListContainers()
response = Manager.ListContainers_Response()
for container in containers:
attr = response.containers.add()
attr.id = container['Id']
attr.created = container['Created']
attr.status = GetContainerStatus(container['Status'])
attr.image = container['Image']
attr.name = container['Name']
return response
def __init__(self, **kwargs):
self.is_docker_daemon_running()
self.test_dir = self._create_temp_dir()
self.imageutils = ImageUtils()
self.containerutils = ContainerUtils()
self.selinux_checks = SELinuxTests()
self.selinux_denials_test = SELinuxDenials()
self.image_inspection_test = InspectImage()
self.container_inspection_test = InspectContainer()
self.metadata = Metadata()
self._process_kwargs(**kwargs)
def GetContainer(self, request, context):
response = Manager.GetContainer_Response()
try:
container = ContainerUtils.GetContainer(request.container_id)
except docker.errors.APIError:
response.exit_code = Manager.GetContainer_Response.ExitCode.NOTFOUND
return response
response.exit_code = Manager.GetContainer_Response.ExitCode.SUCCESS
response.container_attr.id = container['Id']
response.container_attr.created = container['Created']
response.container_attr.status = GetContainerStatus(container['State'])
response.container_attr.image = container['Image']
response.container_attr.name = container['Name']
return response
class ProbeRunner(object):
"""
Probe runner utility
"""
def __init__(self, **kwargs):
self.is_docker_daemon_running()
self.test_dir = self._create_temp_dir()
self.imageutils = ImageUtils()
self.containerutils = ContainerUtils()
self.selinux_checks = SELinuxTests()
self.selinux_denials_test = SELinuxDenials()
self.image_inspection_test = InspectImage()
self.container_inspection_test = InspectContainer()
self.metadata = Metadata()
self._process_kwargs(**kwargs)
def setup(self):
"""
Setup before test run
"""
self.getimage = GetImage(self.offline,
self.test_dir)
# This method processes the image repository and return image name with
# tag
self.cert_container = self.cert_container_name()
def _process_kwargs(self, **kwargs):
"""
Process the kwargs given to __init__ method
"""
self.image = kwargs["image"]
self.dockeruser = kwargs.get("user", None)
self.output_dir = kwargs.get("output_dir", None)
self.offline = kwargs.get("offline", None)
def is_docker_daemon_running(self):
"""
Raise if docker daemon is not running
"""
if not is_docker_running():
raise ctsexceptions.CTSDockerServiceNotRunning
def cert_container_name(self):
"""
Returns a container name
"""
random_name = "".join(choice(ascii_lowercase) for _ in range(6))
return "cert_%s" % random_name
def is_image_tests(self):
"""
If image tests to be ran.
"""
return True
def test_scripts(self):
"""
Returns names of tests scripts
"""
return constants.TEST_SCRIPTS_NAME
def test_scripts_source_path(self):
"""
Source path of tests scripts
"""
return constants.TEST_SCRIPTS_PATH
def test_scripts_dir_in_container(self):
"""
Destination path of tests scripts in container
"""
return constants.TEST_SCRIPTS_DIR_IN_CONT
def cert_temp_parent_dir(self):
"""
Parent directory of test dir at host
"""
return constants.CERT_TEMP_PARENT_DIR
def _create_temp_dir(self):
"""
Create a temporary directory at host to be shared as volume
"""
return tempfile.mkdtemp(dir=self.cert_temp_parent_dir())
def cert_shared_dir_at_host(self):
"""
Shared directory path at host to be used as volume
"""
return self.test_dir
def copy_scripts_in_test_dir(self):
"""
Copy tests scripts in cert dir at host
"""
[copy(script, self.cert_shared_dir_at_host())
for script in self.test_scripts_source_path()]
def change_perm_for_test_dir(self, test_dir, perm):
"""
Change permission to test_dir
"""
os.chmod(test_dir, perm)
def pkg_report_path(self):
"""
Package report path generated in live container test mode
"""
return os.path.join(self.cert_shared_dir_at_host(),
constants.PACKAGE_REPORT)
def _add_user_in_params(self, user, params):
"""
Add user in parameters
"""
# assumes params start with "run"
params.insert(1, "--user")
params.insert(2, user)
return params
# ------------------Image-test-utilities------------------
def _get_params_for_image_tests(self, volumes, entrypoint):
"""
Generate parameters for image tests
"""
# method self._add_user_in_params() asssumes params starts
# "run", hence params should start with "run"
params = ["run", "-v", volumes, "--entrypoint", entrypoint,
"--name", self.cert_container, self.image]
# if container needs to be run as user root
if self.dockeruser:
self._add_user_in_params(self.dockeruser, params)
return params
def _test_kickstart_path_in_container(self):
"""
Returns entry point
"""
return os.path.join(self.test_scripts_dir_in_container(),
constants.TEST_KICKSTART_SCRIPT)
def _get_volumes_mapping(self):
"""
Returns volumes mapping from host to container
"""
volumes = "%s:%s" % (self.cert_shared_dir_at_host(),
self.test_scripts_dir_in_container())
return volumes
def run_image_tests(self):
"""
Run image tests
"""
volumes = self._get_volumes_mapping()
entrypoint = self._test_kickstart_path_in_container()
params = self._get_params_for_image_tests(volumes, entrypoint)
try:
self.containerutils.create_container(params)
except:
raise
else:
msg = "Successfully ran image tests."
return self.pkg_report_path()
# -------------------Test-run-utilities----------------------
def pre_test_run_setup(self):
"""
Run pre test run setup
"""
self.copy_scripts_in_test_dir()
self.change_perm_for_test_dir(self.cert_shared_dir_at_host(), 0777)
def _run(self):
"""
Run all tests with clean up utility
"""
self.run_image_tests()
# image inspection test
msg = "Inspection image under test.."
print msg
inspect_image_report_path = os.path.join(
self.cert_shared_dir_at_host(),
"%s.json" % self.image_inspection_test.__class__.__name__
)
self.image_inspection_test.run(
# image=self.cert_image,
image=self.image,
export_file=inspect_image_report_path)
# metadata tests
metadata_report_path = os.path.join(
self.cert_shared_dir_at_host(),
"%s.json" % self.metadata.__class__.__name__
)
msg = "Collecting metadata of image under test.."
print msg
self.metadata.run(
# image=self.cert_image,
image=self.image,
export_file=metadata_report_path)
def clean_up(self, post_run=True, during_setup=False):
"""
Clean up after test run
"""
msg = "Cleaning.."
try:
if during_setup:
self.clean.remove_test_dir(self.test_dir)
return
if self.cert_container:
self.clean.clean_container(self.cert_container)
if post_run:
if self.test_dir:
self.clean.remove_test_dir(self.test_dir)
if self.image:
self.clean.clean_image(self.image, all_tags=True)
except Exception as e:
raise
def create_testdata_tarball(self):
"""
Create tarball of test data
"""
source_dir = self.cert_shared_dir_at_host()
tempdir = tempfile.mkdtemp(dir=source_dir)
files = [os.path.join(source_dir, item)
for item in os.listdir(source_dir)
if os.path.isfile(os.path.join(source_dir, item))]
[copy(f, tempdir) for f in files]
return create_tarball(tempdir, "container_cert", "/tmp/")
def move_result_to_output_dir(self, result, output):
"""
Move resultant test data from `result` to `output` directory
data present in `result` is deleted after movement to
`output` dir
"""
if not os.path.isdir(output):
raise ctsexceptions.CTSOutputDirectoryDoesNotExist(output)
if os.path.isdir(result):
files = [os.path.join(result, item) for item in os.listdir(result)
if os.path.isfile(os.path.join(result, item))]
# if -t option is given for archiving the output, it will generate a
# tarfile as output and thus it will be a file
elif os.path.isfile(result):
files = [result]
try:
[copy(src, output) for src in files]
except IOError as e:
raise
else:
if os.path.isfile(result):
return os.path.join(output, os.path.basename(result))
else:
return output
def remove_test_scripts_from_result(self):
"""
Remove test scripts from result directory if any
"""
for item in os.listdir(self.cert_shared_dir_at_host()):
if item in self.test_scripts():
os.unlink(os.path.join(self.cert_shared_dir_at_host(), item))
def _post_run(self):
"""
Operations to be performed post test run
"""
self.remove_test_scripts_from_result()
result = self.cert_shared_dir_at_host()
print result
# if testrun data (dir/tarfile) needs to be exported in particular dir
if self.output_dir:
result = self.move_result_to_output_dir(result, self.output_dir)
return result
def run(self):
"""
Run all tests
"""
self.setup()
self.pre_test_run_setup()
self._run()
self._post_run()
def GetFile(self, request, context):
bits, stat = ContainerUtils.GetArchive(request.container_id,
request.path)
for data in bits:
yield Manager.GetFile_Response(data=data)
def RestartContainer(self, request, context):
ContainerUtils.RestartContainer(request.container_id)
return Manager.RestartContainer_Response()
def RemoveContainer(self, request, context):
ContainerUtils.RemoveContainer(request.container_id, request.force)
return Manager.RemoveContainer_Response()
def StopContainer(self, request, context):
ContainerUtils.StopContainer(request.container_id)
return Manager.StopContainer_Response()
def PruneContainers(self, request, context):
ContainerUtils.PruneContainers()
return Manager.PruneContainers_Response()