#350 [ostree-live-image] Add ostree_live_image phase
Closed 7 years ago by qwan. Opened 7 years ago by qwan.
qwan/pungi develop  into  master

file modified
+3
@@ -228,6 +228,7 @@ 

      createrepo_phase = pungi.phases.CreaterepoPhase(compose)

      ostree_installer_phase = pungi.phases.OstreeInstallerPhase(compose)

      ostree_phase = pungi.phases.OSTreePhase(compose)

+     ostree_live_image_phase = pungi.phases.OSTreeLiveImagePhase(compose)

      productimg_phase = pungi.phases.ProductimgPhase(compose, pkgset_phase)

      createiso_phase = pungi.phases.CreateisoPhase(compose)

      liveimages_phase = pungi.phases.LiveImagesPhase(compose)
@@ -350,6 +351,7 @@ 

      image_build_phase.start()

      livemedia_phase.start()

      ostree_installer_phase.start()

+     ostree_live_image_phase.start()

      osbs_phase.start()

  

      createiso_phase.stop()
@@ -357,6 +359,7 @@ 

      image_build_phase.stop()

      livemedia_phase.stop()

      ostree_installer_phase.stop()

+     ostree_live_image_phase.stop()

      osbs_phase.stop()

  

      image_checksum_phase.start()

file modified
+49
@@ -148,6 +148,7 @@ 

       * live-media

       * ostree

       * ostree-installer

+      * ostree-live-image

       * osbs

  

         .. note::
@@ -1077,6 +1078,54 @@ 

      ]

  

  

+ OSTree Live Image Settings

+ ==========================

+ 

+ The ``ostree_live_image`` phase of *Pungi* can create ostree PXE2Live image in a Koji

+ runroot environment.

+ 

+ **ostree_live_image**

+     (*list*) -- a list of variant/arch mapping configurations. The format should be

+     ``[(variant_uid_regex, {arch|*: config_dict})]``.

+ 

+     The configuration dict for each variant arch pair must have these keys:

+ 

+     * ``source_repo_from`` -- (*str*) Name of variant serving as source repository.

+     * ``config_url`` -- (*str*) URL for Git repository with the ``config`` and ``tdl``.

+     * ``config`` -- (*str*) Config file for ``rpm-ostree-toolbox``.

+     * ``tdl`` -- (*str*) TDL file for ``rpm-ostree-toolbox``.

+     * ``ksurl`` -- (*str*) URL for Git repository with the ``kickstart``.

+     * ``kickstart`` -- (*str*) Kickstart file for ``rpm-ostree-toolbox``.

+     * ``ostree_repo`` -- (*str*) Path to OSTree repository.

+ 

+     These keys are optional:

+ 

+     * ``config_branch`` -- (*str*) Git branch of the config repo to use. Defaults to

+       ``master``.

+     * ``kickstart_branch`` -- (*str*) Git branch of the kickstart repo to use. Defaults to

+       ``master``.

+ 

+ 

+ Example config

+ --------------

+ ::

+ 

+     ostree = [

+         ("^Atomic$", {

+             "x86_64": {

+                 'source_repo_from': 'Everything',

+                 'config_url': 'https://git.fedorahosted.org/git/fedora-atomic.git',

+                 'config': 'config.ini',

+                 'config_branch': 'master',

+                 'tdl': 'fedora-atomic-rawhide.tdl',

+                 'ksurl': 'https://git.fedorahosted.org/git/spin-kickstarts.git',

+                 'kickstart': 'fedora-cloud-atomic-pxetolive.ks',

+                 "ostree_repo": "/mnt/koji/compose/atomic/Rawhide/"

+             }

+         })

+     ]

+ 

+ 

  Ostree Installer Settings

  =========================

  

@@ -31,4 +31,5 @@ 

  from .livemedia_phase import LiveMediaPhase  # noqa

  from .ostree import OSTreePhase  # noqa

  from .ostree_installer import OstreeInstallerPhase  # noqa

+ from .ostree_live_image import OSTreeLiveImagePhase  # noqa

  from .osbs import OSBSPhase  # noqa

file modified
+2 -27
@@ -53,8 +53,8 @@ 

          source_variant = compose.variants[config['source_repo_from']]

          source_repo = translate_path(compose, compose.paths.compose.repository(arch, source_variant))

  

-         self._clone_repo(repodir, config['config_url'], config.get('config_branch', 'master'))

