def setup_intermediate_config(self):
"""
Create intermediate config files
Some config files e.g etc/hosts needs to be temporarly copied
from the buildsystem host to the image root system in order to
allow e.g DNS resolution in the way as it is configured on the
buildsystem host. These config files only exists during the image
build process and are not part of the final image
:raises KiwiSetupIntermediateConfigError: if the management of
intermediate configuration files fails
"""
try:
for config in self.config_files:
if os.path.exists(config):
self.cleanup_files.append(config + '.kiwi')
Command.run(
['cp', config, self.root_dir + config + '.kiwi']
)
link_target = os.path.basename(config) + '.kiwi'
Command.run(
['ln', '-s', '-f', link_target, self.root_dir + config]
)
checksum = Checksum(config)
with open(self.root_dir + config + '.sha', 'w') as shasum:
shasum.write(checksum.sha256())
except Exception as e:
self.cleanup()
raise KiwiSetupIntermediateConfigError(
'%s: %s' % (type(e).__name__, format(e))
)
def _cleanup_intermediate_config(self):
# delete kiwi copied config files
config_files_to_delete = []
for config in self.cleanup_files:
config_file = self.root_dir + config
shasum_file = config_file.replace('.kiwi', '.sha')
config_files_to_delete.append(config_file)
config_files_to_delete.append(shasum_file)
checksum = Checksum(config_file)
if not checksum.matches(checksum.sha256(), shasum_file):
message = dedent('''\n
Modifications to intermediate config file detected
The file: {0}
is a copy from the host system and symlinked
to its origin in the image root during build time.
Modifications to this file by e.g script code will not
have any effect because the file gets restored by one
of the following actions:
1. A package during installation provides it
2. A custom version of the file is setup as overlay file
3. The file is not provided by install or overlay and will
be deleted at the end of the build process
If you need a custom version of that file please
provide it as an overlay file in your image
description
''')
log.warning(message.format(config_file))
del self.cleanup_files[:]
# delete stale symlinks if there are any. normally the package
# installation process should have replaced the symlinks with
# real files from the packages. On deletion check for the
# presence of a config file template and restore it
try:
for config in self.config_files:
config_file = self.root_dir + config
if os.path.islink(config_file):
Command.run(['rm', '-f', config_file])
self._restore_config_template(config_file)
Command.run(['rm', '-f'] + config_files_to_delete)
except Exception as issue:
log.warning(
'Failed to cleanup intermediate config files: {0}'.format(issue)
)
self._restore_intermediate_config_rpmnew_variants()
def process(self):
"""
Create result bundle from the image build results in the
specified target directory. Each result image will contain
the specified bundle identifier as part of its filename.
Uncompressed image files will also become xz compressed
and a sha sum will be created from every result image
"""
self.manual = Help()
if self._help():
return
# load serialized result object from target directory
result_directory = os.path.abspath(self.command_args['--target-dir'])
bundle_directory = os.path.abspath(self.command_args['--bundle-dir'])
if result_directory == bundle_directory:
raise KiwiBundleError(
'Bundle directory must be different from target directory'
)
log.info(
'Bundle build results from %s', result_directory
)
result = Result.load(
result_directory + '/kiwi.result'
)
image_version = result.xml_state.get_image_version()
ordered_results = OrderedDict(sorted(result.get_results().items()))
# hard link bundle files, compress and build checksum
if not os.path.exists(bundle_directory):
Path.create(bundle_directory)
for result_file in list(ordered_results.values()):
if result_file.use_for_bundle:
bundle_file_basename = os.path.basename(result_file.filename)
# The bundle id is only taken into account for image results
# which contains the image version in its nane
bundle_file_basename = bundle_file_basename.replace(
image_version,
image_version + '-' + self.command_args['--id']
)
log.info('Creating %s', bundle_file_basename)
bundle_file = ''.join(
[bundle_directory, '/', bundle_file_basename]
)
checksum_file = ''.join(
[bundle_directory, '/', bundle_file_basename, '.sha256']
)
Command.run(
[
'cp', result_file.filename, bundle_file
]
)
if result_file.compress:
log.info('--> XZ compressing')
compress = Compress(bundle_file)
compress.xz(self.runtime_config.get_xz_options())
bundle_file = compress.compressed_filename
checksum_file = compress.compressed_filename + '.sha256'
if self.command_args['--zsync-source']:
zsyncmake = Path.which('zsyncmake', access_mode=os.X_OK)
if zsyncmake:
log.info('--> Creating zsync control file')
Command.run(
[
zsyncmake, '-e',
'-u', os.sep.join(
[
self.command_args['--zsync-source'],
os.path.basename(bundle_file)
]
),
'-o', bundle_file + '.zsync',
bundle_file
]
)
else:
log.warning(
'--> zsyncmake missing, zsync setup skipped'
)
if result_file.shasum:
log.info('--> Creating SHA 256 sum')
checksum = Checksum(bundle_file)
with open(checksum_file, 'w') as shasum:
shasum.write(checksum.sha256())
class TestChecksum(object):
@patch('os.path.exists')
def setup(self, mock_exists):
self.context_manager_mock = mock.Mock()
self.file_mock = mock.Mock()
self.enter_mock = mock.Mock()
self.exit_mock = mock.Mock()
self.enter_mock.return_value = self.file_mock
setattr(self.context_manager_mock, '__enter__', self.enter_mock)
setattr(self.context_manager_mock, '__exit__', self.exit_mock)
read_results = [bytes(b''), bytes(b'data')]
def side_effect(arg):
return read_results.pop()
self.file_mock.read.side_effect = side_effect
mock_exists.return_value = True
self.checksum = Checksum('some-file')
@raises(KiwiFileNotFound)
def test_checksum_file_not_found(self):
Checksum('some-file')
@patch('os.path.exists')
def test_matches_checksum_file_does_not_exist(self, mock_exists):
mock_exists.return_value = False
assert self.checksum.matches('sum', 'some-file') is False
@patch('os.path.exists')
@patch_open
def test_matches(self, mock_open, mock_exists):
mock_exists.return_value = True
mock_open.return_value = self.context_manager_mock
self.file_mock.read.side_effect = None
self.file_mock.read.return_value = 'sum'
assert self.checksum.matches('sum', 'some-file') is True
mock_open.assert_called_once_with('some-file')
assert self.checksum.matches('foo', 'some-file') is False
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.md5')
@patch('os.path.getsize')
@patch_open
def test_md5_xz(
self, mock_open, mock_size, mock_md5, mock_compress, mock_which
):
checksum = mock.Mock
checksum.uncompressed_filename = 'some-file-uncompressed'
mock_which.return_value = 'factor'
compress = mock.Mock()
digest = mock.Mock()
digest.block_size = 1024
digest._calculate_hash_hexdigest = mock.Mock(
return_value=checksum
)
digest.hexdigest = mock.Mock(
return_value='sum'
)
compress.get_format = mock.Mock(
return_value='xz'
)
mock_open.return_value = self.context_manager_mock
mock_size.return_value = 1343225856
mock_md5.return_value = digest
mock_compress.return_value = compress
self.checksum.md5('outfile')
assert mock_open.call_args_list == [
call('some-file', 'rb'),
call('some-file-uncompressed', 'rb'),
call('outfile', 'w')
]
self.file_mock.write.assert_called_once_with(
'sum 163968 8192 163968 8192\n'
)
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.md5')
@patch('os.path.getsize')
@patch_open
def test_md5(
self, mock_open, mock_size, mock_md5, mock_compress, mock_which
):
mock_which.return_value = 'factor'
compress = mock.Mock()
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(
return_value='sum'
)
compress.get_format = mock.Mock(
return_value=None
)
mock_open.return_value = self.context_manager_mock
mock_size.return_value = 1343225856
mock_md5.return_value = digest
mock_compress.return_value = compress
self.checksum.md5('outfile')
assert mock_open.call_args_list == [
call('some-file', 'rb'),
call('outfile', 'w')
]
self.file_mock.write.assert_called_once_with(
'sum 163968 8192\n'
)
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.sha256')
@patch('os.path.getsize')
@patch_open
def test_sha256(
self, mock_open, mock_size, mock_sha256, mock_compress, mock_which
):
mock_which.return_value = 'factor'
compress = mock.Mock()
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(
return_value='sum'
)
compress.get_format = mock.Mock(
return_value=None
)
mock_open.return_value = self.context_manager_mock
mock_size.return_value = 1343225856
mock_sha256.return_value = digest
mock_compress.return_value = compress
self.checksum.sha256('outfile')
assert mock_open.call_args_list == [
call('some-file', 'rb'),
call('outfile', 'w')
]
self.file_mock.write.assert_called_once_with(
'sum 163968 8192\n'
)
@patch('hashlib.sha256')
@patch_open
def test_sha256_plain(self, mock_open, mock_sha256):
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(
return_value='sum'
)
mock_sha256.return_value = digest
mock_open.return_value = self.context_manager_mock
assert self.checksum.sha256() == digest.hexdigest.return_value
@patch('hashlib.md5')
@patch_open
def test_md5_plain(self, mock_open, mock_md5):
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(
return_value='sum'
)
mock_md5.return_value = digest
mock_open.return_value = self.context_manager_mock
assert self.checksum.md5() == digest.hexdigest.return_value
class TestChecksum(object):
@patch('os.path.exists')
def setup(self, mock_exists):
self.context_manager_mock = mock.Mock()
self.file_mock = mock.Mock()
self.enter_mock = mock.Mock()
self.exit_mock = mock.Mock()
self.enter_mock.return_value = self.file_mock
setattr(self.context_manager_mock, '__enter__', self.enter_mock)
setattr(self.context_manager_mock, '__exit__', self.exit_mock)
read_results = [bytes(b''), bytes(b'data')]
def side_effect(arg):
return read_results.pop()
self.file_mock.read.side_effect = side_effect
mock_exists.return_value = True
self.checksum = Checksum('some-file')
@raises(KiwiFileNotFound)
def test_checksum_file_not_found(self):
Checksum('some-file')
@patch('os.path.exists')
def test_matches_checksum_file_does_not_exist(self, mock_exists):
mock_exists.return_value = False
assert self.checksum.matches('sum', 'some-file') is False
@patch('os.path.exists')
@patch_open
def test_matches(self, mock_open, mock_exists):
mock_exists.return_value = True
mock_open.return_value = self.context_manager_mock
self.file_mock.read.side_effect = None
self.file_mock.read.return_value = 'sum'
assert self.checksum.matches('sum', 'some-file') is True
mock_open.assert_called_once_with('some-file')
assert self.checksum.matches('foo', 'some-file') is False
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.md5')
@patch('os.path.getsize')
@patch_open
def test_md5_xz(self, mock_open, mock_size, mock_md5, mock_compress,
mock_which):
checksum = mock.Mock
checksum.uncompressed_filename = 'some-file-uncompressed'
mock_which.return_value = 'factor'
compress = mock.Mock()
digest = mock.Mock()
digest.block_size = 1024
digest._calculate_hash_hexdigest = mock.Mock(return_value=checksum)
digest.hexdigest = mock.Mock(return_value='sum')
compress.get_format = mock.Mock(return_value='xz')
mock_open.return_value = self.context_manager_mock
mock_size.return_value = 1343225856
mock_md5.return_value = digest
mock_compress.return_value = compress
self.checksum.md5('outfile')
assert mock_open.call_args_list == [
call('some-file', 'rb'),
call('some-file-uncompressed', 'rb'),
call('outfile', 'w')
]
self.file_mock.write.assert_called_once_with(
'sum 163968 8192 163968 8192\n')
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.md5')
@patch('os.path.getsize')
@patch_open
def test_md5(self, mock_open, mock_size, mock_md5, mock_compress,
mock_which):
mock_which.return_value = 'factor'
compress = mock.Mock()
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(return_value='sum')
compress.get_format = mock.Mock(return_value=None)
mock_open.return_value = self.context_manager_mock
mock_size.return_value = 1343225856
mock_md5.return_value = digest
mock_compress.return_value = compress
self.checksum.md5('outfile')
assert mock_open.call_args_list == [
call('some-file', 'rb'),
call('outfile', 'w')
]
self.file_mock.write.assert_called_once_with('sum 163968 8192\n')
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.sha256')
@patch('os.path.getsize')
@patch_open
def test_sha256(self, mock_open, mock_size, mock_sha256, mock_compress,
mock_which):
mock_which.return_value = 'factor'
compress = mock.Mock()
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(return_value='sum')
compress.get_format = mock.Mock(return_value=None)
mock_open.return_value = self.context_manager_mock
mock_size.return_value = 1343225856
mock_sha256.return_value = digest
mock_compress.return_value = compress
self.checksum.sha256('outfile')
assert mock_open.call_args_list == [
call('some-file', 'rb'),
call('outfile', 'w')
]
self.file_mock.write.assert_called_once_with('sum 163968 8192\n')
@patch('hashlib.sha256')
@patch_open
def test_sha256_plain(self, mock_open, mock_sha256):
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(return_value='sum')
mock_sha256.return_value = digest
mock_open.return_value = self.context_manager_mock
assert self.checksum.sha256() == digest.hexdigest.return_value
@patch('hashlib.md5')
@patch_open
def test_md5_plain(self, mock_open, mock_md5):
digest = mock.Mock()
digest.block_size = 1024
digest.hexdigest = mock.Mock(return_value='sum')
mock_md5.return_value = digest
mock_open.return_value = self.context_manager_mock
assert self.checksum.md5() == digest.hexdigest.return_value
def process(self):
"""
Create result bundle from the image build results in the
specified target directory. Each result image will contain
the specified bundle identifier as part of its filename.
Uncompressed image files will also become xz compressed
and a sha sum will be created from every result image
"""
self.manual = Help()
if self._help():
return
# load serialized result object from target directory
result_directory = os.path.abspath(self.command_args['--target-dir'])
bundle_directory = os.path.abspath(self.command_args['--bundle-dir'])
if result_directory == bundle_directory:
raise KiwiBundleError(
'Bundle directory must be different from target directory')
log.info('Bundle build results from %s', result_directory)
result = Result.load(result_directory + '/kiwi.result')
image_version = result.xml_state.get_image_version()
image_name = result.xml_state.xml_data.get_name()
ordered_results = OrderedDict(sorted(result.get_results().items()))
# hard link bundle files, compress and build checksum
if not os.path.exists(bundle_directory):
Path.create(bundle_directory)
for result_file in list(ordered_results.values()):
if result_file.use_for_bundle:
bundle_file_basename = os.path.basename(result_file.filename)
# The bundle id is only taken into account for image results
# which contains the image version appended in its file name
part_name = list(bundle_file_basename.partition(image_name))
bundle_file_basename = ''.join([
part_name[0], part_name[1], part_name[2].replace(
image_version,
image_version + '-' + self.command_args['--id'])
])
log.info('Creating %s', bundle_file_basename)
bundle_file = ''.join(
[bundle_directory, '/', bundle_file_basename])
Command.run(['cp', result_file.filename, bundle_file])
if result_file.compress:
log.info('--> XZ compressing')
compress = Compress(bundle_file)
compress.xz(self.runtime_config.get_xz_options())
bundle_file = compress.compressed_filename
if self.command_args['--zsync-source'] and result_file.shasum:
# Files with a checksum are considered to be image files
# and are therefore eligible to be provided via the
# requested Partial/differential file download based on
# zsync
zsyncmake = Path.which('zsyncmake', access_mode=os.X_OK)
if zsyncmake:
log.info('--> Creating zsync control file')
Command.run([
zsyncmake, '-e', '-u',
os.sep.join([
self.command_args['--zsync-source'],
os.path.basename(bundle_file)
]), '-o', bundle_file + '.zsync', bundle_file
])
else:
log.warning(
'--> zsyncmake missing, zsync setup skipped')
if result_file.shasum:
log.info('--> Creating SHA 256 sum')
checksum = Checksum(bundle_file)
with open(bundle_file + '.sha256', 'w') as shasum:
shasum.write('{0} {1}'.format(
checksum.sha256(), os.path.basename(bundle_file)))
class TestChecksum:
@patch('os.path.exists')
def setup(self, mock_exists):
self.ascii = encoding.getregentry().name
read_results = [bytes(b''), bytes(b'data'), bytes(b''), bytes(b'data')]
def side_effect(arg):
print(read_results[0])
return read_results.pop()
self.m_open = mock_open()
self.m_open.return_value.read.side_effect = side_effect
mock_exists.return_value = True
self.checksum = Checksum('some-file')
def test_checksum_file_not_found(self):
with raises(KiwiFileNotFound):
Checksum('some-file')
@patch('os.path.exists')
def test_matches_checksum_file_does_not_exist(self, mock_exists):
mock_exists.return_value = False
assert self.checksum.matches('sum', 'some-file') is False
@patch('os.path.exists')
def test_matches(self, mock_exists):
mock_exists.return_value = True
self.m_open.return_value.read.side_effect = None
self.m_open.return_value.read.return_value = 'sum'
with patch('builtins.open', self.m_open, create=True):
assert self.checksum.matches('sum', 'some-file') is True
self.m_open.assert_called_once_with(
'some-file', encoding=self.ascii
)
with patch('builtins.open', self.m_open, create=True):
assert self.checksum.matches('foo', 'some-file') is False
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.md5')
@patch('os.path.getsize')
def test_md5_xz(self, mock_size, mock_md5, mock_compress, mock_which):
checksum = Mock
checksum.uncompressed_filename = 'some-file-uncompressed'
mock_which.return_value = 'factor'
compress = Mock()
digest = Mock()
digest.block_size = 1024
digest._calculate_hash_hexdigest = Mock(
return_value=checksum
)
digest.hexdigest = Mock(
return_value='sum'
)
compress.get_format = Mock(
return_value='xz'
)
mock_size.return_value = 1343225856
mock_md5.return_value = digest
mock_compress.return_value = compress
with patch('builtins.open', self.m_open, create=True):
self.checksum.md5('outfile')
assert self.m_open.call_args_list == [
call('some-file', 'rb'),
call('some-file-uncompressed', 'rb'),
call('outfile', encoding=self.ascii, mode='w')
]
self.m_open.return_value.write.assert_called_once_with(
'sum 163968 8192 163968 8192\n'
)
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.md5')
@patch('os.path.getsize')
def test_md5(
self, mock_size, mock_md5, mock_compress, mock_which
):
mock_which.return_value = 'factor'
compress = Mock()
digest = Mock()
digest.block_size = 1024
digest.hexdigest = Mock(
return_value='sum'
)
compress.get_format = Mock(
return_value=None
)
mock_size.return_value = 1343225856
mock_md5.return_value = digest
mock_compress.return_value = compress
with patch('builtins.open', self.m_open, create=True):
self.checksum.md5('outfile')
assert self.m_open.call_args_list == [
call('some-file', 'rb'),
call('outfile', encoding=self.ascii, mode='w')
]
self.m_open.return_value.write.assert_called_once_with(
'sum 163968 8192\n'
)
@patch('kiwi.path.Path.which')
@patch('kiwi.utils.checksum.Compress')
@patch('hashlib.sha256')
@patch('os.path.getsize')
def test_sha256(
self, mock_size, mock_sha256, mock_compress, mock_which
):
mock_which.return_value = 'factor'
compress = Mock()
digest = Mock()
digest.block_size = 1024
digest.hexdigest = Mock(
return_value='sum'
)
compress.get_format = Mock(
return_value=None
)
mock_size.return_value = 1343225856
mock_sha256.return_value = digest
mock_compress.return_value = compress
with patch('builtins.open', self.m_open, create=True):
self.checksum.sha256('outfile')
assert self.m_open.call_args_list == [
call('some-file', 'rb'),
call('outfile', encoding=self.ascii, mode='w')
]
self.m_open.return_value.write.assert_called_once_with(
'sum 163968 8192\n'
)
@patch('hashlib.sha256')
def test_sha256_plain(self, mock_sha256):
digest = Mock()
digest.block_size = 1024
digest.hexdigest = Mock(
return_value='sum'
)
mock_sha256.return_value = digest
with patch('builtins.open', self.m_open, create=True):
assert self.checksum.sha256() == digest.hexdigest.return_value
@patch('hashlib.md5')
def test_md5_plain(self, mock_md5):
digest = Mock()
digest.block_size = 1024
digest.hexdigest = Mock(
return_value='sum'
)
mock_md5.return_value = digest
with patch('builtins.open', self.m_open, create=True):
assert self.checksum.md5() == digest.hexdigest.return_value
def process(self):
"""
Create result bundle from the image build results in the
specified target directory. Each result image will contain
the specified bundle identifier as part of its filename.
Uncompressed image files will also become xz compressed
and a sha sum will be created from every result image
"""
self.manual = Help()
if self._help():
return
if self.command_args['--package-as-rpm']:
Privileges.check_for_root_permissions()
# load serialized result object from target directory
result_directory = os.path.abspath(self.command_args['--target-dir'])
bundle_directory = os.path.abspath(self.command_args['--bundle-dir'])
if result_directory == bundle_directory:
raise KiwiBundleError(
'Bundle directory must be different from target directory')
log.info('Bundle build results from %s', result_directory)
result = Result.load(result_directory + '/kiwi.result')
image_version = result.xml_state.get_image_version()
image_name = result.xml_state.xml_data.get_name()
image_description = result.xml_state.get_description_section()
ordered_results = OrderedDict(sorted(result.get_results().items()))
# hard link bundle files, compress and build checksum
if self.command_args['--package-as-rpm']:
Path.wipe(bundle_directory)
if not os.path.exists(bundle_directory):
Path.create(bundle_directory)
bundle_file_format_name = ''
if 'bundle_format' in ordered_results:
bundle_format = ordered_results['bundle_format']
tags = bundle_format['tags']
bundle_file_format_name = bundle_format['pattern']
# Insert image name
bundle_file_format_name = bundle_file_format_name.replace(
'%N', tags.N)
# Insert Concatenated profile name (_)
bundle_file_format_name = bundle_file_format_name.replace(
'%P', tags.P)
# Insert Architecture name
bundle_file_format_name = bundle_file_format_name.replace(
'%A', tags.A)
# Insert Image build type name
bundle_file_format_name = bundle_file_format_name.replace(
'%T', tags.T)
# Insert Image Major version number
bundle_file_format_name = bundle_file_format_name.replace(
'%M', format(tags.M))
# Insert Image Minor version number
bundle_file_format_name = bundle_file_format_name.replace(
'%m', format(tags.m))
# Insert Image Patch version number
bundle_file_format_name = bundle_file_format_name.replace(
'%p', format(tags.p))
# Insert Bundle ID
bundle_file_format_name = bundle_file_format_name.replace(
'%I', self.command_args['--id'])
del (ordered_results['bundle_format'])
for result_file in list(ordered_results.values()):
if result_file.use_for_bundle:
extension = result_file.filename.split('.').pop()
if bundle_file_format_name:
bundle_file_basename = '.'.join(
[bundle_file_format_name, extension])
else:
bundle_file_basename = os.path.basename(
result_file.filename)
# The bundle id is only taken into account for image results
# which contains the image version appended in its file name
part_name = list(
bundle_file_basename.partition(image_name))
bundle_file_basename = ''.join([
part_name[0], part_name[1], part_name[2].replace(
image_version,
image_version + '-' + self.command_args['--id'])
])
log.info('Creating %s', bundle_file_basename)
bundle_file = ''.join(
[bundle_directory, '/', bundle_file_basename])
Command.run(['cp', result_file.filename, bundle_file])
if result_file.compress:
log.info('--> XZ compressing')
compress = Compress(bundle_file)
compress.xz(self.runtime_config.get_xz_options())
bundle_file = compress.compressed_filename
if self.command_args['--zsync-source'] and result_file.shasum:
# Files with a checksum are considered to be image files
# and are therefore eligible to be provided via the
# requested Partial/differential file download based on
# zsync
zsyncmake = Path.which('zsyncmake', access_mode=os.X_OK)
if zsyncmake:
log.info('--> Creating zsync control file')
Command.run([
zsyncmake, '-e', '-u',
os.sep.join([
self.command_args['--zsync-source'],
os.path.basename(bundle_file)
]), '-o', bundle_file + '.zsync', bundle_file
])
else:
log.warning(
'--> zsyncmake missing, zsync setup skipped')
if result_file.shasum:
log.info('--> Creating SHA 256 sum')
checksum = Checksum(bundle_file)
with open(bundle_file + '.sha256', 'w') as shasum:
shasum.write('{0} {1}{2}'.format(
checksum.sha256(), os.path.basename(bundle_file),
os.linesep))
if self.command_args['--package-as-rpm']:
ResultBundleTask._build_rpm_package(
bundle_directory, bundle_file_format_name or image_name,
image_version, image_description.specification,
list(glob.iglob(f'{bundle_directory}/*')))
def fetch(self, update_check=True):
"""
Download box from the open build service
:param bool update_check: check for box updates True|False
"""
download = update_check
repo_source = self.box_config.get_box_source()
if repo_source:
repo = SolverRepository.new(Uri(repo_source, 'rpm-md'))
packages_file = self.box_config.get_box_packages_file()
packages_shasum_file = \
self.box_config.get_box_packages_shasum_file()
if update_check and packages_file and packages_shasum_file:
local_packages_file = os.sep.join(
[self.box_dir, packages_file])
local_packages_shasum_file = os.sep.join(
[self.box_dir, packages_shasum_file])
local_packages_file_tmp = self.box_stage.register(
local_packages_file)
local_packages_shasum_file_tmp = self.box_stage.register(
local_packages_shasum_file)
repo.download_from_repository(packages_file,
local_packages_file_tmp)
checksum = Checksum(local_packages_file_tmp)
shasum = checksum.sha256()
if checksum.matches(shasum, local_packages_shasum_file):
download = False
else:
self._create_packages_checksum(
local_packages_shasum_file_tmp, shasum)
for box_file in self.box_config.get_box_files():
local_box_file = os.sep.join([self.box_dir, box_file])
if not os.path.exists(local_box_file):
download = True
if download:
log.info('Downloading {0}'.format(box_file))
local_box_file_tmp = self.box_stage.register(
local_box_file)
repo.download_from_repository(box_file, local_box_file_tmp)
if download:
self.box_stage.commit()
for box_file in self.box_config.get_box_files():
local_box_file = os.sep.join([self.box_dir, box_file])
if box_file.endswith('.qcow2'):
self.system = local_box_file
if box_file.endswith('.tar.xz'):
self.kernel = self._extract_kernel_from_tarball(
local_box_file)
if self.box_config.use_initrd():
self.initrd = self._extract_initrd_from_tarball(
local_box_file)
return self.vm_setup_type(
system=self.system,
kernel=self.kernel,
initrd=self.initrd,
append='root={0} console={1} {2}'.format(
self.box_config.get_box_root(),
self.box_config.get_box_console(),
self.box_config.get_box_kernel_cmdline()),
ram=self.box_config.get_box_memory_mbytes(),
smp=self.box_config.get_box_processors())
