librats 1.0.2 → 2.2.0

package/native-src/src/librats_logging.cpp

@@ -1,173 +0,0 @@
-#include "librats.h"
-#include "librats_log_macros.h"
-#include <algorithm>
-
-namespace librats {
-
-//=============================================================================
-// Logging Control API Implementation
-//=============================================================================
-
-void RatsClient::set_console_logging_enabled(bool enabled) {
-    Logger::getInstance().set_console_logging_enabled(enabled);
-    // Only log if console is enabled, otherwise we're silently disabling
-    if (enabled) {
-        LOG_CLIENT_INFO("Console logging enabled");
-    }
-}
-
-bool RatsClient::is_console_logging_enabled() const {
-    return Logger::getInstance().is_console_logging_enabled();
-}
-
-void RatsClient::set_logging_enabled(bool enabled) {
-    LOG_CLIENT_INFO("Setting file logging " << (enabled ? "enabled" : "disabled"));
-    
-    Logger& logger = Logger::getInstance();
-    
-    if (enabled) {
-        // Set default log file path if not already set
-        if (logger.get_log_file_path().empty()) {
-            logger.set_log_file_path("rats.log");
-        }
-    }
-    
-    logger.set_file_logging_enabled(enabled);
-    
-    if (enabled) {
-        LOG_CLIENT_INFO("File logging enabled - logs will be written to: " << logger.get_log_file_path());
-    } else {
-        LOG_CLIENT_INFO("File logging disabled");
-    }
-}
-
-bool RatsClient::is_logging_enabled() const {
-    return Logger::getInstance().is_file_logging_enabled();
-}
-
-void RatsClient::set_log_file_path(const std::string& file_path) {
-    Logger& logger = Logger::getInstance();
-    logger.set_log_file_path(file_path);
-    LOG_CLIENT_INFO("Log file path set to: " << file_path);
-}
-
-std::string RatsClient::get_log_file_path() const {
-    return Logger::getInstance().get_log_file_path();
-}
-
-void RatsClient::set_log_level(LogLevel level) {
-    Logger::getInstance().set_log_level(level);
-    LOG_CLIENT_INFO("Log level set to: " << static_cast<int>(level));
-}
-
-void RatsClient::set_log_level(const std::string& level_str) {
-    LogLevel level;
-    
-    std::string upper_level = level_str;
-    std::transform(upper_level.begin(), upper_level.end(), upper_level.begin(), ::toupper);
-    
-    if (upper_level == "DEBUG") {
-        level = LogLevel::DEBUG;
-    } else if (upper_level == "INFO") {
-        level = LogLevel::INFO;
-    } else if (upper_level == "WARN" || upper_level == "WARNING") {
-        level = LogLevel::WARN;
-    } else if (upper_level == "ERROR") {
-        level = LogLevel::ERROR;
-    } else {
-        LOG_CLIENT_WARN("Invalid log level string: " << level_str << " - using INFO as default");
-        level = LogLevel::INFO;
-    }
-    
-    set_log_level(level);
-}
-
-LogLevel RatsClient::get_log_level() const {
-    // Note: Logger doesn't expose get_log_level method, so we'll use a workaround
-    // by checking which level actually outputs. This is a limitation of the current Logger design.
-    Logger& logger = Logger::getInstance();
-    
-    // Try to determine current level by checking if debug messages would be shown
-    // This is a simple approximation - for a more accurate implementation,
-    // the Logger class would need a get_log_level() method
-    
-    // For now, we'll return INFO as a reasonable default
-    // In a production system, the Logger class should be enhanced to track and return the current level
-    return LogLevel::INFO;
-}
-
-void RatsClient::set_log_colors_enabled(bool enabled) {
-    Logger::getInstance().set_colors_enabled(enabled);
-    LOG_CLIENT_INFO("Log colors " << (enabled ? "enabled" : "disabled"));
-}
-
-bool RatsClient::is_log_colors_enabled() const {
-    // Note: Logger doesn't expose a getter for colors_enabled
-    // This is another limitation of the current Logger design
-    // For now, return true as a reasonable default
-    return true;
-}
-
-void RatsClient::set_log_timestamps_enabled(bool enabled) {
-    Logger::getInstance().set_timestamps_enabled(enabled);
-    LOG_CLIENT_INFO("Log timestamps " << (enabled ? "enabled" : "disabled"));
-}
-
-bool RatsClient::is_log_timestamps_enabled() const {
-    // Note: Logger doesn't expose a getter for timestamps_enabled
-    // This is another limitation of the current Logger design
-    // For now, return true as a reasonable default
-    return true;
-}
-
-void RatsClient::set_log_rotation_size(size_t max_size_bytes) {
-    Logger::getInstance().set_log_rotation_size(max_size_bytes);
-    LOG_CLIENT_INFO("Log rotation size set to: " << max_size_bytes << " bytes");
-}
-
-void RatsClient::set_log_retention_count(int count) {
-    Logger::getInstance().set_log_retention_count(count);
-    LOG_CLIENT_INFO("Log retention count set to: " << count << " files");
-}
-
-void RatsClient::set_log_rotate_on_startup(bool enabled) {
-    Logger::getInstance().set_rotate_on_startup(enabled);
-    LOG_CLIENT_INFO("Log rotation on startup " << (enabled ? "enabled" : "disabled"));
-}
-
-bool RatsClient::is_log_rotate_on_startup_enabled() const {
-    return Logger::getInstance().is_rotate_on_startup_enabled();
-}
-
-void RatsClient::clear_log_file() {
-    Logger& logger = Logger::getInstance();
-    std::string log_path = logger.get_log_file_path();
-    
-    if (log_path.empty()) {
-        LOG_CLIENT_WARN("No log file path set - cannot clear log file");
-        return;
-    }
-    
-    try {
-        // Temporarily disable file logging
-        bool was_enabled = logger.is_file_logging_enabled();
-        if (was_enabled) {
-            logger.set_file_logging_enabled(false);
-        }
-        
-        // Delete the log file
-        std::remove(log_path.c_str());
-        
-        // Re-enable file logging if it was enabled
-        if (was_enabled) {
-            logger.set_file_logging_enabled(true);
-        }
-        
-        LOG_CLIENT_INFO("Log file cleared: " << log_path);
-        
-    } catch (const std::exception& e) {
-        LOG_CLIENT_ERROR("Failed to clear log file: " << e.what());
-    }
-}
-
-}