-         self._tweak_mirrorlist(repodir, source_repo)

+         scm.clone_repo(repodir, config['config_url'], config.get('config_branch', 'master'), logger=self.pool._logger)

+         util.tweak_mirrorlist(repodir, source_repo)

  

          # Ensure target directory exists, otherwise Koji task will fail to

          # mount it.
@@ -87,28 +87,3 @@ 

          if output["retcode"] != 0:

              raise RuntimeError("Runroot task failed: %s. See %s for more details."

                                 % (output["task_id"], log_file))

- 

-     def _clone_repo(self, repodir, url, branch):

-         scm.get_dir_from_scm({'scm': 'git', 'repo': url, 'branch': branch, 'dir': '.'},

-                              repodir, logger=self.pool._logger)

- 

-     def _tweak_mirrorlist(self, repodir, source_repo):

-         for file in os.listdir(repodir):

-             if file.endswith('.repo'):

-                 tweak_file(os.path.join(repodir, file), source_repo)

- 

- 

- def tweak_file(path, source_repo):

-     """

-     Ensure a given .repo file points to `source_repo`.

- 

-     This function replaces all lines starting with `mirrorlist`, `metalink` or

-     `baseurl` with `baseurl` set to requested repository.

-     """

-     with open(path, 'r') as f:

-         contents = f.read()

-     replacement = 'baseurl=%s' % source_repo

-     exp = re.compile(r'^(mirrorlist|metalink|baseurl)=.*$', re.MULTILINE)

-     contents = exp.sub(replacement, contents)

-     with open(path, 'w') as f:

-         f.write(contents)

@@ -0,0 +1,112 @@ 

+ # -*- coding: utf-8 -*-

+ 

+ import os

+ from kobo.threads import ThreadPool, WorkerThread

+ 

+ from .base import ConfigGuardedPhase

+ from .. import util

+ from ..paths import translate_path

+ from ..wrappers import kojiwrapper, scm

+ 

+ 

+ class OSTreeLiveImagePhase(ConfigGuardedPhase):

+     name = 'ostree_live_image'

+ 

+     config_options = [

+         {

+             "name": "ostree_live_image",

+             "expected_types": [list],

+             "optional": True,

+         }

+     ]

+ 

+     def __init__(self, compose):

+         super(OSTreeLiveImagePhase, self).__init__(compose)

+         self.pool = ThreadPool(logger=self.compose._logger)

+ 

+     def run(self):

+         for variant in self.compose.get_variants():

+             for arch in variant.arches:

+                 for conf in util.get_arch_variant_data(self.compose.conf, self.name, arch, variant):

+                     self.pool.add(OSTreeLiveImageThread(self.pool))

+                     self.pool.queue_put((self.compose, variant, arch, conf))

+ 

+         self.pool.start()

+ 

+ 

+ class OSTreeLiveImageThread(WorkerThread):

+     def process(self, item, num):

+         compose, variant, arch, config = item

+         self.num = num

+         with util.failable(compose, variant, arch, 'ostree-live-image'):

+             self.worker(compose, variant, arch, config)

+ 

+     def worker(self, compose, variant, arch, config):

+         msg = 'Creating OSTree live image for variant %s, arch %s' % (variant.uid, arch)

+         self.pool.log_info('[BEGIN] %s' % msg)

+         self.logdir = compose.paths.log.topdir('%s/ostree-live-image-%d' % (arch, self.num))

+         workdir = compose.paths.work.topdir('ostree-live-image-%d' % self.num)

+ 

+         source_repo = self._get_source_repo(compose, arch, config['source_repo_from'])

+         config_dir = os.path.join(workdir, 'config_repo')

+         scm.clone_repo(config_dir, config['config_url'], config.get('config_branch', 'master'),

+                        logger=self.pool._logger)

+         config_file = config.get('config')

+         config_file_dir = config_dir

+         if '/' in config_file:

+             config_file_dir = os.path.join(config_dir, os.path.dirname(config_file))

+ 

+         util.tweak_mirrorlist(config_file_dir, source_repo)

+ 

+         kickstart_dir = os.path.join(workdir, 'kickstart_repo')

+         scm.clone_repo(kickstart_dir, config['ksurl'], config.get('kickstart_branch', 'master'),

+                        logger=self.pool._logger)

+ 

+         output_dir = os.path.join(compose.paths.work.topdir(arch), variant.uid, 'ostree_live_image')

