add web queue

grpc support

.github/workflows/tests.yml

@@ -3,22 +3,34 @@ on:
    push:
       branches: [ "main", "develop" ]
    pull_request:
-      branches: [ "main", "develop" ]
+      branches: [ "main" ]
 
 jobs:
    build_job:
       runs-on: ubuntu-latest
+
       steps:
-         - uses: actions/checkout@v3
+        - name: checkout
+          uses: actions/checkout@v4
+          with:
+            submodules: true
+
+        - uses: actions/cache@v3
+          with:
+            path: build/vcpkg_installed
+            key: ${{ runner.os }}-vcpkg-${{ hashFiles('./vcpkg.json') }}
+            restore-keys: ${{ runner.os }}-vcpkg-
 
-         - name: installing
-           run: sudo apt install cmake make g++ clang-tidy
+        - name: installing
+          run: |
+            sudo apt install cmake make g++ clang-tidy
+            git clone https://github.com/microsoft/vcpkg
 
-         - name: configuring
-           run: cmake -S . -B build
+        - name: configuring
+          run: cmake -DCMAKE_TOOLCHAIN_FILE=${PWD}/vcpkg/scripts/buildsystems/vcpkg.cmake -S . -B build
 
-         - name: building
-           run: cmake --build build
+        - name: building
+          run: cmake --build build -j $(nproc)
 
-         - name: testing
-           run: ctest -VV --test-dir build/tests
+        - name: testing
+          run: ctest -VV --test-dir build/tests

.gitignore

@@ -3,3 +3,8 @@ build
 Testing
 
 /CMakePresets.json
