implement communication between server and client (without mutexes and with queue_length of 1)

2 files changed, 47 insertions, 16 deletions

diff --git a/src/server/main.cpp b/src/server/main.cpp
index 4dd7761..424326f 100644
--- a/src/server/main.cpp
+++ b/src/server/main.cpp
@@ -22,5 +22,7 @@ int main(int argc, char* argv[])
 
     SharedMemoryServer<int, std::string> shm(size);
 
+    shm.process_requests();
+
     return 0;
 }
diff --git a/src/server/shared_memory_server.h b/src/server/shared_memory_server.h
index 034466d..6d4fe19 100644
--- a/src/server/shared_memory_server.h
+++ b/src/server/shared_memory_server.h
@@ -2,7 +2,9 @@
 
 #include "hashtable.h"
 #include "shared_memory.h"
+#include <cstring>
 #include <fcntl.h>
+#include <optional>
 #include <sys/mman.h>
 #include <unistd.h>
 
@@ -16,34 +18,61 @@ public:
 
         ftruncate(shm_fd, sizeof(SharedMemory));
 
-        shm = (SharedMemory*)
+        shared_memory = (SharedMemory*)
             mmap(0, sizeof(SharedMemory), PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
-
-        pthread_mutexattr_t mutex_attr;
-        pthread_condattr_t cond_attr;
-        pthread_mutexattr_init(&mutex_attr);
-        pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
-        pthread_condattr_init(&cond_attr);
-        pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED);
-
-        pthread_mutex_init(&shm->mutex, &mutex_attr);
-        pthread_cond_init(&shm->cond_var, &cond_attr);
-
-        shm->head = (shm->tail = 0);
+        shared_memory->processed = true;
     }
 
     ~SharedMemoryServer()
     {
-        munmap(shm, sizeof(SharedMemory));
+        munmap(shared_memory, sizeof(SharedMemory));
         close(shm_fd);
         shm_unlink(SHM_NAME);
+        std::cout << "bye" << '\n';
     }
 
-    void process_requests();
+    void process_requests()
+    {
+        while (true) {
+            sleep(1); // TODO: remove sleep, add a mutex for shared memory, should then work with
+                      // queue size 1
+            if (!shared_memory->processed) {
+                std::cout << "Got a request!" << '\n';
+
+                Request request = shared_memory->request;
+                shared_memory->processed = true;
+
+                K key = deserialize<K>(request.key);
+                V value = deserialize<V>(request.value);
+
+                switch (request.type) {
+                case INSERT:
+                    hash_table.insert(key, value);
+                    break;
+                case GET: {
+                    std::optional<V> result = hash_table.get(key);
+                    if (result.has_value()) {
+                        std::string response = serialize<V>(result.value());
+                        strncpy(shared_memory->response, response.c_str(), MAX_VALUE_SIZE);
+                    }
+                    break;
+                }
+                case DELETE:
+                    hash_table.remove(key);
+                    break;
+                case PRINT:
+                    hash_table.print();
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+    }
 
 private:
     HashTable<K, V> hash_table;
 
     int shm_fd;
-    SharedMemory* shm;
+    SharedMemory* shared_memory;
 };