+         util.makedirs(os.path.dirname(output_dir))

+ 

+         self._run_rpm_ostree_toolbox_cmd(compose, variant, arch, config, config_dir, kickstart_dir, output_dir)

+ 

+         self.pool.log_info('[DONE ] %s' % msg)

+ 

+     def _get_source_repo(self, compose, arch, source):

+         """

+         If `source` is a URL, return it as-is (possibly replacing $arch with

+         actual arch. Otherwise treat is a a variant name and return path to

+         repo in that variant.

+         """

+         if '://' in source:

+             return source.replace('$arch', arch)

+         source_variant = compose.variants[source]

+         return translate_path(

+             compose, compose.paths.compose.repository(arch, source_variant, create_dir=False))

+ 

+     def _run_rpm_ostree_toolbox_cmd(self, compose, variant, arch, config, config_dir, kickstart_dir, output_dir):

+         cmd = [

+             'rpm-ostree-toolbox',
ausil commented 7 years ago

We can not run rpm-ostree-toolbox at least the last time i looked at it the logging and information it provided was not sufficient. additionally there is no /dev/kvm in the buildroots, so any virt would be unaccelerated. this really needs implemented as a process that builds the image, then feeds it to livemedia-creator. I have been working with Brian Lane to get livemedia-creator to be able to make the pxe-to-live in a single livemedia-creator run

+             'liveimage',

+             '--config=%s' % os.path.join(config_dir, config['config']),

+             '--preserve-ks-url',

+             '--ostreerepo=%s' % config['ostree_repo'],

+             '--tdl=%s' % os.path.join(config_dir, config['tdl']),

+             '--kickstart=%s' % os.path.join(kickstart_dir, config['kickstart']),

+             '--outputdir=%s' % output_dir

+         ]

+ 

+         runroot_channel = compose.conf.get("runroot_channel", None)

+         runroot_tag = compose.conf["runroot_tag"]

+ 

+         packages = ['rpm-ostree-toolbox']

+         log_file = os.path.join(self.logdir, 'runroot.log')

+         mounts = [compose.topdir, config['ostree_repo']]

+ 

+         koji = kojiwrapper.KojiWrapper(compose.conf["koji_profile"])

+         koji_cmd = koji.get_runroot_cmd(runroot_tag, arch, cmd,

+                                         channel=runroot_channel,

+                                         use_shell=True, task_id=True,

+                                         packages=packages, mounts=mounts)

+ 

+         output = koji.run_runroot_cmd(koji_cmd, log_file=log_file)

+         if output["retcode"] != 0:

+             raise RuntimeError("Runroot task failed: %s. See %s for more details."

+                                % (output["task_id"], log_file))

file modified
+25
@@ -522,3 +522,28 @@ 

              shutil.copytree(source, destination)

          else:

              shutil.copy2(source, destination)

+ 

+ 

+ def tweak_mirrorlist(dirpath, source_repo):

+     """

+     Replace repo urls with source_repo for all .repo files under `dirpath`.

+     """

+     for file in os.listdir(dirpath):

+         if file.endswith('.repo'):

+             _tweak_file(os.path.join(dirpath, file), source_repo)

+ 

+ 

+ def _tweak_file(path, source_repo):

+     """

+     Ensure a given .repo file points to `source_repo`.

+ 

+     This function replaces all lines starting with `mirrorlist`, `metalink` or

+     `baseurl` with `baseurl` set to requested repository.

+     """

+     with open(path, 'r') as f:

+         contents = f.read()

+     replacement = 'baseurl=%s' % source_repo

+     exp = re.compile(r'^(mirrorlist|metalink|baseurl)=.*$', re.MULTILINE)

+     contents = exp.sub(replacement, contents)

+     with open(path, 'w') as f:

+         f.write(contents)

file modified
+5
@@ -250,3 +250,8 @@ 

      scm.export_dir(scm_repo, scm_dir, scm_branch=scm_branch, target_dir=tmp_dir)

      copy_all(tmp_dir, target_path)

      shutil.rmtree(tmp_dir)

+ 

+ 

+ def clone_repo(repodir, url, branch, logger=None):

+     get_dir_from_scm({'scm': 'git', 'repo': url, 'branch': branch, 'dir': '.'},

+                      repodir, logger=logger)

@@ -0,0 +1,244 @@ 

+ #!/usr/bin/env python

+ # -*- coding: utf-8 -*-

