4 files changed, 126 insertions, 23 deletions

diff --git a/src/client/main.cpp b/src/client/main.cpp
new file mode 100644
index 0000000..2e4a606
--- /dev/null
+++ b/src/client/main.cpp
@@ -0,0 +1,49 @@
+#include "shared_memory.h"
+#include <cstring>
+#include <fcntl.h>
+#include <iostream>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <utility>
+
+void sendRequest(
+    SharedMemory* shared_memory,
+    Operations type,
+    std::pair<const std::string&, const std::string&> arguments)
+{
+    shared_memory->request.type = type;
+    strncpy(shared_memory->request.key, serialize(arguments.first).c_str(), MAX_KEY_SIZE);
+    strncpy(shared_memory->request.value, serialize(arguments.second).c_str(), MAX_VALUE_SIZE);
+    shared_memory->processed = false;
+
+    std::cout << "Command sent" << '\n';
+
+    sleep(2);
+
+    if (type == Operations::GET) {
+        std::string result(shared_memory->response);
+        std::cout << "Result: " << result << std::endl;
+    }
+}
+
+int main()
+{
+    int shm_fd = shm_open(SHM_NAME, O_RDWR, 0666);
+    if (shm_fd == -1) {
+        std::cout << "Server not running" << '\n';
+        return -1;
+    }
+
+    SharedMemory* shared_memory =
+        (SharedMemory*)mmap(0, sizeof(SharedMemory), PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
+
+    std::cout << "Start inserting.." << '\n';
+    sendRequest(shared_memory, INSERT, std::pair(serialize(10), serialize(5)));
+
+    std::cout << "Start printing.." << '\n';
+    sendRequest(shared_memory, PRINT, std::pair(serialize(10), serialize(5)));
+
+    munmap(shared_memory, sizeof(SharedMemory));
+    close(shm_fd);
+    return 0;
+}
diff --git a/src/common/shared_memory.h b/src/common/shared_memory.h
index 53c7fb7..43fe2f5 100644
--- a/src/common/shared_memory.h
+++ b/src/common/shared_memory.h
@@ -1,16 +1,39 @@
 #pragma once
 
 #include <pthread.h>
+#include <sstream>
 
-#define QUEUE_SIZE 10
 #define SHM_NAME "/hashtable_queue"
+#define MAX_KEY_SIZE 64
+#define MAX_VALUE_SIZE 128
 
-enum Operations { INSERT, DELETE, GET };
+enum Operations { INSERT, DELETE, GET, PRINT };
+
+struct Request {
+    Operations type;
+    char key[MAX_KEY_SIZE];
+    char value[MAX_VALUE_SIZE];
+};
 
 struct SharedMemory {
-    pthread_mutex_t mutex;
-    pthread_cond_t cond_var;
-    Operations queue[QUEUE_SIZE];
-    int head;
-    int tail;
+    Request request;
+    bool processed;
+    char response[MAX_VALUE_SIZE];
 };
+
+template <typename T>
+std::string serialize(const T& data)
+{
+    std::ostringstream oss;
+    oss << data;
+    return oss.str();
+}
+
+template <typename T>
+T deserialize(const std::string& str)
+{
+    std::istringstream iss(str);
+    T data;
+    iss >> data;
+    return data;
+}
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;
 };