WIP: Repository class refactoring

include/cloysterhpc/services/repo.h

@@ -12,6 +12,9 @@
 #include <string_view>
 #include <vector>
 
+#include <glibmm/fileutils.h>
+#include <glibmm/keyfile.h>
+
 /**
  * @brief This class represents an EL .repo file as it's found in
  * /etc/yum.repos.d/
@@ -47,4 +50,73 @@ class repo {
     static void load_repository(std::filesystem::path path);
 };
 
+class repository_exception : public std::runtime_error {
+public:
+    explicit repository_exception(const std::string& msg)
+        : std::runtime_error(msg)
+    {
+    }
+};
+
+
+
+/**
+ * Generic file class
+ *
+ * This class should only read and write, 
+ */
+class GenericFile {
+protected:
+    std::filesystem::path m_path;
+public:
+    GenericFile(const std::filesystem::path& path)
+        : m_path(path)
+    {}
+
+    virtual void read() {}
+    virtual void write() {}
+};
+
+
+
+struct ELRepo {
+    std::string group;
+    std::string name;
+    std::optional<std::string> baseURL;
+    std::optional<std::string> metalink;
+    bool enabled;
+    bool gpgcheck;
+    std::string gpgkey;
+
+    // (P/ todos os repositórios)
+    // std::string release;
+
+};
+
+
+/**
+ * Repository file class
+ *
+ * This class should parse the repository data
+ */
+class ELRepoFile : GenericFile {
+private:    
+    Glib::RefPtr<Glib::KeyFile> m_file;
+
+    std::vector<ELRepo> parseData();
+    void unparseData(const std::vector<ELRepo>&);
+public:
+    ELRepoFile(const std::filesystem::path& path)
+        : GenericFile(path)
+    {}
+
+    virtual void read() override;
+    virtual void write() override;
+
+    std::vector<ELRepo> parse();
+    std::vector<ELRepo> parse(const std::stringstream& ss);
+    void unparse( const std::vector<ELRepo>& repositories );
+    void unparse( const std::vector<ELRepo>& repositories, std::stringstream& ss );
+};
+
 #endif // CLOYSTERHPC_REPO_H_

src/services/repo.cpp

@@ -56,3 +56,100 @@ void repo::load_repository(std::filesystem::path path)
         fmt::print("KeyFile Error: {}\n", ex.what());
     }
 }
+
+void ELRepoFile::read()
+{
+    try {
+        m_file = Glib::KeyFile::create();
+        m_file->load_from_file(m_path.string());
+    } catch (Glib::FileError& e) {
+        throw repository_exception(
+            std::format("Could not load repository file {} ({})",
+                m_path.string(), e.what()));
+    }
+}
+
+void ELRepoFile::write() { m_file->save_to_file(m_path.string()); }
+
+std::vector<ELRepo> ELRepoFile::parse()
+{
+    this->read();
+
+    return this->parseData();
+}
+
+std::vector<ELRepo> ELRepoFile::parse(const std::stringstream& ss)
+{
+    m_file = Glib::KeyFile::create();
+    m_file->load_from_data(ss.str().c_str());
+    return this->parseData();
+}
+
+
+std::vector<ELRepo>  ELRepoFile::parseData()
+{
+    auto reponames = m_file->get_groups();
+
+    std::vector<ELRepo> repositories;
+
+    auto get_optional_string
+        = [this](auto group, auto key) -> std::optional<Glib::ustring> {
+        return m_file->has_key(group, key)
+            ? std::make_optional(m_file->get_string(group, key))
+            : std::nullopt;
+    };
+
+    for (const auto& repogroup : reponames) {
+        auto name = m_file->get_string(repogroup, "name");
+
+        if (name.empty()) {
+            throw repository_exception(std::format(
+                "Could not load repo name from repo '{}' at m_file {}",
+                repogroup.raw(), m_path.string()));
+        }
+
+        auto metalink = get_optional_string(repogroup, "metalink");
+        auto baseurl = get_optional_string(repogroup, "baseurl");
+
+        auto enabled = m_file->get_boolean(repogroup, "enabled");
+        auto gpgcheck = m_file->get_boolean(repogroup, "gpgcheck");
+        auto gpgkey = m_file->get_string(repogroup, "gpgkey");
+
+        ELRepo repo;
+        repo.group = repogroup.raw();
+        repo.name = name.raw();
+        repo.metalink
+            = metalink.transform([](const auto& v) { return v.raw(); });
+        repo.baseURL = baseurl.transform([](const auto& v) { return v.raw(); });
+        repo.enabled = enabled;
+        repo.gpgcheck = gpgcheck;
+        repo.gpgkey = gpgkey;
+        repositories.push_back(std::move(repo));
+    }
+
+    return repositories;
+}
+
+void ELRepoFile::unparseData(const std::vector<ELRepo>& repositories)
+{    
+    for (const auto& repo : repositories) {
+        m_file->set_string(repo.group, "name", repo.name);
+        m_file->set_boolean(repo.group, "enabled", repo.enabled);
+        m_file->set_boolean(repo.group, "gpgcheck", repo.gpgcheck);
+        m_file->set_string(repo.group, "gpgkey", repo.gpgkey);
+    }    
+}
+
+void ELRepoFile::unparse(const std::vector<ELRepo>& repositories)
+{
+    this->unparseData(repositories);
+    this->write();
+}
+
+
+void ELRepoFile::unparse(const std::vector<ELRepo>& repositories, std::stringstream& ss)
+{
+    this->unparseData(repositories);
+    ss.seekp(0);
+    ss << m_file->to_data();
+}