engine.h

#ifndef CAPIO_CL_ENGINE_H
#define CAPIO_CL_ENGINE_H
#include <jsoncons/basic_json.hpp>
#include <shared_mutex>
#include <vector>
 
#include "capiocl.hpp"
#include "capiocl/api.h"
#include "capiocl/monitor.h"
#include "capiocl/serializer.h"

namespace capiocl::engine {

struct CapioCLEntry final {
    // LCOV_EXCL_START
    std::vector<std::string> producers;
    std::vector<std::string> consumers;
    std::vector<std::filesystem::path> file_dependencies;
    std::string commit_rule            = commitRules::ON_TERMINATION;
    std::string fire_rule              = fireRules::UPDATE;
    long directory_children_count      = 0;
    long commit_on_close_count         = 0;
    bool enable_directory_count_update = true;
    bool store_in_memory               = false;
    bool permanent                     = false;
    bool excluded                      = false;
    bool is_file                       = true;
    // LCOV_EXCL_STOP

    static CapioCLEntry fromJson(const std::string &in);

    [[nodiscard]] std::string toJson() const;

    CapioCLEntry &operator+=(const CapioCLEntry &rhs);

    CapioCLEntry operator+(const CapioCLEntry &rhs);

    bool operator==(const CapioCLEntry &other);

    bool operator!=(const CapioCLEntry &other);
};

class Engine final {
    friend class serializer::Serializer;

    mutable std::shared_mutex _shared_mutex;

    bool store_all_in_memory = false;

    configuration::CapioClConfiguration configuration;

    void configureMonitorBackends();

    monitor::Monitor monitor;

    std::string node_name;

    std::string workflow_name;

    std::unique_ptr<api::CapioClApiServer> webapi_server;

    mutable std::unordered_map<std::string, CapioCLEntry> _capio_cl_entries;

    mutable std::unordered_map<std::string, std::string> _glob_patterns;

    mutable std::unordered_map<std::string, std::vector<std::string>> _normalized_aliases;

    static bool _isGlobPattern(const std::string &path);

    void _addToGlobIndex(const std::string &path) const;

    void _removeFromGlobIndex(const std::string &path) const;

    bool _isAppListed(const std::string &path, const std::string &app_name,
                      std::vector<std::string> CapioCLEntry::*list) const;

    static std::string truncateLastN(const std::string &str, const std::size_t n) {
        if (str.length() > n) {
            return "[..] " + str.substr(str.length() - n);
        }
        return str;
    }

    void _newFile(const std::filesystem::path &path) const;

    void compute_directory_entry_count(const std::filesystem::path &path) const;
 
  public:
    explicit Engine(bool use_default_settings = true);

    explicit Engine(const configuration::CapioClConfiguration &config);

    void print() const;

    bool contains(const std::filesystem::path &file) const;

    size_t size() const;

    void add(std::filesystem::path &path, std::vector<std::string> &producers,
             std::vector<std::string> &consumers, const std::string &commit_rule,
             const std::string &fire_rule, bool permanent, bool exclude,
             std::vector<std::filesystem::path> &dependencies);

    void add(const std::filesystem::path &path, const CapioCLEntry &entry) const;

    void addProducer(const std::filesystem::path &path, std::string &producer);

    void addConsumer(const std::filesystem::path &path, std::string &consumer);

    void addFileDependency(const std::filesystem::path &path,
                           std::filesystem::path &file_dependency);

    void newFile(const std::filesystem::path &path) const;

    void remove(const std::filesystem::path &path) const;

    void setCommitRule(const std::filesystem::path &path, const std::string &commit_rule);

    void setFireRule(const std::filesystem::path &path, const std::string &fire_rule);

    void setPermanent(const std::filesystem::path &path, bool value);

    void setExclude(const std::filesystem::path &path, bool value);

    void setDirectory(const std::filesystem::path &path);

    void setFile(const std::filesystem::path &path);

    void setCommitedCloseNumber(const std::filesystem::path &path, long num);

 
    void setDirectoryFileCount(const std::filesystem::path &path, long num);

    void setFileDeps(const std::filesystem::path &path,
                     const std::vector<std::filesystem::path> &dependencies);

    void setStoreFileInMemory(const std::filesystem::path &path);

    void setAllStoreInMemory();

    void setStoreFileInFileSystem(const std::filesystem::path &path);

    void setWorkflowName(const std::string &name);

    long getDirectoryFileCount(const std::filesystem::path &path) const;

    std::string getCommitRule(const std::filesystem::path &path) const;

    std::string getFireRule(const std::filesystem::path &path) const;

    std::vector<std::string> getProducers(const std::filesystem::path &path) const;

    std::vector<std::string> getConsumers(const std::filesystem::path &path) const;

    long getCommitCloseCount(const std::filesystem::path &path) const;

    std::vector<std::filesystem::path>
    getCommitOnFileDependencies(const std::filesystem::path &path) const;

    std::vector<std::string> getFileToStoreInMemory() const;

    std::set<std::string> getHomeNode(const std::filesystem::path &path) const;

    void setHomeNode(const std::filesystem::path &path) const;

    const std::string &getWorkflowName() const;

    bool isProducer(const std::filesystem::path &path, const std::string &app_name) const;

    bool isConsumer(const std::filesystem::path &path, const std::string &app_name) const;

    bool isFirable(const std::filesystem::path &path) const;

    bool isFile(const std::filesystem::path &path) const;

    bool isExcluded(const std::filesystem::path &path) const;

    bool isDirectory(const std::filesystem::path &path) const;

    bool isStoredInMemory(const std::filesystem::path &path) const;

    bool isPermanent(const std::filesystem::path &path) const;

    bool isCommitted(const std::filesystem::path &path) const;

    bool increaseCloseCount(const std::filesystem::path &path) const;

    void setCommitted(const std::filesystem::path &path) const;

    std::vector<std::string> getPaths() const;

    bool operator==(const Engine &other) const;

    void loadConfiguration(const std::string &path);

    void useDefaultConfiguration();

    void startApiServer();
};
 
} // namespace capiocl::engine
 
#endif // CAPIO_CL_ENGINE_H