| |
@@ -0,0 +1,821 @@
|
| |
+ From 0ef58ca01d680c74f9776bf593990e8e9cadb98d Mon Sep 17 00:00:00 2001
|
| |
+ From: "Owen W. Taylor" <otaylor@fishsoup.net>
|
| |
+ Date: Tue, 31 Jul 2018 09:14:35 -0400
|
| |
+ Subject: [PATCH 3/3] Move to using flatpak-module-tools as a library
|
| |
+
|
| |
+ https://github.com/projectatomic/atomic-reactor/pull/1052
|
| |
+
|
| |
+ Instead of sharing code cut-and-paste between atomic-reactor and
|
| |
+ https://pagure.io/flatpak-module-tools, make atomic-reactor use
|
| |
+ flatpak-module-tools as a library for the shared code. This will
|
| |
+ prevent the code getting out of sync, and make future maintenance
|
| |
+ easier.
|
| |
+
|
| |
+ The flatpak-module-tools version has major improvements to how
|
| |
+ the filesystem tree is postprocessed to make a Flatpak using configuration
|
| |
+ options from container.yaml, needing some small adjustments of the
|
| |
+ tests here.
|
| |
+ ---
|
| |
+ atomic_reactor/plugins/exit_koji_import.py | 6 +-
|
| |
+ atomic_reactor/plugins/exit_koji_promote.py | 6 +-
|
| |
+ .../plugins/pre_flatpak_create_dockerfile.py | 152 ++-------
|
| |
+ .../plugins/pre_resolve_module_compose.py | 12 +-
|
| |
+ .../plugins/prepub_flatpak_create_oci.py | 368 +--------------------
|
| |
+ images/dockerhost-builder/Dockerfile | 2 +-
|
| |
+ images/privileged-builder/Dockerfile | 2 +-
|
| |
+ requirements-flatpak.txt | 1 +
|
| |
+ tests/flatpak.py | 17 +-
|
| |
+ 9 files changed, 57 insertions(+), 509 deletions(-)
|
| |
+
|
| |
+ diff --git a/atomic_reactor/plugins/exit_koji_import.py b/atomic_reactor/plugins/exit_koji_import.py
|
| |
+ index 4b1e1c9..e59b557 100644
|
| |
+ --- a/atomic_reactor/plugins/exit_koji_import.py
|
| |
+ +++ b/atomic_reactor/plugins/exit_koji_import.py
|
| |
+ @@ -24,6 +24,7 @@ from atomic_reactor.plugins.pre_reactor_config import get_openshift_session
|
| |
+
|
| |
+ try:
|
| |
+ from atomic_reactor.plugins.pre_flatpak_create_dockerfile import get_flatpak_source_info
|
| |
+ + from atomic_reactor.plugins.pre_resolve_module_compose import get_compose_info
|
| |
+ except ImportError:
|
| |
+ # modulemd and/or pdc_client not available
|
| |
+ def get_flatpak_source_info(_):
|
| |
+ @@ -353,7 +354,10 @@ class KojiImportPlugin(ExitPlugin):
|
| |
+
|
| |
+ flatpak_source_info = get_flatpak_source_info(self.workflow)
|
| |
+ if flatpak_source_info is not None:
|
| |
+ - extra['image'].update(flatpak_source_info.koji_metadata())
|
| |
+ + compose_info = get_compose_info(self.workflow)
|
| |
+ + koji_metadata = compose_info.koji_metadata()
|
| |
+ + koji_metadata['flatpak'] = True
|
| |
+ + extra['image'].update(koji_metadata)
|
| |
+
|
| |
+ koji_task_owner = get_koji_task_owner(self.session, koji_task_id).get('name')
|
| |
+ extra['submitter'] = self.session.getLoggedInUser()['name']
|
| |
+ diff --git a/atomic_reactor/plugins/exit_koji_promote.py b/atomic_reactor/plugins/exit_koji_promote.py
|
| |
+ index da33380..0fe1f47 100644
|
| |
+ --- a/atomic_reactor/plugins/exit_koji_promote.py
|
| |
+ +++ b/atomic_reactor/plugins/exit_koji_promote.py
|
| |
+ @@ -30,6 +30,7 @@ from atomic_reactor.util import get_parent_image_koji_data
|
| |
+
|
| |
+ try:
|
| |
+ from atomic_reactor.plugins.pre_flatpak_create_dockerfile import get_flatpak_source_info
|
| |
+ + from atomic_reactor.plugins.pre_resolve_module_compose import get_compose_info
|
| |
+ except ImportError:
|
| |
+ # modulemd and/or pdc_client not available
|
| |
+ def get_flatpak_source_info(_):
|
| |
+ @@ -564,7 +565,10 @@ class KojiPromotePlugin(ExitPlugin):
|
| |
+
|
| |
+ flatpak_source_info = get_flatpak_source_info(self.workflow)
|
| |
+ if flatpak_source_info is not None:
|
| |
+ - extra['image'].update(flatpak_source_info.koji_metadata())
|
| |
+ + compose_info = get_compose_info(self.workflow)
|
| |
+ + koji_metadata = compose_info.koji_metadata()
|
| |
+ + koji_metadata['flatpak'] = True
|
| |
+ + extra['image'].update(koji_metadata)
|
| |
+
|
| |
+ resolve_comp_result = self.workflow.prebuild_results.get(PLUGIN_RESOLVE_COMPOSES_KEY)
|
| |
+ if resolve_comp_result:
|
| |
+ diff --git a/atomic_reactor/plugins/pre_flatpak_create_dockerfile.py b/atomic_reactor/plugins/pre_flatpak_create_dockerfile.py
|
| |
+ index 148be70..a53e0da 100644
|
| |
+ --- a/atomic_reactor/plugins/pre_flatpak_create_dockerfile.py
|
| |
+ +++ b/atomic_reactor/plugins/pre_flatpak_create_dockerfile.py
|
| |
+ @@ -20,6 +20,8 @@ Example configuration:
|
| |
+
|
| |
+ import os
|
| |
+
|
| |
+ +from flatpak_module_tools.flatpak_builder import FlatpakSourceInfo, FlatpakBuilder
|
| |
+ +
|
| |
+ from atomic_reactor.constants import DOCKERFILE_FILENAME, YUM_REPOS_DIR
|
| |
+ from atomic_reactor.plugin import PreBuildPlugin
|
| |
+ from atomic_reactor.plugins.pre_resolve_module_compose import get_compose_info
|
| |
+ @@ -52,67 +54,6 @@ RUN chroot /var/tmp/flatpak-build/ /bin/sh /tmp/cleanup.sh
|
| |
+ '''
|
| |
+
|
| |
+
|
| |
+ -class FlatpakSourceInfo(object):
|
| |
+ - def __init__(self, flatpak_yaml, compose):
|
| |
+ - self.flatpak_yaml = flatpak_yaml
|
| |
+ - self.compose = compose
|
| |
+ -
|
| |
+ - mmd = compose.base_module.mmd
|
| |
+ - # A runtime module must have a 'runtime' profile, but can have other
|
| |
+ - # profiles for SDKs, minimal runtimes, etc.
|
| |
+ - self.runtime = 'runtime' in mmd.peek_profiles()
|
| |
+ -
|
| |
+ - module_spec = split_module_spec(compose.source_spec)
|
| |
+ - if module_spec.profile:
|
| |
+ - self.profile = module_spec.profile
|
| |
+ - elif self.runtime:
|
| |
+ - self.profile = 'runtime'
|
| |
+ - else:
|
| |
+ - self.profile = 'default'
|
| |
+ -
|
| |
+ - assert self.profile in mmd.peek_profiles()
|
| |
+ -
|
| |
+ - # The module for the Flatpak runtime that this app runs against
|
| |
+ - @property
|
| |
+ - def runtime_module(self):
|
| |
+ - assert not self.runtime
|
| |
+ - compose = self.compose
|
| |
+ -
|
| |
+ - dependencies = compose.base_module.mmd.props.dependencies
|
| |
+ - # A built module should have its dependencies already expanded
|
| |
+ - assert len(dependencies) == 1
|
| |
+ -
|
| |
+ - for key in dependencies[0].peek_buildrequires().keys():
|
| |
+ - try:
|
| |
+ - module = compose.modules[key]
|
| |
+ - if 'runtime' in module.mmd.peek_profiles():
|
| |
+ - return module
|
| |
+ - except KeyError:
|
| |
+ - pass
|
| |
+ -
|
| |
+ - raise RuntimeError("Failed to identify runtime module in the buildrequires for {}"
|
| |
+ - .format(compose.base_module.name))
|
| |
+ -
|
| |
+ - # All modules that were build against the Flatpak runtime,
|
| |
+ - # and thus were built with prefix=/app. This is primarily the app module
|
| |
+ - # but might contain modules shared between multiple flatpaks as well.
|
| |
+ - @property
|
| |
+ - def app_modules(self):
|
| |
+ - runtime_module_name = self.runtime_module.mmd.props.name
|
| |
+ -
|
| |
+ - def is_app_module(m):
|
| |
+ - dependencies = m.mmd.props.dependencies
|
| |
+ - return runtime_module_name in dependencies[0].peek_buildrequires()
|
| |
+ -
|
| |
+ - return [m for m in self.compose.modules.values() if is_app_module(m)]
|
| |
+ -
|
| |
+ - def koji_metadata(self):
|
| |
+ - metadata = self.compose.koji_metadata()
|
| |
+ - metadata['flatpak'] = True
|
| |
+ -
|
| |
+ - return metadata
|
| |
+ -
|
| |
+ -
|
| |
+ WORKSPACE_SOURCE_KEY = 'source_info'
|
| |
+
|
| |
+
|
| |
+ @@ -157,7 +98,12 @@ class FlatpakCreateDockerfilePlugin(PreBuildPlugin):
|
| |
+ raise RuntimeError(
|
| |
+ "resolve_module_compose must be run before flatpak_create_dockerfile")
|
| |
+
|
| |
+ - return FlatpakSourceInfo(flatpak_yaml, compose_info)
|
| |
+ + module_spec = split_module_spec(compose_info.source_spec)
|
| |
+ +
|
| |
+ + return FlatpakSourceInfo(flatpak_yaml,
|
| |
+ + compose_info.modules,
|
| |
+ + compose_info.base_module,
|
| |
+ + module_spec.profile)
|
| |
+
|
| |
+ def run(self):
|
| |
+ """
|
| |
+ @@ -168,38 +114,18 @@ class FlatpakCreateDockerfilePlugin(PreBuildPlugin):
|
| |
+
|
| |
+ set_flatpak_source_info(self.workflow, source)
|
| |
+
|
| |
+ - module_info = source.compose.base_module
|
| |
+ -
|
| |
+ - # For a runtime, certain information is duplicated between the container.yaml
|
| |
+ - # and the modulemd, check that it matches
|
| |
+ - if source.runtime:
|
| |
+ - flatpak_yaml = source.flatpak_yaml
|
| |
+ - flatpak_xmd = module_info.mmd.props.xmd['flatpak']
|
| |
+ -
|
| |
+ - def check(condition, what):
|
| |
+ - if not condition:
|
| |
+ - raise RuntimeError(
|
| |
+ - "Mismatch for {} betweeen module xmd and container.yaml".format(what))
|
| |
+ + builder = FlatpakBuilder(source, None, None)
|
| |
+
|
| |
+ - check(flatpak_yaml['branch'] == flatpak_xmd['branch'], "'branch'")
|
| |
+ - check(source.profile in flatpak_xmd['runtimes'], 'profile name')
|
| |
+ -
|
| |
+ - profile_xmd = flatpak_xmd['runtimes'][source.profile]
|
| |
+ -
|
| |
+ - check(flatpak_yaml['id'] == profile_xmd['id'], "'id'")
|
| |
+ - check(flatpak_yaml.get('runtime', None) ==
|
| |
+ - profile_xmd.get('runtime', None), "'runtime'")
|
| |
+ - check(flatpak_yaml.get('sdk', None) == profile_xmd.get('sdk', None), "'sdk'")
|
| |
+ + builder.precheck()
|
| |
+
|
| |
+ # Create the dockerfile
|
| |
+
|
| |
+ + module_info = source.base_module
|
| |
+ +
|
| |
+ # We need to enable all the modules other than the platform pseudo-module
|
| |
+ - modules_str = ' '.join(sorted(m.mmd.props.name + ':' + m.mmd.props.stream
|
| |
+ - for m in source.compose.modules.values()
|
| |
+ - if m.mmd.props.name != 'platform'))
|
| |
+ + modules_str = ' '.join(builder.get_enable_modules())
|
| |
+
|
| |
+ - install_packages = module_info.mmd.peek_profiles()[source.profile].props.rpms.get()
|
| |
+ - install_packages_str = ' '.join(install_packages)
|
| |
+ + install_packages_str = ' '.join(builder.get_install_packages())
|
| |
+
|
| |
+ df_path = os.path.join(self.workflow.builder.df_dir, DOCKERFILE_FILENAME)
|
| |
+ with open(df_path, 'w') as fp:
|
| |
+ @@ -213,54 +139,16 @@ class FlatpakCreateDockerfilePlugin(PreBuildPlugin):
|
| |
+
|
| |
+ self.workflow.builder.set_df_path(df_path)
|
| |
+
|
| |
+ - # For a runtime, we want to make sure that the set of RPMs that is installed
|
| |
+ - # into the filesystem is *exactly* the set that is listed in the runtime
|
| |
+ - # profile. Requiring the full listed set of RPMs to be listed makes it
|
| |
+ - # easier to catch unintentional changes in the package list that might break
|
| |
+ - # applications depending on the runtime. It also simplifies the checking we
|
| |
+ - # do for application flatpaks, since we can simply look at the runtime
|
| |
+ - # modulemd to find out what packages are present in the runtime.
|
| |
+ - #
|
| |
+ - # For an application, we want to make sure that each RPM that is installed
|
| |
+ - # into the filesystem is *either* an RPM that is part of the 'runtime'
|
| |
+ - # profile of the base runtime, or from a module that was built with
|
| |
+ - # flatpak-rpm-macros in the install root and, thus, prefix=/app.
|
| |
+ - #
|
| |
+ - # We achieve this by restricting the set of available packages in the dnf
|
| |
+ - # configuration to just the ones that we want.
|
| |
+ - #
|
| |
+ - # The advantage of doing this upfront, rather than just checking after the
|
| |
+ - # fact is that this makes sure that when a application is being installed,
|
| |
+ - # we don't get a different package to satisfy a dependency than the one
|
| |
+ - # in the runtime - e.g. aajohan-comfortaa-fonts to satisfy font(:lang=en)
|
| |
+ - # because it's alphabetically first.
|
| |
+ -
|
| |
+ - if not source.runtime:
|
| |
+ - runtime_module = source.runtime_module
|
| |
+ - runtime_profile = runtime_module.mmd.peek_profiles()['runtime']
|
| |
+ - available_packages = sorted(runtime_profile.props.rpms.get())
|
| |
+ -
|
| |
+ - for m in source.app_modules:
|
| |
+ - # Strip off the '.rpm' suffix from the filename to get something
|
| |
+ - # that DNF can parse.
|
| |
+ - available_packages.extend(x[:-4] for x in m.rpms)
|
| |
+ - else:
|
| |
+ - base_module = source.compose.base_module
|
| |
+ - runtime_profile = base_module.mmd.peek_profiles()['runtime']
|
| |
+ - available_packages = sorted(runtime_profile.props.rpms.get())
|
| |
+ -
|
| |
+ + includepkgs = builder.get_includepkgs()
|
| |
+ includepkgs_path = os.path.join(self.workflow.builder.df_dir, 'atomic-reactor-includepkgs')
|
| |
+ with open(includepkgs_path, 'w') as f:
|
| |
+ - f.write('includepkgs = ' + ','.join(available_packages) + '\n')
|
| |
+ + f.write('includepkgs = ' + ','.join(includepkgs) + '\n')
|
| |
+
|
| |
+ # Create the cleanup script
|
| |
+
|
| |
+ cleanupscript = os.path.join(self.workflow.builder.df_dir, "cleanup.sh")
|
| |
+ with open(cleanupscript, 'w') as f:
|
| |
+ - cleanup_commands = source.flatpak_yaml.get('cleanup-commands')
|
| |
+ - if cleanup_commands is not None:
|
| |
+ - f.write(cleanup_commands.rstrip())
|
| |
+ - f.write("\n")
|
| |
+ + f.write(builder.get_cleanup_script())
|
| |
+ os.chmod(cleanupscript, 0o0755)
|
| |
+
|
| |
+ # Add a yum-repository pointing to the compose
|
| |
+ @@ -270,9 +158,11 @@ class FlatpakCreateDockerfilePlugin(PreBuildPlugin):
|
| |
+ stream=module_info.stream,
|
| |
+ version=module_info.version)
|
| |
+
|
| |
+ + compose_info = get_compose_info(self.workflow)
|
| |
+ +
|
| |
+ repo = {
|
| |
+ 'name': repo_name,
|
| |
+ - 'baseurl': source.compose.repo_url,
|
| |
+ + 'baseurl': compose_info.repo_url,
|
| |
+ 'enabled': 1,
|
| |
+ 'gpgcheck': 0,
|
| |
+ }
|
| |
+ @@ -280,4 +170,4 @@ class FlatpakCreateDockerfilePlugin(PreBuildPlugin):
|
| |
+ path = os.path.join(YUM_REPOS_DIR, repo_name + '.repo')
|
| |
+ self.workflow.files[path] = render_yum_repo(repo, escape_dollars=False)
|
| |
+
|
| |
+ - override_build_kwarg(self.workflow, 'module_compose_id', source.compose.compose_id)
|
| |
+ + override_build_kwarg(self.workflow, 'module_compose_id', compose_info.compose_id)
|
| |
+ diff --git a/atomic_reactor/plugins/pre_resolve_module_compose.py b/atomic_reactor/plugins/pre_resolve_module_compose.py
|
| |
+ index 5ce6e29..df5f040 100644
|
| |
+ --- a/atomic_reactor/plugins/pre_resolve_module_compose.py
|
| |
+ +++ b/atomic_reactor/plugins/pre_resolve_module_compose.py
|
| |
+ @@ -23,6 +23,9 @@ Example configuration:
|
| |
+ }
|
| |
+ """
|
| |
+
|
| |
+ +
|
| |
+ +from flatpak_module_tools.flatpak_builder import ModuleInfo
|
| |
+ +
|
| |
+ import gi
|
| |
+ try:
|
| |
+ gi.require_version('Modulemd', '1.0')
|
| |
+ @@ -37,15 +40,6 @@ from atomic_reactor.plugins.pre_reactor_config import (get_pdc_session, get_odcs
|
| |
+ get_pdc, get_odcs)
|
| |
+
|
| |
+
|
| |
+ -class ModuleInfo(object):
|
| |
+ - def __init__(self, name, stream, version, mmd, rpms):
|
| |
+ - self.name = name
|
| |
+ - self.stream = stream
|
| |
+ - self.version = version
|
| |
+ - self.mmd = mmd
|
| |
+ - self.rpms = rpms
|
| |
+ -
|
| |
+ -
|
| |
+ class ComposeInfo(object):
|
| |
+ def __init__(self, source_spec, compose_id, base_module, modules, repo_url):
|
| |
+ self.source_spec = source_spec
|
| |
+ diff --git a/atomic_reactor/plugins/prepub_flatpak_create_oci.py b/atomic_reactor/plugins/prepub_flatpak_create_oci.py
|
| |
+ index b86e792..d1b6463 100644
|
| |
+ --- a/atomic_reactor/plugins/prepub_flatpak_create_oci.py
|
| |
+ +++ b/atomic_reactor/plugins/prepub_flatpak_create_oci.py
|
| |
+ @@ -10,14 +10,7 @@ pre_flatpak_create_dockerfile, extracts the tree at /var/tmp/flatpak-build
|
| |
+ and turns it into a Flatpak application or runtime.
|
| |
+ """
|
| |
+
|
| |
+ -import os
|
| |
+ -from six.moves import configparser
|
| |
+ -import re
|
| |
+ -import shlex
|
| |
+ -import shutil
|
| |
+ -import subprocess
|
| |
+ -import tarfile
|
| |
+ -from textwrap import dedent
|
| |
+ +from flatpak_module_tools.flatpak_builder import FlatpakBuilder
|
| |
+
|
| |
+ from atomic_reactor.constants import IMAGE_TYPE_OCI, IMAGE_TYPE_OCI_TAR
|
| |
+ from atomic_reactor.plugin import PrePublishPlugin
|
| |
+ @@ -26,99 +19,6 @@ from atomic_reactor.rpm_util import parse_rpm_output
|
| |
+ from atomic_reactor.util import get_exported_image_metadata
|
| |
+
|
| |
+
|
| |
+ -# Returns flatpak's name for the current arch
|
| |
+ -def get_arch():
|
| |
+ - return subprocess.check_output(['flatpak', '--default-arch'],
|
| |
+ - universal_newlines=True).strip()
|
| |
+ -
|
| |
+ -
|
| |
+ -# flatpak build-init requires the sdk and runtime to be installed on the
|
| |
+ -# build system (so that subsequent build steps can execute things with
|
| |
+ -# the SDK). While it isn't impossible to download the runtime image and
|
| |
+ -# install the flatpak, that would be a lot of unnecessary complexity
|
| |
+ -# since our build step is just unpacking the filesystem we've already
|
| |
+ -# created. This is a stub implementation of 'flatpak build-init' that
|
| |
+ -# doesn't check for the SDK or use it to set up the build filesystem.
|
| |
+ -def build_init(directory, appname, sdk, runtime, runtime_branch, tags=[]):
|
| |
+ - if not os.path.isdir(directory):
|
| |
+ - os.mkdir(directory)
|
| |
+ - with open(os.path.join(directory, "metadata"), "w") as f:
|
| |
+ - f.write(dedent("""\
|
| |
+ - [Application]
|
| |
+ - name={appname}
|
| |
+ - runtime={runtime}/{arch}/{runtime_branch}
|
| |
+ - sdk={sdk}/{arch}/{runtime_branch}
|
| |
+ - """.format(appname=appname,
|
| |
+ - sdk=sdk,
|
| |
+ - runtime=runtime,
|
| |
+ - runtime_branch=runtime_branch,
|
| |
+ - arch=get_arch())))
|
| |
+ - if tags:
|
| |
+ - f.write("tags=" + ";".join(tags) + "\n")
|
| |
+ - os.mkdir(os.path.join(directory, "files"))
|
| |
+ -
|
| |
+ -
|
| |
+ -# add_app_prefix('org.gimp', 'gimp, 'gimp.desktop') => org.gimp.desktop
|
| |
+ -# add_app_prefix('org.gnome', 'eog, 'eog.desktop') => org.gnome.eog.desktop
|
| |
+ -def add_app_prefix(app_id, root, full):
|
| |
+ - prefix = app_id
|
| |
+ - if prefix.endswith('.' + root):
|
| |
+ - prefix = prefix[:-(1 + len(root))]
|
| |
+ - return prefix + '.' + full
|
| |
+ -
|
| |
+ -
|
| |
+ -def find_desktop_files(builddir):
|
| |
+ - desktopdir = os.path.join(builddir, 'files/share/applications')
|
| |
+ - for (dirpath, dirnames, filenames) in os.walk(desktopdir):
|
| |
+ - for filename in filenames:
|
| |
+ - if filename.endswith('.desktop'):
|
| |
+ - yield os.path.join(dirpath, filename)
|
| |
+ -
|
| |
+ -
|
| |
+ -def find_icons(builddir, name):
|
| |
+ - icondir = os.path.join(builddir, 'files/share/icons/hicolor')
|
| |
+ - for (dirpath, dirnames, filenames) in os.walk(icondir):
|
| |
+ - for filename in filenames:
|
| |
+ - if filename.startswith(name + '.'):
|
| |
+ - yield os.path.join(dirpath, filename)
|
| |
+ -
|
| |
+ -
|
| |
+ -def update_desktop_files(app_id, builddir):
|
| |
+ - for full_path in find_desktop_files(builddir):
|
| |
+ - cp = configparser.RawConfigParser()
|
| |
+ - cp.read([full_path])
|
| |
+ - try:
|
| |
+ - icon = cp.get('Desktop Entry', 'Icon')
|
| |
+ - except configparser.NoOptionError:
|
| |
+ - icon = None
|
| |
+ -
|
| |
+ - # Does it have an icon?
|
| |
+ - if icon and not icon.startswith(app_id):
|
| |
+ - found_icon = False
|
| |
+ -
|
| |
+ - # Rename any matching icons
|
| |
+ - for icon_file in find_icons(builddir, icon):
|
| |
+ - shutil.copy(icon_file,
|
| |
+ - os.path.join(os.path.dirname(icon_file),
|
| |
+ - add_app_prefix(app_id, icon, os.path.basename(icon_file))))
|
| |
+ - found_icon = True
|
| |
+ -
|
| |
+ - # If we renamed the icon, change the desktop file
|
| |
+ - if found_icon:
|
| |
+ - subprocess.check_call(['desktop-file-edit',
|
| |
+ - '--set-icon',
|
| |
+ - add_app_prefix(app_id, icon, icon), full_path])
|
| |
+ -
|
| |
+ - # Is the desktop file not prefixed with the app id, then prefix it
|
| |
+ - basename = os.path.basename(full_path)
|
| |
+ - if not basename.startswith(app_id):
|
| |
+ - shutil.move(full_path,
|
| |
+ - os.path.join(os.path.dirname(full_path),
|
| |
+ - add_app_prefix(app_id,
|
| |
+ - basename[:-len('.desktop')],
|
| |
+ - basename)))
|
| |
+ -
|
| |
+ -
|
| |
+ # This converts the generator provided by the export() operation to a file-like
|
| |
+ # object with a read that we can pass to tarfile.
|
| |
+ class StreamAdapter(object):
|
| |
+ @@ -165,133 +65,11 @@ class FlatpakCreateOciPlugin(PrePublishPlugin):
|
| |
+ """
|
| |
+ super(FlatpakCreateOciPlugin, self).__init__(tasker, workflow)
|
| |
+
|
| |
+ - # Compiles a list of path mapping rules to a simple function that matches
|
| |
+ - # against a list of fixed patterns, see below for rule syntax
|
| |
+ - def _compile_target_rules(rules):
|
| |
+ - ROOT = "var/tmp/flatpak-build"
|
| |
+ -
|
| |
+ - patterns = []
|
| |
+ - for source, target in rules:
|
| |
+ - source = re.sub("^ROOT", ROOT, source)
|
| |
+ - if source.endswith("/"):
|
| |
+ - patterns.append((re.compile(source + "(.*)"), target, False))
|
| |
+ - patterns.append((source[:-1], target, True))
|
| |
+ - else:
|
| |
+ - patterns.append((source, target, True))
|
| |
+ -
|
| |
+ - def get_target_func(self, path):
|
| |
+ - for source, target, is_exact_match in patterns:
|
| |
+ - if is_exact_match:
|
| |
+ - if source == path:
|
| |
+ - return target
|
| |
+ - else:
|
| |
+ - m = source.match(path)
|
| |
+ - if m:
|
| |
+ - return os.path.join(target, m.group(1))
|
| |
+ -
|
| |
+ - return None
|
| |
+ -
|
| |
+ - return get_target_func
|
| |
+ -
|
| |
+ - # Rules for mapping paths within the exported filesystem image to their
|
| |
+ - # location in the final flatpak filesystem
|
| |
+ - #
|
| |
+ - # ROOT = /var/tmp/flatpak-build
|
| |
+ - # No trailing slash - map a directory itself exactly
|
| |
+ - # trailing slash - map a directory and everything inside of it
|
| |
+ -
|
| |
+ - _get_target_path_runtime = _compile_target_rules([
|
| |
+ - # We need to make sure that 'files' is created before 'files/etc',
|
| |
+ - # which wouldn't happen if just relied on ROOT/usr/ => files.
|
| |
+ - # Instead map ROOT => files and omit ROOT/usr
|
| |
+ - ("ROOT", "files"),
|
| |
+ - ("ROOT/usr", None),
|
| |
+ -
|
| |
+ - # We map ROOT/usr => files and ROOT/etc => files/etc. This creates
|
| |
+ - # A conflict between ROOT/usr/etc and /ROOT/etc. Just assume there
|
| |
+ - # is nothing useful in /ROOT/usr/etc.
|
| |
+ - ("ROOT/usr/etc/", None),
|
| |
+ -
|
| |
+ - ("ROOT/usr/", "files"),
|
| |
+ - ("ROOT/etc/", "files/etc")
|
| |
+ - ])
|
| |
+ -
|
| |
+ - _get_target_path_app = _compile_target_rules([
|
| |
+ - ("ROOT/app/", "files")
|
| |
+ - ])
|
| |
+ -
|
| |
+ - def _get_target_path(self, export_path):
|
| |
+ - if self.source.runtime:
|
| |
+ - return self._get_target_path_runtime(export_path)
|
| |
+ - else:
|
| |
+ - return self._get_target_path_app(export_path)
|
| |
+ -
|
| |
+ def _export_container(self, container_id):
|
| |
+ - outfile = os.path.join(self.workflow.source.workdir, 'filesystem.tar.gz')
|
| |
+ - manifestfile = os.path.join(self.workflow.source.workdir, 'flatpak-build.rpm_qf')
|
| |
+ -
|
| |
+ export_generator = self.tasker.d.export(container_id)
|
| |
+ export_stream = StreamAdapter(export_generator)
|
| |
+
|
| |
+ - out_fileobj = open(outfile, "wb")
|
| |
+ - compress_process = subprocess.Popen(['gzip', '-c'],
|
| |
+ - stdin=subprocess.PIPE,
|
| |
+ - stdout=out_fileobj)
|
| |
+ - in_tf = tarfile.open(fileobj=export_stream, mode='r|')
|
| |
+ - out_tf = tarfile.open(fileobj=compress_process.stdin, mode='w|')
|
| |
+ -
|
| |
+ - for member in in_tf:
|
| |
+ - if member.name == 'var/tmp/flatpak-build.rpm_qf':
|
| |
+ - reader = in_tf.extractfile(member)
|
| |
+ - with open(manifestfile, 'wb') as out:
|
| |
+ - out.write(reader.read())
|
| |
+ - reader.close()
|
| |
+ - target_name = self._get_target_path(member.name)
|
| |
+ - if target_name is None:
|
| |
+ - continue
|
| |
+ -
|
| |
+ - # Match the ownership/permissions changes done by 'flatpak build-export'.
|
| |
+ - # See commit_filter() in:
|
| |
+ - # https://github.com/flatpak/flatpak/blob/master/app/flatpak-builtins-build-export.c
|
| |
+ - #
|
| |
+ - # We'll run build-export anyways in the app case, but in the runtime case we skip
|
| |
+ - # flatpak build-export and use ostree directly.
|
| |
+ - member.uid = 0
|
| |
+ - member.gid = 0
|
| |
+ - member.uname = "root"
|
| |
+ - member.gname = "root"
|
| |
+ -
|
| |
+ - if member.isdir():
|
| |
+ - member.mode = 0o0755
|
| |
+ - elif member.mode & 0o0100:
|
| |
+ - member.mode = 0o0755
|
| |
+ - else:
|
| |
+ - member.mode = 0o0644
|
| |
+ -
|
| |
+ - member.name = target_name
|
| |
+ - if member.islnk():
|
| |
+ - # Hard links have full paths within the archive (no leading /)
|
| |
+ - link_target = self._get_target_path(member.linkname)
|
| |
+ - if link_target is None:
|
| |
+ - self.log.debug("Skipping %s, hard link to %s", target_name, link_target)
|
| |
+ - continue
|
| |
+ - member.linkname = link_target
|
| |
+ - out_tf.addfile(member)
|
| |
+ - elif member.issym():
|
| |
+ - # Symlinks have the literal link target, which will be
|
| |
+ - # relative to the chroot and doesn't need rewriting
|
| |
+ - out_tf.addfile(member)
|
| |
+ - else:
|
| |
+ - f = in_tf.extractfile(member)
|
| |
+ - out_tf.addfile(member, fileobj=f)
|
| |
+ -
|
| |
+ - in_tf.close()
|
| |
+ - out_tf.close()
|
| |
+ - export_stream.close()
|
| |
+ - compress_process.stdin.close()
|
| |
+ - if compress_process.wait() != 0:
|
| |
+ - raise RuntimeError("gzip failed")
|
| |
+ - out_fileobj.close()
|
| |
+ + outfile, manifestfile = self.builder._export_from_stream(export_stream)
|
| |
+
|
| |
+ return outfile, manifestfile
|
| |
+
|
| |
+ @@ -310,148 +88,23 @@ class FlatpakCreateOciPlugin(PrePublishPlugin):
|
| |
+ self.log.info("Cleaning up docker container")
|
| |
+ self.tasker.d.remove_container(container_id)
|
| |
+
|
| |
+ - def _get_components(self, manifest):
|
| |
+ - with open(manifest, 'r') as f:
|
| |
+ - lines = f.readlines()
|
| |
+ -
|
| |
+ - return parse_rpm_output(lines)
|
| |
+ -
|
| |
+ - def _filter_app_manifest(self, components):
|
| |
+ - runtime_rpms = self.source.runtime_module.mmd.peek_profiles()['runtime'].props.rpms
|
| |
+ -
|
| |
+ - return [c for c in components if not runtime_rpms.contains(c['name'])]
|
| |
+ -
|
| |
+ - def _create_runtime_oci(self, tarred_filesystem, outfile):
|
| |
+ - info = self.source.flatpak_yaml
|
| |
+ -
|
| |
+ - builddir = os.path.join(self.workflow.source.workdir, "build")
|
| |
+ - os.mkdir(builddir)
|
| |
+ -
|
| |
+ - repo = os.path.join(self.workflow.source.workdir, "repo")
|
| |
+ - subprocess.check_call(['ostree', 'init', '--mode=archive-z2', '--repo', repo])
|
| |
+ -
|
| |
+ - id_ = info['id']
|
| |
+ - runtime_id = info.get('runtime', id_)
|
| |
+ - sdk_id = info.get('sdk', id_)
|
| |
+ - branch = info['branch']
|
| |
+ -
|
| |
+ - args = {
|
| |
+ - 'id': id_,
|
| |
+ - 'runtime_id': runtime_id,
|
| |
+ - 'sdk_id': sdk_id,
|
| |
+ - 'arch': get_arch(),
|
| |
+ - 'branch': branch
|
| |
+ - }
|
| |
+ -
|
| |
+ - METADATA_TEMPLATE = dedent("""\
|
| |
+ - [Runtime]
|
| |
+ - name={id}
|
| |
+ - runtime={runtime_id}/{arch}/{branch}
|
| |
+ - sdk={sdk_id}/{arch}/{branch}
|
| |
+ -
|
| |
+ - [Environment]
|
| |
+ - LD_LIBRARY_PATH=/app/lib64:/app/lib
|
| |
+ - GI_TYPELIB_PATH=/app/lib64/girepository-1.0
|
| |
+ - """)
|
| |
+ -
|
| |
+ - with open(os.path.join(builddir, 'metadata'), 'w') as f:
|
| |
+ - f.write(METADATA_TEMPLATE.format(**args))
|
| |
+ -
|
| |
+ - runtime_ref = 'runtime/{id}/{arch}/{branch}'.format(**args)
|
| |
+ -
|
| |
+ - subprocess.check_call(['ostree', 'commit',
|
| |
+ - '--repo', repo, '--owner-uid=0',
|
| |
+ - '--owner-gid=0', '--no-xattrs',
|
| |
+ - '--branch', runtime_ref,
|
| |
+ - '-s', 'build of ' + runtime_ref,
|
| |
+ - '--tree=tar=' + tarred_filesystem,
|
| |
+ - '--tree=dir=' + builddir])
|
| |
+ - subprocess.check_call(['ostree', 'summary', '-u', '--repo', repo])
|
| |
+ -
|
| |
+ - subprocess.check_call(['flatpak', 'build-bundle', repo,
|
| |
+ - '--oci', '--runtime',
|
| |
+ - outfile, id_, branch])
|
| |
+ -
|
| |
+ - return runtime_ref
|
| |
+ -
|
| |
+ - def _find_runtime_info(self):
|
| |
+ - runtime_module = self.source.runtime_module
|
| |
+ -
|
| |
+ - flatpak_xmd = runtime_module.mmd.props.xmd['flatpak']
|
| |
+ - runtime_id = flatpak_xmd['runtimes']['runtime']['id']
|
| |
+ - sdk_id = flatpak_xmd['runtimes']['runtime'].get('sdk', runtime_id)
|
| |
+ - runtime_version = flatpak_xmd['branch']
|
| |
+ -
|
| |
+ - return runtime_id, sdk_id, runtime_version
|
| |
+ -
|
| |
+ - def _create_app_oci(self, tarred_filesystem, outfile):
|
| |
+ - info = self.source.flatpak_yaml
|
| |
+ - app_id = info['id']
|
| |
+ - app_branch = info.get('branch', 'master')
|
| |
+ -
|
| |
+ - builddir = os.path.join(self.workflow.source.workdir, "build")
|
| |
+ - os.mkdir(builddir)
|
| |
+ -
|
| |
+ - repo = os.path.join(self.workflow.source.workdir, "repo")
|
| |
+ -
|
| |
+ - runtime_id, sdk_id, runtime_version = self._find_runtime_info()
|
| |
+ -
|
| |
+ - # See comment for build_init() for why we can't use 'flatpak build-init'
|
| |
+ - # subprocess.check_call(['flatpak', 'build-init',
|
| |
+ - # builddir, app_id, runtime_id, runtime_id, runtime_version])
|
| |
+ - build_init(builddir, app_id, sdk_id, runtime_id, runtime_version, tags=info.get('tags', []))
|
| |
+ -
|
| |
+ - # with gzip'ed tarball, tar is several seconds faster than tarfile.extractall
|
| |
+ - subprocess.check_call(['tar', 'xCfz', builddir, tarred_filesystem])
|
| |
+ -
|
| |
+ - update_desktop_files(app_id, builddir)
|
| |
+ -
|
| |
+ - finish_args = []
|
| |
+ - if 'finish-args' in info:
|
| |
+ - # shlex.split(None) reads from standard input, so avoid that
|
| |
+ - finish_args = shlex.split(info['finish-args'] or '')
|
| |
+ - if 'command' in info:
|
| |
+ - finish_args = ['--command', info['command']] + finish_args
|
| |
+ -
|
| |
+ - subprocess.check_call(['flatpak', 'build-finish'] + finish_args + [builddir])
|
| |
+ - subprocess.check_call(['flatpak', 'build-export', repo, builddir, app_branch])
|
| |
+ -
|
| |
+ - subprocess.check_call(['flatpak', 'build-bundle', repo, '--oci',
|
| |
+ - outfile, app_id, app_branch])
|
| |
+ -
|
| |
+ - app_ref = 'app/{app_id}/{arch}/{branch}'.format(app_id=app_id,
|
| |
+ - arch=get_arch(),
|
| |
+ - branch=app_branch)
|
| |
+ -
|
| |
+ - return app_ref
|
| |
+ -
|
| |
+ def run(self):
|
| |
+ self.source = get_flatpak_source_info(self.workflow)
|
| |
+ if self.source is None:
|
| |
+ raise RuntimeError("flatpak_create_dockerfile must be run before flatpak_create_oci")
|
| |
+
|
| |
+ + self.builder = FlatpakBuilder(self.source, self.workflow.source.workdir,
|
| |
+ + 'var/tmp/flatpak-build',
|
| |
+ + parse_manifest=parse_rpm_output)
|
| |
+ +
|
| |
+ tarred_filesystem, manifest = self._export_filesystem()
|
| |
+ self.log.info('filesystem tarfile written to %s', tarred_filesystem)
|
| |
+ self.log.info('manifest written to %s', manifest)
|
| |
+
|
| |
+ - all_components = self._get_components(manifest)
|
| |
+ - if self.source.runtime:
|
| |
+ - image_components = all_components
|
| |
+ - else:
|
| |
+ - image_components = self._filter_app_manifest(all_components)
|
| |
+ -
|
| |
+ - self.log.info("Components:\n%s",
|
| |
+ - "\n".join(" {name}-{epoch}:{version}-{release}.{arch}.rpm"
|
| |
+ - .format(**c) for c in image_components))
|
| |
+ -
|
| |
+ + image_components = self.builder.get_components(manifest)
|
| |
+ self.workflow.image_components = image_components
|
| |
+
|
| |
+ - outfile = os.path.join(self.workflow.source.workdir, 'flatpak-oci-image')
|
| |
+ -
|
| |
+ - if self.source.runtime:
|
| |
+ - ref_name = self._create_runtime_oci(tarred_filesystem, outfile)
|
| |
+ - else:
|
| |
+ - ref_name = self._create_app_oci(tarred_filesystem, outfile)
|
| |
+ + ref_name, outfile, tarred_outfile = self.builder.build_container(tarred_filesystem)
|
| |
+
|
| |
+ metadata = get_exported_image_metadata(outfile, IMAGE_TYPE_OCI)
|
| |
+ metadata['ref_name'] = ref_name
|
| |
+ @@ -459,11 +112,6 @@ class FlatpakCreateOciPlugin(PrePublishPlugin):
|
| |
+
|
| |
+ self.log.info('OCI image is available as %s', outfile)
|
| |
+
|
| |
+ - tarred_outfile = outfile + '.tar'
|
| |
+ - with tarfile.TarFile(tarred_outfile, "w") as tf:
|
| |
+ - for f in os.listdir(outfile):
|
| |
+ - tf.add(os.path.join(outfile, f), f)
|
| |
+ -
|
| |
+ metadata = get_exported_image_metadata(tarred_outfile, IMAGE_TYPE_OCI_TAR)
|
| |
+ metadata['ref_name'] = ref_name
|
| |
+ self.workflow.exported_image_sequence.append(metadata)
|
| |
+ diff --git a/images/dockerhost-builder/Dockerfile b/images/dockerhost-builder/Dockerfile
|
| |
+ index 11368b9..7e5be3e 100644
|
| |
+ --- a/images/dockerhost-builder/Dockerfile
|
| |
+ +++ b/images/dockerhost-builder/Dockerfile
|
| |
+ @@ -1,5 +1,5 @@
|
| |
+ FROM fedora:latest
|
| |
+ -RUN dnf -y install docker git python-docker-py python-setuptools desktop-file-utils e2fsprogs flatpak koji libmodulemd ostree python2-gobject-base python-backports-lzma osbs gssproxy && dnf clean all
|
| |
+ +RUN dnf -y install docker git python-docker-py python-setuptools desktop-file-utils e2fsprogs flatpak koji libmodulemd ostree python2-gobject-base python2-flatpak-module-tools python-backports-lzma osbs gssproxy && dnf clean all
|
| |
+ ADD ./atomic-reactor.tar.gz /tmp/
|
| |
+ RUN cd /tmp/atomic-reactor-*/ && python setup.py install
|
| |
+ CMD ["atomic-reactor", "--verbose", "inside-build"]
|
| |
+ diff --git a/images/privileged-builder/Dockerfile b/images/privileged-builder/Dockerfile
|
| |
+ index a6fa7fd..75653bf 100644
|
| |
+ --- a/images/privileged-builder/Dockerfile
|
| |
+ +++ b/images/privileged-builder/Dockerfile
|
| |
+ @@ -1,5 +1,5 @@
|
| |
+ FROM fedora:latest
|
| |
+ -RUN dnf -y install docker git python-docker-py python-setuptools desktop-file-utils e2fsprogs flatpak koji libmodulemd ostree python2-gobject-base python-backports-lzma osbs gssproxy && dnf clean all
|
| |
+ +RUN dnf -y install docker git python-docker-py python-setuptools desktop-file-utils e2fsprogs flatpak koji libmodulemd ostree python2-gobject-base python2-flatpak-module-tools python-backports-lzma osbs gssproxy && dnf clean all
|
| |
+ ADD ./atomic-reactor.tar.gz /tmp/
|
| |
+ RUN cd /tmp/atomic-reactor-*/ && python setup.py install
|
| |
+ ADD ./docker.sh /tmp/docker.sh
|
| |
+ diff --git a/requirements-flatpak.txt b/requirements-flatpak.txt
|
| |
+ index a751b49..acb27ca 100644
|
| |
+ --- a/requirements-flatpak.txt
|
| |
+ +++ b/requirements-flatpak.txt
|
| |
+ @@ -1 +1,2 @@
|
| |
+ +flatpak-module-tools
|
| |
+ pdc-client
|
| |
+ diff --git a/tests/flatpak.py b/tests/flatpak.py
|
| |
+ index 2ac42e9..c412284 100644
|
| |
+ --- a/tests/flatpak.py
|
| |
+ +++ b/tests/flatpak.py
|
| |
+ @@ -1,11 +1,12 @@
|
| |
+ import yaml
|
| |
+
|
| |
+ +from atomic_reactor.util import split_module_spec
|
| |
+ +
|
| |
+ try:
|
| |
+ - from atomic_reactor.plugins.pre_resolve_module_compose import (ModuleInfo,
|
| |
+ - ComposeInfo,
|
| |
+ + from atomic_reactor.plugins.pre_resolve_module_compose import (ComposeInfo,
|
| |
+ set_compose_info)
|
| |
+ - from atomic_reactor.plugins.pre_flatpak_create_dockerfile import (FlatpakSourceInfo,
|
| |
+ - set_flatpak_source_info)
|
| |
+ + from atomic_reactor.plugins.pre_flatpak_create_dockerfile import set_flatpak_source_info
|
| |
+ + from flatpak_module_tools.flatpak_builder import FlatpakSourceInfo, ModuleInfo
|
| |
+ from gi.repository import Modulemd
|
| |
+ MODULEMD_AVAILABLE = True
|
| |
+ except ImportError:
|
| |
+ @@ -123,6 +124,9 @@ flatpak:
|
| |
+ # Test overriding the automatic "first executable in /usr/bin'
|
| |
+ command: eog2
|
| |
+ tags: ["Viewer"]
|
| |
+ + copy-icon: true
|
| |
+ + rename-desktop-file: eog.desktop
|
| |
+ + rename-icon: eog
|
| |
+ finish-args: >
|
| |
+ """ + "".join(" {}\n".format(a) for a in FLATPAK_APP_FINISH_ARGS)
|
| |
+
|
| |
+ @@ -342,7 +346,10 @@ def setup_flatpak_source_info(workflow, config=APP_CONFIG):
|
| |
+
|
| |
+ flatpak_yaml = yaml.safe_load(config['container_yaml'])['flatpak']
|
| |
+
|
| |
+ - source = FlatpakSourceInfo(flatpak_yaml, compose)
|
| |
+ + module_spec = split_module_spec(compose.source_spec)
|
| |
+ +
|
| |
+ + source = FlatpakSourceInfo(flatpak_yaml, compose.modules, compose.base_module,
|
| |
+ + module_spec.profile)
|
| |
+ set_flatpak_source_info(workflow, source)
|
| |
+
|
| |
+ return source
|
| |
+ --
|
| |
+ 2.14.3
|
| |
+
|
| |
otaylor
commented 5 years ago
Add patch to fix compatibility issues with recent docker/docker-py [merged upstream]
Add patch to drop platforms from target tag that aren't in the cluster config
Add patch to use Flatpak code from flatpak-module-tools, rather than cut-and-paste