+
+/*.data
+
+/vcpkg_installed
+/vcpkg

CMakeLists.txt

@@ -1,13 +1,43 @@
-cmake_minimum_required(VERSION 3.27)
-project(equeue)
+cmake_minimum_required(VERSION 3.28)
 
-option(BUILD_TESTS "Build the unit tests" ON)
+#set(VCPKG_ROOT "vcpkg" CACHE PATH "vcpkg root dir")
+#set(CMAKE_TOOLCHAIN_FILE "${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" CACHE FILEPATH "toolchain")
 
 set(CMAKE_CXX_STANDARD 20)
 
-add_subdirectory(proto)
+option(BUILD_TESTS "Build the unit tests" ON)
+
+project(equeue LANGUAGES C CXX)
+
+file(GLOB_RECURSE ALL_SOURCE_FILES ${CMAKE_SOURCE_DIR}/*.hpp)
 
-#set(CMAKE_CXX_CLANG_TIDY clang-tidy)
+add_custom_target(
+    lint
+    COMMAND clang-tidy
+    ${ALL_SOURCE_FILES}
+    --config-file=${CMAKE_SOURCE_DIR}/.clang-tidy
+)
+
+#if(UNIX)
+#    if(NOT EXISTS ${VCPKG_ROOT}/vcpkg) 
+#        execute_process(COMMAND ./bootstrap-vcpkg.sh -disableMetrics WORKING_DIRECTORY ${VCPKG_ROOT})
+#    endif()
+#    set(VCPKG_EXEC ${VCPKG_ROOT}/vcpkg CACHE FILEPATH "vcpkg executable")
+#elseif(WIN32)
+#    if(NOT EXISTS ${VCPKG_ROOT}/vcpkg) 
+#        execute_process(COMMAND ./bootstrap-vcpkg.bat -disableMetrics WORKING_DIRECTORY ${VCPKG_ROOT})
+#    endif()
+#    set(VCPKG_EXEC ${VCPKG_ROOT}/vcpkg.exe CACHE FILEPATH "vcpkg executable")
+#else()
+#    message(FATAL_ERROR "Not Recognized OS Error")
+#endif()
+#
+#function(LibraryInstall LIB)
+#    execute_process(COMMAND ${VCPKG_EXEC} install ${LIB})
+#endfunction()
+
+#############################################################
+add_subdirectory(proto)
 
 add_library(${PROJECT_NAME} INTERFACE)
 target_sources(${PROJECT_NAME} INTERFACE
@@ -20,6 +50,7 @@ target_sources(${PROJECT_NAME} INTERFACE
         detail/utils.hpp
         queue.hpp
         proto/queue.pb.h
+        proto/queue.grpc.pb.h
 )
 
 if(${BUILD_TESTS})

include/detail/meta.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <type_traits>
 #include <concepts>
 #include <string>
-#include <type_traits>
 
 #include "types.hpp"
 

include/detail/proto_storage.hpp

@@ -19,7 +19,7 @@ using node_p_t         = std::shared_ptr<QueueStorageNode>;
 template<typename T>
 using node_container_t = std::list<T>;
 
-bool operator==(const node_p_t& lhs, const node_p_t& rhs){
+bool operator==(const node_p_t lhs, const node_p_t rhs){
     if (lhs->priority() != rhs->priority()) return false;
     //if (lhs->created_at() != rhs->created_at()) return false;
 
@@ -64,11 +64,12 @@ class proto_storage
         node_p_t node;
 
         wrapper_node() : node(std::make_shared<node_t>()) {}
-        explicit wrapper_node(const node_t& _node) : node(std::make_shared<node_t>(_node)) {}
+        wrapper_node(const node_t& _node) {
+            node = std::make_shared<node_t>(_node);
+        }
 
         wrapper_node(const wrapper_node&) = delete;
         wrapper_node(wrapper_node&&) = delete;
-        wrapper_node& operator=(wrapper_node&) = delete;
         wrapper_node& operator=(wrapper_node&&) = delete;
         ~wrapper_node() = default;
 
@@ -85,10 +86,15 @@ class proto_storage
 
 public:
     using node   = node_t;
-    using node_p = node_p_t;
+    using node_ptr = node_p_t;
 
     proto_storage() = default;
     ~proto_storage() = default;
+
+    proto_storage(const proto_storage&) = delete;
+    proto_storage(proto_storage&&) = delete;
+    proto_storage& operator=(proto_storage&&) = delete;
+    proto_storage operator=(const proto_storage&) = delete;
 
     inline node_p_t& extract(){
         return store.back().node;
@@ -99,6 +105,12 @@ class proto_storage
             store.pop_back();
     }
 
+    void insert(QueueStorageNode& node){
+        store.emplace_front();
+        store.front().node = std::make_shared<QueueStorageNode>(node);
+        if(node.priority() != 0) store.sort();
+    }
+
     void insert(uint32_t priority, const void* raw, std::size_t size){
         //using google::protobuf::util::TimeUtil;
 
@@ -162,7 +174,7 @@ class proto_storage
         QueueStorage pb_store;
 
         for (auto it = store.rbegin(); it != store.rend(); it++){
-            node_t* _node = pb_store.add_node();
+            node* _node = pb_store.add_node();
             // is it really nead to copy? may be to swap and to erase?
             _node->CopyFrom(*it->node.get());
         }

include/detail/types.hpp

@@ -18,4 +18,4 @@ enum value_t {
 
 }; // namespace detail
 }; // namespace queue
-}; // namespace efesx
+}; // namespace detail

include/queue.hpp

@@ -12,14 +12,13 @@ namespace queue {
 using storage_t    = detail::proto_storage;
 
 using node_t       = storage_t::node;
-using node_p_t     = storage_t::node_p;
+using node_p_t     = storage_t::node_ptr;
 using node_value_t = node_t::DataCase;
 
 template<typename Storage>
 class basic_queue {
 private:
     Storage storage;
-    int a = 8;
 public:
     basic_queue() = default;
     ~basic_queue() = default;
@@ -39,7 +38,7 @@ class basic_queue {
 
     /**
      * @brief Get top data node from queue
-     * @return node_p_t& - reference to shared pointer of data node in queue
+     * @return node_p_t& - the reference to shared pointer of data node in queue
     */
     node_p_t& dequeue(){
         return storage.extract();

include/ts_queue.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <shared_mutex>
+#include <any>
+
+#include "detail/proto_storage.hpp"
+#include "queue.hpp"
+
+
+namespace efesx::ts_queue {
+
+using storage_t    = queue::detail::proto_storage;
+
+using node_t       = storage_t::node;
+using node_p_t     = storage_t::node_ptr;
+using node_value_t = node_t::DataCase;
+
+template<typename BasicQueue>
+class basic_ts_queue {
+private:
+    BasicQueue queue;
+    std::shared_mutex mtx;
+
+public:
+    basic_ts_queue() = default;
+    ~basic_ts_queue() = default;
+
+    basic_ts_queue(const basic_ts_queue&)  = delete;
+    basic_ts_queue(basic_ts_queue&&)  = delete;
+    basic_ts_queue& operator=(basic_ts_queue&&) = delete;
+    basic_ts_queue operator=(const basic_ts_queue&) = delete;
+
+    /**
+     * @brief Put any (any standard type in C++, except classes, structs and enums) data to queue.
+    */
+    template<typename...Args>
+    void enqueue(Args...args){
+        std::unique_lock lck(mtx);
+        queue.enqueue(args...);
+    }
+
+    /**
+     * @brief Get top data node from queue
+     * @return node_p_t& - the reference to shared pointer of data node in queue
+    */
+    std::any dequeue(bool _pop = false){
+        std::unique_lock lock(mtx);
+
+        if (queue.empty()) return std::any();
+
+        node_p_t res = queue.dequeue();
+
+        if(_pop) queue.pop();
+
+        return res;
+    }
+
+    /**
+     * @brief Delete delete top data node from queue
+    */
+    void pop(){
+        std::unique_lock lck(mtx);
+        if (queue.empty()) return;
+        queue.pop();
+    }
+
+    /**
+     * @brief Returns amount of data nodes in queue
+    */
+    std::size_t amount(){
+        std::shared_lock lck(mtx);
+        return queue.amount();
+    }
+
+    /**
+     * @brief Is queue empty?
+    */
+    bool empty(){
+        std::shared_lock lck(mtx);
+        return queue.empty();
+    }
+
+    /**
+     * @brief Serialize queue to file
+    */
+    bool save_to_disk(const std::string& file){
+        std::shared_lock lck(mtx);
+        return queue.save_to_disk(file);
+    }
+
+    /**
+     * @brief Deserialize queue to file
+    */
+    bool load_from_disk(const std::string& file){
+        std::unique_lock lck(mtx);
+        return queue.load_from_disk(file);
+    }
+
+    bool operator==(const basic_ts_queue<BasicQueue>& oth) const {
+        return (queue == oth.queue);
+    }
+};
+
+using ts_queue = basic_ts_queue<efesx::queue::basic_queue<storage_t>>;
+
+}; // namespace efesx::ts_queue