Skip using srpm repos

DNF has a bug (#1191289) when the SRPM repo isn't the first one used,
and we don't need them for lorax anyway.

(cherry picked from commit 62de8c26f8)

lorax.spec

@@ -1,14 +1,18 @@
 %define debug_package %{nil}
 
 Name:           lorax
-Version:        22.4
+Version:        22.5
 Release:        1%{?dist}
 Summary:        Tool for creating the anaconda install images
 
 Group:          Applications/System
 License:        GPLv2+
 URL:            https://github.com/rhinstaller/lorax
-Source0:        https://github.com/rhinstaller/%{name}/archive/%{name}-${version}-%{release}.tar.gz
+# To generate Source0 do:
+# git clone https://github.com/rhinstaller/lorax
+# git checkout -b archive-branch lorax-%%{version}-%%{release}
+# tito build --tgz
+Source0:        %{name}-%{version}.tar.gz
 
 BuildRequires:  python2-devel
 
@@ -33,9 +37,9 @@ Requires:       squashfs-tools >= 4.2
 Requires:       util-linux
 Requires:       xz
 Requires:       pigz
-Requires:       yum
 Requires:       pykickstart
 Requires:       dracut >= 030
+Requires:       dnf
 
 %if 0%{?fedora}
 # Fedora specific deps
@@ -76,7 +80,7 @@ including live isos and disk images. It can use libvirtd for the install, or
 Anaconda's image install feature.
 
 %prep
-%setup -q
+%setup -q -n %{name}-%{version}
 
 %build
 
@@ -102,6 +106,11 @@ make DESTDIR=$RPM_BUILD_ROOT mandir=%{_mandir} install
 %{_mandir}/man1/*.1*
 
 %changelog
+* Thu Feb 12 2015 Brian C. Lane <bcl@redhat.com> 22.5-1
+- os-release moved to /usr/lib (#1191713) (bcl@redhat.com)
+- Use /usr/bin/python2 in scripts (bcl@redhat.com)
+- Add bridge-utils (#1188812) (bcl@redhat.com)
+
 * Fri Feb 06 2015 Brian C. Lane <bcl@redhat.com> 22.4-1
 - livemedia-creator: Add --timeout option to cancel install after X minutes
   (bcl@redhat.com)

rel-eng/packages/lorax

@@ -1 +1 @@
-22.4-1 ./
+22.5-1 ./

src/pylorax/__init__.py

@@ -36,7 +36,7 @@ import selinux
 from pylorax.base import BaseLoraxClass, DataHolder
 import pylorax.output as output
 
-import yum
+import dnf
 
 from pylorax.sysutils import joinpaths, remove, linktree
 from rpmUtils.arch import getBaseArch
@@ -87,6 +87,7 @@ class Lorax(BaseLoraxClass):
         self.conf.add_section("lorax")
         self.conf.set("lorax", "debug", "1")
         self.conf.set("lorax", "sharedir", "/usr/share/lorax")
+        self.conf.set("lorax", "logdir", "/var/log/lorax")
 
         self.conf.add_section("output")
         self.conf.set("output", "colors", "1")
@@ -96,9 +97,6 @@ class Lorax(BaseLoraxClass):
         self.conf.add_section("templates")
         self.conf.set("templates", "ramdisk", "ramdisk.ltmpl")
 
-        self.conf.add_section("yum")
-        self.conf.set("yum", "skipbroken", "0")
-
         self.conf.add_section("compression")
         self.conf.set("compression", "type", "xz")
         self.conf.set("compression", "args", "")
@@ -149,7 +147,7 @@ class Lorax(BaseLoraxClass):
         fh.setLevel(logging.DEBUG)
         logger.addHandler(fh)
 
-    def run(self, ybo, product, version, release, variant="", bugurl="",
+    def run(self, dbo, product, version, release, variant="", bugurl="",
             isfinal=False, workdir=None, outputdir=None, buildarch=None, volid=None,
             domacboot=True, doupgrade=True, remove_temp=False,
             installpkgs=None,
@@ -182,7 +180,7 @@ class Lorax(BaseLoraxClass):
             os.makedirs(self.workdir)
 
         # set up log directory
-        logdir = '/var/log/lorax'
+        logdir = self.conf.get("lorax", "logdir")
         if not os.path.isdir(logdir):
             os.makedirs(logdir)
 
@@ -221,16 +219,16 @@ class Lorax(BaseLoraxClass):
             logger.critical("selinux must be disabled or in Permissive mode")
             sys.exit(1)
 
-        # do we have a proper yum base object?
-        logger.info("checking yum base object")
-        if not isinstance(ybo, yum.YumBase):
-            logger.critical("no yum base object")
+        # do we have a proper dnf base object?
+        logger.info("checking dnf base object")
+        if not isinstance(dbo, dnf.Base):
+            logger.critical("no dnf base object")
             sys.exit(1)
-        self.inroot = ybo.conf.installroot
+        self.inroot = dbo.conf.installroot
         logger.debug("using install root: {0}".format(self.inroot))
 
         if not buildarch:
-            buildarch = get_buildarch(ybo)
+            buildarch = get_buildarch(dbo)
 
         logger.info("setting up build architecture")
         self.arch = ArchData(buildarch)
@@ -253,15 +251,14 @@ class Lorax(BaseLoraxClass):
             sys.exit(1)
 
         templatedir = self.conf.get("lorax", "sharedir")
-        # NOTE: rb.root = ybo.conf.installroot (== self.inroot)
+        # NOTE: rb.root = dbo.conf.installroot (== self.inroot)
         rb = RuntimeBuilder(product=self.product, arch=self.arch,
-                            yum=ybo, templatedir=templatedir,
+                            dbo=dbo, templatedir=templatedir,
                             installpkgs=installpkgs,
                             add_templates=add_templates,
                             add_template_vars=add_template_vars)
 
         logger.info("installing runtime packages")
-        rb.yum.conf.skip_broken = self.conf.getboolean("yum", "skipbroken")
         rb.install()
 
         # write .buildstamp
@@ -306,6 +303,7 @@ class Lorax(BaseLoraxClass):
         rb.create_runtime(joinpaths(installroot,runtime),
                           compression=compression, compressargs=compressargs,
                           size=size)
+        rb.finished()
 
         logger.info("preparing to build output tree and boot images")
         treebuilder = TreeBuilder(product=self.product, arch=self.arch,
@@ -358,10 +356,12 @@ class Lorax(BaseLoraxClass):
             remove(self.workdir)
 
 
-def get_buildarch(ybo):
+def get_buildarch(dbo):
     # get architecture of the available anaconda package
     buildarch = None
-    for anaconda in ybo.doPackageLists(patterns=["anaconda"]).available:
+    q = dbo.sack.query()
+    a = q.available()
+    for anaconda in a.filter(name="anaconda"):
         if anaconda.arch != "src":
             buildarch = anaconda.arch
             break

src/pylorax/dnfhelper.py

@@ -0,0 +1,107 @@
+#
+# dnfhelper.py
+#
+# Copyright (C) 2010-2014 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Red Hat Author(s):  Martin Gracik <mgracik@redhat.com>
+#                     Brian C. Lane <bcl@redhat.com>
+#
+
+import logging
+logger = logging.getLogger("pylorax.dnfhelper")
+import dnf
+import collections
+import time
+import pylorax.output as output
+
+__all__ = ['LoraxDownloadCallback', 'LoraxRpmCallback']
+
+def _paced(fn):
+    """Execute `fn` no more often then every 2 seconds."""
+    def paced_fn(self, *args):
+        now = time.time()
+        if now - self.last_time < 2:
+            return
+        self.last_time = now
+        return fn(self, *args)
+    return paced_fn
+
+
+class LoraxDownloadCallback(dnf.callback.DownloadProgress):
+    def __init__(self):
+        self.downloads = collections.defaultdict(int)
+        self.last_time = time.time()
+        self.total_files = 0
+        self.total_size = 0
+
+        self.pkgno = 0
+        self.total = 0
+
+        self.output = output.LoraxOutput()
+
+    @_paced
+    def _update(self):
+        msg = "Downloading %(pkgno)s / %(total_files)s RPMs, " \
+              "%(downloaded)s / %(total_size)s (%(percent)d%%) done.\n"
+        downloaded = sum(self.downloads.values())
+        vals = {
+            'downloaded'  : downloaded,
+            'percent'     : int(100 * downloaded/self.total_size),
+            'pkgno'       : self.pkgno,
+            'total_files' : self.total_files,
+            'total_size'  : self.total_size
+        }
+        self.output.write(msg % vals)
+
+    def end(self, payload, status, err_msg):
+        nevra = str(payload)
+        if status is dnf.callback.STATUS_OK:
+            self.downloads[nevra] = payload.download_size
+            self.pkgno += 1
+            self._update()
+            return
+        logger.critical("Failed to download '%s': %d - %s", nevra, status, err_msg)
+
+    def progress(self, payload, done):
+        nevra = str(payload)
+        self.downloads[nevra] = done
+        self._update()
+
+    def start(self, total_files, total_size):
+        self.total_files = total_files
+        self.total_size = total_size
+
+
+class LoraxRpmCallback(dnf.callback.LoggingTransactionDisplay):
+    def __init__(self, queue):
+        super(LoraxRpmCallback, self).__init__()
+        self._queue = queue
+        self._last_ts = None
+        self.cnt = 0
+
+    def event(self, package, action, te_current, te_total, ts_current, ts_total):
+        if action == self.PKG_INSTALL and te_current == 0:
+            # do not report same package twice
+            if self._last_ts == ts_current:
+                return
+            self._last_ts = ts_current
+
+            msg = '(%d/%d) %s.%s' % \
+                (ts_current, ts_total, package.name, package.arch)
+            self.cnt += 1
+            self._queue.put(('install', msg))
+        elif action == self.TRANS_POST:
+            self._queue.put(('post', None))

src/pylorax/ltmpl.py

@@ -28,15 +28,18 @@ from os.path import basename, isdir
 from subprocess import CalledProcessError
 
 from pylorax.sysutils import joinpaths, cpfile, mvfile, replace, remove
-from pylorax.yumhelper import LoraxDownloadCallback, LoraxTransactionCallback, LoraxRpmCallback
+from pylorax.dnfhelper import LoraxDownloadCallback, LoraxRpmCallback
 from pylorax.base import DataHolder
 from pylorax.executils import runcmd, runcmd_output
 from pylorax.imgutils import mkcpio
+import pylorax.output as output
 
 from mako.lookup import TemplateLookup
 from mako.exceptions import text_error_template
 import sys, traceback
 import struct
+import dnf
+import multiprocessing
 
 class LoraxTemplate(object):
     def __init__(self, directories=None):
@@ -108,7 +111,7 @@ class LoraxTemplateRunner(object):
     This class parses and executes Lorax templates. Sample usage:
 
       # install a bunch of packages
-      runner = LoraxTemplateRunner(inroot=rundir, outroot=rundir, yum=yum_obj)
+      runner = LoraxTemplateRunner(inroot=rundir, outroot=rundir, dbo=dnf_obj)
       runner.run("install-packages.ltmpl")
 
       # modify a runtime dir
@@ -145,11 +148,11 @@ class LoraxTemplateRunner(object):
 
     * Commands should raise exceptions for errors - don't use sys.exit()
     '''
-    def __init__(self, inroot, outroot, yum=None, fatalerrors=True,
+    def __init__(self, inroot, outroot, dbo=None, fatalerrors=True,
                                         templatedir=None, defaults=None):
         self.inroot = inroot
         self.outroot = outroot
-        self.yum = yum
+        self.dbo = dbo
         self.fatalerrors = fatalerrors
         self.templatedir = templatedir or "/usr/share/lorax"
         self.templatefile = None
@@ -166,8 +169,14 @@ class LoraxTemplateRunner(object):
         return joinpaths(self.inroot, path)
 
     def _filelist(self, *pkgs):
-        pkglist = self.yum.doPackageLists(pkgnarrow="installed", patterns=pkgs)
-        return set([f for pkg in pkglist.installed for f in pkg.filelist+pkg.ghostlist])
+        """ Return the list of files in the packages """
+        pkglist = []
+        for pkg_glob in pkgs:
+            pkglist += list(self.dbo.sack.query().installed().filter(name__glob=pkg_glob))
+
+        # dnf/hawkey doesn't make any distinction between file, dir or ghost like yum did
+        # so only return the files.
+        return set(f for pkg in pkglist for f in pkg.files if not os.path.isdir(self._out(f)))
 
     def _getsize(self, *files):
         return sum(os.path.getsize(self._out(f)) for f in files if os.path.isfile(self._out(f)))
@@ -447,9 +456,9 @@ class LoraxTemplateRunner(object):
             cmd = cmd[1:]
 
         try:
-            output = runcmd_output(cmd, cwd=cwd)
-            if output:
-                logger.debug('command output:\n%s', output)
+            stdout = runcmd_output(cmd, cwd=cwd)
+            if stdout:
+                logger.debug('command output:\n%s', stdout)
             logger.debug("command finished successfully")
         except CalledProcessError as e:
             if e.output:
@@ -471,10 +480,10 @@ class LoraxTemplateRunner(object):
 
         for p in pkgs:
             try:
-                self.yum.install(pattern=p)
+                self.dbo.install(p)
             except Exception as e: # pylint: disable=broad-except
                 # FIXME: save exception and re-raise after the loop finishes
-                logger.error("installpkg %s failed: %s",p,str(e))
+                logger.error("installpkg %s failed: %s", p, str(e))
                 if required:
                     raise
 
@@ -501,19 +510,59 @@ class LoraxTemplateRunner(object):
           Actually install all the packages requested by previous 'installpkg'
           commands.
         '''
-        self.yum.buildTransaction()
-        dl_callback = LoraxDownloadCallback()
-        self.yum.repos.setProgressBar(dl_callback)
-        self.yum.processTransaction(callback=LoraxTransactionCallback(dl_callback),
-                                    rpmDisplay=LoraxRpmCallback())
 
-        # verify if all packages that were supposed to be installed,
-        # are really installed
-        errs = [t.po for t in self.yum.tsInfo if not self.yum.rpmdb.contains(po=t.po)]
-        for po in errs:
-            logger.error("package '%s' was not installed", po)
+        def do_transaction(base, queue):
+            try:
+                display = LoraxRpmCallback(queue)
+                base.do_transaction(display=display)
+            except BaseException as e:
+                logger.error("The transaction process has ended abruptly: %s", e)
+                queue.put(('quit', str(e)))
 
-        self.yum.closeRpmDB()
+        try:
+            logger.info("Checking dependencies")
+            self.dbo.resolve()
+        except dnf.exceptions.DepsolveError as e:
+            logger.error("Dependency check failed: %s", e)
+            raise
+        logger.info("%d packages selected", len(self.dbo.transaction))
+        if len(self.dbo.transaction) == 0:
+            raise Exception("No packages in transaction")
+
+        pkgs_to_download = self.dbo.transaction.install_set
+        logger.info("Downloading packages")
+        progress = LoraxDownloadCallback()
+        try:
+            self.dbo.download_packages(pkgs_to_download, progress)
+        except dnf.exceptions.DownloadError as e:
+            logger.error("Failed to download the following packages: %s", e)
+            raise
+
+        logger.info("Preparing transaction from installation source")
+        queue = multiprocessing.Queue()
+        msgout = output.LoraxOutput()
+        process = multiprocessing.Process(target=do_transaction, args=(self.dbo, queue))
+        process.start()
+        (token, msg) = queue.get()
+        while token not in ('post', 'quit'):
+            if token == 'install':
+                logging.info("%s", msg)
+                msgout.writeline(msg)
+            (token, msg) = queue.get()
+        if token == 'quit':
+            logger.error("Transaction failed.")
+            raise Exception("Transaction failed")
+
+        logger.info("Performing post-installation setup tasks")
+        process.join()
+
+        # Reset the package sack to pick up the installed packages
+        self.dbo.reset(repos=False)
+        self.dbo.fill_sack(load_system_repo=True, load_available_repos=False)
+
+        # At this point dnf should know about the installed files. Double check that it really does.
+        if len(self._filelist("anaconda-core")) == 0:
+            raise Exception("Failed to reset dbo to installed package set")
 
     def removefrom(self, pkg, *globs):
         '''

src/pylorax/treebuilder.py

@@ -67,27 +67,30 @@ def generate_module_info(moddir, outfile=None):
 
 class RuntimeBuilder(object):
     '''Builds the anaconda runtime image.'''
-    def __init__(self, product, arch, yum, templatedir=None,
+    def __init__(self, product, arch, dbo, templatedir=None,
                  installpkgs=None,
                  add_templates=None,
                  add_template_vars=None):
-        root = yum.conf.installroot
+        root = dbo.conf.installroot
         # use a copy of product so we can modify it locally
         product = product.copy()
         product.name = product.name.lower()
-        self.vars = DataHolder(arch=arch, product=product, yum=yum, root=root,
+        self.vars = DataHolder(arch=arch, product=product, dbo=dbo, root=root,
                                basearch=arch.basearch, libdir=arch.libdir)
-        self.yum = yum
+        self.dbo = dbo
         self._runner = LoraxTemplateRunner(inroot=root, outroot=root,
-                                           yum=yum, templatedir=templatedir)
+                                           dbo=dbo, templatedir=templatedir)
         self.add_templates = add_templates or []
         self.add_template_vars = add_template_vars or {}
         self._installpkgs = installpkgs or []
         self._runner.defaults = self.vars
+        self.dbo.reset()
 
     def _install_branding(self):
         release = None
-        for pkg in self.yum.whatProvides('/etc/system-release', None, None):
+        q = self.dbo.sack.query()
+        a = q.available()
+        for pkg in a.filter(provides='/etc/system-release'):
             if pkg.name.startswith('generic'):
                 continue
             else:
@@ -119,9 +122,10 @@ class RuntimeBuilder(object):
         '''debugging data: write out lists of package contents'''
         if not os.path.isdir(pkglistdir):
             os.makedirs(pkglistdir)
-        for pkgobj in self.yum.doPackageLists(pkgnarrow='installed').installed:
+        q = self.dbo.sack.query()
+        for pkgobj in q.installed():
             with open(joinpaths(pkglistdir, pkgobj.name), "w") as fobj:
-                for fname in pkgobj.filelist + pkgobj.dirlist:
+                for fname in pkgobj.files:
                     fobj.write("{0}\n".format(fname))
 
     def postinstall(self):
@@ -143,8 +147,9 @@ class RuntimeBuilder(object):
         '''debugging data: write a big list of pkg sizes'''
         fobj = open(pkgsizefile, "w")
         getsize = lambda f: os.lstat(f).st_size if os.path.exists(f) else 0
-        for p in sorted(self.yum.doPackageLists(pkgnarrow='installed').installed):
-            pkgsize = sum(getsize(joinpaths(self.vars.root,f)) for f in p.filelist)
+        q = self.dbo.sack.query()
+        for p in sorted(q.installed()):
+            pkgsize = sum(getsize(joinpaths(self.vars.root,f)) for f in p.files)
             fobj.write("{0.name}.{0.arch}: {1}\n".format(p, pkgsize))
 
     def generate_module_data(self):
@@ -169,6 +174,13 @@ class RuntimeBuilder(object):
         imgutils.mksquashfs(workdir, outfile, compression, compressargs)
         remove(workdir)
 
+    def finished(self):
+        """ Done using RuntimeBuilder
+
+        Close the dnf base object
+        """
+        self.dbo.close()
+
 class TreeBuilder(object):
     '''Builds the arch-specific boot images.
     inroot should be the installtree root (the newly-built runtime dir)'''

src/pylorax/yumhelper.py

@@ -1,127 +0,0 @@
-#
-# yumhelper.py
-#
-# Copyright (C) 2010-2014 Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Red Hat Author(s):  Martin Gracik <mgracik@redhat.com>
-#
-
-import logging
-logger = logging.getLogger("pylorax.yumhelper")
-import sys
-import yum, yum.callbacks, yum.rpmtrans
-import pylorax.output as output
-
-__all__ = ['LoraxDownloadCallback', 'LoraxTransactionCallback',
-           'LoraxRpmCallback']
-
-class LoraxDownloadCallback(yum.callbacks.DownloadBaseCallback):
-    def __init__(self):
-        yum.callbacks.DownloadBaseCallback.__init__(self)
-
-        self.pkgno = 0
-        self.total = 0
-
-        self.output = output.LoraxOutput()
-
-
-    def updateProgress(self, name, frac, fread, ftime):
-        """
-            Update the progress bar
-            @param name: filename
-            @param frac: progress fraction (0 -> 1)
-            @param fread: formated string containing BytesRead
-            @param ftime: formated string containing remaining or elapsed time
-        """
-        # Only update when it is finished downloading
-        if frac < 1:
-            return
-
-        self.pkgno += 1
-        info = "({0:3d}/{1:3d}) "
-        info = info.format(self.pkgno, self.total)
-
-        infolen, pkglen = len(info), len(name)
-        if (infolen + pkglen) > self.output.width:
-            name = "{0}...".format(name[:self.output.width-infolen-3])
-
-        msg = "{0}<b>{1}</b>\n".format(info, name)
-        self.output.write(msg)
-
-
-class LoraxTransactionCallback(object):
-
-    def __init__(self, dl_callback):
-        self.output = output.LoraxOutput()
-
-        self.dl_callback = dl_callback
-
-    def event(self, state, data=None):
-        if state == yum.callbacks.PT_DOWNLOAD:
-            self.output.write("downloading packages\n")
-        elif state == yum.callbacks.PT_DOWNLOAD_PKGS:
-            # Initialize the total number of packages being downloaded
-            self.dl_callback.total = len(data)
-        elif state == yum.callbacks.PT_GPGCHECK:
-            self.output.write("checking package signatures\n")
-        elif state == yum.callbacks.PT_TEST_TRANS:
-            self.output.write("running test transaction\n")
-        elif state == yum.callbacks.PT_TRANSACTION:
-            self.output.write("running transaction\n")
-
-
-class LoraxRpmCallback(yum.rpmtrans.RPMBaseCallback):
-
-    def __init__(self):
-        yum.rpmtrans.RPMBaseCallback.__init__(self)
-        self.output = output.LoraxOutput()
-
-    def event(self, package, action, te_current, te_total,
-              ts_current, ts_total):
-
-        action_str = self.action[action].encode("utf-8")
-        info = "({0:3d}/{1:3d}) [{2:3.0f}%] {3} "
-        info = info.format(ts_current, ts_total,
-                           float(te_current) / float(te_total) * 100,
-                           action_str.lower())
-
-        pkg = "{0}".format(package)
-
-        infolen, pkglen = len(info), len(pkg)
-        if (infolen + pkglen) > self.output.width:
-            pkg = "{0}...".format(pkg[:self.output.width-infolen-3])
-
-        msg = "{0}<b>{1}</b>".format(info, pkg)
-
-        # When not outputting to a tty we only want to print it once at the end
-        if sys.stdout.isatty():
-            self.output.write(msg + "\r")
-            if te_current == te_total:
-                self.output.write("\n")
-        elif te_current == te_total:
-            self.output.write(msg + "\n")
-
-
-    def filelog(self, package, action):
-        if self.fileaction.get(action) == "Installed":
-            logger.debug("{0} installed successfully".format(package))
-
-    def errorlog(self, msg):
-        logger.warning("RPM transaction error: %s", msg)
-
-    def scriptout(self, package, msgs):
-        if msgs:
-            logger.info("%s scriptlet output:\n%s", package, msgs)

src/sbin/lorax

@@ -25,20 +25,16 @@ import logging
 log = logging.getLogger("lorax")
 program_log = logging.getLogger("program")
 pylorax_log = logging.getLogger("pylorax")
-yum_log = logging.getLogger("yum")
+dnf_log = logging.getLogger("dnf")
 
 
 import sys
 import os
 import tempfile
 from optparse import OptionParser, OptionGroup
-import ConfigParser
 import shutil
 
-import yum
-# This is a bit of a hack to short circuit yum's internal logging
-# handler setup.  We already set one up so we don't need it to run.
-yum.logginglevels._added_handlers = True
+import dnf
 import pylorax
 
 def setup_logging(opts):
@@ -67,12 +63,12 @@ def setup_logging(opts):
     fh.setLevel(logging.DEBUG)
     program_log.addHandler(fh)
 
-    # yum logging
-    yum_log.setLevel(logging.DEBUG)
-    logfile = os.path.abspath(os.path.dirname(opts.logfile))+"/yum.log"
+    # dnf logging
+    dnf_log.setLevel(logging.DEBUG)
+    logfile = os.path.abspath(os.path.dirname(opts.logfile))+"/dnf.log"
     fh = logging.FileHandler(filename=logfile, mode="w")
     fh.setLevel(logging.DEBUG)
-    yum_log.addHandler(fh)
+    dnf_log.addHandler(fh)
 
 
 def main(args):
@@ -91,57 +87,60 @@ def main(args):
     # required arguments for image creation
     required = OptionGroup(parser, "required arguments")
     required.add_option("-p", "--product", help="product name",
-            metavar="STRING")
+                        metavar="STRING")
     required.add_option("-v", "--version", help="version identifier",
-            metavar="STRING")
+                        metavar="STRING")
     required.add_option("-r", "--release", help="release information",
-            metavar="STRING")
+                        metavar="STRING")
     required.add_option("-s", "--source",
-            help="source repository (may be listed multiple times)",
-            metavar="REPOSITORY", action="append", default=[])
+                        help="source repository (may be listed multiple times)",
+                        metavar="REPOSITORY", action="append", default=[])
 
     # optional arguments
     optional = OptionGroup(parser, "optional arguments")
     optional.add_option("-m", "--mirrorlist",
-            help="mirrorlist repository (may be listed multiple times)",
-            metavar="REPOSITORY", action="append", default=[])
+                        help="mirrorlist repository (may be listed multiple times)",
+                        metavar="REPOSITORY", action="append", default=[])
     optional.add_option("-t", "--variant",
-            help="variant name", metavar="STRING")
+                        help="variant name", metavar="STRING")
     optional.add_option("-b", "--bugurl",
-            help="bug reporting URL for the product", metavar="URL",
-            default="your distribution provided bug reporting tool")
+                        help="bug reporting URL for the product", metavar="URL",
+                        default="your distribution provided bug reporting tool")
     optional.add_option("--isfinal", help="",
-            action="store_true", default=False, dest="isfinal")
+                        action="store_true", default=False, dest="isfinal")
     optional.add_option("-c", "--config", default="/etc/lorax/lorax.conf",
-            help="config file", metavar="STRING")
+                        help="config file", metavar="STRING")
     optional.add_option("--proxy", default=None,
-            help="repo proxy url:port", metavar="STRING")
-    optional.add_option("-e", "--excludepkgs", default=[],
-            action="append", metavar="STRING",
-            help="package glob to exclude (may be listed multiple times)")
+                        help="repo proxy url:port", metavar="STRING")
     optional.add_option("-i", "--installpkgs", default=[],
-            action="append", metavar="STRING",
-            help="package glob to install before runtime-install.tmpl runs. (may be listed multiple times)")
+                        action="append", metavar="STRING",
+                        help="package glob to install before runtime-install.tmpl runs. (may be listed multiple times)")
     optional.add_option("--buildarch", default=None,
-            help="build architecture", metavar="STRING")
+                        help="build architecture", metavar="STRING")
     optional.add_option("--volid", default=None,
-            help="volume id", metavar="STRING")
+                        help="volume id", metavar="STRING")
     optional.add_option("--macboot", help="",
-            action="store_true", default=True, dest="domacboot")
+                        action="store_true", default=True, dest="domacboot")
     optional.add_option("--nomacboot", help="",
-            action="store_false", dest="domacboot")
+                        action="store_false", dest="domacboot")
     optional.add_option("--noupgrade", help="",
-            action="store_false", default=True, dest="doupgrade")
+                        action="store_false", default=True, dest="doupgrade")
     optional.add_option("--logfile", default="./lorax.log",
-            help="Path to logfile")
+                        help="Path to logfile")
     optional.add_option("--tmp", default="/var/tmp",
-            help="Top level temporary directory" )
+                        help="Top level temporary directory" )
+    optional.add_option("--cachedir", default=None,
+                        help="DNF cache directory. Default is a temporary dir.")
+    optional.add_option("--workdir", default=None,
+                        help="Work directory, overrides --tmp. Default is a temporary dir under /var/tmp")
+    optional.add_option("--force", default=False, action="store_true",
+                        help="Run even when the destination directory exists")
     optional.add_option("--add-template", dest="add_templates",
-            action="append", help="Additional template to execute",
-            default=[])
+                        action="append", help="Additional template to execute",
+                        default=[])
     optional.add_option("--add-template-var", dest="add_template_vars",
-            action="append", help="Set variable for additional templates",
-            default=[])
+                        action="append", help="Set variable for additional templates",
+                        default=[])
 
     # add the option groups to the parser
     parser.add_option_group(required)
@@ -149,7 +148,7 @@ def main(args):
 
     # add the show version option
     parser.add_option("-V", help="show program's version number and exit",
-            action="store_true", default=False, dest="showver")
+                      action="store_true", default=False, dest="showver")
 
     # parse the arguments
     opts, args = parser.parse_args()
@@ -168,30 +167,43 @@ def main(args):
             or not opts.source or not outputdir:
         parser.error("missing one or more required arguments")
 
-    if os.path.exists(outputdir):
-        parser.error("output directory should not exist.")
+    if not opts.force and os.path.exists(outputdir):
+        parser.error("output directory %s should not exist." % outputdir)
 
     opts.logfile = os.path.abspath(opts.logfile)
+    if not os.path.exists(os.path.dirname(opts.logfile)):
+        os.makedirs(os.path.dirname(opts.logfile))
+    if opts.cachedir:
+        opts.cachedir = os.path.abspath(opts.cachedir)
+    if opts.workdir:
+        opts.workdir = os.path.abspath(opts.workdir)
 
     setup_logging(opts)
 
-    tempfile.tempdir = opts.tmp
+    if not opts.workdir:
+        tempfile.tempdir = opts.tmp
 
-    # create the temporary directory for lorax
-    tempdir = tempfile.mkdtemp(prefix="lorax.", dir=tempfile.gettempdir())
+        # create the temporary directory for lorax
+        tempdir = tempfile.mkdtemp(prefix="lorax.", dir=tempfile.gettempdir())
+    else:
+        tempdir = opts.workdir
+        if not os.path.exists(tempdir):
+            os.makedirs(tempdir)
 
-    # create the yumbase object
     installtree = os.path.join(tempdir, "installtree")
-    os.mkdir(installtree)
-    yumtempdir = os.path.join(tempdir, "yum")
-    os.mkdir(yumtempdir)
+    if not os.path.exists(installtree):
+        os.mkdir(installtree)
+    dnftempdir = os.path.join(tempdir, "dnf")
+    if not os.path.exists(dnftempdir):
+        os.mkdir(dnftempdir)
 
-    yb = get_yum_base_object(installtree, opts.source, opts.mirrorlist,
-                             yumtempdir, opts.proxy, opts.excludepkgs)
+    dnfbase = get_dnf_base_object(installtree, opts.source, opts.mirrorlist,
+                                  dnftempdir, opts.proxy, opts.version, opts.cachedir)
 
-    if yb is None:
-        print("error: unable to create the yumbase object", file=sys.stderr)
-        shutil.rmtree(tempdir)
+    if dnfbase is None:
+        print("error: unable to create the dnf base object", file=sys.stderr)
+        if not opts.workdir:
+            shutil.rmtree(tempdir)
         sys.exit(1)
 
     parsed_add_template_vars = {}
@@ -204,7 +216,8 @@ def main(args):
     # run lorax
     lorax = pylorax.Lorax()
     lorax.configure(conf_file=opts.config)
-    lorax.run(yb, opts.product, opts.version, opts.release,
+    lorax.conf.set("lorax", "logdir", os.path.dirname(opts.logfile))
+    lorax.run(dnfbase, opts.product, opts.version, opts.release,
               opts.variant, opts.bugurl, opts.isfinal,
               workdir=tempdir, outputdir=outputdir, buildarch=opts.buildarch,
               volid=opts.volid, domacboot=opts.domacboot, doupgrade=opts.doupgrade,
@@ -214,9 +227,22 @@ def main(args):
               remove_temp=True)
 
 
-def get_yum_base_object(installroot, repositories, mirrorlists=None,
-                        tempdir="/var/tmp", proxy=None, excludepkgs=None):
+def get_dnf_base_object(installroot, repositories, mirrorlists=None,
+                        tempdir="/var/tmp", proxy=None, releasever="21",
+                        cachedir=None):
+    """ Create a dnf Base object and setup the repositories and installroot
 
+        :param string installroot: Full path to the installroot
+        :param list repositories: List of repositories to use for the installation
+        :param list mirrorlist: List of mirrors to use
+        :param string tempdir: Path of temporary directory
+        :param string proxy: http proxy to use when fetching packages
+        :param string releasever: Release version to pass to dnf
+        :param string cachedir: Directory to use for caching packages
+
+        If tempdir is not set /var/tmp is used.
+        If cachedir is None a dnf.cache directory is created inside tmpdir
+    """
     def sanitize_repo(repo):
         """Convert bare paths to file:/// URIs, and silently reject protocols unhandled by yum"""
         if repo.startswith("/"):
@@ -227,7 +253,6 @@ def get_yum_base_object(installroot, repositories, mirrorlists=None,
             return None
 
     mirrorlists = mirrorlists or []
-    excludepkgs = excludepkgs or []
 
     # sanitize the repositories
     repositories = map(sanitize_repo, repositories)
@@ -237,78 +262,77 @@ def get_yum_base_object(installroot, repositories, mirrorlists=None,
     repositories = filter(bool, repositories)
     mirrorlists = filter(bool, mirrorlists)
 
-    cachedir = os.path.join(tempdir, "yum.cache")
+    if not cachedir:
+        cachedir = os.path.join(tempdir, "dnf.cache")
     if not os.path.isdir(cachedir):
         os.mkdir(cachedir)
 
-    yumconf = os.path.join(tempdir, "yum.conf")
-    c = ConfigParser.ConfigParser()
+    logdir = os.path.join(tempdir, "dnf.logs")
+    if not os.path.isdir(logdir):
+        os.mkdir(logdir)
 
-    # add the main section
-    section = "main"
-    data = {"cachedir": cachedir,
-            "keepcache": 0,
-            "gpgcheck": 0,
-            "plugins": 0,
-            "reposdir": "",
-            "tsflags": "nodocs"}
+    dnfbase = dnf.Base()
+    conf = dnfbase.conf
+    conf.logdir = logdir
+    conf.cachedir = cachedir
+
+    # Turn off logging to the console
+    conf.debuglevel = 10
+    conf.errorlevel = 0
+    dnfbase.logging.setup_from_dnf_conf(conf)
+
+    conf.releasever = releasever
+    conf.installroot = installroot
+    conf.prepend_installroot('persistdir')
+    conf.tsflags.append('nodocs')
 
     if proxy:
-        data["proxy"] = proxy
+        conf.proxy = proxy
 
-    if excludepkgs:
-        data["exclude"] = " ".join(excludepkgs)
-
-    c.add_section(section)
-    map(lambda (key, value): c.set(section, key, value), data.items())
-
-    # add the main repository - the first repository from list
-    section = "lorax-repo"
-    data = {"name": "lorax repo",
-            "baseurl": repositories[0],
-            "enabled": 1}
-
-    c.add_section(section)
-    map(lambda (key, value): c.set(section, key, value), data.items())
-
-    # add the extra repositories
-    for n, extra in enumerate(repositories[1:], start=1):
-        section = "lorax-extra-repo-{0:d}".format(n)
-        data = {"name": "lorax extra repo {0:d}".format(n),
-                "baseurl": extra,
-                "enabled": 1}
-
-        c.add_section(section)
-        map(lambda (key, value): c.set(section, key, value), data.items())
+    # add the repositories
+    for i, r in enumerate(repositories):
+        if "SRPM" in r or "srpm" in r:
+            log.info("Skipping source repo: %s" % r)
+            continue
+        repo_name = "lorax-repo-%d" % i
+        repo = dnf.repo.Repo(repo_name, cachedir)
+        repo.baseurl = [r]
+        if proxy:
+            repo.proxy = proxy
+        repo.enable()
+        dnfbase.repos.add(repo)
+        log.info("Added '%s': %s", repo_name, r)
+        log.info("Fetching metadata...")
+        try:
+            repo.load()
+        except dnf.exceptions.RepoError as e:
+            log.error("Error fetching metadata for %s: %s", repo_name, e)
+            return None
 
     # add the mirrorlists
-    for n, mirror in enumerate(mirrorlists, start=1):
-        section = "lorax-mirrorlist-{0:d}".format(n)
-        data = {"name": "lorax mirrorlist {0:d}".format(n),
-                "mirrorlist": mirror,
-                "enabled": 1 }
+    for i, r in enumerate(mirrorlists):
+        if "SRPM" in r or "srpm" in r:
+            log.info("Skipping source repo: %s" % r)
+            continue
+        repo_name = "lorax-mirrorlist-%d" % i
+        repo = dnf.repo.Repo(repo_name, cachedir)
+        repo.mirrorlist = r
+        if proxy:
+            repo.proxy = proxy
+        repo.enable()
+        dnfbase.repos.add(repo)
+        log.info("Added '%s': %s", repo_name, r)
+        log.info("Fetching metadata...")
+        try:
+            repo.load()
+        except dnf.exceptions.RepoError as e:
+            log.error("Error fetching metadata for %s: %s", repo_name, e)
+            return None
 
-        c.add_section(section)
-        map(lambda (key, value): c.set(section, key, value), data.items())
+    dnfbase.fill_sack(load_system_repo=False)
+    dnfbase.read_comps()
 
-    # write the yum configuration file
-    with open(yumconf, "w") as f:
-        c.write(f)
-
-    # create the yum base object
-    yb = yum.YumBase()
-
-    yb.preconf.fn = yumconf
-    yb.preconf.root = installroot
-    #yb.repos.setCacheDir(cachedir)
-
-    # Turn on as much yum logging as we can
-    yb.preconf.debuglevel = 6
-    yb.preconf.errorlevel = 6
-    yb.logger.setLevel(logging.DEBUG)
-    yb.verbose_logger.setLevel(logging.DEBUG)
-
-    return yb
+    return dnfbase
 
 
 if __name__ == "__main__":