log_server.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/logger/interfaces/logger_types.h>
#include <string>
#include <memory>
#include <vector>
#include <atomic>
#include <thread>
 
namespace kcenon::logger::server {
 
struct server_config {
    std::string host = "localhost";
    uint16_t port = 9999;
    size_t max_connections = 100;
    size_t buffer_size = 8192;
    bool enable_compression = false;
    bool enable_encryption = false;
};
 
class log_server {
private:
    server_config config_;
    std::atomic<bool> running_{false};
    std::vector<std::thread> worker_threads_;
 
public:
    explicit log_server(const server_config& config = {}) : config_(config) {}
 
    ~log_server() {
        stop();
    }
 
    bool start() {
        if (running_.load()) {
            return false;
        }
 
        running_.store(true);
 
        // Start worker threads
        for (size_t i = 0; i < std::thread::hardware_concurrency(); ++i) {
            worker_threads_.emplace_back([this]() {
                worker_loop();
            });
        }
 
        return true;
    }
 
    void stop() {
        if (!running_.load()) {
            return;
        }
 
        running_.store(false);
 
        for (auto& thread : worker_threads_) {
            if (thread.joinable()) {
                thread.join();
            }
        }
        worker_threads_.clear();
    }
 
    bool is_running() const {
        return running_.load();
    }
 
    const server_config& get_config() const {
        return config_;
    }
 
private:
    void worker_loop() {
        while (running_.load()) {
            // Worker implementation would go here
            // For now, just sleep to simulate work
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }
};
 
class log_server_factory {
public:
    static std::unique_ptr<log_server> create_basic(const server_config& config = {}) {
        return std::make_unique<log_server>(config);
    }
 
    static std::unique_ptr<log_server> create_default() {
        return create_basic();
    }
};
 
} // namespace kcenon::logger::server