[luksopenswaphookcfg] Partial implementation in C++

- Futz a bit with the string replacements -- do not assume #
  will introduce a comment half-way through a line.

src/modules/luksopenswaphookcfg/CMakeLists.txt

@@ -17,5 +17,6 @@ calamares_add_plugin( luksopenswaphook
 calamares_add_test(
     luksopenswaphooktest
     SOURCES
+        LOSHJob.cpp
         Tests.cpp
 )

src/modules/luksopenswaphookcfg/LOSHInfo.h

@@ -0,0 +1,62 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *  SPDX-FileCopyrightText: 2021 Adriaan de Groot <groot@kde.org>
+ *  SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+#ifndef LUKSOPENSWAPHOOKCFG_LOSHINFO_H
+#define LUKSOPENSWAPHOOKCFG_LOSHINFO_H
+
+#include <QString>
+
+/** @brief Information needed to create a suitable config file
+ *
+ * The LUKS swap configuration has a handful of keys that need to
+ * be written to the config file. This struct holds those keys
+ * and can find the key values from Global Storage (where the
+ * *partition* module sets them).
+ */
+struct LOSHInfo
+{
+    // Member names copied from Python code
+    QString swap_outer_uuid;
+    QString swap_mapper_name;
+    QString mountable_keyfile_device;
+    QString swap_device_path;
+
+    bool isValid() const { return !swap_device_path.isEmpty(); }
+
+    /** @brief Helper method for doing key-value replacements
+     *
+     * Given a named @p key (e.g. "duck", or "swap_device"), returns the
+     * value set for that key. Invalid keys (e.g. "duck") return an empty string.
+     */
+    QString replacementFor( const QString& key ) const
+    {
+        if ( key == QStringLiteral( "swap_device" ) )
+        {
+            return swap_device_path;
+        }
+        if ( key == QStringLiteral( "crypt_swap_name" ) )
+        {
+            return swap_mapper_name;
+        }
+        if ( key == QStringLiteral( "keyfile_device" ) )
+        {
+            return mountable_keyfile_device;
+        }
+        if ( key == QStringLiteral( "keyfile_filename" ) )
+        {
+            return QStringLiteral( "crypto_keyfile.bin" );
+        }
+        return QString();
+    }
+
+    /** @brief Creates a struct from information already set in GS
+     *
+     * TODO: implement this in LOSHJob.cpp
+     */
+    static LOSHInfo fromGlobalStorage() { return LOSHInfo {}; }
+};
+
+#endif

src/modules/luksopenswaphookcfg/LOSHJob.cpp

@@ -4,59 +4,117 @@
  *  SPDX-License-Identifier: GPL-3.0-or-later
  *
  */
+#include "LOSHJob.h"
 
-#include "CppJob.h"
+#include "LOSHInfo.h"
-#include "DllMacro.h"
+
+#include "GlobalStorage.h"
+#include "JobQueue.h"
+#include "utils/CalamaresUtilsSystem.h"
+#include "utils/Logger.h"
 #include "utils/Permissions.h"
 #include "utils/PluginFactory.h"
+#include "utils/Variant.h"
 
 #include <QList>
 #include <QObject>
 #include <QVariantMap>
 
-class PLUGINDLLEXPORT LOSHJob : public Calamares::CppJob
-{
-    Q_OBJECT
-
-public:
-    explicit LOSHJob( QObject* parent = nullptr );
-    ~LOSHJob() override;
-
-    QString prettyName() const override;
-
-    Calamares::JobResult exec() override;
-
-    void setConfigurationMap( const QVariantMap& configurationMap ) override;
-
-private:
-};
-
 LOSHJob::LOSHJob( QObject* parent )
     : Calamares::CppJob( parent )
 {
 }
 
+LOSHJob::~LOSHJob() {}
+
+
 QString
 LOSHJob::prettyName() const
 {
     return tr( "Configuring encrypted swap." );
 }
 
+STATICTEST QString
+get_assignment_part( const QString& line )
+{
+    static QRegularExpression re( "^[# \\t]*([A-Za-z_]+)[ \\t]*=" );
+    auto m = re.match( line );
+    if ( m.hasMatch() )
+    {
+        return m.captured( 1 );
+    }
+    return QString();
+}
+
+/** Writes the config file at @p path
+ *
+ * NOTE: @p path is relative to the target system, not an absolute path.
+ */
+STATICTEST void
+write_openswap_conf( const QString& path, QStringList& contents, const LOSHInfo& info )
+{
+    if ( info.isValid() )
+    {
+        for ( auto& line : contents )
+        {
+            const QString key = get_assignment_part( line );
+            QString replacement = info.replacementFor( key );
+            if ( !replacement.isEmpty() )
+            {
+                line.clear();
+                line.append( QStringLiteral( "%1=%2" ).arg( key, replacement ) );
+            }
+        }
+        cDebug() << "Writing" << contents.length() << "line configuration to" << path;
+        // \n between each two lines, and a \n at the end
+        CalamaresUtils::System::instance()->createTargetFile(
+            path, contents.join( '\n' ).append( '\n' ).toUtf8(), CalamaresUtils::System::WriteMode::Overwrite );
+    }
+    else
+    {
+        cDebug() << "Will not write an invalid configuration to" << path;
+    }
+}
 
 Calamares::JobResult
 LOSHJob::exec()
 {
+    const auto* sys = CalamaresUtils::System::instance();
+    if ( !sys )
+    {
+        return Calamares::JobResult::internalError(
+            "LuksOpenSwapHook", tr( "No target system available." ), Calamares::JobResult::InvalidConfiguration );
+    }
+
+    Calamares::GlobalStorage* gs
+        = Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
+    if ( !gs || gs->value( "rootMountPoint" ).toString().isEmpty() )
+    {
+        return Calamares::JobResult::internalError(
+            "LuksOpenSwapHook", tr( "No rootMountPoint is set." ), Calamares::JobResult::InvalidConfiguration );
+    }
+    if ( m_configFilePath.isEmpty() )
+    {
+        return Calamares::JobResult::internalError(
+            "LuksOpenSwapHook", tr( "No configFilePath is set." ), Calamares::JobResult::InvalidConfiguration );
+    }
+
+    QStringList contents = sys->readTargetFile( m_configFilePath );
+    if ( contents.isEmpty() )
+    {
+        contents << QStringLiteral( "# swap_device=" ) << QStringLiteral( "# crypt_swap_name=" )
+                 << QStringLiteral( "# keyfile_device=" ) << QStringLiteral( "# keyfile_filename=" );
+    }
+
+    write_openswap_conf( m_configFilePath, contents, LOSHInfo::fromGlobalStorage() );
     return Calamares::JobResult::ok();
 }
 
 void
 LOSHJob::setConfigurationMap( const QVariantMap& configurationMap )
 {
+    m_configFilePath = CalamaresUtils::getString(
+        configurationMap, QStringLiteral( "configFilePath" ), QStringLiteral( "/etc/openswap.conf" ) );
 }
 
-CALAMARES_PLUGIN_FACTORY_DECLARATION( LOSHJobFactory )
 CALAMARES_PLUGIN_FACTORY_DEFINITION( LOSHJobFactory, registerPlugin< LOSHJob >(); )
-
-#include "utils/moc-warnings.h"
-
-#include "LOSHJob.moc"

src/modules/luksopenswaphookcfg/LOSHJob.h

@@ -0,0 +1,37 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *  SPDX-FileCopyrightText: 2021 Adriaan de Groot <groot@kde.org>
+ *  SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+#ifndef LUKSOPENSWAPHOOKCFG_LOSHJOB_H
+#define LUKSOPENSWAPHOOKCFG_LOSHJOB_H
+
+#include "CppJob.h"
+#include "DllMacro.h"
+#include "utils/PluginFactory.h"
+
+#include <QString>
+#include <QVariantMap>
+
+class PLUGINDLLEXPORT LOSHJob : public Calamares::CppJob
+{
+    Q_OBJECT
+
+public:
+    explicit LOSHJob( QObject* parent = nullptr );
+    ~LOSHJob() override;
+
+    QString prettyName() const override;
+
+    Calamares::JobResult exec() override;
+
+    void setConfigurationMap( const QVariantMap& configurationMap ) override;
+
+private:
+    QString m_configFilePath;
+};
+
+CALAMARES_PLUGIN_FACTORY_DECLARATION( LOSHJobFactory )
+
+#endif

src/modules/luksopenswaphookcfg/Tests.cpp

@@ -5,12 +5,22 @@
  *
  */
 
+#include "LOSHInfo.h"
+#include "LOSHJob.h"
+
+#include "GlobalStorage.h"
+#include "JobQueue.h"
+#include "utils/CalamaresUtilsSystem.h"
 #include "utils/Logger.h"
 
 #include <QtTest/QtTest>
 
 // LOSH = LUKS Open Swap Hook (Job)
 
+// Implementation details
+extern QString get_assignment_part( const QString& line );
+extern void write_openswap_conf( const QString& path, QStringList& contents, const LOSHInfo& info );
+
 class LOSHTests : public QObject
 {
     Q_OBJECT
@@ -21,7 +31,12 @@ public:
 private Q_SLOTS:
     void initTestCase();
 
-    void testTrue();
+    void testAssignmentExtraction_data();
+    void testAssignmentExtraction();
+
+    void testLOSHInfo();
+    void testConfigWriting();
+    void testJob();
 };
 
 LOSHTests::LOSHTests() {}
@@ -33,6 +48,169 @@ LOSHTests::initTestCase()
     cDebug() << "LOSH test started.";
 }
 
