prepare calamares 2.4.2 with dracut luks support

3 files changed, 1997 insertions, 0 deletions

diff --git a/app-admin/calamares/Manifest b/app-admin/calamares/Manifest
index a584cfc5..251d3951 100644
--- a/app-admin/calamares/Manifest
+++ b/app-admin/calamares/Manifest
@@ -1,2 +1,3 @@
 DIST calamares-1.1.tar.gz 3641655 SHA256 db0b5f09d62f43c433ff53462dc35bd43bbc4fd618fa1aac081ebb05b570edee SHA512 5b67f99e8a13f0147d510ddef2f6ba90ec81e65526159643fe3a577f62030e7a466d9dfbad0fb7befa22e59074222dd5123565b871c90c2ed25f3547ca1bb582 WHIRLPOOL c9de81bcdff03d85c98438d00fa925216e3c50670eb7354e4574c499c8b49d8fbb77e99c5733e5a9e5d97e6c9a1b795fcdf35df0cad0002227fc8b051ffc2406
 DIST calamares-2.3.tar.gz 2029483 SHA256 c499a8a8ea1573c6f0323398fb092f8978958202e11c9d339202c35c73276f9f SHA512 be0b1e328ebd6bddab3a163bf38649fd4f64cfe74213946f00b0d05c76fba870662386328c0ccb7656dc63975a1b28058be7eda56b2cee792fba78443ab6d36e WHIRLPOOL aa1602aa06a4320f5a263c24e17c322bbdfcd83b7f11012e4b2cec895d6a18cdbf627d82f614ace60c62572374a9fb247216619fa0a4de207e3f8267bf51cd9e
