Varius bugfixes

CMakeLists.txt

@@ -18,7 +18,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
 
 # Set compiler flags
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -pedantic -O0 -Wno-gnu-zero-variadic-macro-arguments")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -pedantic -O0")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
 
 #####################################

src/common/capio/constants.hpp

@@ -36,9 +36,9 @@ constexpr char CAPIO_SERVER_CLI_LOG_SERVER_WARNING[] = "[ \033[1;33m SERVER \033
 constexpr char CAPIO_SERVER_CLI_LOG_SERVER_ERROR[]   = "[ \033[1;31m SERVER \033[0m ] ";
 constexpr char LOG_CAPIO_START_REQUEST[]             = "\n+++++++++++ SYSCALL %s (%d) +++++++++++";
 constexpr char LOG_CAPIO_END_REQUEST[]               = "----------- END SYSCALL ----------\n";
-constexpr char CAPIO_SERVER_LOG_START_REQUEST_MSG[]  = "\n+++++++++++++++++REQUEST+++++++++++++++++";
-constexpr char CAPIO_SERVER_LOG_END_REQUEST_MSG[]    = "~~~~~~~~~~~~~~~END REQUEST~~~~~~~~~~~~~~~";
-constexpr int CAPIO_LOG_MAX_MSG_LEN                  = 2048;
+constexpr char CAPIO_SERVER_LOG_START_REQUEST_MSG[] = "\n+++++++++++++++++REQUEST+++++++++++++++++";
+constexpr char CAPIO_SERVER_LOG_END_REQUEST_MSG[]   = "~~~~~~~~~~~~~~~END REQUEST~~~~~~~~~~~~~~~";
+constexpr int CAPIO_LOG_MAX_MSG_LEN                 = 2048;
 
 // CAPIO streaming semantics
 constexpr char CAPIO_FILE_MODE_NO_UPDATE[]           = "no_update";

src/posix/libcapio_posix.cpp

@@ -360,6 +360,7 @@ static int hook(long syscall_number, long arg0, long arg1, long arg2, long arg3,
         return 1;
     }
 
+    LOG("Handling syscall NO %ld (max num is %ld)", syscall_number, CAPIO_NR_SYSCALLS);
     return syscallTable[syscall_number](arg0, arg1, arg2, arg3, arg4, arg5, result);
 }
 

src/server/capio-cl-engine/capio_cl_engine.hpp

@@ -1,6 +1,7 @@
 #ifndef CAPIO_ENGINE_HPP
 #define CAPIO_ENGINE_HPP
 
