librats 1.0.2 → 2.2.0

package/native-src/src/librats_statistic.cpp

@@ -1,105 +0,0 @@
-#include "librats.h"
-#include "librats_log_macros.h"
-#include "os.h"
-
-namespace librats {
-
-    
-// =========================================================================
-// Statistics and Information
-// =========================================================================
-
-nlohmann::json RatsClient::get_connection_statistics() const {
-    nlohmann::json stats;
-    
-    {
-        std::lock_guard<std::mutex> lock(peers_mutex_);
-        stats["total_peers"] = peers_.size();
-        stats["validated_peers"] = get_peer_count_unlocked();
-        stats["max_peers"] = max_peers_;
-    }
-    
-    stats["running"] = is_running();
-    stats["listen_port"] = listen_port_;
-    stats["our_peer_id"] = get_our_peer_id();
-    stats["encryption_enabled"] = is_encryption_enabled();
-    
-    // DHT statistics (IPv4 + IPv6 combined)
-    if (is_dht_running()) {
-        stats["dht_running"] = true;
-        stats["dht_routing_table_size"] = get_dht_routing_table_size();
-        stats["dht_ipv4_running"] = (dht_client_ && dht_client_->is_running());
-        stats["dht_ipv6_running"] = (dht_client_v6_ && dht_client_v6_->is_running());
-        if (dht_client_ && dht_client_->is_running()) {
-            stats["dht_ipv4_routing_table_size"] = dht_client_->get_routing_table_size();
-        }
-        if (dht_client_v6_ && dht_client_v6_->is_running()) {
-            stats["dht_ipv6_routing_table_size"] = dht_client_v6_->get_routing_table_size();
-        }
-    } else {
-        stats["dht_running"] = false;
-    }
-    
-    // mDNS statistics
-    stats["mdns_running"] = is_mdns_running();
-    
-    // Reconnection statistics
-    {
-        std::lock_guard<std::mutex> lock(reconnect_mutex_);
-        stats["reconnect_enabled"] = reconnect_config_.enabled;
-        stats["reconnect_queue_size"] = reconnect_queue_.size();
-        stats["reconnect_max_attempts"] = reconnect_config_.max_attempts;
-    }
-    
-    return stats;
-}
-
-// Cached formatting helpers - computed once on first use
-static const std::string& get_box_separator() {
-    static const std::string separator = supports_unicode() ? 
-        "════════════════════════════════════════════════════════════════════" :
-        "=====================================================================";
-    return separator;
-}
-
-static const std::string& get_box_vertical() {
-    static const std::string vertical = supports_unicode() ? "│" : "|";
-    return vertical;
-}
-
-static const std::string& get_checkmark() {
-    static const std::string checkmark = supports_unicode() ? "✓" : "[*]";
-    return checkmark;
-}
-
-void RatsClient::log_handshake_completion_unlocked(const RatsPeer& peer) {
-    // Calculate connection duration
-    auto now = std::chrono::steady_clock::now();
-    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - peer.connected_at);
-    
-    // Get current peer count (assumes peers_mutex_ is already locked)
-    int current_peer_count = get_peer_count_unlocked();
-    
-    // Create visually appealing log output
-    std::string connection_type = peer.is_outgoing ? "OUTGOING" : "INCOMING";
-    const std::string& separator = get_box_separator();
-    const std::string& vertical = get_box_vertical();
-    const std::string& checkmark = get_checkmark();
-    
-    LOG_CLIENT_INFO("");
-    LOG_CLIENT_INFO(separator);
-    LOG_CLIENT_INFO(checkmark << " HANDSHAKE COMPLETED - NEW PEER CONNECTED");
-    LOG_CLIENT_INFO(separator);
-    LOG_CLIENT_INFO(vertical << " Peer ID       : " << peer.peer_id);
-    LOG_CLIENT_INFO(vertical << " Address       : " << peer.ip << ":" << peer.port);
-    LOG_CLIENT_INFO(vertical << " Connection    : " << connection_type);
-    LOG_CLIENT_INFO(vertical << " Protocol Ver. : " << peer.version);
-    LOG_CLIENT_INFO(vertical << " Socket        : " << peer.socket);
-    LOG_CLIENT_INFO(vertical << " Duration      : " << duration.count() << "ms");
-    LOG_CLIENT_INFO(vertical << " Network Peers : " << current_peer_count << "/" << max_peers_);
-    
-    LOG_CLIENT_INFO(separator);
-    LOG_CLIENT_INFO("");
-}
-
-}