+DIST calamares-2.4.2.tar.gz 2137039 SHA256 4620fd4e9c2d9868e6c20a5c600f123e91080f7ef3a7c6ea55314aa57841b96a SHA512 152857f256f15ff72c44087baf8d4d9d452c5692e131334dd429f40c0e212eac01178352fd17f4020a128f880d3a91dbd634500384d53752d4313a08de816112 WHIRLPOOL 1aa6919a461d5b02a43a4cdbd580a9e7fc9bdc3b048f467f082c4d053c83e5bae5f5777439870828d12153789aac2e4f3b4b6868732dd7c70b0baec3ad4d65c3
diff --git a/app-admin/calamares/calamares-2.4.2.ebuild b/app-admin/calamares/calamares-2.4.2.ebuild
new file mode 100644
index 00000000..bbe4dc24
--- /dev/null
+++ b/app-admin/calamares/calamares-2.4.2.ebuild
@@ -0,0 +1,78 @@
+# Copyright 1999-2015 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: $
+
+EAPI=5
+PYTHON_COMPAT=( python3_4 )
+
+inherit eutils cmake-utils python-r1
+
+SRC_URI="https://github.com/calamares/calamares/releases/download/v${PV}/${P}.tar.gz"
+
+DESCRIPTION="Distribution-independent installer framework"
+HOMEPAGE="http://calamares.io"
+
+LICENSE="GPL-3"
+SLOT="0"
+KEYWORDS="amd64"
+IUSE="+python"
+
+S="${WORKDIR}/${P}"
+
+DEPEND="
+	dev-vcs/git
+	python? (
+		>=dev-libs/boost-1.55.0-r2[python_targets_python3_4]
+	)
+	>=dev-qt/designer-5.6.0:5
+	>=dev-qt/linguist-tools-5.6.0:5
+	>=dev-qt/qtconcurrent-5.6.0:5
+	>=dev-qt/qtcore-5.6.0:5
+	>=dev-qt/qtdbus-5.6.0:5
+	>=dev-qt/qtdeclarative-5.6.0:5
+	>=dev-qt/qtgui-5.6.0:5
+	>=dev-qt/qtnetwork-5.6.0:5
+	>=dev-qt/qtopengl-5.6.0:5
+	>=dev-qt/qtprintsupport-5.6.0:5
+	>=dev-qt/qtscript-5.6.0:5
+	>=dev-qt/qtsvg-5.6.0:5
+	>=dev-qt/qttest-5.6.0:5
+	>=dev-qt/qtwebengine-5.6.0:5
+	>=dev-qt/qtwebchannel-5.6.0:5
+	>=dev-qt/qtwidgets-5.6.0:5
+	>=dev-qt/qtxml-5.6.0:5
+	>=dev-qt/qtxmlpatterns-5.6.0:5
+	>=dev-cpp/yaml-cpp-0.5.1
+	>=kde-frameworks/extra-cmake-modules-5.18.0
+	>=sys-libs/kpmcore-2.2.0"
+
+RDEPEND=">=app-misc/calamares-runtime-3.1[branding]"
+
+src_prepare() {
+	# patch dracut module to be called the way we want it, until the module becomes configurable
+	epatch ${FILESDIR}/${PN}-kogaion-dracut-call.patch
+	# calamares dracut luks patch
+	epatch ${FILESDIR}/${P}-dracut-luks-fde.patch
+	# replace calamares installer desktop icon
+	sed -i "s/Icon=calamares/Icon=start-here/g" "${S}/calamares.desktop"
+	# fix installer doesn't start from desktop launcher (IMPROVE THIS UGLY THINGY)
+	sed -i "s/pkexec //g" "${S}/calamares.desktop"
+	sed -i "s/calamares/calamares-pkexec/g" "${S}/calamares.desktop"
+	# If qtchooser is installed, it may break the build, because moc,rcc and uic binaries for wrong qt version may be used.
+	# Setting QT_SELECT environment variable will enforce correct binaries (fix taken from vlc ebuild)
+	export QT_SELECT=qt5
+}
+
+src_configure() {
+	local mycmakeargs=(
+		-DWITH_PARTITIONMANAGER=1
+	)
+	cmake-utils_src_configure
+}
+
+src_install() {
+	cmake-utils_src_install
+	insinto /usr/bin
+	insopts -m 755
+	doins ${FILESDIR}/calamares-pkexec
+}
diff --git a/app-admin/calamares/files/calamares-2.4.2-dracut-luks-fde.patch b/app-admin/calamares/files/calamares-2.4.2-dracut-luks-fde.patch
new file mode 100644
index 00000000..55669822
--- /dev/null
+++ b/app-admin/calamares/files/calamares-2.4.2-dracut-luks-fde.patch
@@ -0,0 +1,1918 @@
+From 03c7357dbcb70c047c0aac0a2566c50aaaed1168 Mon Sep 17 00:00:00 2001
+From: Kevin Kofler <kevin.kofler@chello.at>
+Date: Sun, 25 Sep 2016 03:20:50 +0200
+Subject: [PATCH] Add support for LUKS full disk encryption with dracut.
+
+Add support for C++/Qt batch job plugins
+
+These job plugins work similarly to view modules, with the following
+differences:
+
+* These jobs need to link only libcalamares, not libcalamaresui. For
+  this reason, PluginFactory was moved from libcalamaresui to
+  libcalamares. (It depends only on QtCore.)
+
+* Instead of deriving from ViewModule, derive from CppJob (which is a
+  subclass of Job).
+
+* Like process and Python jobs, a job plugin is a single job, whereas a
+  ViewModule can generate a whole list of jobs.
+
+The CppJob and CppJobModule classes are new. In Module::fromDescriptor,
+the combination type=job, intf=qtplugin is now supported and mapped to
+CppJobModule.
+
+[fstab] Do not omit "/" from crypttab.
+
+At least the Debian update-initramfs needs the entry to be there (see
+pull request #254). Dracut will probably need it too. And logically, it
+should be there.
+
+[fstab] Write configurable options to crypttab (default: luks).
+
+fstab.conf: Add a new "crypttabOptions" option that defaults to "luks".
+            Document that for Debian and Debian-based distributions, the
+            setting should be changed to "luks,keyscript=/bin/cat".
+
+main.py: Append the options from the above setting to the end of every
+         line in crypttab.
+
+At least the "luks" option should always be there, because there may be
+different encryption types. The Debian initramfs-tools also require the
+Debian-specific keyscript option and will otherwise ignore the keyfile
+entirely (see pull request #254).
+
+[dracutlukscfg] New module: pre-configuration for dracut+LUKS.
+
+Add a dracutlukscfg module to write a
+/etc/dracut.conf.d/calamares-luks.conf file for LUKS full disk
+encryption support with Dracut.
+
+You should run:
+
+* partition
+* luksbootkeyfile
+* dracutlukscfg
+* dracut
+
+in that order (not necessarily in immediate sequence). The
+luksopenswaphook module is not used with Dracut.
+---
+ settings.conf                                    |   1 +
+ src/libcalamares/CMakeLists.txt                  |   2 +
+ src/libcalamares/CppJob.cpp                      |  45 +++
+ src/libcalamares/CppJob.h                        |  51 ++++
+ src/libcalamares/utils/PluginFactory.cpp         | 123 ++++++++
+ src/libcalamares/utils/PluginFactory.h           | 370 +++++++++++++++++++++++
+ src/libcalamares/utils/PluginFactory_p.h         |  54 ++++
+ src/libcalamaresui/CMakeLists.txt                |   3 +-
+ src/libcalamaresui/modulesystem/CppJobModule.cpp | 128 ++++++++
+ src/libcalamaresui/modulesystem/CppJobModule.h   |  53 ++++
+ src/libcalamaresui/modulesystem/Module.cpp       |   7 +-
+ src/libcalamaresui/utils/PluginFactory.cpp       | 123 --------
+ src/libcalamaresui/utils/PluginFactory.h         | 370 -----------------------
+ src/libcalamaresui/utils/PluginFactory_p.h       |  54 ----
+ src/modules/dracutlukscfg/CMakeLists.txt         |   9 +
+ src/modules/dracutlukscfg/DracutLuksCfgJob.cpp   | 143 +++++++++
+ src/modules/dracutlukscfg/DracutLuksCfgJob.h     |  56 ++++
+ src/modules/dracutlukscfg/module.desc            |   7 +
+ src/modules/fstab/fstab.conf                     |   3 +
+ src/modules/fstab/main.py                        |  21 +-
+ 20 files changed, 1064 insertions(+), 559 deletions(-)
+ create mode 100644 src/libcalamares/CppJob.cpp
+ create mode 100644 src/libcalamares/CppJob.h
+ create mode 100644 src/libcalamares/utils/PluginFactory.cpp
+ create mode 100644 src/libcalamares/utils/PluginFactory.h
+ create mode 100644 src/libcalamares/utils/PluginFactory_p.h
+ create mode 100644 src/libcalamaresui/modulesystem/CppJobModule.cpp
+ create mode 100644 src/libcalamaresui/modulesystem/CppJobModule.h
+ delete mode 100644 src/libcalamaresui/utils/PluginFactory.cpp
+ delete mode 100644 src/libcalamaresui/utils/PluginFactory.h
+ delete mode 100644 src/libcalamaresui/utils/PluginFactory_p.h
+ create mode 100644 src/modules/dracutlukscfg/CMakeLists.txt
+ create mode 100644 src/modules/dracutlukscfg/DracutLuksCfgJob.cpp
+ create mode 100644 src/modules/dracutlukscfg/DracutLuksCfgJob.h
+ create mode 100644 src/modules/dracutlukscfg/module.desc
+
+diff --git a/settings.conf b/settings.conf
+index 0721098..d4439a7 100644
+--- a/settings.conf
++++ b/settings.conf
+@@ -79,6 +79,7 @@ sequence:
+   - localecfg
+ #  - luksbootkeyfile
+ #  - luksopenswaphookcfg
++#  - dracutlukscfg
+   - initcpiocfg
+   - initcpio
+   - users
+diff --git a/src/libcalamares/CMakeLists.txt b/src/libcalamares/CMakeLists.txt
+index 966ca9c..b1f6c48 100644
+--- a/src/libcalamares/CMakeLists.txt
++++ b/src/libcalamares/CMakeLists.txt
+@@ -11,6 +11,7 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/../calamares/CalamaresVersion.h.in
+                 ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersion.h )
+ 
+ set( libSources
++    CppJob.cpp
+     GlobalStorage.cpp
+     Job.cpp
+     JobQueue.cpp
+@@ -24,6 +25,7 @@ set( libSources
+     utils/CalamaresUtils.cpp
+     utils/CalamaresUtilsSystem.cpp
+     utils/Logger.cpp
++    utils/PluginFactory.cpp
+     utils/Retranslator.cpp
+ )
+ 
+diff --git a/src/libcalamares/CppJob.cpp b/src/libcalamares/CppJob.cpp
+new file mode 100644
+index 0000000..1925e39
+--- /dev/null
++++ b/src/libcalamares/CppJob.cpp
+@@ -0,0 +1,45 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2014, Teo Mrnjavac <teo@kde.org>
++ *   Copyright 2016, Kevin Kofler <kevin.kofler@chello.at>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "CppJob.h"
++
++namespace Calamares
++{
++
++CppJob::CppJob( QObject* parent )
++    : Job( parent )
++{}
++
++
++CppJob::~CppJob()
++{}
++
++
++void
++CppJob::setModuleInstanceKey( const QString& instanceKey )
++{
++    m_instanceKey = instanceKey;
++}
++
++
++void
++CppJob::setConfigurationMap( const QVariantMap& configurationMap )
++{}
++
++}
+diff --git a/src/libcalamares/CppJob.h b/src/libcalamares/CppJob.h
+new file mode 100644
+index 0000000..a6e6735
+--- /dev/null
++++ b/src/libcalamares/CppJob.h
+@@ -0,0 +1,51 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2014-2015, Teo Mrnjavac <teo@kde.org>
++ *   Copyright 2016, Kevin Kofler <kevin.kofler@chello.at>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef CALAMARES_CPPJOB_H
++#define CALAMARES_CPPJOB_H
++
++#include <QObject>
++#include <QVariant>
++
++#include "DllMacro.h"
++#include "Typedefs.h"
++#include "Job.h"
++
++namespace Calamares
++{
++
++class DLLEXPORT CppJob : public Job
++{
++    Q_OBJECT
++public:
++    explicit CppJob( QObject* parent = nullptr );
++    virtual ~CppJob();
++
++    void setModuleInstanceKey( const QString& instanceKey );
++    QString moduleInstanceKey() const { return m_instanceKey; }
++
++    virtual void setConfigurationMap( const QVariantMap& configurationMap );
++
++protected:
++    QString m_instanceKey;
++};
++
++}
++
++#endif // CALAMARES_CPPJOB_H
+diff --git a/src/libcalamares/utils/PluginFactory.cpp b/src/libcalamares/utils/PluginFactory.cpp
+new file mode 100644
+index 0000000..30a5bf4
+--- /dev/null
++++ b/src/libcalamares/utils/PluginFactory.cpp
+@@ -0,0 +1,123 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
++ *
++ *   Based on KPluginFactory from KCoreAddons, KDE project
++ *   Copyright 2007, Matthias Kretz <kretz@kde.org>
++ *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "PluginFactory.h"
++#include "PluginFactory_p.h"
++
++#include <QObjectCleanupHandler>
++#include <QDebug>
++
++Q_GLOBAL_STATIC(QObjectCleanupHandler, factorycleanup)
++
++extern int kLibraryDebugArea();
++
++namespace Calamares
++{
++
++PluginFactory::PluginFactory()
++    : d_ptr(new PluginFactoryPrivate)
++{
++    Q_D(PluginFactory);
++    d->q_ptr = this;
++
++    factorycleanup()->add(this);
++}
++
++PluginFactory::PluginFactory(PluginFactoryPrivate &d)
++    : d_ptr(&d)
++{
++    factorycleanup()->add(this);
++}
++
++PluginFactory::~PluginFactory()
++{
++    delete d_ptr;
++}
++
++void PluginFactory::doRegisterPlugin(const QString &keyword, const QMetaObject *metaObject, CreateInstanceFunction instanceFunction)
++{
++    Q_D(PluginFactory);
++
++    Q_ASSERT(metaObject);
++
++    // we allow different interfaces to be registered without keyword
++    if (!keyword.isEmpty()) {
++        if (d->createInstanceHash.contains(keyword)) {
++            qWarning() << "A plugin with the keyword" << keyword << "was already registered. A keyword must be unique!";
++        }
++        d->createInstanceHash.insert(keyword, PluginFactoryPrivate::Plugin(metaObject, instanceFunction));
++    } else {
++        const QList<PluginFactoryPrivate::Plugin> clashes(d->createInstanceHash.values(keyword));
++        const QMetaObject *superClass = metaObject->superClass();
++        if (superClass) {
++            for (const PluginFactoryPrivate::Plugin &plugin : clashes) {
++                for (const QMetaObject *otherSuper = plugin.first->superClass(); otherSuper;
++                        otherSuper = otherSuper->superClass()) {
++                    if (superClass == otherSuper) {
++                        qWarning() << "Two plugins with the same interface(" << superClass->className() << ") were registered. Use keywords to identify the plugins.";
++                    }
++                }
++            }
++        }
++        for (const PluginFactoryPrivate::Plugin &plugin : clashes) {
++            superClass = plugin.first->superClass();
++            if (superClass) {
++                for (const QMetaObject *otherSuper = metaObject->superClass(); otherSuper;
++                        otherSuper = otherSuper->superClass()) {
++                    if (superClass == otherSuper) {
++                        qWarning() << "Two plugins with the same interface(" << superClass->className() << ") were registered. Use keywords to identify the plugins.";
++                    }
++                }
++            }
++        }
++        d->createInstanceHash.insertMulti(keyword, PluginFactoryPrivate::Plugin(metaObject, instanceFunction));
++    }
++}
++
++QObject *PluginFactory::create(const char *iface, QWidget *parentWidget, QObject *parent, const QString &keyword)
++{
++    Q_D(PluginFactory);
++
++    QObject *obj = 0;
++
++    const QList<PluginFactoryPrivate::Plugin> candidates(d->createInstanceHash.values(keyword));
++    // for !keyword.isEmpty() candidates.count() is 0 or 1
++
++    for (const PluginFactoryPrivate::Plugin &plugin : candidates) {
++        for (const QMetaObject *current = plugin.first; current; current = current->superClass()) {
++            if (0 == qstrcmp(iface, current->className())) {
++                if (obj) {
++                    qWarning() << "ambiguous interface requested from a DSO containing more than one plugin";
++                }
++                obj = plugin.second(parentWidget, parent);
++                break;
++            }
++        }
++    }
++
++    if (obj) {
++        emit objectCreated(obj);
++    }
++    return obj;
++}
++
++}
+diff --git a/src/libcalamares/utils/PluginFactory.h b/src/libcalamares/utils/PluginFactory.h
+new file mode 100644
+index 0000000..c0053ba
+--- /dev/null
++++ b/src/libcalamares/utils/PluginFactory.h
+@@ -0,0 +1,370 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
++ *
++ *   Based on KPluginFactory from KCoreAddons, KDE project
++ *   Copyright 2007, Matthias Kretz <kretz@kde.org>
++ *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef CALAMARESPLUGINFACTORY_H
++#define CALAMARESPLUGINFACTORY_H
++
++#include "DllMacro.h"
++
++#include <QtCore/QObject>
++#include <QtCore/QVariant>
++#include <QtCore/QStringList>
++
++namespace Calamares
++{
++class PluginFactoryPrivate;
++}
++
++#define CalamaresPluginFactory_iid "io.calamares.PluginFactory"
++
++#define CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY_SKEL(name, baseFactory, ...) \
++    class name : public Calamares::PluginFactory \
++    { \
++        Q_OBJECT \
++        Q_INTERFACES(Calamares::PluginFactory) \
++        __VA_ARGS__ \
++    public: \
++        explicit name(); \
++        ~name(); \
++    private: \
++        void init(); \
++    };
++
++#define CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, baseFactory) \
++    CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY_SKEL(name, baseFactory, Q_PLUGIN_METADATA(IID CalamaresPluginFactory_iid))
++
++#define CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations) \
++    name::name() \
++    { \
++        pluginRegistrations \
++    } \
++    name::~name() {}
++
++#define CALAMARES_PLUGIN_FACTORY_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations) \
++    CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, baseFactory) \
++    CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations)
++
++#define CALAMARES_PLUGIN_FACTORY_DECLARATION(name) CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, Calamares::PluginFactory)
++#define CALAMARES_PLUGIN_FACTORY_DEFINITION(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
++
++/**
++ * \relates PluginFactory
++ *
++ * Create a PluginFactory subclass and export it as the root plugin object.
++ *
++ * \param name The name of the PluginFactory derived class.
++ *
++ * \param pluginRegistrations Code to be inserted into the constructor of the
++ * class. Usually a series of registerPlugin() calls.
++ *
++ * Example:
++ * \code
++ * #include <PluginFactory.h>
++ * #include <plugininterface.h>
++ *
++ * class MyPlugin : public PluginInterface
++ * {
++ * public:
++ *     MyPlugin(QObject *parent, const QVariantList &args)
++ *         : PluginInterface(parent)
++ *     {}
++ * };
++ *
++ * CALAMARES_PLUGIN_FACTORY(MyPluginFactory,
++ *                  registerPlugin<MyPlugin>();
++ *                 )
++ *
++ * #include <myplugin.moc>
++ * \endcode
++ *
++ * \see CALAMARES_PLUGIN_FACTORY_DECLARATION
++ * \see CALAMARES_PLUGIN_FACTORY_DEFINITION
++ */
++#define CALAMARES_PLUGIN_FACTORY(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
++
++/**
++ * \relates PluginFactory
++ *
++ * CALAMARES_PLUGIN_FACTORY_DECLARATION declares the PluginFactory subclass. This macro
++ * can be used in a header file.
++ *
++ * \param name The name of the PluginFactory derived class.
++ *
++ * \see CALAMARES_PLUGIN_FACTORY
++ * \see CALAMARES_PLUGIN_FACTORY_DEFINITION
++ */
++#define CALAMARES_PLUGIN_FACTORY_DECLARATION(name) CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, Calamares::PluginFactory)
++
++/**
++ * \relates PluginFactory
++ * CALAMARES_PLUGIN_FACTORY_DEFINITION defines the PluginFactory subclass. This macro
++ * can <b>not</b> be used in a header file.
++ *
++ * \param name The name of the PluginFactory derived class.
++ *
++ * \param pluginRegistrations Code to be inserted into the constructor of the
++ * class. Usually a series of registerPlugin() calls.
++ *
++ * \see CALAMARES_PLUGIN_FACTORY
++ * \see CALAMARES_PLUGIN_FACTORY_DECLARATION
++ */
++#define CALAMARES_PLUGIN_FACTORY_DEFINITION(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
++
++namespace Calamares
++{
++
++/**
++ * \class PluginFactory PluginFactory.h <PluginFactory.h>
++ *
++ * PluginFactory provides a convenient way to provide factory-style plugins.
++ * Qt plugins provide a singleton object, but a common pattern is for plugins
++ * to generate as many objects of a particular type as the application requires.
++ * By using PluginFactory, you can avoid implementing the factory pattern
++ * yourself.
++ *
++ * PluginFactory also allows plugins to provide multiple different object
++ * types, indexed by keywords.
++ *
++ * The objects created by PluginFactory must inherit QObject, and must have a
++ * standard constructor pattern:
++ * \li if the object is a KPart::Part, it must be of the form
++ * \code
++ * T(QWidget *parentWidget, QObject *parent, const QVariantList &args)
++ * \endcode
++ * \li if it is a QWidget, it must be of the form
++ * \code
++ * T(QWidget *parent, const QVariantList &args)
++ * \endcode
++ * \li otherwise it must be of the form
++ * \code
++ * T(QObject *parent, const QVariantList &args)
++ * \endcode
++ *
++ * You should typically use either CALAMARES_PLUGIN_FACTORY() or
++ * CALAMARES_PLUGIN_FACTORY_WITH_JSON() in your plugin code to create the factory.  The
++ * typical pattern is
++ *
++ * \code
++ * #include <PluginFactory.h>
++ * #include <plugininterface.h>
++ *
++ * class MyPlugin : public PluginInterface
++ * {
++ * public:
++ *     MyPlugin(QObject *parent, const QVariantList &args)
++ *         : PluginInterface(parent)
++ *     {}
++ * };
++ *
++ * CALAMARES_PLUGIN_FACTORY(MyPluginFactory,
++ *                  registerPlugin<MyPlugin>();
++ *                 )
++ * #include <myplugin.moc>
++ * \endcode
++ *
++ * If you want to load a library use KPluginLoader.
++ * The application that wants to instantiate plugin classes can do the following:
++ * \code
++ * PluginFactory *factory = KPluginLoader("libraryname").factory();
++ * if (factory) {
++ *     PluginInterface *p1 = factory->create<PluginInterface>(parent);
++ *     OtherInterface *p2  = factory->create<OtherInterface>(parent);
++ *     NextInterface *p3   = factory->create<NextInterface>("keyword1", parent);
++ *     NextInterface *p3   = factory->create<NextInterface>("keyword2", parent);
++ * }
++ * \endcode
++ *
++ * \author Matthias Kretz <kretz@kde.org>
++ * \author Bernhard Loos <nhuh.put@web.de>
++ */
++class DLLEXPORT PluginFactory : public QObject
++{
++    Q_OBJECT
++    Q_DECLARE_PRIVATE(PluginFactory)
++public:
++    /**
++     * This constructor creates a factory for a plugin.
++     */
++    explicit PluginFactory();
++
++    /**
++     * This destroys the PluginFactory.
++     */
++    virtual ~PluginFactory();
++
++    /**
++     * Use this method to create an object. It will try to create an object which inherits
++     * \p T. If it has multiple choices, you will get a fatal error (kFatal()), so be careful
++     * to request a unique interface or use keywords.
++     *
++     * \tparam T The interface for which an object should be created. The object will inherit \p T.
++     * \param parent The parent of the object. If \p parent is a widget type, it will also passed
++     *               to the parentWidget argument of the CreateInstanceFunction for the object.
++     * \returns A pointer to the created object is returned, or 0 if an error occurred.
++     */
++    template<typename T>
++    T *create(QObject *parent = 0);
++
++    /**
++     * Use this method to create an object. It will try to create an object which inherits
++     * \p T and was registered with \p keyword.
++     *
++     * \tparam T The interface for which an object should be created. The object will inherit \p T.
++     * \param keyword The keyword of the object.
++     * \param parent The parent of the object. If \p parent is a widget type, it will also passed
++     *               to the parentWidget argument of the CreateInstanceFunction for the object.
++     * \returns A pointer to the created object is returned, or 0 if an error occurred.
++     */
++    template<typename T>
++    T *create(const QString &keyword, QObject *parent = 0);
++
++Q_SIGNALS:
++    void objectCreated(QObject *object);
++
++protected:
++    /**
++     * Function pointer type to a function that instantiates a plugin.
++     */
++    typedef QObject *(*CreateInstanceFunction)(QWidget *, QObject *);
++
++    /**
++     * This is used to detect the arguments need for the constructor of plugin classes.
++     * You can inherit it, if you want to add new classes and still keep support for the old ones.
++     */
++    template<class impl>
++    struct InheritanceChecker {
++        CreateInstanceFunction createInstanceFunction(QWidget *)
++        {
++            return &createInstance<impl, QWidget>;
++        }
++        CreateInstanceFunction createInstanceFunction(...)
++        {
++            return &createInstance<impl, QObject>;
++        }
++    };
++
++    explicit PluginFactory(PluginFactoryPrivate &dd);
++
++    /**
++     * Registers a plugin with the factory. Call this function from the constructor of the
++     * PluginFactory subclass to make the create function able to instantiate the plugin when asked
++     * for an interface the plugin implements.
++     *
++     * \tparam T the name of the plugin class
++     *
++     * \param keyword An optional keyword as unique identifier for the plugin. This allows you to
++     * put more than one plugin with the same interface into the same library using the same
++     * factory. X-KDE-PluginKeyword is a convenient way to specify the keyword in a desktop file.
++     *
++     * \param instanceFunction A function pointer to a function that creates an instance of the
++     * plugin. The default function that will be used depends on the type of interface. If the
++     * interface inherits from
++     * \li \c KParts::Part the function will call
++     * \code
++     * new T(QWidget *parentWidget, QObject *parent)
++     * \endcode
++     * \li \c QWidget the function will call
++     * \code
++     * new T(QWidget *parent)
++     * \endcode
++     * \li else the function will call
++     * \code
++     * new T(QObject *parent)
++     * \endcode
++     */
++    template<class T>
++    void registerPlugin(const QString &keyword = QString(),
++                        CreateInstanceFunction instanceFunction
++                        = InheritanceChecker<T>().createInstanceFunction(reinterpret_cast<T *>(0)))
++    {
++        doRegisterPlugin(keyword, &T::staticMetaObject, instanceFunction);
++    }
++
++    PluginFactoryPrivate *const d_ptr;
++
++    /**
++     * This function is called when the factory asked to create an Object.
++     *
++     * You may reimplement it to provide a very flexible factory. This is especially useful to
++     * provide generic factories for plugins implemeted using a scripting language.
++     *
++     * \param iface The staticMetaObject::className() string identifying the plugin interface that
++     * was requested. E.g. for KCModule plugins this string will be "KCModule".
++     * \param parentWidget Only used if the requested plugin is a KPart.
++     * \param parent The parent object for the plugin object.
++     * \param args A plugin specific list of arbitrary arguments.
++     * \param keyword A string that uniquely identifies the plugin. If a KService is used this
++     * keyword is read from the X-KDE-PluginKeyword entry in the .desktop file.
++     */
++    virtual QObject *create(const char *iface, QWidget *parentWidget, QObject *parent, const QString &keyword);
++
++    template<class impl, class ParentType>
++    static QObject *createInstance(QWidget *parentWidget, QObject *parent)
++    {
++        Q_UNUSED(parentWidget);
++        ParentType *p = 0;
++        if (parent) {
++            p = qobject_cast<ParentType *>(parent);
++            Q_ASSERT(p);
++        }
++        return new impl(p);
++    }
++
++private:
++    void doRegisterPlugin(const QString &keyword, const QMetaObject *metaObject, CreateInstanceFunction instanceFunction);
++};
++
++template<typename T>
++inline T *PluginFactory::create(QObject *parent)
++{
++    QObject *o = create(T::staticMetaObject.className(),
++                        parent && parent->isWidgetType() ? reinterpret_cast<QWidget *>(parent) : 0,
++                        parent,
++                        QString());
++
++    T *t = qobject_cast<T *>(o);
++    if (!t) {
++        delete o;
++    }
++    return t;
++}
++
++template<typename T>
++inline T *PluginFactory::create(const QString &keyword, QObject *parent)
++{
++    QObject *o = create(T::staticMetaObject.className(),
++                        parent && parent->isWidgetType() ? reinterpret_cast<QWidget *>(parent) : 0,
++                        parent,
++                        keyword);
++
++    T *t = qobject_cast<T *>(o);
++    if (!t) {
++        delete o;
++    }
++    return t;
++}
++
++}
++
++Q_DECLARE_INTERFACE(Calamares::PluginFactory, CalamaresPluginFactory_iid)
++
++#endif // CALAMARESPLUGINFACTORY_H
+diff --git a/src/libcalamares/utils/PluginFactory_p.h b/src/libcalamares/utils/PluginFactory_p.h
+new file mode 100644
+index 0000000..a0b4a1c
+--- /dev/null
++++ b/src/libcalamares/utils/PluginFactory_p.h
+@@ -0,0 +1,54 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
++ *
++ *   Based on KPluginFactory from KCoreAddons, KDE project
++ *   Copyright 2007, Matthias Kretz <kretz@kde.org>
++ *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef CALAMARESPLUGINFACTORY_P_H
++#define CALAMARESPLUGINFACTORY_P_H
++
++#include "PluginFactory.h"
++
++#include <QtCore/QHash>
++
++namespace Calamares
++{
++
++class PluginFactoryPrivate
++{
++    Q_DECLARE_PUBLIC(PluginFactory)
++protected:
++    typedef QPair<const QMetaObject *, PluginFactory::CreateInstanceFunction> Plugin;
++
++    PluginFactoryPrivate()
++        : catalogInitialized( false )
++        , q_ptr( nullptr )
++    {}
++    ~PluginFactoryPrivate() {}
++
++    QHash<QString, Plugin> createInstanceHash;
++    QString catalogName;
++    bool catalogInitialized;
++
++    PluginFactory *q_ptr;
++};
++
++}
++
++#endif // CALAMARESPLUGINFACTORY_P_H
+diff --git a/src/libcalamaresui/CMakeLists.txt b/src/libcalamaresui/CMakeLists.txt
+index 939d05a..478034b 100644
+--- a/src/libcalamaresui/CMakeLists.txt
++++ b/src/libcalamaresui/CMakeLists.txt
+@@ -1,6 +1,7 @@
+ set( CALAMARESUI_LIBRARY_TARGET calamaresui )
+ 
+ list( APPEND ${CALAMARESUI_LIBRARY_TARGET}_SOURCES
++    modulesystem/CppJobModule.cpp
+     modulesystem/Module.cpp
+     modulesystem/ModuleManager.cpp
+     modulesystem/ProcessJobModule.cpp
+@@ -14,8 +15,6 @@ list( APPEND ${CALAMARESUI_LIBRARY_TARGET}_SOURCES
+     utils/qjsonmodel.cpp
+     utils/qjsonitem.cpp
+ 
+-    utils/PluginFactory.cpp
+-
+     viewpages/AbstractPage.cpp
+     viewpages/ViewStep.cpp
+ 
+diff --git a/src/libcalamaresui/modulesystem/CppJobModule.cpp b/src/libcalamaresui/modulesystem/CppJobModule.cpp
+new file mode 100644
+index 0000000..15e41c2
+--- /dev/null
++++ b/src/libcalamaresui/modulesystem/CppJobModule.cpp
+@@ -0,0 +1,128 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2014, Teo Mrnjavac <teo@kde.org>
++ *   Copyright 2016, Kevin Kofler <kevin.kofler@chello.at>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "CppJobModule.h"
++
++#include "utils/PluginFactory.h"
++#include "utils/Logger.h"
++#include "CppJob.h"
++
++#include <QDir>
++#include <QPluginLoader>
++
++namespace Calamares {
++
++
++Module::Type
++CppJobModule::type() const
++{
++    return Job;
++}
++
++
++Module::Interface
++CppJobModule::interface() const
++{
++    return QtPlugin;
++}
++
++
++void
++CppJobModule::loadSelf()
++{
++    if ( m_loader )
++    {
++        PluginFactory* pf = qobject_cast< PluginFactory* >( m_loader->instance() );
++        if ( !pf )
++        {
++            cDebug() << Q_FUNC_INFO << m_loader->errorString();
++            return;
++        }
++
++        CppJob *cppJob = pf->create< Calamares::CppJob >();
++        if ( !cppJob )
++        {
++            cDebug() << Q_FUNC_INFO << m_loader->errorString();
++            return;
++        }
++//        cDebug() << "CppJobModule loading self for instance" << instanceKey()
++//                 << "\nCppJobModule at address" << this
++//                 << "\nCalamares::PluginFactory at address" << pf
++//                 << "\nCppJob at address" << cppJob;
++
++        cppJob->setModuleInstanceKey( instanceKey() );
++        cppJob->setConfigurationMap( m_configurationMap );
++        m_job = Calamares::job_ptr( static_cast< Calamares::Job * >( cppJob ) );
++        m_loaded = true;
++        cDebug() << "CppJobModule" << instanceKey() << "loading complete.";
++    }
++}
++
++
++QList< job_ptr >
++CppJobModule::jobs() const
++{
++    return QList< job_ptr >() << m_job;
++}
++
++
++void
++CppJobModule::initFrom( const QVariantMap& moduleDescriptor )
++{
++    Module::initFrom( moduleDescriptor );
++    QDir directory( location() );
++    QString load;
++    if ( !moduleDescriptor.value( "load" ).toString().isEmpty() )
++    {
++        load = moduleDescriptor.value( "load" ).toString();
++        load = directory.absoluteFilePath( load );
++    }
++    // If a load path is not specified, we look for a plugin to load in the directory.
++    if ( load.isEmpty() || !QLibrary::isLibrary( load ) )
++    {
++        const QStringList ls = directory.entryList( QStringList{ "*.so" } );
++        if ( !ls.isEmpty() )
++        {
++            for ( QString entry : ls )
++            {
++                entry = directory.absoluteFilePath( entry );
++                if ( QLibrary::isLibrary( entry ) )
++                {
++                    load = entry;
++                    break;
++                }
++            }
++        }
++    }
++
++    m_loader = new QPluginLoader( load );
++}
++
++CppJobModule::CppJobModule()
++    : Module()
++    , m_loader( nullptr )
++{
++}
++
++CppJobModule::~CppJobModule()
++{
++    delete m_loader;
++}
++
++} // namespace Calamares
+diff --git a/src/libcalamaresui/modulesystem/CppJobModule.h b/src/libcalamaresui/modulesystem/CppJobModule.h
+new file mode 100644
+index 0000000..127614e
+--- /dev/null
++++ b/src/libcalamaresui/modulesystem/CppJobModule.h
+@@ -0,0 +1,53 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2014, Teo Mrnjavac <teo@kde.org>
++ *   Copyright 2016, Kevin Kofler <kevin.kofler@chello.at>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef CALAMARES_CPPJOBMODULE_H
++#define CALAMARES_CPPJOBMODULE_H
++
++#include "UiDllMacro.h"
++#include "Module.h"
++
++class QPluginLoader;
++
++namespace Calamares {
++
++class UIDLLEXPORT CppJobModule : public Module
++{
++public:
++    Type type() const override;
++    Interface interface() const override;
++
++    void loadSelf() override;
++    QList< job_ptr > jobs() const override;
++
++protected:
++    void initFrom( const QVariantMap& moduleDescriptor ) override;
++
++private:
++    friend class Module; //so only the superclass can instantiate
++    explicit CppJobModule();
++    virtual ~CppJobModule();
++
++    QPluginLoader* m_loader;
++    job_ptr m_job;
++};
++
++} // namespace Calamares
++
++#endif // CALAMARES_CPPJOBMODULE_H
+diff --git a/src/libcalamaresui/modulesystem/Module.cpp b/src/libcalamaresui/modulesystem/Module.cpp
+index 7809754..2a2fe77 100644
+--- a/src/libcalamaresui/modulesystem/Module.cpp
++++ b/src/libcalamaresui/modulesystem/Module.cpp
+@@ -19,6 +19,7 @@
+ #include "Module.h"
+ 
+ #include "ProcessJobModule.h"
++#include "CppJobModule.h"
+ #include "ViewModule.h"
+ #include "utils/CalamaresUtils.h"
+ #include "utils/YamlUtils.h"
+@@ -76,7 +77,11 @@ Module::fromDescriptor( const QVariantMap& moduleDescriptor,
+     }
+     else if ( typeString == "job" )
+     {
+-        if ( intfString == "process" )
++        if ( intfString == "qtplugin" )
++        {
++            m = new CppJobModule();
++        }
++        else if ( intfString == "process" )
+         {
+             m = new ProcessJobModule();
+         }
+diff --git a/src/libcalamaresui/utils/PluginFactory.cpp b/src/libcalamaresui/utils/PluginFactory.cpp
+deleted file mode 100644
+index 30a5bf4..0000000
+--- a/src/libcalamaresui/utils/PluginFactory.cpp
++++ /dev/null
+@@ -1,123 +0,0 @@
+-/* === This file is part of Calamares - <http://github.com/calamares> ===
+- *
+- *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
+- *
+- *   Based on KPluginFactory from KCoreAddons, KDE project
+- *   Copyright 2007, Matthias Kretz <kretz@kde.org>
+- *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
+- *
+- *   Calamares 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 3 of the License, or
+- *   (at your option) any later version.
+- *
+- *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
+- */
+-
+-#include "PluginFactory.h"
+-#include "PluginFactory_p.h"
+-
+-#include <QObjectCleanupHandler>
+-#include <QDebug>
+-
+-Q_GLOBAL_STATIC(QObjectCleanupHandler, factorycleanup)
+-
+-extern int kLibraryDebugArea();
+-
+-namespace Calamares
+-{
+-
+-PluginFactory::PluginFactory()
+-    : d_ptr(new PluginFactoryPrivate)
+-{
+-    Q_D(PluginFactory);
+-    d->q_ptr = this;
+-
+-    factorycleanup()->add(this);
+-}
+-
+-PluginFactory::PluginFactory(PluginFactoryPrivate &d)
+-    : d_ptr(&d)
+-{
+-    factorycleanup()->add(this);
+-}
+-
+-PluginFactory::~PluginFactory()
+-{
+-    delete d_ptr;
+-}
+-
+-void PluginFactory::doRegisterPlugin(const QString &keyword, const QMetaObject *metaObject, CreateInstanceFunction instanceFunction)
+-{
+-    Q_D(PluginFactory);
+-
+-    Q_ASSERT(metaObject);
+-
+-    // we allow different interfaces to be registered without keyword
+-    if (!keyword.isEmpty()) {
+-        if (d->createInstanceHash.contains(keyword)) {
+-            qWarning() << "A plugin with the keyword" << keyword << "was already registered. A keyword must be unique!";
+-        }
+-        d->createInstanceHash.insert(keyword, PluginFactoryPrivate::Plugin(metaObject, instanceFunction));
+-    } else {
+-        const QList<PluginFactoryPrivate::Plugin> clashes(d->createInstanceHash.values(keyword));
+-        const QMetaObject *superClass = metaObject->superClass();
+-        if (superClass) {
+-            for (const PluginFactoryPrivate::Plugin &plugin : clashes) {
+-                for (const QMetaObject *otherSuper = plugin.first->superClass(); otherSuper;
+-                        otherSuper = otherSuper->superClass()) {
+-                    if (superClass == otherSuper) {
+-                        qWarning() << "Two plugins with the same interface(" << superClass->className() << ") were registered. Use keywords to identify the plugins.";
+-                    }
+-                }
+-            }
+-        }
+-        for (const PluginFactoryPrivate::Plugin &plugin : clashes) {
+-            superClass = plugin.first->superClass();
+-            if (superClass) {
+-                for (const QMetaObject *otherSuper = metaObject->superClass(); otherSuper;
+-                        otherSuper = otherSuper->superClass()) {
+-                    if (superClass == otherSuper) {
+-                        qWarning() << "Two plugins with the same interface(" << superClass->className() << ") were registered. Use keywords to identify the plugins.";
+-                    }
+-                }
+-            }
+-        }
+-        d->createInstanceHash.insertMulti(keyword, PluginFactoryPrivate::Plugin(metaObject, instanceFunction));
+-    }
+-}
+-
+-QObject *PluginFactory::create(const char *iface, QWidget *parentWidget, QObject *parent, const QString &keyword)
+-{
+-    Q_D(PluginFactory);
+-
+-    QObject *obj = 0;
+-
+-    const QList<PluginFactoryPrivate::Plugin> candidates(d->createInstanceHash.values(keyword));
+-    // for !keyword.isEmpty() candidates.count() is 0 or 1
+-
+-    for (const PluginFactoryPrivate::Plugin &plugin : candidates) {
+-        for (const QMetaObject *current = plugin.first; current; current = current->superClass()) {
+-            if (0 == qstrcmp(iface, current->className())) {
+-                if (obj) {
+-                    qWarning() << "ambiguous interface requested from a DSO containing more than one plugin";
+-                }
+-                obj = plugin.second(parentWidget, parent);
+-                break;
+-            }
+-        }
+-    }
+-
+-    if (obj) {
+-        emit objectCreated(obj);
+-    }
+-    return obj;
+-}
+-
+-}
+diff --git a/src/libcalamaresui/utils/PluginFactory.h b/src/libcalamaresui/utils/PluginFactory.h
+deleted file mode 100644
+index a77d959..0000000
+--- a/src/libcalamaresui/utils/PluginFactory.h
++++ /dev/null
+@@ -1,370 +0,0 @@
+-/* === This file is part of Calamares - <http://github.com/calamares> ===
+- *
+- *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
+- *
+- *   Based on KPluginFactory from KCoreAddons, KDE project
+- *   Copyright 2007, Matthias Kretz <kretz@kde.org>
+- *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
+- *
+- *   Calamares 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 3 of the License, or
+- *   (at your option) any later version.
+- *
+- *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
+- */
+-
+-#ifndef CALAMARESPLUGINFACTORY_H
+-#define CALAMARESPLUGINFACTORY_H
+-
+-#include "UiDllMacro.h"
+-
+-#include <QtCore/QObject>
+-#include <QtCore/QVariant>
+-#include <QtCore/QStringList>
+-
+-namespace Calamares
+-{
+-class PluginFactoryPrivate;
+-}
+-
+-#define CalamaresPluginFactory_iid "io.calamares.PluginFactory"
+-
+-#define CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY_SKEL(name, baseFactory, ...) \
+-    class name : public Calamares::PluginFactory \
+-    { \
+-        Q_OBJECT \
+-        Q_INTERFACES(Calamares::PluginFactory) \
+-        __VA_ARGS__ \
+-    public: \
+-        explicit name(); \
+-        ~name(); \
+-    private: \
+-        void init(); \
+-    };
+-
+-#define CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, baseFactory) \
+-    CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY_SKEL(name, baseFactory, Q_PLUGIN_METADATA(IID CalamaresPluginFactory_iid))
+-
+-#define CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations) \
+-    name::name() \
+-    { \
+-        pluginRegistrations \
+-    } \
+-    name::~name() {}
+-
+-#define CALAMARES_PLUGIN_FACTORY_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations) \
+-    CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, baseFactory) \
+-    CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations)
+-
+-#define CALAMARES_PLUGIN_FACTORY_DECLARATION(name) CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, Calamares::PluginFactory)
+-#define CALAMARES_PLUGIN_FACTORY_DEFINITION(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
+-
+-/**
+- * \relates PluginFactory
+- *
+- * Create a PluginFactory subclass and export it as the root plugin object.
+- *
+- * \param name The name of the PluginFactory derived class.
+- *
+- * \param pluginRegistrations Code to be inserted into the constructor of the
+- * class. Usually a series of registerPlugin() calls.
+- *
+- * Example:
+- * \code
+- * #include <PluginFactory.h>
+- * #include <plugininterface.h>
+- *
+- * class MyPlugin : public PluginInterface
+- * {
+- * public:
+- *     MyPlugin(QObject *parent, const QVariantList &args)
+- *         : PluginInterface(parent)
+- *     {}
+- * };
+- *
+- * CALAMARES_PLUGIN_FACTORY(MyPluginFactory,
+- *                  registerPlugin<MyPlugin>();
+- *                 )
+- *
+- * #include <myplugin.moc>
+- * \endcode
+- *
+- * \see CALAMARES_PLUGIN_FACTORY_DECLARATION
+- * \see CALAMARES_PLUGIN_FACTORY_DEFINITION
+- */
+-#define CALAMARES_PLUGIN_FACTORY(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
+-
+-/**
+- * \relates PluginFactory
+- *
+- * CALAMARES_PLUGIN_FACTORY_DECLARATION declares the PluginFactory subclass. This macro
+- * can be used in a header file.
+- *
+- * \param name The name of the PluginFactory derived class.
+- *
+- * \see CALAMARES_PLUGIN_FACTORY
+- * \see CALAMARES_PLUGIN_FACTORY_DEFINITION
+- */
+-#define CALAMARES_PLUGIN_FACTORY_DECLARATION(name) CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, Calamares::PluginFactory)
+-
+-/**
+- * \relates PluginFactory
+- * CALAMARES_PLUGIN_FACTORY_DEFINITION defines the PluginFactory subclass. This macro
+- * can <b>not</b> be used in a header file.
+- *
+- * \param name The name of the PluginFactory derived class.
+- *
+- * \param pluginRegistrations Code to be inserted into the constructor of the
+- * class. Usually a series of registerPlugin() calls.
+- *
+- * \see CALAMARES_PLUGIN_FACTORY
+- * \see CALAMARES_PLUGIN_FACTORY_DECLARATION
+- */
+-#define CALAMARES_PLUGIN_FACTORY_DEFINITION(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
+-
+-namespace Calamares
+-{
+-
+-/**
+- * \class PluginFactory PluginFactory.h <PluginFactory.h>
+- *
+- * PluginFactory provides a convenient way to provide factory-style plugins.
+- * Qt plugins provide a singleton object, but a common pattern is for plugins
+- * to generate as many objects of a particular type as the application requires.
+- * By using PluginFactory, you can avoid implementing the factory pattern
+- * yourself.
+- *
+- * PluginFactory also allows plugins to provide multiple different object
+- * types, indexed by keywords.
+- *
+- * The objects created by PluginFactory must inherit QObject, and must have a
+- * standard constructor pattern:
+- * \li if the object is a KPart::Part, it must be of the form
+- * \code
+- * T(QWidget *parentWidget, QObject *parent, const QVariantList &args)
+- * \endcode
+- * \li if it is a QWidget, it must be of the form
+- * \code
+- * T(QWidget *parent, const QVariantList &args)
+- * \endcode
+- * \li otherwise it must be of the form
+- * \code
+- * T(QObject *parent, const QVariantList &args)
+- * \endcode
+- *
+- * You should typically use either CALAMARES_PLUGIN_FACTORY() or
+- * CALAMARES_PLUGIN_FACTORY_WITH_JSON() in your plugin code to create the factory.  The
+- * typical pattern is
+- *
+- * \code
+- * #include <PluginFactory.h>
+- * #include <plugininterface.h>
+- *
+- * class MyPlugin : public PluginInterface
+- * {
+- * public:
+- *     MyPlugin(QObject *parent, const QVariantList &args)
+- *         : PluginInterface(parent)
+- *     {}
+- * };
+- *
+- * CALAMARES_PLUGIN_FACTORY(MyPluginFactory,
+- *                  registerPlugin<MyPlugin>();
+- *                 )
+- * #include <myplugin.moc>
+- * \endcode
+- *
+- * If you want to load a library use KPluginLoader.
+- * The application that wants to instantiate plugin classes can do the following:
+- * \code
+- * PluginFactory *factory = KPluginLoader("libraryname").factory();
+- * if (factory) {
+- *     PluginInterface *p1 = factory->create<PluginInterface>(parent);
+- *     OtherInterface *p2  = factory->create<OtherInterface>(parent);
+- *     NextInterface *p3   = factory->create<NextInterface>("keyword1", parent);
+- *     NextInterface *p3   = factory->create<NextInterface>("keyword2", parent);
+- * }
+- * \endcode
+- *
+- * \author Matthias Kretz <kretz@kde.org>
+- * \author Bernhard Loos <nhuh.put@web.de>
+- */
+-class UIDLLEXPORT PluginFactory : public QObject
+-{
+-    Q_OBJECT
+-    Q_DECLARE_PRIVATE(PluginFactory)
+-public:
+-    /**
+-     * This constructor creates a factory for a plugin.
+-     */
+-    explicit PluginFactory();
+-
+-    /**
+-     * This destroys the PluginFactory.
+-     */
+-    virtual ~PluginFactory();
+-
+-    /**
+-     * Use this method to create an object. It will try to create an object which inherits
+-     * \p T. If it has multiple choices, you will get a fatal error (kFatal()), so be careful
+-     * to request a unique interface or use keywords.
+-     *
+-     * \tparam T The interface for which an object should be created. The object will inherit \p T.
+-     * \param parent The parent of the object. If \p parent is a widget type, it will also passed
+-     *               to the parentWidget argument of the CreateInstanceFunction for the object.
+-     * \returns A pointer to the created object is returned, or 0 if an error occurred.
+-     */
+-    template<typename T>
+-    T *create(QObject *parent = 0);
+-
+-    /**
+-     * Use this method to create an object. It will try to create an object which inherits
+-     * \p T and was registered with \p keyword.
+-     *
+-     * \tparam T The interface for which an object should be created. The object will inherit \p T.
+-     * \param keyword The keyword of the object.
+-     * \param parent The parent of the object. If \p parent is a widget type, it will also passed
+-     *               to the parentWidget argument of the CreateInstanceFunction for the object.
+-     * \returns A pointer to the created object is returned, or 0 if an error occurred.
+-     */
+-    template<typename T>
+-    T *create(const QString &keyword, QObject *parent = 0);
+-
+-Q_SIGNALS:
+-    void objectCreated(QObject *object);
+-
+-protected:
+-    /**
+-     * Function pointer type to a function that instantiates a plugin.
+-     */
+-    typedef QObject *(*CreateInstanceFunction)(QWidget *, QObject *);
+-
+-    /**
+-     * This is used to detect the arguments need for the constructor of plugin classes.
+-     * You can inherit it, if you want to add new classes and still keep support for the old ones.
+-     */
+-    template<class impl>
+-    struct InheritanceChecker {
+-        CreateInstanceFunction createInstanceFunction(QWidget *)
+-        {
+-            return &createInstance<impl, QWidget>;
+-        }
+-        CreateInstanceFunction createInstanceFunction(...)
+-        {
+-            return &createInstance<impl, QObject>;
+-        }
+-    };
+-
+-    explicit PluginFactory(PluginFactoryPrivate &dd);
+-
+-    /**
+-     * Registers a plugin with the factory. Call this function from the constructor of the
+-     * PluginFactory subclass to make the create function able to instantiate the plugin when asked
+-     * for an interface the plugin implements.
+-     *
+-     * \tparam T the name of the plugin class
+-     *
+-     * \param keyword An optional keyword as unique identifier for the plugin. This allows you to
+-     * put more than one plugin with the same interface into the same library using the same
+-     * factory. X-KDE-PluginKeyword is a convenient way to specify the keyword in a desktop file.
+-     *
+-     * \param instanceFunction A function pointer to a function that creates an instance of the
+-     * plugin. The default function that will be used depends on the type of interface. If the
+-     * interface inherits from
+-     * \li \c KParts::Part the function will call
+-     * \code
+-     * new T(QWidget *parentWidget, QObject *parent)
+-     * \endcode
+-     * \li \c QWidget the function will call
+-     * \code
+-     * new T(QWidget *parent)
+-     * \endcode
+-     * \li else the function will call
+-     * \code
+-     * new T(QObject *parent)
+-     * \endcode
+-     */
+-    template<class T>
+-    void registerPlugin(const QString &keyword = QString(),
+-                        CreateInstanceFunction instanceFunction
+-                        = InheritanceChecker<T>().createInstanceFunction(reinterpret_cast<T *>(0)))
+-    {
+-        doRegisterPlugin(keyword, &T::staticMetaObject, instanceFunction);
+-    }
+-
+-    PluginFactoryPrivate *const d_ptr;
+-
+-    /**
+-     * This function is called when the factory asked to create an Object.
+-     *
+-     * You may reimplement it to provide a very flexible factory. This is especially useful to
+-     * provide generic factories for plugins implemeted using a scripting language.
+-     *
+-     * \param iface The staticMetaObject::className() string identifying the plugin interface that
+-     * was requested. E.g. for KCModule plugins this string will be "KCModule".
+-     * \param parentWidget Only used if the requested plugin is a KPart.
+-     * \param parent The parent object for the plugin object.
+-     * \param args A plugin specific list of arbitrary arguments.
+-     * \param keyword A string that uniquely identifies the plugin. If a KService is used this
+-     * keyword is read from the X-KDE-PluginKeyword entry in the .desktop file.
+-     */
+-    virtual QObject *create(const char *iface, QWidget *parentWidget, QObject *parent, const QString &keyword);
+-
+-    template<class impl, class ParentType>
+-    static QObject *createInstance(QWidget *parentWidget, QObject *parent)
+-    {
+-        Q_UNUSED(parentWidget);
+-        ParentType *p = 0;
+-        if (parent) {
+-            p = qobject_cast<ParentType *>(parent);
+-            Q_ASSERT(p);
+-        }
+-        return new impl(p);
+-    }
+-
+-private:
+-    void doRegisterPlugin(const QString &keyword, const QMetaObject *metaObject, CreateInstanceFunction instanceFunction);
+-};
+-
+-template<typename T>
+-inline T *PluginFactory::create(QObject *parent)
+-{
+-    QObject *o = create(T::staticMetaObject.className(),
+-                        parent && parent->isWidgetType() ? reinterpret_cast<QWidget *>(parent) : 0,
+-                        parent,
+-                        QString());
+-
+-    T *t = qobject_cast<T *>(o);
+-    if (!t) {
+-        delete o;
+-    }
+-    return t;
+-}
+-
+-template<typename T>
+-inline T *PluginFactory::create(const QString &keyword, QObject *parent)
+-{
+-    QObject *o = create(T::staticMetaObject.className(),
+-                        parent && parent->isWidgetType() ? reinterpret_cast<QWidget *>(parent) : 0,
+-                        parent,
+-                        keyword);
+-
+-    T *t = qobject_cast<T *>(o);
+-    if (!t) {
+-        delete o;
+-    }
+-    return t;
+-}
+-
+-}
+-
+-Q_DECLARE_INTERFACE(Calamares::PluginFactory, CalamaresPluginFactory_iid)
+-
+-#endif // CALAMARESPLUGINFACTORY_H
+diff --git a/src/libcalamaresui/utils/PluginFactory_p.h b/src/libcalamaresui/utils/PluginFactory_p.h
+deleted file mode 100644
+index a0b4a1c..0000000
+--- a/src/libcalamaresui/utils/PluginFactory_p.h
++++ /dev/null
+@@ -1,54 +0,0 @@
+-/* === This file is part of Calamares - <http://github.com/calamares> ===
+- *
+- *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
+- *
+- *   Based on KPluginFactory from KCoreAddons, KDE project
+- *   Copyright 2007, Matthias Kretz <kretz@kde.org>
+- *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
+- *
+- *   Calamares 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 3 of the License, or
+- *   (at your option) any later version.
+- *
+- *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
+- */
+-
+-#ifndef CALAMARESPLUGINFACTORY_P_H
+-#define CALAMARESPLUGINFACTORY_P_H
+-
+-#include "PluginFactory.h"
+-
+-#include <QtCore/QHash>
+-
+-namespace Calamares
+-{
+-
+-class PluginFactoryPrivate
+-{
+-    Q_DECLARE_PUBLIC(PluginFactory)
+-protected:
+-    typedef QPair<const QMetaObject *, PluginFactory::CreateInstanceFunction> Plugin;
+-
+-    PluginFactoryPrivate()
+-        : catalogInitialized( false )
+-        , q_ptr( nullptr )
+-    {}
+-    ~PluginFactoryPrivate() {}
+-
+-    QHash<QString, Plugin> createInstanceHash;
+-    QString catalogName;
+-    bool catalogInitialized;
+-
+-    PluginFactory *q_ptr;
+-};
+-
+-}
+-
+-#endif // CALAMARESPLUGINFACTORY_P_H
+diff --git a/src/modules/dracutlukscfg/CMakeLists.txt b/src/modules/dracutlukscfg/CMakeLists.txt
+new file mode 100644
+index 0000000..a239521
+--- /dev/null
++++ b/src/modules/dracutlukscfg/CMakeLists.txt
+@@ -0,0 +1,9 @@
++calamares_add_plugin( dracutlukscfg
++    TYPE job
++    EXPORT_MACRO PLUGINDLLEXPORT_PRO
++    SOURCES
++        DracutLuksCfgJob.cpp
++    LINK_LIBRARIES
++        calamares
++    SHARED_LIB
++)
+diff --git a/src/modules/dracutlukscfg/DracutLuksCfgJob.cpp b/src/modules/dracutlukscfg/DracutLuksCfgJob.cpp
+new file mode 100644
+index 0000000..273ff98
+--- /dev/null
++++ b/src/modules/dracutlukscfg/DracutLuksCfgJob.cpp
+@@ -0,0 +1,143 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2016, Kevin Kofler <kevin.kofler@chello.at>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "DracutLuksCfgJob.h"
++
++#include <QDir>
++#include <QFile>
++#include <QFileInfo>
++#include <QTextStream>
++
++#include "CalamaresVersion.h"
++#include "JobQueue.h"
++#include "GlobalStorage.h"
++
++#include "utils/Logger.h"
++
++// static
++const QString DracutLuksCfgJob::CONFIG_FILE = QStringLiteral( "/etc/dracut.conf.d/calamares-luks.conf" );
++
++// static
++const char *DracutLuksCfgJob::CONFIG_FILE_CONTENTS =
++    "# Configuration file automatically written by the Calamares system installer\n"
++    "# (This file is written once at install time and should be safe to edit.)\n"
++    "# Enables support for LUKS full disk encryption with single sign on from GRUB.\n"
++    "\n"
++    "# force installing /etc/crypttab even if hostonly=\"no\", install the keyfile\n"
++    "install_items+=\" /etc/crypttab /crypto_keyfile.bin \"\n";
++
++// static
++const QString DracutLuksCfgJob::CONFIG_FILE_SWAPLINE = QStringLiteral( "# enable automatic resume from swap\nadd_device+=\" /dev/disk/by-uuid/%1 \"\n" );
++
++// static
++QString
++DracutLuksCfgJob::rootMountPoint()
++{
++    Calamares::GlobalStorage *globalStorage = Calamares::JobQueue::instance()->globalStorage();
++    return globalStorage->value( QStringLiteral( "rootMountPoint" ) ).toString();
++}
++
++// static
++QVariantList
++DracutLuksCfgJob::partitions()
++{
++    Calamares::GlobalStorage *globalStorage = Calamares::JobQueue::instance()->globalStorage();
++    return globalStorage->value( QStringLiteral( "partitions" ) ).toList();
++}
++
++// static
++bool
++DracutLuksCfgJob::isRootEncrypted()
++{
++    const QVariantList partitions = DracutLuksCfgJob::partitions();
++    for ( const QVariant &partition : partitions )
++    {
++        QVariantMap partitionMap = partition.toMap();
++        QString mountPoint = partitionMap.value( QStringLiteral( "mountPoint" ) ).toString();
++        if ( mountPoint == QStringLiteral( "/" ) )
++            return partitionMap.contains( QStringLiteral( "luksMapperName" ) );
++    }
++    return false;
++}
++
++// static
++QString
++DracutLuksCfgJob::swapOuterUuid()
++{
++    const QVariantList partitions = DracutLuksCfgJob::partitions();
++    for ( const QVariant &partition : partitions )
++    {
++        QVariantMap partitionMap = partition.toMap();
++        QString fsType = partitionMap.value( QStringLiteral( "fs" ) ).toString();
++        if ( fsType == QStringLiteral( "linuxswap" ) && partitionMap.contains( QStringLiteral( "luksMapperName" ) ) )
++            return partitionMap.value( QStringLiteral( "luksUuid" ) ).toString();
++    }
++    return QString();
++}
++
++DracutLuksCfgJob::DracutLuksCfgJob( QObject* parent )
++    : Calamares::CppJob( parent )
++{
++}
++
++
++DracutLuksCfgJob::~DracutLuksCfgJob()
++{
++}
++
++
++QString
++DracutLuksCfgJob::prettyName() const
++{
++    if ( isRootEncrypted() )
++        return tr( "Write LUKS configuration for Dracut to %1" ).arg( CONFIG_FILE );
++    else
++        return tr( "Skip writing LUKS configuration for Dracut: \"/\" partition is not encrypted" );
++}
++
++
++Calamares::JobResult
++DracutLuksCfgJob::exec()
++{
++    if ( isRootEncrypted() )
++    {
++        const QString realConfigFilePath = rootMountPoint() + CONFIG_FILE;
++        cDebug() << "[DRACUTLUKSCFG]: Writing" << realConfigFilePath;
++        QDir( QStringLiteral( "/" ) ).mkpath( QFileInfo( realConfigFilePath ).absolutePath() );
++        QFile configFile( realConfigFilePath );
++        if ( ! configFile.open( QIODevice::WriteOnly | QIODevice::Text ) )
++        {
++            cDebug() << "[DRACUTLUKSCFG]: Failed to open" << realConfigFilePath;
++            return Calamares::JobResult::error( tr( "Failed to open %1" ).arg( realConfigFilePath ) );
++        }
++        QTextStream outStream( &configFile );
++        outStream << CONFIG_FILE_CONTENTS;
++        const QString swapOuterUuid = DracutLuksCfgJob::swapOuterUuid();
++        if ( ! swapOuterUuid.isEmpty() )
++        {
++            cDebug() << "[DRACUTLUKSCFG]: Swap outer UUID" << swapOuterUuid;
++            outStream << CONFIG_FILE_SWAPLINE.arg( swapOuterUuid ).toLatin1();
++        }
++        cDebug() << "[DRACUTLUKSCFG]: Wrote config to" << realConfigFilePath;
++    } else
++        cDebug() << "[DRACUTLUKSCFG]: / not encrypted, skipping";
++
++    return Calamares::JobResult::ok();
++}
++
++CALAMARES_PLUGIN_FACTORY_DEFINITION( DracutLuksCfgJobFactory, registerPlugin<DracutLuksCfgJob>(); )
+diff --git a/src/modules/dracutlukscfg/DracutLuksCfgJob.h b/src/modules/dracutlukscfg/DracutLuksCfgJob.h
+new file mode 100644
+index 0000000..bfedb85
+--- /dev/null
++++ b/src/modules/dracutlukscfg/DracutLuksCfgJob.h
+@@ -0,0 +1,56 @@
++/* === This file is part of Calamares - <http://github.com/calamares> ===
++ *
++ *   Copyright 2016, Kevin Kofler <kevin.kofler@chello.at>
++ *
++ *   Calamares 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 3 of the License, or
++ *   (at your option) any later version.
++ *
++ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef DRACUTLUKSCFGJOB_H
++#define DRACUTLUKSCFGJOB_H
++
++#include <QObject>
++#include <QVariantMap>
++
++#include <CppJob.h>
++
++#include <utils/PluginFactory.h>
++
++#include <PluginDllMacro.h>
++
++class PLUGINDLLEXPORT DracutLuksCfgJob : public Calamares::CppJob
++{
++    Q_OBJECT
++
++public:
++    explicit DracutLuksCfgJob( QObject* parent = nullptr );
++    virtual ~DracutLuksCfgJob();
++
++    QString prettyName() const override;
++
++    Calamares::JobResult exec() override;
++
++private:
++    static const QString CONFIG_FILE;
++    static const char *CONFIG_FILE_CONTENTS;
++    static const QString CONFIG_FILE_SWAPLINE;
++
++    static QString rootMountPoint();
++    static QVariantList partitions();
++    static bool isRootEncrypted();
++    static QString swapOuterUuid();
++};
++
++CALAMARES_PLUGIN_FACTORY_DECLARATION( DracutLuksCfgJobFactory )
++
++#endif // DRACUTLUKSCFGJOB_H
+diff --git a/src/modules/dracutlukscfg/module.desc b/src/modules/dracutlukscfg/module.desc
+new file mode 100644
+index 0000000..10d9b78
+--- /dev/null
++++ b/src/modules/dracutlukscfg/module.desc
+@@ -0,0 +1,7 @@
++# Module metadata file for dracutlukscfg job
++# Syntax is YAML 1.2
++---
++type:      "job"
++name:      "dracutlukscfg"
++interface: "qtplugin"
++load:      "libcalamares_job_dracutlukscfg.so"
+diff --git a/src/modules/fstab/fstab.conf b/src/modules/fstab/fstab.conf
+index 7dbf529..c3dbfc3 100644
+--- a/src/modules/fstab/fstab.conf
++++ b/src/modules/fstab/fstab.conf
+@@ -8,3 +8,6 @@ ssdExtraMountOptions:
+     xfs: discard
+     swap: discard
+     btrfs: discard,compress=lzo
++crypttabOptions: luks
++# For Debian and Debian-based distributions, change the above line to:
++# crypttabOptions: luks,keyscript=/bin/cat
+diff --git a/src/modules/fstab/main.py b/src/modules/fstab/main.py
+index 65f483b..05b094f 100644
+--- a/src/modules/fstab/main.py
++++ b/src/modules/fstab/main.py
+@@ -102,11 +102,13 @@ class FstabGenerator(object):
+     :param mount_options:
+     :param ssd_extra_mount_options:
+     """
+-    def __init__(self, partitions, root_mount_point, mount_options, ssd_extra_mount_options):
++    def __init__(self, partitions, root_mount_point, mount_options,
++                 ssd_extra_mount_options, crypttab_options):
+         self.partitions = partitions
+         self.root_mount_point = root_mount_point
+         self.mount_options = mount_options
+         self.ssd_extra_mount_options = ssd_extra_mount_options
++        self.crypttab_options = crypttab_options
+         self.ssd_disks = set()
+         self.root_is_ssd = False
+ 
+@@ -152,21 +154,20 @@ class FstabGenerator(object):
+         if not mapper_name or not luks_uuid:
+             return None
+ 
+-        if mount_point == "/":
+-            return None
+-
+         return dict(
+             name=mapper_name,
+             device="UUID=" + luks_uuid,
+             password="/crypto_keyfile.bin",
++            options=self.crypttab_options,
+         )
+ 
+     def print_crypttab_line(self, dct, file=None):
+         """ Prints line to '/etc/crypttab' file. """
+-        line = "{:21} {:<45} {}".format(dct["name"],
+-                                        dct["device"],
+-                                        dct["password"],
+-                                       )
++        line = "{:21} {:<45} {} {}".format(dct["name"],
++                                           dct["device"],
++                                           dct["password"],
++                                           dct["options"],
++                                          )
+ 
+         print(line, file=file)
+ 
+@@ -258,9 +259,11 @@ def run():
+     root_mount_point = global_storage.value("rootMountPoint")
+     mount_options = conf["mountOptions"]
+     ssd_extra_mount_options = conf.get("ssdExtraMountOptions", {})
++    crypttab_options = conf.get("crypttabOptions", "luks")
+     generator = FstabGenerator(partitions,
+                                root_mount_point,
+                                mount_options,
+-                               ssd_extra_mount_options)
++                               ssd_extra_mount_options,
++                               crypttab_options)
+ 
+     return generator.run()
+-- 
+2.1.0
+