+#include "client-manager/client_manager.hpp"
 #include "utils/common.hpp"
 
 class CapioCLEngine {
@@ -18,7 +19,7 @@ class CapioCLEngine {
                        >
         _locations;
 
-    static inline std::string truncate_last_n(const std::string &str, int n) {
+    static std::string truncate_last_n(const std::string &str, int n) {
         return str.length() > n ? "[..] " + str.substr(str.length() - n) : str;
     }
 
@@ -107,6 +108,7 @@ class CapioCLEngine {
 
     // TODO: might need to be improved
     bool file_to_be_handled(std::filesystem::path::iterator::reference path) const {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
         for (const auto &entry : _locations) {
             auto capio_path = entry.first;
             if (path == capio_path) {
@@ -121,14 +123,18 @@ class CapioCLEngine {
         return false;
     };
 
-    inline void add(std::string &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) {
+    void add(std::string &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) {
+        START_LOG(gettid(), "call(path=%s, commit=%s, fire=%s, permanent=%s, exclude=%s)",
+                  path.c_str(), commit_rule.c_str(), fire_rule.c_str(), permanent ? "YES" : "NO",
+                  exclude ? "YES" : "NO");
         _locations.emplace(path, std::make_tuple(producers, consumers, commit_rule, fire_rule,
                                                  permanent, exclude, true, -1, -1));
     }
 
-    inline void newFile(const std::string &path) {
+    void newFile(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
         if (_locations.find(path) == _locations.end()) {
             std::string commit = CAPIO_FILE_COMMITTED_ON_TERMINATION;
             std::string fire   = CAPIO_FILE_MODE_UPDATE;
@@ -153,66 +159,121 @@ class CapioCLEngine {
         }
     }
 
-    inline void addProducer(const std::string &path, std::string &producer) {
+    void addProducer(const std::string &path, std::string &producer) {
+        START_LOG(gettid(), "call(path=%s, producer=%s)", path.c_str(), producer.c_str());
         producer.erase(remove_if(producer.begin(), producer.end(), isspace), producer.end());
         std::get<0>(_locations.at(path)).emplace_back(producer);
     }
 
-    inline void addConsumer(const std::string &path, std::string &consumer) {
+    void addConsumer(const std::string &path, std::string &consumer) {
+        START_LOG(gettid(), "call(path=%s, consumer=%s)", path.c_str(), consumer.c_str());
         consumer.erase(remove_if(consumer.begin(), consumer.end(), isspace), consumer.end());
         std::get<1>(_locations.at(path)).emplace_back(consumer);
     }
 
-    inline void setCommitRule(const std::string &path, const std::string &commit_rule) {
+    void setCommitRule(const std::string &path, const std::string &commit_rule) {
+        START_LOG(gettid(), "call(path=%s, commit_rule=%s)", path.c_str(), commit_rule.c_str());
         std::get<2>(_locations.at(path)) = commit_rule;
     }
 
-    inline std::string getCommitRule(const std::string &path) {
+    std::string getCommitRule(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        LOG("Fire rule: %s", std::get<2>(_locations.at(path)).c_str());
         return std::get<2>(_locations.at(path));
     }
 
-    inline void setFireRule(const std::string &path, const std::string &fire_rule) {
+    void setFireRule(const std::string &path, const std::string &fire_rule) {
+        START_LOG(gettid(), "call(path=%s, fire_rule=%s)", path.c_str(), fire_rule.c_str());
         std::get<3>(_locations.at(path)) = fire_rule;
     }
 
-    inline std::string getFireRule(const std::string &path) {
+    std::string getFireRule(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
         return std::get<3>(_locations.at(path));
     }
 
-    inline void setPermanent(const std::string &path, bool value) {
+    void setPermanent(const std::string &path, bool value) {
+        START_LOG(gettid(), "call(path=%s, value=%s)", path.c_str(), value ? "true" : "false");
         std::get<4>(_locations.at(path)) = value;
     }
 
-    inline void setExclude(const std::string &path, const bool value) {
+    void setExclude(const std::string &path, const bool value) {
+        START_LOG(gettid(), "call(path=%s, value=%s)", path.c_str(), value ? "true" : "false");
         std::get<5>(_locations.at(path)) = value;
     }
 
-    inline void setDirectory(const std::string &path) { std::get<6>(_locations.at(path)) = false; }
+    void setDirectory(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        std::get<6>(_locations.at(path)) = false;
+    }
 
-    inline bool isDirectory(const std::string &path) const {
+    bool isDirectory(const std::string &path) const {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
         return !std::get<6>(_locations.at(path));
     }
 
-    inline void setFile(const std::string &path) { std::get<6>(_locations.at(path)) = true; }
+    void setFile(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        std::get<6>(_locations.at(path)) = true;
+    }
 
-    inline bool isFile(const std::string &path) const { return std::get<6>(_locations.at(path)); }
+    bool isFile(const std::string &path) const {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        return std::get<6>(_locations.at(path));
+    }
 
-    inline void setCommitedNumber(const std::string &path, const int num) {
+    void setCommitedNumber(const std::string &path, const int num) {
+        START_LOG(gettid(), "call(path=%s, num=%ld)", path.c_str(), num);
         std::get<7>(_locations.at(path)) = num;
     }
 
-    inline void setDirectoryFileCount(const std::string &path, long num) {
+    void setDirectoryFileCount(const std::string &path, long num) {
+        START_LOG(gettid(), "call(path=%s, num=%ld)", path.c_str(), num);
         std::get<8>(_locations.at(path)) = num;
     }
 
-    inline void remove(const std::string &path) { _locations.erase(path); }
+    void remove(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        _locations.erase(path);
+    }
 
     // TODO: return vector
-    inline auto producers(const std::string &path) { return std::get<0>(_locations.at(path)); }
+    auto producers(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        return std::get<0>(_locations.at(path));
+    }
 
     // TODO: return vector
-    inline auto consumers(const std::string &path) { return std::get<1>(_locations.at(path)); }
+    auto consumers(const std::string &path) {
+        START_LOG(gettid(), "call(path=%s)", path.c_str());
+        return std::get<1>(_locations.at(path));
+    }
+
+    bool isProducer(const std::string &path, const pid_t pid) {
+        START_LOG(gettid(), "call(path=%s, pid=%ld", path.c_str(), pid);
+
+        const auto app_name = client_manager->get_app_name(pid);
+        LOG("App name for tid %d is %s", pid, app_name.c_str());
+
+        // check for exact entry
+        if (_locations.find(path) != _locations.end()) {
+            LOG("Found exact match for path");
+            std::vector<std::string> producers = std::get<0>(_locations.at(path));
+            return std::find(producers.begin(), producers.end(), app_name) != producers.end();
+        }
+        LOG("No exact match found in locations. checking for globs");
+        // check for glob
+        for (const auto &[k, entry] : _locations) {
+            if (match_globs(k, path)) {
+                LOG("Found possible glob match");
+                std::vector<std::string> producers = std::get<0>(_locations.at(k));
+                return std::find(producers.begin(), producers.end(), app_name) != producers.end();
+            }
+        }
+        LOG("No match has been found");
+        return false;
+    }
 };
 
-inline CapioCLEngine *capio_cl_engine;
+CapioCLEngine *capio_cl_engine;
 #endif // CAPIO_ENGINE_HPP

src/server/capio-cl-engine/json_parser.hpp

@@ -142,7 +142,7 @@ class JsonParser {
                         std::filesystem::path file_fs(elem);
                         if (file_fs.is_relative() ||
                             first_is_subpath_of_second(file_fs, get_capio_dir())) {
-                            LOG("Saving file %s to locations", elem.data());
+                            LOG("Saving file %s to locations", std::string(elem).c_str());
                             streaming_names.emplace_back(elem);
                         }
                     }

src/server/client-manager/client_manager.hpp

@@ -11,6 +11,7 @@ class ClientManager {
 
   public:
     ClientManager() {
+        START_LOG(gettid(), "call()");
         bufs_response                = new CSBufResponse_t();
         app_names                    = new std::unordered_map<int, const std::string>;
         files_to_be_committed_by_tid = new std::unordered_map<pid_t, std::vector<std::string> *>;
@@ -19,6 +20,7 @@ class ClientManager {
     }
 
     ~ClientManager() {
+        START_LOG(gettid(), "call()");
         delete bufs_response;
         delete app_names;
         delete files_to_be_committed_by_tid;
@@ -32,6 +34,7 @@ class ClientManager {
      * @return
      */
     inline void register_new_client(pid_t tid, const std::string &app_name) const {
+        START_LOG(gettid(), "call(tid=%ld, app_name=%s)", tid, app_name.c_str());
         // TODO: replace numbers with constexpr
         auto *p_buf_response =
             new CircularBuffer<capio_off64_t>(SHM_COMM_CHAN_NAME_RESP + std::to_string(tid),
@@ -47,6 +50,7 @@ class ClientManager {
      * @return
      */
     inline void remove_client(pid_t tid) {
+        START_LOG(gettid(), "call(tid=%ld)", tid);
         auto it_resp = bufs_response->find(tid);
         if (it_resp != bufs_response->end()) {
             delete it_resp->second;
@@ -68,12 +72,19 @@ class ClientManager {
     }
 
     void add_producer_file_path(pid_t tid, std::string &path) const {
+        START_LOG(gettid(), "call(tid=%ld, path=%s)", tid, path.c_str());
         files_to_be_committed_by_tid->at(tid)->emplace_back(path);
     }
 
     [[nodiscard]] auto get_produced_files(pid_t tid) const {
+        START_LOG(gettid(), "call(tid=%ld)", tid);
         return files_to_be_committed_by_tid->at(tid);
     }
+
+    std::string get_app_name(pid_t tid) const {
+        START_LOG(gettid(), "call(tid=%ld)", tid);
+        return app_names->at(tid);
+    }
 };
 
 inline ClientManager *client_manager;

src/server/client-manager/handlers/consent.hpp

@@ -26,8 +26,9 @@ inline void consent_to_proceed_handler(const char *const str) {
         return;
     }
 
-    if (std::filesystem::exists(path) || CapioFileManager::is_committed(path)) {
-        LOG("It is possible to unlokc waiting thread");
+    if (std::filesystem::exists(path) || CapioFileManager::is_committed(path) ||
+        capio_cl_engine->isProducer(path, tid)) {
+        LOG("It is possible to unlock waiting thread");
         client_manager->reply_to_client(tid, 1);
     } else {
         LOG("Requested file %s does not exists yet. awaiting for creation", path);

src/server/file-manager/file_manager.hpp

@@ -1,20 +1,26 @@
 #ifndef FILE_MANAGER_HEADER_HPP
 #define FILE_MANAGER_HEADER_HPP
 
+#include <mutex>
+std::mutex threads_mutex;
+std::mutex data_mutex;
+
 class CapioFileManager {
     std::unordered_map<std::string, std::vector<pid_t> *> *thread_awaiting_file_creation;
     std::unordered_map<std::string, std::unordered_map<pid_t, capio_off64_t> *>
         *thread_awaiting_data;
 
   public:
     CapioFileManager() {
+        START_LOG(gettid(), "call()");
         thread_awaiting_file_creation = new std::unordered_map<std::string, std::vector<pid_t> *>;
         thread_awaiting_data =
             new std::unordered_map<std::string, std::unordered_map<pid_t, capio_off64_t> *>;
         std::cout << CAPIO_SERVER_CLI_LOG_SERVER << "CapioFileManager initialization completed."
                   << std::endl;
     }
     ~CapioFileManager() {
+        START_LOG(gettid(), "call()");
         delete thread_awaiting_file_creation;
         delete thread_awaiting_data;
     }