package/native-src/src/librats_storage.cpp

@@ -1,189 +0,0 @@
-#include "librats.h"
-
-#ifdef RATS_STORAGE
-
-#include "storage.h"
-#include "logger.h"
-
-namespace librats {
-
-//=============================================================================
-// Storage Manager Access
-//=============================================================================
-
-StorageManager& RatsClient::get_storage_manager() {
-    if (!storage_manager_) {
-        // Initialize storage manager on first access
-        StorageConfig config;
-        config.data_directory = data_directory_.empty() ? "./storage" : data_directory_ + "/storage";
-        storage_manager_ = std::make_unique<StorageManager>(*this, config);
-    }
-    return *storage_manager_;
-}
-
-bool RatsClient::is_storage_available() const {
-    return storage_manager_ != nullptr;
-}
-
-//=============================================================================
-// Put Operations
-//=============================================================================
-
-bool RatsClient::storage_put(const std::string& key, const std::string& value) {
-    return get_storage_manager().put(key, value);
-}
-
-bool RatsClient::storage_put(const std::string& key, int64_t value) {
-    return get_storage_manager().put(key, value);
-}
-
-bool RatsClient::storage_put(const std::string& key, double value) {
-    return get_storage_manager().put(key, value);
-}
-
-bool RatsClient::storage_put(const std::string& key, const std::vector<uint8_t>& value) {
-    return get_storage_manager().put(key, value);
-}
-
-bool RatsClient::storage_put_json(const std::string& key, const nlohmann::json& value) {
-    return get_storage_manager().put_json(key, value);
-}
-
-//=============================================================================
-// Get Operations
-//=============================================================================
-
-std::optional<std::string> RatsClient::storage_get_string(const std::string& key) const {
-    if (!storage_manager_) {
-        return std::nullopt;
-    }
-    return storage_manager_->get_string(key);
-}
-
-std::optional<int64_t> RatsClient::storage_get_int(const std::string& key) const {
-    if (!storage_manager_) {
-        return std::nullopt;
-    }
-    return storage_manager_->get_int(key);
-}
-
-std::optional<double> RatsClient::storage_get_double(const std::string& key) const {
-    if (!storage_manager_) {
-        return std::nullopt;
-    }
-    return storage_manager_->get_double(key);
-}
-
-std::optional<std::vector<uint8_t>> RatsClient::storage_get_binary(const std::string& key) const {
-    if (!storage_manager_) {
-        return std::nullopt;
-    }
-    return storage_manager_->get_binary(key);
-}
-
-std::optional<nlohmann::json> RatsClient::storage_get_json(const std::string& key) const {
-    if (!storage_manager_) {
-        return std::nullopt;
-    }
-    return storage_manager_->get_json(key);
-}
-
-//=============================================================================
-// Delete and Query Operations
-//=============================================================================
-
-bool RatsClient::storage_delete(const std::string& key) {
-    if (!storage_manager_) {
-        return false;
-    }
-    return storage_manager_->remove(key);
-}
-
-bool RatsClient::storage_has(const std::string& key) const {
-    if (!storage_manager_) {
-        return false;
-    }
-    return storage_manager_->has(key);
-}
-
-std::vector<std::string> RatsClient::storage_keys() const {
-    if (!storage_manager_) {
-        return {};
-    }
-    return storage_manager_->keys();
-}
-
-std::vector<std::string> RatsClient::storage_keys_with_prefix(const std::string& prefix) const {
-    if (!storage_manager_) {
-        return {};
-    }
-    return storage_manager_->keys_with_prefix(prefix);
-}
-
-size_t RatsClient::storage_size() const {
-    if (!storage_manager_) {
-        return 0;
-    }
-    return storage_manager_->size();
-}
-
-//=============================================================================
-// Synchronization
-//=============================================================================
-
-bool RatsClient::storage_request_sync() {
-    return get_storage_manager().request_sync();
-}
-
-bool RatsClient::is_storage_synced() const {
-    if (!storage_manager_) {
-        return false;
-    }
-    return storage_manager_->is_synced();
-}
-
-//=============================================================================
-// Statistics and Configuration
-//=============================================================================
-
-nlohmann::json RatsClient::get_storage_statistics() const {
-    if (!storage_manager_) {
-        nlohmann::json empty;
-        empty["available"] = false;
-        return empty;
-    }
-    
-    nlohmann::json stats = storage_manager_->get_statistics_json();
-    stats["available"] = true;
-    return stats;
-}
-
-void RatsClient::set_storage_config(const StorageConfig& config) {
-    get_storage_manager().set_config(config);
-}
-
-const StorageConfig& RatsClient::get_storage_config() const {
-    // Need to ensure storage manager exists for this call
-    // Create a static default config to return if not available
-    static StorageConfig default_config;
-    if (!storage_manager_) {
-        return default_config;
-    }
-    return storage_manager_->get_config();
-}
-
-//=============================================================================
-// Event Handlers
-//=============================================================================
-
-void RatsClient::on_storage_change(StorageChangeCallback callback) {
-    get_storage_manager().set_change_callback(callback);
-}
-
-void RatsClient::on_storage_sync_complete(StorageSyncCompleteCallback callback) {
-    get_storage_manager().set_sync_complete_callback(callback);
-}
-
-} // namespace librats
-
-#endif // RATS_STORAGE

