def test_create_jessie_image(capsys):
print(os.getcwd())
with workspace():
edi_exec = os.path.join(get_project_root(), 'bin', 'edi')
project_name = 'pytest-{}'.format(get_random_string(6))
config_command = [edi_exec, 'config', 'init', project_name, 'debian-jessie-amd64']
run(config_command) # run as non root
parser = edi._setup_command_line_interface()
cli_args = parser.parse_args(['image', 'create', '{}-develop.yml'.format(project_name)])
Create().run_cli(cli_args)
out, err = capsys.readouterr()
print(out)
assert not err
lxc_compression_algo = get_server_image_compression_algorithm()
lxc_export_extension = get_file_extension_from_image_compression_algorithm(lxc_compression_algo)
images = [
os.path.join(get_artifact_dir(), '{}-develop_edicommand_image_bootstrap_di.tar.gz'.format(project_name)),
os.path.join(get_artifact_dir(), '{}-develop_edicommand_image_lxc_di.tar.gz'.format(project_name)),
os.path.join(get_artifact_dir(), '{}-develop_edicommand_lxc_export{}'.format(project_name,
lxc_export_extension)),
os.path.join(get_artifact_dir(), '{}-develop.result'.format(project_name)),
]
for image in images:
assert os.path.isfile(image)
image_store_items = [
"{}-develop_edicommand_lxc_import_di".format(project_name),
"{}-develop_edicommand_lxc_publish".format(project_name)
]
lxc_image_list_cmd = ['lxc', 'image', 'list']
result = run(lxc_image_list_cmd, stdout=subprocess.PIPE)
for image_store_item in image_store_items:
assert image_store_item in result.stdout
parser = edi._setup_command_line_interface()
cli_args = parser.parse_args(['image', 'create', '--clean', '{}-develop.yml'.format(project_name)])
Create().run_cli(cli_args)
parser = edi._setup_command_line_interface()
cli_args = parser.parse_args(['image', 'create', '--recursive-clean', '8',
'{}-develop.yml'.format(project_name)])
Create().run_cli(cli_args)
for image in images:
assert not os.path.isfile(image)
result = run(lxc_image_list_cmd, stdout=subprocess.PIPE)
for image_store_item in image_store_items:
assert image_store_item not in result.stdout
def _result_folder(self):
if not self._needs_qemu():
return None
else:
folder_name = "{0}_{1}".format(self.config.get_configuration_name(),
self._get_command_file_name_prefix())
return os.path.join(get_artifact_dir(), folder_name)
def _result(self):
archive_name = ("{0}_{1}{2}.tar.{3}"
).format(self.config.get_configuration_name(),
self._get_command_file_name_prefix(),
self.config.get_context_suffix(),
self.config.get_compression())
return os.path.join(get_artifact_dir(), archive_name)
def _get_commands(self):
artifactdir = get_artifact_dir()
commands = self.config.get_ordered_path_items(self.config_section)
augmented_commands = []
artifacts = dict()
if self.input_artifact:
artifacts['edi_input_artifact'] = self.input_artifact
for name, path, dictionary, raw_node in commands:
output = raw_node.get('output')
if type(output) != dict:
raise FatalError(('''The output specification in command node '{}' is not a key value dictionary.'''
).format(name))
new_artifacts = dict()
for artifact_key, artifact_item in output.items():
if str(artifact_item) != os.path.basename(artifact_item):
raise FatalError((('''The specified output artifact '{}' within the '''
'''command node '{}' is invalid.\n'''
'''The output shall be a file or a folder (no '/' in string).''')
).format(artifact_key, name))
artifact_path = os.path.join(artifactdir, artifact_item)
new_artifacts[artifact_key] = str(artifact_path)
artifacts.update(new_artifacts)
dictionary.update(artifacts)
filename, content = self._render_command_file(path, dictionary)
augmented_commands.append((filename, content, name, path, dictionary, raw_node, new_artifacts))
return augmented_commands
def test_artifacts_folder_removal(monkeypatch):
suppress_chown_during_debuild(monkeypatch)
with workspace() as workdir:
create_artifact_dir()
artifacts_dir = get_artifact_dir()
assert str(workdir) in str(artifacts_dir)
random_dir_name = get_random_string(20)
abs_dir_name = os.path.join(artifacts_dir, random_dir_name)
run(['mkdir', '-p', abs_dir_name])
assert os.path.isdir(abs_dir_name)
safely_remove_artifacts_folder(abs_dir_name)
assert not os.path.isdir(abs_dir_name)
def safely_remove_artifacts_folder(abs_folder_path, sudo=False):
"""
Do some paranoid checking before removing a folder possibly using sudo.
:param abs_folder_path: Absolute path to folder that should get deleted.
:param sudo: If True, use sudo to delete folder.
"""
artifacts_dir = get_artifact_dir()
assert 'artifacts' in str(abs_folder_path)
assert str(artifacts_dir) in str(abs_folder_path)
assert os.path.isdir(abs_folder_path)
assert os.path.isabs(abs_folder_path)
mount_result = run(['mount'], stdout=subprocess.PIPE)
if str(abs_folder_path) in mount_result.stdout:
raise FatalError(('''Refusing to delete '{}' since it contains mounted elements.'''
).format(abs_folder_path))
run(['rm', '-rf', abs_folder_path], sudo=sudo)
def test_artifacts_folder_removal_as_sudo():
with workspace() as workdir:
create_artifact_dir()
artifacts_dir = get_artifact_dir()
assert str(workdir) in str(artifacts_dir)
random_dir_name = get_random_string(20)
abs_dir_name = os.path.join(artifacts_dir, random_dir_name)
mount_folder = os.path.join(workdir, get_random_string(20))
mount_point = os.path.join(abs_dir_name, 'mnt')
for folder in [abs_dir_name, mount_folder, mount_point]:
run(['mkdir', '-p', folder])
assert os.path.isdir(folder)
run(['mount', '--bind', mount_folder, mount_point], sudo=True)
with pytest.raises(FatalError) as error:
safely_remove_artifacts_folder(abs_dir_name, sudo=True)
assert abs_dir_name in error.value.message
run(['umount', mount_point], sudo=True)
safely_remove_artifacts_folder(abs_dir_name, sudo=True)
assert not os.path.isdir(abs_dir_name)
def _result(self):
if not self._needs_qemu():
return None
else:
return os.path.join(get_artifact_dir(),
self._get_qemu_binary_name())
def test_build_stretch_container(capsys, datadir):
with workspace():
edi_exec = os.path.join(get_project_root(), 'bin', 'edi')
project_name = 'pytest-{}'.format(get_random_string(6))
config_command = [
edi_exec, 'config', 'init', project_name,
'debian-stretch-{}'.format(get_debian_architecture())
]
run(config_command) # run as non root
# enable ssh server and create a default user
modify_develop_overlay(project_name)
# copy pub key into default pub key folder
prepare_pub_key(datadir)
container_name = 'pytest-{}'.format(get_random_string(6))
parser = edi._setup_command_line_interface()
cli_args = parser.parse_args([
'-v', 'lxc', 'configure', container_name,
'{}-develop.yml'.format(project_name)
])
Configure().run_cli(cli_args)
out, err = capsys.readouterr()
print(out)
assert not err
images = [
os.path.join(
get_artifact_dir(),
'{}-develop_edicommand_image_bootstrap.tar.gz'.format(
project_name)),
os.path.join(
get_artifact_dir(),
'{}-develop_edicommand_lxc_prepare.tar.gz'.format(
project_name))
]
for image in images:
assert os.path.isfile(image)
lxc_image_list_cmd = [lxc_exec(), 'image', 'list']
result = run(lxc_image_list_cmd, stdout=subprocess.PIPE)
assert project_name in result.stdout
parser = edi._setup_command_line_interface()
cli_args = parser.parse_args(
['-v', 'clean', '{}-develop.yml'.format(project_name)])
Clean().run_cli(cli_args)
for image in images:
assert not os.path.isfile(image)
result = run(lxc_image_list_cmd, stdout=subprocess.PIPE)
assert project_name not in result.stdout
verification_command = [
lxc_exec(), 'exec', container_name, '--', 'cat', '/etc/os-release'
]
result = run(verification_command, stdout=subprocess.PIPE)
assert '''VERSION_ID="9"''' in result.stdout
assert 'ID=debian' in result.stdout
os.chmod(os.path.join(str(datadir), 'keys'), 0o700)
os.chmod(os.path.join(str(datadir), 'keys', 'test_id_rsa'), 0o600)
container_ip = get_container_ip_addr(container_name, 'lxcif0')
ssh_cmd = [
'ssh', '-i',
str(os.path.join(str(datadir), 'keys', 'test_id_rsa')), '-o',
'UserKnownHostsFile=/dev/null', '-o', 'StrictHostKeyChecking=no',
'testuser@{}'.format(container_ip), 'true'
]
# ssh command should work without password due to proper ssh key setup!
run(ssh_cmd, sudo=True, timeout=5)
verify_shared_folder(container_name)
stop_command = [lxc_exec(), 'stop', container_name]
run(stop_command)
delete_command = [lxc_exec(), 'delete', container_name]
run(delete_command)
def _result(self):
algorithm = get_server_image_compression_algorithm()
extension = get_file_extension_from_image_compression_algorithm(
algorithm)
archive = "{}{}".format(self._result_base_name(), extension)
return os.path.join(get_artifact_dir(), archive)
def _image_without_extension(self):
return os.path.join(get_artifact_dir(), self._result_base_name())
