Merge pull request #5 from ckrinitsin/fixes HEAD main

Fixes

3 files changed, 44 insertions, 12 deletions

diff --git a/src/server/hashtable.h b/src/server/hashtable.h
index e09fcd4..334a62e 100644
--- a/src/server/hashtable.h
+++ b/src/server/hashtable.h
@@ -29,6 +29,11 @@ public:
     }
 
     /**
+     * @brief Constructs a new Hashtable.
+     */
+    HashTable() {}
+
+    /**
      * @brief Insert a kv-pair into the hashtable.
      *
      * @param key The key to determine the bucket.
diff --git a/src/server/main.cpp b/src/server/main.cpp
index d724bd5..42b7668 100644
--- a/src/server/main.cpp
+++ b/src/server/main.cpp
@@ -1,14 +1,30 @@
+#include <csignal>
 #include <cstdint>
 #include <iostream>
 #include <stdexcept>
 #include <string>
 
-#include "shared_memory_server.h"
+#include "server.h"
+
+Server<int, int> shm;
+
+/**
+ * @brief Shuts the server down, when pressing <Ctrl+C>.
+ *
+ * @param signal Specifies the signal, which was caught.
+ */
+void signal_handler(int signal)
+{
+    if (signal == SIGINT) {
+        std::cout << "Server shutting down" << '\n';
+        exit(0);
+    }
+}
 
 int main(int argc, char* argv[])
 {
     if (argc != 2) {
-        std::cout << "One argument required" << '\n';
+        std::cout << "Usage: " << argv[0] << " <number-of-buckets>\n";
         return 1;
     }
 
@@ -20,7 +36,9 @@ int main(int argc, char* argv[])
         return 1;
     }
 
-    Server<int, int> shm(size);
+    shm.initialize_hashtable(size);
+
+    std::signal(SIGINT, signal_handler);
 
     shm.process_requests();
 
diff --git a/src/server/shared_memory_server.h b/src/server/server.h
index 6c97e64..4c019f1 100644
--- a/src/server/shared_memory_server.h
+++ b/src/server/server.h
@@ -2,6 +2,7 @@
 
 #include "hashtable.h"
 #include "shared_memory.h"
+#include <csignal>
 #include <cstring>
 #include <fcntl.h>
 #include <optional>
@@ -18,13 +19,14 @@ class Server {
 public:
     /**
      * @brief Constructs a new hashtable and initializes a shared memory buffer.
-     *
-     * @param size The number of buckets in the hashtable.
      */
-    Server(size_t size)
-        : hash_table(size)
+    Server()
     {
-        shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
+        shm_fd = shm_open(SHM_NAME, O_EXCL | O_CREAT | O_RDWR, 0666);
+        if (shm_fd == -1) {
+            std::cout << "Server is already running!" << '\n';
+            exit(-1);
+        }
 
         ftruncate(shm_fd, sizeof(SharedMemory));
 
@@ -55,6 +57,13 @@ public:
     }
 
     /**
+     * @brief Initializes the hashtable.
+     *
+     * @param size The number of buckets in the hashtable.
+     */
+    void initialize_hashtable(size_t size) { hash_table = HashTable<K, V>(size); }
+
+    /**
      * @brief The main loop of the server.
      *
      * @details The server checks the shared memory for new requests and executes them.
@@ -64,11 +73,11 @@ public:
         while (true) {
             pthread_mutex_lock(&shared_memory->mutex);
 
-            if (shared_memory->tail == shared_memory->head && !shared_memory->full) {
+            if (shared_memory->request[shared_memory->head].status != SENT) {
                 pthread_cond_wait(&shared_memory->cond_var, &shared_memory->mutex);
             }
 
-            Request* request = &shared_memory->request[shared_memory->tail];
+            Request* request = &shared_memory->request[shared_memory->head];
 
             K key = deserialize<K>(request->key);
             V value = deserialize<V>(request->value);
@@ -130,8 +139,8 @@ public:
             default:
                 break;
             }
-            shared_memory->tail = (1 + shared_memory->tail) % QUEUE_SIZE;
-            shared_memory->full = false;
+            shared_memory->request[shared_memory->head].status = PROCESSED;
+            shared_memory->head = (1 + shared_memory->head) % QUEUE_SIZE;
             pthread_cond_signal(&shared_memory->cond_var);
             pthread_mutex_unlock(&shared_memory->mutex);
         }