package/native-src/src/rats_export.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#ifdef _WIN32
-  #if defined(RATS_EXPORT_DLL)
-    #define RATS_API __declspec(dllexport)
-  #elif defined(RATS_IMPORT_DLL)
-    #define RATS_API __declspec(dllimport)
-  #else
-    #define RATS_API
-  #endif
-#else
-  #if __GNUC__ >= 4
-    #define RATS_API __attribute__((visibility("default")))
-  #else
-    #define RATS_API
-  #endif
-#endif

package/native-src/src/receive_buffer.cpp

@@ -1,82 +0,0 @@
-#include "receive_buffer.h"
-#include <cstring>
-
-namespace librats {
-
-ReceiveBuffer::ReceiveBuffer(size_t initial_capacity)
-    : buffer_(initial_capacity)
-    , recv_start_(0)
-    , recv_end_(0) {
-}
-
-void ReceiveBuffer::received(size_t bytes) {
-    recv_end_ += bytes;
-    if (recv_end_ > buffer_.size()) {
-        recv_end_ = buffer_.size();  // Safety clamp
-    }
-}
-
-void ReceiveBuffer::ensure_space(size_t bytes) {
-    size_t available = buffer_.size() - recv_end_;
-    
-    if (available >= bytes) {
-        return;  // Already have enough space
-    }
-    
-    // Try normalizing first to reclaim front space
-    if (recv_start_ > 0) {
-        normalize();
-        available = buffer_.size() - recv_end_;
-        if (available >= bytes) {
-            return;
-        }
-    }
-    
-    // Need to grow the buffer
-    size_t needed = recv_end_ + bytes;
-    size_t new_size = buffer_.size();
-    
-    // Grow by 1.5x or to needed size, whichever is larger
-    while (new_size < needed) {
-        new_size = new_size * 3 / 2;
-        if (new_size < 256) new_size = 256;  // Minimum growth
-    }
-    
-    buffer_.resize(new_size);
-}
-
-void ReceiveBuffer::consume(size_t bytes) {
-    recv_start_ += bytes;
-    if (recv_start_ > recv_end_) {
-        recv_start_ = recv_end_;  // Safety clamp
-    }
-    
-    // If buffer is now empty, reset pointers
-    if (recv_start_ == recv_end_) {
-        recv_start_ = 0;
-        recv_end_ = 0;
-    }
-}
-
-void ReceiveBuffer::normalize() {
-    if (recv_start_ == 0) {
-        return;  // Nothing to do
-    }
-    
-    size_t data_size = recv_end_ - recv_start_;
-    
-    if (data_size > 0) {
-        // Move data to the beginning
-        std::memmove(buffer_.data(), buffer_.data() + recv_start_, data_size);
-    }
-    
-    recv_end_ = data_size;
-    recv_start_ = 0;
-}
-
-void ReceiveBuffer::clear() {
-    recv_start_ = 0;
-    recv_end_ = 0;
-}
-
-} // namespace librats

