Adding OFED option and Cluster singleton with global getter

Author: dhilst

include/cloysterhpc/functions.h

@@ -1,7 +1,8 @@
 #ifndef CLOYSTERHPC_FUNCTIONS_H_
 #define CLOYSTERHPC_FUNCTIONS_H_
 
-#include "services/log.h"
+#include <cloysterhpc/models/cluster.h>
+#include <cloysterhpc/services/log.h>
 #include <boost/process/child.hpp>
 #include <boost/process/pipe.hpp>
 #include <cloysterhpc/services/repos.h>
@@ -19,6 +20,9 @@ namespace cloyster {
 extern bool dryRun;
 
 using OS = cloyster::models::OS;
+
+void initClusterSingleton(std::unique_ptr<models::Cluster> cluster);
+models::Cluster& getClusterSingleton();
 std::shared_ptr<cloyster::services::BaseRunner> getRunner();
 std::shared_ptr<cloyster::services::repos::RepoManager> getRepoManager(
     const OS& osinfo);
@@ -222,6 +226,29 @@ std::filesystem::directory_iterator openDir(const Path& path)
         fmt::format("Dry Run: Would open directory {}", path.string()));
 }
 
+/**
+ * @brief Converts enum to string.
+ * @desc The case is the same used in the enum definition. Convert
+ * it to lower before comparing.
+ */
+template <typename T>
+requires std::is_enum_v<T>
+std::string enumToString(T enumValue)
+{
+    return static_cast<std::string>(magic_enum::enum_name<T>(enumValue));
+}
+
+/**
+ * @brief Converts a string to an enum if possible
+ * @desc The comparison is made case insensitive
+ */
+template <typename T>
+requires std::is_enum_v<T>
+std::optional<T> enumOfStringOpt(const std::string& str)
+{
+    return magic_enum::enum_cast<T>(str, magic_enum::case_insensitive);
+}
+
 }
 
 #endif // CLOYSTERHPC_FUNCTIONS_H_

include/cloysterhpc/models/answerfile.h

@@ -11,6 +11,8 @@
 #include <cloysterhpc/mailsystem/postfix.h>
 #include <cloysterhpc/models/os.h>
 #include <cloysterhpc/tools/ITool.h>
+#include <cloysterhpc/ofed.h>
+#include <magic_enum/magic_enum.hpp>
 #include <optional>
 #include <vector>
 
@@ -156,6 +158,12 @@ class AnswerFile {
         std::filesystem::path key_file;
     };
 
+    struct AFOFED {
+        std::string kind = static_cast<std::string>(magic_enum::enum_name(OFED::Kind::Inbox));
+        std::string version = "latest";
+        bool enabled = false;
+    };
+
     std::filesystem::path m_path;
     inifile m_ini;
 
@@ -268,6 +276,7 @@ class AnswerFile {
     void loadNodes();
     void loadTools();
     void loadNVHPC();
+    void loadOFED();
 
     void dumpNodes();
 
@@ -343,6 +352,7 @@ class AnswerFile {
     AFSystem system;
     AFNodes nodes;
     AFPostfix postfix;
+    AFOFED ofed;
 
     /**
      * @brief Loads the answer file from the specified path.

include/cloysterhpc/models/cluster.h

@@ -181,7 +181,7 @@ class Cluster {
     void setProvisioner(Provisioner);
 
     std::optional<OFED> getOFED() const;
-    void setOFED(OFED::Kind kind);
+    void setOFED(OFED::Kind kind, std::string version = "latest");
 
     std::optional<std::unique_ptr<QueueSystem>>& getQueueSystem();
     void setQueueSystem(QueueSystem::Kind kind);

include/cloysterhpc/models/queuesystem.h

@@ -9,8 +9,6 @@
 #include <fmt/format.h>
 #include <string>
 
-#include <cloysterhpc/functions.h>
-
 // Forward declaration of Cluster
 namespace cloyster::models {
 

include/cloysterhpc/ofed.h

@@ -6,7 +6,11 @@
 #ifndef CLOYSTERHPC_OFED_H_
 #define CLOYSTERHPC_OFED_H_
 
-#include <cloysterhpc/functions.h>
+#include "services/repos.h"
+#include <string>
+
+#include <utility>
+
 
 /**
  * @class OFED
@@ -26,21 +30,28 @@ class OFED {
 
 private:
     Kind m_kind { Kind::Inbox };
+    std::string m_version;
 
 public:
     OFED() = default;
-    explicit OFED(Kind kind);
+    OFED(Kind kind, std::string version)
+    : m_kind(kind)
+    , m_version(std::move(version))
+    {}
 
     void setKind(Kind kind);
     [[nodiscard]] Kind getKind() const;
 
+    void setVersion(std::string&& value) { m_version = std::move(value); }
+    [[nodiscard]] std::string getVersion() const { return m_version; }
+
     /**
      * @brief Installs the OFED software package.
      *
      * This method installs the appropriate OFED components based on the
      * specified kind.
      */
-    void install() const;
+    void install(cloyster::services::repos::RepoManager& repoManager) const;
 };
 
 #endif // CLOYSTERHPC_OFED_H_

include/cloysterhpc/services/shell.h

@@ -23,7 +23,6 @@ using cloyster::models::Cluster;
  */
 class Shell final : public Execution {
 private:
-    const std::unique_ptr<Cluster> m_cluster;
 
     /**
      * @brief Configures SELinux mode.
@@ -171,20 +170,14 @@ class Shell final : public Execution {
     static void disableSELinux();
 
 public:
-    /**
-     * @brief Constructs a Shell object.
-     *
-     * Initializes the Shell object with a reference to a Cluster object.
-     *
-     * @param cluster A reference to a unique pointer managing a Cluster object.
-     */
-    explicit Shell(const std::unique_ptr<Cluster> cluster);
     /**
      * @brief Installs and configures the system.
      *
      * This function performs the installation and configuration processes.
      */
     void install() override;
+
+    Shell();
 };
 
 };

