Fixed deadlock on startup

Author: marcoSanti

CMakeLists.txt

@@ -97,5 +97,6 @@ install(
 
 IF (CAPIO_BUILD_TESTS)
     message(STATUS "Building CAPIO test suite")
+    add_compile_definitions(CAPIO_BUILD_TESTS)
     add_subdirectory(tests)
 ENDIF (CAPIO_BUILD_TESTS)

src/posix/utils/requests.hpp

@@ -50,7 +50,19 @@ inline void handshake_request(const long tid, const long pid, const std::string
     char req[CAPIO_REQ_MAX_SIZE];
     sprintf(req, "%04d %ld %ld %s", CAPIO_REQUEST_HANDSHAKE, tid, pid, app_name.c_str());
     buf_requests->write(req, CAPIO_REQ_MAX_SIZE);
-    bufs_response->at(pid)->read();
+
+#ifndef CAPIO_BUILD_TESTS
+    /*
+     * The handshake request must be blocking ONLY when not building tests. This is because when
+     * starting unit tests, the binary is loaded with libcapio_posix.so underneath thus performing
+     * a handshake request. If the handshake is blocking, then the capio_server binary cannot be
+     * started as the whole process is waiting for a handshake.
+     */
+    if (bufs_response->at(pid)->read() == 0) {
+        ERR_EXIT("Error: handshake request sent while capio_server is shutting down!");
+    }
+#endif
+
     LOG("Sent handshake request");
 }
 

src/server/client-manager/client_manager.hpp

@@ -123,9 +123,7 @@ class ClientManager {
         return CAPIO_DEFAULT_APP_NAME;
     }
 
-    inline auto get_connected_posix_client() {
-        return bufs_response->size();
-    }
+    inline auto get_connected_posix_client() { return bufs_response->size(); }
 };
 
 inline ClientManager *client_manager;

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

@@ -16,14 +16,27 @@ inline void handshake_handler(const char *const str) {
     char app_name[1024];
     sscanf(str, "%d %d %s", &tid, &pid, app_name);
     START_LOG(gettid(), "call(tid=%ld, pid=%ld, app_name=%s)", tid, pid, app_name);
-    if (termination_phase) {
-        LOG("Termination phase is in progress. ignoring further handshakes.");
-        return;
-    }
+
     client_manager->register_client(app_name, tid);
     storage_service->register_client(app_name, tid);
-    // Unlock client waiting to start
-    client_manager->reply_to_client(tid, 1);
+    /*
+     * The handshake request must be blocking ONLY when not building tests. This is because when
+     * starting unit tests, the binary is loaded with libcapio_posix.so underneath thus performing
+     * a handshake request. If the handshake is blocking, then the capio_server binary cannot be
+     * started as the whole process is waiting for a handshake.
+     */
+#ifndef CAPIO_BUILD_TESTS
+    // If not on termination phase, return 1. Otherwise, return 0
+    // if - is returned posix application will terminate
+    if (!termination_phase) {
+        // Unlock client waiting to start
+        LOG("Allowing handshake to continue");
+        client_manager->reply_to_client(tid, 1);
+    } else {
+        LOG("Termination phase is in progress. ignoring further handshakes.");
+        client_manager->reply_to_client(tid, 0);
+    }
+#endif
 }
 
 #endif // HANDSHAKE_HPP

src/server/client-manager/request_handler_engine.hpp

@@ -134,16 +134,15 @@ class RequestHandlerEngine {
                 if (termination_phase) {
                     std::cout << CAPIO_LOG_SERVER_CLI_LEVEL_WARNING << " [ " << node_name << " ] "
                               << "Termination phase is in progress... Ignoring Exception likely "
-                                 "thrown while "
-                                 "reciving SIGUSR1"
+                                 "thrown while receiving SIGUSR1"
                               << std::endl;
                     continue;
                 }
                 throw e;
             }
 
             if (code < 0 && errno == EINTR) {
-                LOG("Signal recived while waiting on data. skipping iteration");
+                LOG("Signal received while waiting on data. skipping iteration");
                 continue;
             }
 

src/server/utils/signals.hpp

@@ -46,15 +46,14 @@ inline void sig_term_handler(int signum, siginfo_t *info, void *ptr) {
     exit(EXIT_SUCCESS);
 }
 
-
 inline void sig_usr1_handler(int signum, siginfo_t *info, void *ptr) {
     if (gettid() != CAPIO_SERVER_MAIN_PID) {
         return;
     }
     START_LOG(gettid(), "call(signal=[%d] (%s) from process with pid=%ld)", signum,
               strsignal(signum), info != nullptr ? info->si_pid : -1);
     std::cout << CAPIO_LOG_SERVER_CLI_LEVEL_WARNING << " [ " << node_name << " ] "
-            << "Recived request for graceful shutdown!" << std::endl;
+              << "Received request for graceful shutdown!" << std::endl;
     termination_phase = true;
 }
 
@@ -67,28 +66,23 @@ inline void setup_signal_handlers() {
     static struct sigaction sigact, sigact_usr1;
     memset(&sigact, 0, sizeof(sigact));
     memset(&sigact, 0, sizeof(sigact_usr1));
-    sigact.sa_sigaction = sig_term_handler;
-    sigact.sa_flags     = SA_SIGINFO;
+    sigact.sa_sigaction      = sig_term_handler;
+    sigact.sa_flags          = SA_SIGINFO;
     sigact_usr1.sa_sigaction = sig_usr1_handler;
     sigact_usr1.sa_flags     = SA_SIGINFO;
-    int res             = sigaction(SIGTERM, &sigact, nullptr);
-    res                 = res | sigaction(SIGILL, &sigact, nullptr);
-    res                 = res | sigaction(SIGABRT, &sigact, nullptr);
-    res                 = res | sigaction(SIGFPE, &sigact, nullptr);
-    res                 = res | sigaction(SIGSEGV, &sigact, nullptr);
-    res                 = res | sigaction(SIGQUIT, &sigact, nullptr);
-    res                 = res | sigaction(SIGPIPE, &sigact, nullptr);
-    res                 = res | sigaction(SIGINT, &sigact, nullptr);
-    res                 = res | sigaction(SIGUSR1, &sigact_usr1, nullptr);
+    int res = sigaction(SIGTERM, &sigact, nullptr) | sigaction(SIGILL, &sigact, nullptr) |
+              sigaction(SIGABRT, &sigact, nullptr) | sigaction(SIGFPE, &sigact, nullptr) |
+              sigaction(SIGSEGV, &sigact, nullptr) | sigaction(SIGQUIT, &sigact, nullptr) |
+              sigaction(SIGPIPE, &sigact, nullptr) | sigaction(SIGINT, &sigact, nullptr) |
+              sigaction(SIGUSR1, &sigact_usr1, nullptr);
     if (res == -1) {
         ERR_EXIT("sigaction for SIGTERM");
     }
 }
 
-
 /*
  * Defining here the RequestHandlerEngine::handle_termination_phase()
- * to avoid recursive include wihin the header files
+ * to avoid recursive include within the header files
  */
 inline void RequestHandlerEngine::handle_termination_phase() const {
     START_LOG(capio_syscall(SYS_gettid), "call()");
@@ -100,5 +94,4 @@ inline void RequestHandlerEngine::handle_termination_phase() const {
     sig_term_handler(SIGTERM, nullptr, nullptr);
 }
 
-
 #endif // CAPIO_SERVER_HANDLERS_SIGNALS_HPP