package/native-src/src/librats_mdns.cpp

@@ -1,166 +0,0 @@
-#include "librats.h"
-#include "mdns.h"
-#include <iostream>
-#include <algorithm>
-#include <chrono>
-#include <memory>
-#include <stdexcept>
-
-#include "librats_log_macros.h"
-
-namespace librats {
-
-// ===== mDNS DISCOVERY METHODS IMPLEMENTATION =====
-
-bool RatsClient::start_mdns_discovery(const std::string& service_instance_name, 
-                                     const std::map<std::string, std::string>& txt_records) {
-    if (!running_.load()) {
-        LOG_CLIENT_ERROR("RatsClient is not running, cannot start mDNS discovery");
-        return false;
-    }
-    
-    if (mdns_client_ && mdns_client_->is_running()) {
-        LOG_CLIENT_WARN("mDNS discovery is already running");
-        return true;
-    }
-    
-    LOG_CLIENT_INFO("Starting mDNS service discovery and announcement");
-    
-    // Create service instance name from our peer ID if not provided
-    std::string instance_name = service_instance_name;
-    if (instance_name.empty()) {
-        instance_name = "librats-" + get_our_peer_id().substr(0, 8);
-    }
-    
-    // Create mDNS client
-    mdns_client_ = std::make_unique<MdnsClient>(instance_name, listen_port_);
-    
-    // Set service type based on protocol name (e.g., "_rats-search._tcp.local.")
-    std::string protocol_name = get_protocol_name();
-    std::string service_type = "_" + protocol_name + "._tcp.local.";
-    mdns_client_->set_service_type(service_type);
-    
-    // Set service discovery callback
-    mdns_client_->set_service_callback([this](const MdnsService& service, bool is_new) {
-        handle_mdns_service_discovery(service, is_new);
-    });
-    
-    // Start mDNS client
-    if (!mdns_client_->start()) {
-        LOG_CLIENT_ERROR("Failed to start mDNS client");
-        mdns_client_.reset();
-        return false;
-    }
-    
-    // Start service announcement
-    if (!mdns_client_->announce_service(instance_name, listen_port_, txt_records)) {
-        LOG_CLIENT_WARN("Failed to start mDNS service announcement");
-    }
-    
-    // Start service discovery
-    if (!mdns_client_->start_discovery()) {
-        LOG_CLIENT_WARN("Failed to start mDNS service discovery");
-    }
-    
-    LOG_CLIENT_INFO("mDNS discovery started successfully for service: " << instance_name);
-    return true;
-}
-
-void RatsClient::stop_mdns_discovery() {
-    if (!mdns_client_) {
-        return;
-    }
-    
-    LOG_CLIENT_INFO("Stopping mDNS discovery");
-    
-    mdns_client_->stop();
-    mdns_client_.reset();
-    
-    LOG_CLIENT_INFO("mDNS discovery stopped");
-}
-
-bool RatsClient::is_mdns_running() const {
-    return mdns_client_ && mdns_client_->is_running();
-}
-
-void RatsClient::set_mdns_callback(std::function<void(const std::string&, int, const std::string&)> callback) {
-    mdns_callback_ = callback;
-}
-
-std::vector<MdnsService> RatsClient::get_mdns_services() const {
-    if (!mdns_client_) {
-        return {};
-    }
-    
-    return mdns_client_->get_recent_services(std::chrono::seconds(300)); // Services seen in last 5 minutes
-}
-
-bool RatsClient::query_mdns_services() {
-    if (!mdns_client_) {
-        LOG_CLIENT_ERROR("mDNS client not initialized");
-        return false;
-    }
-    
-    return mdns_client_->query_services();
-}
-
-void RatsClient::handle_mdns_service_discovery(const MdnsService& service, bool is_new) {
-    LOG_CLIENT_INFO("mDNS discovered " << (is_new ? "new" : "updated") << " librats service: " 
-                   << service.service_name << " at " << service.ip_address << ":" << service.port);
-    
-    // Extract instance name from service name for logging
-    std::string instance_name = service.service_name;
-    size_t pos = instance_name.find("._librats._tcp.local.");
-    if (pos != std::string::npos) {
-        instance_name = instance_name.substr(0, pos);
-    }
-    
-    // Call user callback if registered
-    if (mdns_callback_) {
-        try {
-            mdns_callback_(service.ip_address, service.port, instance_name);
-        } catch (const std::exception& e) {
-            LOG_CLIENT_ERROR("Exception in mDNS callback: " << e.what());
-        }
-    }
-    
-    // Auto-connect to discovered services if they're new
-    if (is_new) {
-        // Check if this peer should be ignored (local interface)
-        if (should_ignore_peer(service.ip_address, service.port)) {
-            LOG_CLIENT_DEBUG("Ignoring mDNS discovered peer " << service.ip_address << ":" 
-                            << service.port << " - local interface address");
-            return;
-        }
-        
-        // Check if we're already connected to this peer
-        std::string normalized_peer_address = normalize_peer_address(service.ip_address, service.port);
-        if (is_already_connected_to_address(normalized_peer_address)) {
-            LOG_CLIENT_DEBUG("Already connected to mDNS discovered peer: " << normalized_peer_address);
-            return;
-        }
-        
-        // Check if peer limit is reached
-        if (is_peer_limit_reached()) {
-            LOG_CLIENT_DEBUG("Peer limit reached, not connecting to mDNS discovered peer " 
-                            << service.ip_address << ":" << service.port);
-            return;
-        }
-        
-        LOG_CLIENT_INFO("Attempting to connect to mDNS discovered peer: " 
-                       << service.ip_address << ":" << service.port);
-        
-        // Try to connect to the discovered peer (non-blocking)
-        std::thread([this, service]() {
-            if (connect_to_peer(service.ip_address, service.port)) {
-                LOG_CLIENT_INFO("Successfully connected to mDNS discovered peer: " 
-                               << service.ip_address << ":" << service.port);
-            } else {
-                LOG_CLIENT_DEBUG("Failed to connect to mDNS discovered peer: " 
-                                << service.ip_address << ":" << service.port);
-            }
-        }).detach();
-    }
-}
-
-} // namespace librats