+ 

+ 

+ import unittest

+ import mock

+ 

+ import os

+ import sys

+ 

+ sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

+ 

+ from tests import helpers

+ from pungi.phases import ostree_live_image as ostree

+ 

+ 

+ class OSTreeLiveImagePhaseTest(helpers.PungiTestCase):

+ 

+     def test_validate(self):

+         compose = helpers.DummyCompose(self.topdir, {

+             'ostree_live_image': [

+                 ("^Atomic$", {

+                     "x86_64": {

+                         "source_repo_from": "Everything",

+                         "config_url": "https://git.fedorahosted.org/git/fedora-atomic.git",

+                         "config": "config.ini",

+                         "tdl": "fedora-atomic-rawhide.tdl",

+                         "ksurl": "https://git.fedorahosted.org/git/spin-kickstarts.git",

+                         "kickstart": "fedora-atomic.ks",

+                         "ostree_repo": "/mnt/koji/compose/atomic/rawhide/"

+                     }

+                 })

+             ]

+         })

+ 

+         phase = ostree.OSTreeLiveImagePhase(compose)

+         try:

+             phase.validate()

+         except:

+             self.fail('Correct config must validate')

+ 

+     def test_validate_bad_conf(self):

+         compose = helpers.DummyCompose(self.topdir, {

+             'ostree_live_image': 'yes please'

+         })

+ 

+         phase = ostree.OSTreeLiveImagePhase(compose)

+         with self.assertRaises(ValueError):

+             phase.validate()

+ 

+     @mock.patch('pungi.phases.ostree_live_image.ThreadPool')

+     def test_run(self, ThreadPool):

+         cfg = mock.Mock()

+         compose = helpers.DummyCompose(self.topdir, {

+             'ostree_live_image': [

+                 ('^Everything$', {'x86_64': cfg})

+             ]

+         })

+ 

+         pool = ThreadPool.return_value

+ 

+         phase = ostree.OSTreeLiveImagePhase(compose)

+         phase.run()

+ 

+         self.assertEqual(len(pool.add.call_args_list), 1)

+         self.assertEqual(pool.queue_put.call_args_list,

+                          [mock.call((compose, compose.variants['Everything'], 'x86_64', cfg))])

+ 

+     @mock.patch('pungi.phases.ostree_live_image.ThreadPool')

+     def test_skip_without_config(self, ThreadPool):

+         compose = helpers.DummyCompose(self.topdir, {})

+         compose.just_phases = None

+         compose.skip_phases = []

+         phase = ostree.OSTreeLiveImagePhase(compose)

+         self.assertTrue(phase.skip())

+ 

+ 

+ class OSTreeLiveImageThreadTest(helpers.PungiTestCase):

+ 

+     def setUp(self):

+         super(OSTreeLiveImageThreadTest, self).setUp()

+         self.repo = os.path.join(self.topdir, 'place/for/atomic')

+ 

+     def _dummy_config_repo(self, target, url, branch, logger=None):

+         helpers.touch(os.path.join(target, 'fedora-atomic-docker-host.json'))

+         helpers.touch(os.path.join(target, 'fedora-rawhide.repo'),

+                       'mirrorlist=mirror-mirror-on-the-wall')

+         helpers.touch(os.path.join(target, 'fedora-24.repo'),

+                       'metalink=who-is-the-fairest-of-them-all')

+         helpers.touch(os.path.join(target, 'fedora-23.repo'),

+                       'baseurl=why-not-zoidberg?')

+ 

+     @mock.patch('pungi.wrappers.scm.clone_repo')

+     @mock.patch('pungi.wrappers.kojiwrapper.KojiWrapper')

+     def test_run(self, KojiWrapper, clone_repo):

+         # will be called twice, one for config repo, another for kickstart repo

+         clone_repo.side_effect = self._dummy_config_repo

+ 

+         compose = helpers.DummyCompose(self.topdir, {

+             'koji_profile': 'koji',

+             'runroot_tag': 'rrt',

+             'translate_paths': [

+                 (self.topdir + '/compose', 'http://example.com')

+             ]

+         })

+         pool = mock.Mock()

+         cfg = {

+             'source_repo_from': 'Everything',

+             'config_url': 'https://git.fedorahosted.org/git/fedora-atomic.git',

+             'config': 'config.ini',

+             'config_branch': 'master',

+             'tdl': 'fedora-atomic-rawhide.tdl',

+             'ksurl': 'https://git.fedorahosted.org/git/spin-kickstarts.git',

+             'kickstart': 'fedora-cloud-atomic-pxetolive.ks',

+             'ostree_repo': self.repo

+         }