+
+void
+LOSHTests::testAssignmentExtraction_data()
+{
+    QTest::addColumn< QString >( "line" );
+    QTest::addColumn< QString >( "match" );
+
+    QTest::newRow( "empty" ) << QString() << QString();
+    QTest::newRow( "comment-only1" ) << QStringLiteral( "#  " ) << QString();
+    QTest::newRow( "comment-only2" ) << QStringLiteral( "###" ) << QString();
+    QTest::newRow( "comment-only3" ) << QStringLiteral( "# # #" ) << QString();
+
+    QTest::newRow( "comment-text" ) << QStringLiteral( "#   NOTE:" ) << QString();
+    QTest::newRow( "comment-story" ) << QStringLiteral( "# This is a shell comment" ) << QString();
+    // We look for assignments, but only for single-words
+    QTest::newRow( "comment-space-eq" ) << QStringLiteral( "# Check that a = b" ) << QString();
+
+
+    QTest::newRow( "assignment1" ) << QStringLiteral( "a=1" ) << QStringLiteral( "a" );
+    QTest::newRow( "assignment2" ) << QStringLiteral( "a = 1" ) << QStringLiteral( "a" );
+    QTest::newRow( "assignment3" ) << QStringLiteral( "#   a=1" ) << QStringLiteral( "a" );
+    QTest::newRow( "assignment4" ) << QStringLiteral( "cows   = 12" ) << QStringLiteral( "cows" );
+    QTest::newRow( "assignment5" ) << QStringLiteral( "#   # cows=1" ) << QStringLiteral( "cows" );
+    QTest::newRow( "assignment6" ) << QStringLiteral( "# moose='cool'  # not cows" ) << QStringLiteral( "moose" );
+    QTest::newRow( "assignment7" ) << QStringLiteral( " moose=cows=42" ) << QStringLiteral( "moose" );
+}
+
+void
+LOSHTests::testAssignmentExtraction()
+{
+    QFETCH( QString, line );
+    QFETCH( QString, match );
+
+    QCOMPARE( get_assignment_part( line ), match );
+}
+
+static CalamaresUtils::System*
+file_setup( const QTemporaryDir& tempRoot )
+{
+    CalamaresUtils::System* ss = CalamaresUtils::System::instance();
+    if ( !ss )
+    {
+        ss = new CalamaresUtils::System( true );
+    }
+
+    Calamares::GlobalStorage* gs
+        = Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
+    if ( !gs )
+    {
+        cDebug() << "Creating new JobQueue";
+        (void)new Calamares::JobQueue();
+        gs = Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
+    }
+    if ( gs )
+    {
+        // Working with a rootMountPoint set
+        gs->insert( "rootMountPoint", tempRoot.path() );
+    }
+    return ss;
+}
+
+static void
+make_valid_loshinfo( LOSHInfo& i )
+{
+    i.swap_outer_uuid = QStringLiteral( "UUID-0000" );
+    i.swap_mapper_name = QStringLiteral( "/dev/mapper/0000" );
+    i.swap_device_path = QStringLiteral( "/dev/sda0" );
+    i.mountable_keyfile_device = QStringLiteral( "/dev/ada0p0s0" );
+}
+
+void
+LOSHTests::testLOSHInfo()
+{
+    LOSHInfo i {};
+    QVERIFY( !i.isValid() );
+
+    make_valid_loshinfo( i );
+    QVERIFY( i.isValid() );
+    QCOMPARE( i.replacementFor( QStringLiteral( "swap_device" ) ), QStringLiteral( "/dev/sda0" ) );
+    QCOMPARE( i.replacementFor( QStringLiteral( "duck" ) ), QString() );
+}
+
+
+void
+LOSHTests::testConfigWriting()
+{
+    QTemporaryDir tempRoot( QDir::tempPath() + QStringLiteral( "/test-job-XXXXXX" ) );
+    QVERIFY( tempRoot.isValid() );
+    auto* ss = file_setup( tempRoot );
+    QVERIFY( ss );
+    QVERIFY( Calamares::JobQueue::instance()->globalStorage() );
+    QVERIFY( QFile::exists( tempRoot.path() ) );
+    QVERIFY( QFileInfo(tempRoot.path()).isDir() );
+
+    const QString targetFilePath = QStringLiteral( "losh.conf" );
+    const QString filePath = tempRoot.filePath( targetFilePath );
+    QStringList contents { QStringLiteral( "# Calamares demo" ),
+                           QStringLiteral( "#  swap_device=a thing" ),
+                           QStringLiteral( "#  duck duck swap_device=another" ) };
+
+    // When the information is invalid, file contents are unchanged,
+    // and no file is written either.
+    LOSHInfo i {};
+    QVERIFY( !i.isValid() );
+    QVERIFY( !QFile::exists( filePath ) );
+    write_openswap_conf( targetFilePath, contents, i );  // Invalid i
+    QVERIFY( !QFile::exists( filePath ) );
+    QCOMPARE( contents.length(), 3 );
+    QCOMPARE( contents.at( 1 ).left( 4 ), QStringLiteral( "#  s" ) );
+
+    // Can we write there at all?
+    QFile derp(filePath);
+    QVERIFY(derp.open(QIODevice::WriteOnly));
+    QVERIFY(derp.write("xx", 2));
+    derp.close();
+    QVERIFY(QFile::exists(filePath));
+    QVERIFY(QFile::remove(filePath));
+
+    // Once the information is valid, though, the file is written
+    make_valid_loshinfo( i );
+    QVERIFY( i.isValid() );
+    QVERIFY( !QFile::exists( filePath ) );
+    write_openswap_conf( targetFilePath, contents, i );  // Now it is valid
+    QVERIFY( QFile::exists( filePath ) );
+    QCOMPARE( contents.length(), 3 );
+    QCOMPARE( i.swap_device_path, QStringLiteral( "/dev/sda0" ) );  // expected key value
+    QCOMPARE( contents.at( 1 ), QStringLiteral( "swap_device=/dev/sda0" ) );  // expected line
+
+    // readLine() returns with newlines-added
+    QFile f( filePath );
+    QVERIFY( f.open( QIODevice::ReadOnly ) );
+    QCOMPARE( f.readLine(), QStringLiteral( "# Calamares demo\n" ) );
+    QCOMPARE( f.readLine(), QStringLiteral( "swap_device=/dev/sda0\n" ) );
+    QCOMPARE( f.readLine(), QStringLiteral( "#  duck duck swap_device=another\n" ) );
+    QCOMPARE( f.readLine(), QString() );
+    QVERIFY( f.atEnd() );
+
+    // Note how the contents is updated on every write_openswap_conf()
+    i.swap_device_path = QStringLiteral( "/dev/zram/0.zram" );
+    write_openswap_conf( targetFilePath, contents, i );  // Still valid
+    QCOMPARE( contents.length(), 3 );
+    QCOMPARE( i.swap_device_path, QStringLiteral( "/dev/zram/0.zram" ) );  // expected key value
+    QCOMPARE( contents.at( 1 ), QStringLiteral( "swap_device=/dev/zram/0.zram" ) );  // expected line
+}
+
+
+void LOSHTests::testJob()
+{
+    QTemporaryDir tempRoot( QDir::tempPath() + QStringLiteral( "/test-job-XXXXXX" ) );
+    QVERIFY( tempRoot.isValid() );
+    auto* ss = file_setup( tempRoot );
+    QVERIFY( ss );
+
+    LOSHJob j;
+    j.setConfigurationMap(QVariantMap());
+    auto jobresult = j.exec();
+    QVERIFY(jobresult);
+    QVERIFY( QFile::exists( tempRoot.filePath( "etc/openswap.conf" ) ) );
+}
+
+
+QTEST_GUILESS_MAIN( LOSHTests )
+
 #include "utils/moc-warnings.h"
 
 #include "Tests.moc"