handle_alternative_ipc_configurations.hpp

// handle_alternative_ipc_configurations.hpp
// Created by Greg on 1/30/25.
// Copyright (C) 2025 Presage Security, Inc.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <filesystem>
#include <glog/logging.h>
#include <absl/flags/flag.h>
#include <absl/status/status.h>
#include <absl/status/statusor.h>
#include "stream_backend.hpp"
#include "file_ipc/file_ipc_configuration.hpp"
#include "file_ipc/file_ipc_configuration_flags.hpp"
#include "redis_ipc/redis_ipc_configuration.hpp"
#include "redis_ipc/redis_ipc_configuration_flags.hpp"
 
// Forward declare flags
ABSL_DECLARE_FLAG(std::string, file_ipc_config_path);
ABSL_DECLARE_FLAG(std::string, redis_ipc_config_path);
ABSL_DECLARE_FLAG(bool, save_default_file_ipc_config);
ABSL_DECLARE_FLAG(bool, save_default_redis_ipc_config);
 
namespace presage::smartspectra::ipc {

template<StreamBackend Backend>
struct IpcConfigTraits;
 
template<>
struct IpcConfigTraits<StreamBackend::kFile> {
    using Traits = file_ipc::FileIpcConfigurationTraits;
};
 
template<>
struct IpcConfigTraits<StreamBackend::kRedis> {
    using Traits = redis_ipc::RedisIpcConfigurationTraits;
};

template<StreamBackend Backend>
int SaveDefaultIpcConfig() {
    using Traits = typename IpcConfigTraits<Backend>::Traits;
    using ConfigType = typename Traits::ConfigType;
 
    ConfigType default_config;
    std::filesystem::path config_path = Traits::config_filename;
 
    auto status = ConfigType::SaveToJson(default_config, config_path);
 
    if (!status.ok()) {
        LOG(ERROR) << "Failed to save default " << Traits::backend_name
                   << " configuration: " << status.message();
        google::ShutdownGoogleLogging();
        return EXIT_FAILURE;
    }
 
    std::filesystem::path absolute_path = std::filesystem::absolute(config_path);
    LOG(INFO) << "Default " << Traits::backend_name << " configuration saved to: " << absolute_path;
    LOG(INFO) << "You can now customize this file and use it with appropriate configuration flags";
    google::ShutdownGoogleLogging();
    return EXIT_SUCCESS;
}

template<StreamBackend Backend>
bool LoadAndPrepareIpcConfig(
    StreamBackend backend_type,
    typename IpcConfigTraits<Backend>::Traits::ConfigType& config
) {
    using Traits = typename IpcConfigTraits<Backend>::Traits;
    using ConfigType = typename Traits::ConfigType;
 
    // Skip if this backend is not being used
    if (backend_type != Backend) {
        return true;
    }
 
    // Get the config path flag using the trait
    std::string config_path = [&]() -> std::string {
        if constexpr (Backend == StreamBackend::kFile) {
            return absl::GetFlag(FLAGS_file_ipc_config_path);
        } else if constexpr (Backend == StreamBackend::kRedis) {
            return absl::GetFlag(FLAGS_redis_ipc_config_path);
        } else {
            return "";
        }
    }();
 
    // Load configuration from file if path is specified
    if (!config_path.empty()) {
        auto config_result = ConfigType::LoadFromJson(config_path);
        if (!config_result.ok()) {
            LOG(ERROR) << "Failed to load " << Traits::backend_name
                      << " configuration from " << config_path
                      << ": " << config_result.status().message();
            google::ShutdownGoogleLogging();
            return false;
        }
        config = *config_result;
        LOG(INFO) << "Loaded " << Traits::backend_name << " configuration from: " << config_path;
    } else {
        // Use default configuration
        LOG(INFO) << "Using default " << Traits::backend_name << " configuration (no config file specified)";
    }
 
    // Apply command-line flag overrides
    auto final_config = [&]() -> absl::StatusOr<typename IpcConfigTraits<Backend>::Traits::ConfigType> {
        if constexpr (Backend == StreamBackend::kFile) {
            return file_ipc::ApplyFlagsToConfiguration(config);
        } else if constexpr (Backend == StreamBackend::kRedis) {
            return redis_ipc::ApplyFlagsToConfiguration(config);
        } else {
            return absl::InternalError("Unknown backend type");
        }
    }();
 
    if (!final_config.ok()) {
        LOG(ERROR) << "Failed to apply flags to " << Traits::backend_name
                   << " configuration: " << final_config.status().message();
        google::ShutdownGoogleLogging();
        return false;
    }
 
    config = *final_config;
    Traits::LogFinalConfig(config);
    return true;
}
 
} // namespace presage::smartspectra::ipc