+ 

+         koji = KojiWrapper.return_value

+         koji.run_runroot_cmd.return_value = {

+             'task_id': 1234,

+             'retcode': 0,

+             'output': 'Foo bar\n',

+         }

+ 

+         t = ostree.OSTreeLiveImageThread(pool)

+ 

+         t.process((compose, compose.variants['Everything'], 'x86_64', cfg), 1)

+ 

+         clone_repo.assert_has_calls([

+             mock.call(self.topdir + '/work/ostree-live-image-1/config_repo',

+                       'https://git.fedorahosted.org/git/fedora-atomic.git', 'master', logger=pool._logger),

+             mock.call(self.topdir + '/work/ostree-live-image-1/kickstart_repo',

+                       'https://git.fedorahosted.org/git/spin-kickstarts.git', 'master', logger=pool._logger)

+         ])

+ 

+         self.assertEqual(koji.get_runroot_cmd.call_args_list,

+                          [mock.call('rrt', 'x86_64',

+                                     ['rpm-ostree-toolbox',

+                                      'liveimage',

+                                      '--config=%s/config.ini' % (self.topdir + '/work/ostree-live-image-1/config_repo'),

+                                      '--preserve-ks-url',

+                                      '--ostreerepo=%s' % self.repo,

+                                      '--tdl=%s/fedora-atomic-rawhide.tdl' % (

+                                          self.topdir + '/work/ostree-live-image-1/config_repo'),

+                                      '--kickstart=%s/fedora-cloud-atomic-pxetolive.ks' % (

+                                          self.topdir + '/work/ostree-live-image-1/kickstart_repo'),

+                                      '--outputdir=%s' % (

+                                          self.topdir + '/work/x86_64/Everything/ostree_live_image'),

+                                      ],

+                                     channel=None, mounts=[self.topdir, self.repo],

+                                     packages=['rpm-ostree-toolbox'],

+                                     task_id=True, use_shell=True)])

+         self.assertEqual(koji.run_runroot_cmd.call_args_list,

+                          [mock.call(koji.get_runroot_cmd.return_value,

+                                     log_file=self.topdir + '/logs/x86_64/ostree-live-image-1/runroot.log')])

+ 

+         with open(self.topdir + '/work/ostree-live-image-1/config_repo/fedora-rawhide.repo') as f:

+             self.assertIn('baseurl=http://example.com/Everything/x86_64/os',

+                           f.read())

+         with open(self.topdir + '/work/ostree-live-image-1/config_repo/fedora-24.repo') as f:

+             self.assertIn('baseurl=http://example.com/Everything/x86_64/os',

+                           f.read())

+         with open(self.topdir + '/work/ostree-live-image-1/config_repo/fedora-23.repo') as f:

+             self.assertIn('baseurl=http://example.com/Everything/x86_64/os',

+                           f.read())

+ 

+     @mock.patch('pungi.wrappers.scm.clone_repo')

+     @mock.patch('pungi.wrappers.kojiwrapper.KojiWrapper')

+     def test_run_fail(self, KojiWrapper, clone_repo):

+         clone_repo.side_effect = self._dummy_config_repo

+ 

+         compose = helpers.DummyCompose(self.topdir, {

+             'koji_profile': 'koji',

+             'runroot_tag': 'rrt',

+             'failable_deliverables': [

+                 ('^.*$', {'*': ['ostree-live-image']})

+             ]

+         })

+         pool = mock.Mock()

+         cfg = {

+             'source_repo_from': 'Everything',

+             'config_url': 'https://git.fedorahosted.org/git/fedora-atomic.git',

+             'config': 'config.ini',

+             'config_branch': 'master',

+             'tdl': 'fedora-atomic-rawhide.tdl',

+             'ksurl': 'https://git.fedorahosted.org/git/spin-kickstarts.git',

+             'kickstart': 'fedora-cloud-atomic-pxetolive.ks',

+             'ostree_repo': self.repo

+         }

+         koji = KojiWrapper.return_value

+         koji.run_runroot_cmd.return_value = {

+             'task_id': 1234,

+             'retcode': 1,

+             'output': 'Foo bar\n',

+         }

+ 

