WIP: Repository class refactoring

include/cloysterhpc/functions.h

@@ -4,12 +4,14 @@
 #include <boost/process/child.hpp>
 #include <boost/process/pipe.hpp>
 #include <filesystem>
+#include <glibmm/ustring.h>
 #include <list>
 #include <optional>
 #include <string>
 #include <vector>
 
 #include <boost/asio.hpp>
+#include <glibmm/keyfile.h>
 
 namespace cloyster {
 // Globals
@@ -164,6 +166,9 @@ std::string findAndReplace(const std::string_view& source,
  */
 void copyFile(std::filesystem::path source, std::filesystem::path destination);
 
+std::optional<Glib::ustring> readKeyfileString(Glib::RefPtr<Glib::KeyFile> file,
+    const std::string_view& group, const std::string_view& key);
+
 } /* namespace cloyster */
 
 #endif // CLOYSTERHPC_FUNCTIONS_H_

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,80 @@ 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:
+    explicit GenericFile(const std::filesystem::path& path)
+        : m_path(path)
+    {
+    }
+
+    virtual void read() { }
+    virtual void write() { }
+
+    virtual ~GenericFile() = default;
+};
+
+struct ELRepo {
+    std::string group;
+    std::string name;
+    std::optional<std::string> base_url;
+    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>&);
+
+    std::vector<ELRepo> m_repositories;
+
+public:
+    explicit ELRepoFile(const std::filesystem::path& path)
+        : GenericFile(path)
+    {
+    }
+
+    virtual void read() override;
+    virtual void write() override;
+
+    void parse();
+    void parse(const std::stringstream& ss);
+    void unparse();
+    void unparse(std::stringstream& ss);
+
+    [[nodiscard]] std::vector<ELRepo>& getRepositories();
+    [[nodiscard]] const std::vector<ELRepo>& getRepositoriesConst() const;
+
+    ~ELRepoFile() override = default;
+};
+
 #endif // CLOYSTERHPC_REPO_H_

src/functions.cpp

@@ -351,4 +351,12 @@ void copyFile(std::filesystem::path source, std::filesystem::path destination)
     }
 }
 
+std::optional<Glib::ustring> readKeyfileString(Glib::RefPtr<Glib::KeyFile> file,
+    const std::string_view& group, const std::string_view& key)
+{
+    return file->has_key(group.data(), key.data())
+        ? std::make_optional(file->get_string(group.data(), key.data()))
+        : std::nullopt;
+}
+
 } // namespace cloyster

src/services/repo.cpp

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <cloysterhpc/functions.h>
 #include <cloysterhpc/services/repo.h>
 #include <fmt/printf.h>
 #include <glibmm/fileutils.h>
@@ -56,3 +57,105 @@ 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()); }
+
+void ELRepoFile::parse()
+{
+    read();
+
+    m_repositories = parseData();
+}
+
+void ELRepoFile::parse(const std::stringstream& ss)
+{
+    m_file = Glib::KeyFile::create();
+    m_file->load_from_data(ss.str().c_str());
+    m_repositories = parseData();
+}
+
+std::vector<ELRepo> ELRepoFile::parseData()
+{
+    auto reponames = m_file->get_groups();
+
+    std::vector<ELRepo> repositories;
+
+    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 = cloyster::readKeyfileString(
+            m_file, std::string_view { repogroup.c_str() }, "metalink");
+        auto baseurl = cloyster::readKeyfileString(
+            m_file, std::string_view { repogroup.c_str() }, "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.base_url
+            = 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()
+{
+    unparseData(m_repositories);
+    write();
+}
+
+void ELRepoFile::unparse(std::stringstream& ss)
+{
+    unparseData(m_repositories);
+    ss.seekp(0);
+    ss << m_file->to_data();
+}
+
+[[nodiscard]] std::vector<ELRepo>& ELRepoFile::getRepositories()
+{
+    return m_repositories;
+}
+
+[[nodiscard]] const std::vector<ELRepo>&
+ELRepoFile::getRepositoriesConst() const
+{
+    return m_repositories;
+}