include/cloysterhpc/services/xcat.h

@@ -45,8 +45,6 @@ class XCAT : public Provisioner {
      */
     enum class NodeType { Compute, Service };
 
-    const std::unique_ptr<Cluster>& m_cluster;
-
     struct {
         std::vector<std::string_view> otherpkgs = {};
         // @TODO: We need to support more than one osimage (:
@@ -189,6 +187,9 @@ class XCAT : public Provisioner {
     static void configureEL9();
 
 public:
+    XCAT();
+
+
     /**
      * @brief Download the repositories
      */
@@ -262,8 +263,6 @@ class XCAT : public Provisioner {
      * This function resets the nodes.
      */
     static void resetNodes();
-
-    explicit XCAT(const std::unique_ptr<Cluster>& cluster);
 };
 
 };

src/functions.cpp

@@ -4,6 +4,7 @@
  */
 
 #include <cloysterhpc/functions.h>
+#include <cloysterhpc/models/cluster.h>
 
 #include <chrono>
 #include <cstdio> /* FILE*, fopen, fclose */
@@ -62,8 +63,22 @@ std::shared_ptr<BaseRunner> getRunner()
     return runner.value();
 }
 
+using cloyster::models::Cluster;
 using cloyster::services::repos::RepoManager;
 
+static std::unique_ptr<Cluster> clusterSingleton;
+void initClusterSingleton(std::unique_ptr<Cluster> cluster)
+{
+    assert(!clusterSingleton);
+    clusterSingleton = std::move(cluster);
+}
+
+Cluster& getClusterSingleton()
+{
+    assert(clusterSingleton);
+    return *clusterSingleton;
+}
+
 std::shared_ptr<RepoManager> getRepoManager(const OS& osinfo)
 {
     static std::optional<std::shared_ptr<RepoManager>> repoManager

src/main.cpp

@@ -17,6 +17,7 @@
 #include <cloysterhpc/services/shell.h>
 #include <cloysterhpc/verification.h>
 #include <cloysterhpc/view/newt.h>
+#include <cloysterhpc/functions.h>
 #include <internal_use_only/config.hpp>
 #include <regex>
 
@@ -190,8 +191,10 @@ int main(int argc, const char** argv)
             model->dumpData(dumped_answerfile);
         }
 
+        cloyster::initClusterSingleton(std::move(model));
+
         std::unique_ptr<Execution> executionEngine
-            = std::make_unique<cloyster::services::Shell>(std::move(model));
+            = std::make_unique<cloyster::services::Shell>();
 
         executionEngine->install();
 

src/models/answerfile.cpp

@@ -49,6 +49,7 @@ void AnswerFile::loadOptions()
     loadNodes();
     loadTools();
     loadPostfix();
+    loadOFED();
 }
 
 void AnswerFile::dumpNetwork(
@@ -397,6 +398,9 @@ void AnswerFile::loadSystemSettings()
             afDistro, magic_enum::case_insensitive)) {
         system.distro = formatDistro.value();
     } else {
+        if (cloyster::dryRun) {
+            return;
+        }
         throw std::runtime_error(
             fmt::format("Unsupported distro: {}", afDistro));
     }
@@ -607,6 +611,23 @@ void AnswerFile::loadPostfix()
     postfix.key_file = m_ini.getValue("postfix", "smtpd_tls_key_file", false);
 }
 
+void AnswerFile::loadOFED()
+{
+    auto kind = m_ini.getValue("ofed", "kind");
+    if (kind != "") {
+        ofed.enabled = true; 
+        ofed.kind = kind;
+        auto afVersion = m_ini.getValue("ofed", "version");
+        if (afVersion != "") {
+            ofed.version =  afVersion;
+        } else {
+            ofed.version = "latest"; // use as default
+        }
+
+        LOG_DEBUG("OFED enabled, {} {}", ofed.kind, ofed.version)
+    }
+}
+
 };
 
 #ifdef BUILD_TESTING