+         t = ostree.OSTreeLiveImageThread(pool)

+ 

+         t.process((compose, compose.variants['Everything'], 'x86_64', cfg), 1)

+ 

+         compose.log_info.assert_has_calls([

+             mock.call('[FAIL] Ostree live image (variant Everything, arch x86_64) failed, but going on anyway.'),

+             mock.call('Runroot task failed: 1234. See %s for more details.'

+                       % (self.topdir + '/logs/x86_64/ostree-live-image-1/runroot.log'))

+         ])

+ 

+     @mock.patch('pungi.wrappers.scm.clone_repo')

+     @mock.patch('pungi.wrappers.kojiwrapper.KojiWrapper')

+     def test_run_handle_exception(self, KojiWrapper, clone_repo):

+         clone_repo.side_effect = self._dummy_config_repo

+ 

+         compose = helpers.DummyCompose(self.topdir, {

+             'koji_profile': 'koji',

+             'runroot_tag': 'rrt',

+             'failable_deliverables': [

+                 ('^.*$', {'*': ['ostree-live-image']})

+             ]

+         })

+         pool = mock.Mock()

+         cfg = {

+             'source_repo_from': 'Everything',

+             'config_url': 'https://git.fedorahosted.org/git/fedora-atomic.git',

+             'config': 'config.ini',

+             'config_branch': 'master',

+             'tdl': 'fedora-atomic-rawhide.tdl',

+             'ksurl': 'https://git.fedorahosted.org/git/spin-kickstarts.git',

+             'kickstart': 'fedora-cloud-atomic-pxetolive.ks',

+             'ostree_repo': self.repo

+         }

+         koji = KojiWrapper.return_value

+         koji.run_runroot_cmd.side_effect = helpers.boom

+ 

+         t = ostree.OSTreeLiveImageThread(pool)

+ 

+         t.process((compose, compose.variants['Everything'], 'x86_64', cfg), 1)

+ 

+         compose.log_info.assert_has_calls([

+             mock.call('[FAIL] Ostree live image (variant Everything, arch x86_64) failed, but going on anyway.'),

+             mock.call('BOOM')

+         ])

+ 

+ 

+ if __name__ == '__main__':

+     unittest.main()

This phase runs rpm-ostree-toolbox to create PXE2Live image in koji
runroot task.

Signed-off-by: Qixiang Wan qwan@redhat.com

It is a list according to the code, right?

Sphinx gives ugly warnings about "Title underline too short."

All imports here except os and the threading stuff seem to be unused.

Can this option be renamed to ksurl? That name is used in other phases already.

Minor nitpick: pep8 would like two empty lines here.

Overall, the code looks good to me. I did not try to run it, though. Unless the configuration is present, merging would not affect any compose.

As far as I understand it, the image will be generated somewhere under work/ directory. That will not get shipped when the compose is done. Is that intended? I would expect the image to be copied to compose/<variant>/<arch>/iso/ (probably) and also added to the images.json metadata. Is there a reason why this is not done?

rebased

7 years ago

hi @lsedlar, thanks for reviewing this, I've updated code per your comments. The only thing I haven't updated is copy image to compose dir and update images.json, since I'm not pretty sure about how the PXE2Live image should be organized and shipped at this moment, so I'm going to do that once I'm be confident of how to do that.

rebased

7 years ago

We can not run rpm-ostree-toolbox at least the last time i looked at it the logging and information it provided was not sufficient. additionally there is no /dev/kvm in the buildroots, so any virt would be unaccelerated. this really needs implemented as a process that builds the image, then feeds it to livemedia-creator. I have been working with Brian Lane to get livemedia-creator to be able to make the pxe-to-live in a single livemedia-creator run

needs to be rebased

There is a failables refactor change merged today, I need to update the patch as well.

We can not run rpm-ostree-toolbox at least the last time i looked at it the logging and information it provided was not sufficient. additionally there is no /dev/kvm in the buildroots, so any virt would be unaccelerated. this really needs implemented as a process that builds the image, then feeds it to livemedia-creator. I have been working with Brian Lane to get livemedia-creator to be able to make the pxe-to-live in a single livemedia-creator run

Thanks for pointing this out, I was unable to get a koji env to run runroot task, and only tested with unittest, so was not aware of that. I'll first update all ostree stuff with local composing support first, then add PXE2Live image with local build only.

Pull-Request has been closed by qwan

7 years ago