package/native-src/src/receive_buffer.h

@@ -1,127 +0,0 @@
-#pragma once
-
-/**
- * @file receive_buffer.h
- * @brief Efficient receive buffer with O(1) consume operation
- * 
- * Unlike std::vector where erase() is O(n), this buffer uses
- * start/end pointers to mark the valid data region. The consume()
- * operation simply advances the start pointer.
- */
-
-#include <vector>
-#include <cstdint>
-#include <cstddef>
-
-namespace librats {
-
-/**
- * @brief Efficient receive buffer with O(1) consume operation
- * 
- * Unlike std::vector where erase() is O(n), this buffer uses
- * start/end pointers to mark the valid data region. The consume()
- * operation simply advances the start pointer.
- * 
- * Periodically call normalize() to compact the buffer and reclaim space.
- * 
- * Usage:
- *   1. ensure_space(bytes) - make room for recv()
- *   2. recv(socket, write_ptr(), write_space())
- *   3. received(bytes) - mark bytes as received
- *   4. Process data via data()/size()
- *   5. consume(bytes) - mark bytes as processed
- *   6. normalize() - periodically compact buffer
- */
-class ReceiveBuffer {
-public:
-    /**
-     * @brief Create receive buffer with initial capacity
-     */
-    explicit ReceiveBuffer(size_t initial_capacity = 4096);
-    
-    //=========================================================================
-    // Write interface (for recv())
-    //=========================================================================
-    
-    /**
-     * @brief Get pointer where new data should be written
-     */
-    uint8_t* write_ptr() { return buffer_.data() + recv_end_; }
-    
-    /**
-     * @brief Get available space for writing
-     */
-    size_t write_space() const { return buffer_.size() - recv_end_; }
-    
-    /**
-     * @brief Mark bytes as received (after successful recv())
-     */
-    void received(size_t bytes);
-    
-    /**
-     * @brief Ensure at least 'bytes' space is available for writing
-     * 
-     * May reallocate or normalize the buffer.
-     */
-    void ensure_space(size_t bytes);
-    
-    //=========================================================================
-    // Read interface (for parsing)
-    //=========================================================================
-    
-    /**
-     * @brief Get pointer to unprocessed data
-     */
-    const uint8_t* data() const { return buffer_.data() + recv_start_; }
-    
-    /**
-     * @brief Get size of unprocessed data
-     */
-    size_t size() const { return recv_end_ - recv_start_; }
-    
-    /**
-     * @brief Check if buffer has no unprocessed data
-     */
-    bool empty() const { return recv_start_ == recv_end_; }
-    
-    /**
-     * @brief Mark bytes as consumed/processed - O(1) operation!
-     * 
-     * This is the key advantage over vector::erase().
-     */
-    void consume(size_t bytes);
-    
-    //=========================================================================
-    // Buffer management
-    //=========================================================================
-    
-    /**
-     * @brief Compact buffer by moving data to the beginning
-     * 
-     * Call this periodically to reclaim space at the front.
-     * This is O(n) but should be called infrequently.
-     */
-    void normalize();
-    
-    /**
-     * @brief Clear all data
-     */
-    void clear();
-    
-    /**
-     * @brief Get total buffer capacity
-     */
-    size_t capacity() const { return buffer_.size(); }
-    
-    /**
-     * @brief Get wasted space at the front (for diagnostics)
-     */
-    size_t front_waste() const { return recv_start_; }
-
-private:
-    std::vector<uint8_t> buffer_;
-    size_t recv_start_ = 0;  ///< Start of unprocessed data
-    size_t recv_end_ = 0;    ///< End of received data (write position)
-};
-
-} // namespace librats