chore: initial commit

rediska/worker/AsyncWorker.cpp

@@ -0,0 +1,157 @@
+#include "rediska/worker/AsyncWorker.hpp"
+#include <google/protobuf/empty.pb.h>
+#include "v1/primitives/bool.grpc.pb.h"
+#include "v1/primitives/bool.pb.h"
+#include "v1/primitives/int.grpc.pb.h"
+#include "v1/primitives/int.pb.h"
+#include "v1/primitives/string.grpc.pb.h"
+#include "v1/primitives/string.pb.h"
+#include "v1/collections/list.grpc.pb.h"
+#include "v1/collections/list.pb.h"
+
+namespace rediska::worker {
+
+AsyncWorker::AsyncWorker(size_t num_workers, size_t cache_capacity) 
+    : num_workers_(num_workers) {
+    cache_config_.maxCapacity = cache_capacity;
+    cache_config_.ttl = 0;
+    cache_config_.resetTTLOnAccess = true;
+    InitializeCache();
+}
+
+AsyncWorker::~AsyncWorker() {
+    Stop();
+}
+
+void AsyncWorker::Start() {
+    if (running_) return;
+    
+    running_ = true;
+    workers_.reserve(num_workers_);
+    
+    for (size_t i = 0; i < num_workers_; ++i) {
+        workers_.emplace_back(&AsyncWorker::WorkerLoop, this);
+    }
+}
+
+void AsyncWorker::Stop() {
+    if (!running_) return;
+    
+    running_ = false;
+    queue_cv_.notify_all();
+    
+    for (auto& worker : workers_) {
+        if (worker.joinable()) {
+            worker.join();
+        }
+    }
+    
+    workers_.clear();
+}
+
+void AsyncWorker::Enqueue(QueueMessage msg) {
+    {
+        std::lock_guard<std::mutex> lock(queue_mutex_);
+        message_queue_.push(std::move(msg));
+    }
+    queue_cv_.notify_one();
+}
+
+void AsyncWorker::WorkerLoop() {
+    while (running_) {
+        QueueMessage msg;
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            queue_cv_.wait(lock, [this] { return !message_queue_.empty() || !running_; });
+            
+            if (!running_) break;
+            
+            msg = std::move(message_queue_.front());
+            message_queue_.pop();
+        }
+        
+        ProcessMessage(msg);
+    }
+}
+
+void AsyncWorker::ProcessMessage(QueueMessage& msg) {
+    if (!msg.responder) return;
+    
+    try {
+        switch (msg.operation) {
+            case OperationId::SET: {
+                if (msg.type == CacheValueId::ARRAY) {
+                    v1::collections::list::ListSetResponse response;
+                    msg.respond<v1::collections::list::ListSetResponse>(response);
+                } else {
+                    google::protobuf::Empty response;
+                    msg.respond<google::protobuf::Empty>(response);
+                }
+                break;
+            }
+            case OperationId::GET: {
+                cache_->get(std::string(msg.key));
+                
+                // заглушка, пока кэш не интегрирован полностью TODO
+                if (msg.type == CacheValueId::BOOLEAN) {
+                    v1::primitives::boolean::BoolGetResponse response;
+                    response.set_value(false);
+                    msg.respond<v1::primitives::boolean::BoolGetResponse>(response);
+                } else if (msg.type == CacheValueId::INT) {
+                    v1::primitives::integer::IntGetResponse response;
+                    response.set_value(0);
+                    msg.respond<v1::primitives::integer::IntGetResponse>(response);
+                } else if (msg.type == CacheValueId::STRING) {
+                    v1::primitives::str::StringGetResponse response;
+                    response.set_value("cached_value");
+                    msg.respond<v1::primitives::str::StringGetResponse>(response);
+                } else if (msg.type == CacheValueId::ARRAY) {
+                    v1::collections::list::ListGetResponse response;
+                    msg.respond<v1::collections::list::ListGetResponse>(response);
+                }
+                break;
+            }
+            case OperationId::DELETE: {
+                if (msg.type == CacheValueId::BOOLEAN) {
+                    v1::primitives::boolean::BoolDeleteResponse response;
+                    response.set_removed_value(false);
+                    msg.respond<v1::primitives::boolean::BoolDeleteResponse>(response);
+                } else if (msg.type == CacheValueId::INT) {
+                    v1::primitives::integer::IntDeleteResponse response;
+                    response.set_removed_value(0);
+                    msg.respond<v1::primitives::integer::IntDeleteResponse>(response);
+                } else if (msg.type == CacheValueId::STRING) {
+                    v1::primitives::str::StringDeleteResponse response;
+                    response.set_removed_value("");
+                    msg.respond<v1::primitives::str::StringDeleteResponse>(response);
+                } else if (msg.type == CacheValueId::ARRAY) {
+                    google::protobuf::Empty response;
+                    msg.respond<google::protobuf::Empty>(response);
+                }
+                break;
+            }
+            case OperationId::LIST_PUSH_BACK:
+            case OperationId::LIST_POP_BACK:
+            case OperationId::LIST_INSERT:
+            case OperationId::LIST_ERASE: {
+                google::protobuf::Empty response;
+                msg.respond<google::protobuf::Empty>(response);
+                break;
+            }
+            default:
+                break;
+        }
+    } catch (const std::exception& e) {
+        std::cout << "Error processing message: " << e.what() << std::endl;
+    }
+}
+
+void AsyncWorker::InitializeCache() {
+    auto callback = [this](auto result) {
+        // TODO
+    };
+    
+    cache_ = std::make_unique<cache::LRU>(cache_config_, callback);
+}
+
+} // namespace rediska::worker