CMakeLists.txt

cmake_minimum_required(VERSION 3.20)
project(raftkv CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
endif()

option(RAFTKV_WITH_GRPC "Build the gRPC server and client binaries" ON)
option(RAFTKV_WITH_LEVELDB "Use leveldb for persistent storage" ON)
option(RAFTKV_BUILD_TESTS "Build unit and integration tests" ON)
option(RAFTKV_BUILD_BENCH "Build the throughput benchmark" ON)
option(RAFTKV_ASAN "Enable AddressSanitizer" OFF)
option(RAFTKV_UBSAN "Enable UndefinedBehaviorSanitizer" OFF)
option(RAFTKV_TSAN "Enable ThreadSanitizer" OFF)

add_compile_options(-Wall -Wextra -Wpedantic -Wno-unused-parameter)

if(RAFTKV_ASAN)
    add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
    add_link_options(-fsanitize=address)
endif()
if(RAFTKV_UBSAN)
    add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
    add_link_options(-fsanitize=undefined)
endif()
if(RAFTKV_TSAN)
    add_compile_options(-fsanitize=thread -fno-omit-frame-pointer)
    add_link_options(-fsanitize=thread)
endif()

# ---------------------------------------------------------------------------
# Protobuf (always required)
# ---------------------------------------------------------------------------
# Try CONFIG mode first (newer protobuf installs); fall back to MODULE mode
# (the FindProtobuf.cmake shipped with CMake) for apt-installed protobuf.
find_package(Protobuf CONFIG QUIET)
if(NOT Protobuf_FOUND)
    find_package(Protobuf REQUIRED)
endif()
message(STATUS "Using protobuf ${Protobuf_VERSION}")

# Locate the protoc binary. CONFIG mode exports `protobuf::protoc` as a target;
# MODULE mode exports it via Protobuf_PROTOC_EXECUTABLE. Normalize.
if(TARGET protobuf::protoc)
    set(PROTOC_CMD protobuf::protoc)
elseif(Protobuf_PROTOC_EXECUTABLE)
    set(PROTOC_CMD ${Protobuf_PROTOC_EXECUTABLE})
elseif(PROTOBUF_PROTOC_EXECUTABLE)
    set(PROTOC_CMD ${PROTOBUF_PROTOC_EXECUTABLE})
else()
    message(FATAL_ERROR "protoc not found via CONFIG or MODULE mode")
endif()

# Generate C++ from proto files. We do this manually rather than via
# protobuf_generate_cpp so the same logic works whether protobuf was found
# in CONFIG mode or MODULE mode.
set(PROTO_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/proto)
set(PROTO_GEN_DIR ${CMAKE_CURRENT_BINARY_DIR}/proto_gen)
file(MAKE_DIRECTORY ${PROTO_GEN_DIR})

set(PROTO_FILES
    ${PROTO_SRC_DIR}/raft.proto
    ${PROTO_SRC_DIR}/kv.proto
)

set(PROTO_GENERATED_SRCS)
set(PROTO_GENERATED_HDRS)
foreach(PROTO_FILE ${PROTO_FILES})
    get_filename_component(PROTO_NAME ${PROTO_FILE} NAME_WE)
    set(GEN_SRC ${PROTO_GEN_DIR}/${PROTO_NAME}.pb.cc)
    set(GEN_HDR ${PROTO_GEN_DIR}/${PROTO_NAME}.pb.h)
    add_custom_command(
        OUTPUT ${GEN_SRC} ${GEN_HDR}
        COMMAND ${PROTOC_CMD}
        ARGS --cpp_out=${PROTO_GEN_DIR}
             -I${PROTO_SRC_DIR}
             ${PROTO_FILE}
        DEPENDS ${PROTO_FILE}
        COMMENT "Generating C++ from ${PROTO_NAME}.proto"
        VERBATIM
    )
    list(APPEND PROTO_GENERATED_SRCS ${GEN_SRC})
    list(APPEND PROTO_GENERATED_HDRS ${GEN_HDR})
endforeach()

add_library(raftkv_proto STATIC ${PROTO_GENERATED_SRCS})
target_include_directories(raftkv_proto PUBLIC ${PROTO_GEN_DIR})
target_link_libraries(raftkv_proto PUBLIC protobuf::libprotobuf)
target_compile_options(raftkv_proto PRIVATE -Wno-unused-parameter -Wno-deprecated-declarations)

# ---------------------------------------------------------------------------
# leveldb (optional, falls back to file-backed storage)
# ---------------------------------------------------------------------------
set(HAVE_LEVELDB 0)
if(RAFTKV_WITH_LEVELDB)
    find_path(LEVELDB_INCLUDE_DIR leveldb/db.h)
    find_library(LEVELDB_LIBRARY leveldb)
    if(LEVELDB_INCLUDE_DIR AND LEVELDB_LIBRARY)
        set(HAVE_LEVELDB 1)
        message(STATUS "Using leveldb at ${LEVELDB_LIBRARY}")
    else()
        message(STATUS "leveldb not found; using file-backed storage fallback")
    endif()
endif()

# ---------------------------------------------------------------------------
# gRPC (optional)
# ---------------------------------------------------------------------------
set(HAVE_GRPC 0)
set(GRPC_LIB_TARGET "")
if(RAFTKV_WITH_GRPC)
    find_package(gRPC CONFIG QUIET)
    if(gRPC_FOUND)
        set(HAVE_GRPC 1)
        set(GRPC_LIB_TARGET gRPC::grpc++)
        message(STATUS "Using gRPC ${gRPC_VERSION} (CONFIG)")
    else()
        # apt ships gRPC without cmake config files. Fall back to pkg-config.
        find_package(PkgConfig QUIET)
        if(PkgConfig_FOUND)
            pkg_check_modules(GRPCPP IMPORTED_TARGET grpc++)
            if(GRPCPP_FOUND)
                set(HAVE_GRPC 1)
                set(GRPC_LIB_TARGET PkgConfig::GRPCPP)
                message(STATUS "Using gRPC ${GRPCPP_VERSION} (pkg-config)")
            endif()
        endif()
    endif()
    if(HAVE_GRPC)
        # Locate the grpc_cpp_plugin used by protoc.
        find_program(GRPC_CPP_PLUGIN grpc_cpp_plugin)
        if(NOT GRPC_CPP_PLUGIN AND TARGET gRPC::grpc_cpp_plugin)
            set(GRPC_CPP_PLUGIN $<TARGET_FILE:gRPC::grpc_cpp_plugin>)
        endif()
        if(NOT GRPC_CPP_PLUGIN)
            message(STATUS "grpc_cpp_plugin not found; disabling gRPC build")
            set(HAVE_GRPC 0)
        endif()
    else()
        message(STATUS "gRPC not found; building without RPC server")
    endif()
endif()

if(HAVE_GRPC)
    set(GRPC_GEN_DIR ${CMAKE_CURRENT_BINARY_DIR}/proto_gen_grpc)
    file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
    set(GRPC_GENERATED_SRCS)
    foreach(PROTO_FILE ${PROTO_FILES})
        get_filename_component(PROTO_NAME ${PROTO_FILE} NAME_WE)
        set(GEN_SRC ${GRPC_GEN_DIR}/${PROTO_NAME}.grpc.pb.cc)
        set(GEN_HDR ${GRPC_GEN_DIR}/${PROTO_NAME}.grpc.pb.h)
        add_custom_command(
            OUTPUT ${GEN_SRC} ${GEN_HDR}
            COMMAND ${PROTOC_CMD}
            ARGS --grpc_out=${GRPC_GEN_DIR}
                 --plugin=protoc-gen-grpc=${GRPC_CPP_PLUGIN}
                 -I${PROTO_SRC_DIR}
                 ${PROTO_FILE}
            DEPENDS ${PROTO_FILE}
            COMMENT "Generating gRPC C++ from ${PROTO_NAME}.proto"
            VERBATIM
        )
        list(APPEND GRPC_GENERATED_SRCS ${GEN_SRC})
    endforeach()
    add_library(raftkv_grpc STATIC ${GRPC_GENERATED_SRCS})
    target_include_directories(raftkv_grpc PUBLIC ${GRPC_GEN_DIR} ${PROTO_GEN_DIR})
    target_link_libraries(raftkv_grpc PUBLIC raftkv_proto ${GRPC_LIB_TARGET})
    target_compile_options(raftkv_grpc PRIVATE -Wno-unused-parameter -Wno-deprecated-declarations)
endif()

# ---------------------------------------------------------------------------
# Core library (no gRPC dependency)
# ---------------------------------------------------------------------------
set(CORE_SRCS
    src/core/log.cpp
    src/core/state_machine.cpp
    src/core/persister.cpp
    src/core/snapshot.cpp
    src/raft/node.cpp
    src/raft/election.cpp
    src/raft/replication.cpp
    src/raft/peers.cpp
    src/raft/membership.cpp
    src/chaos/injector.cpp
    src/chaos/scenarios.cpp
)

add_library(raftkv_core STATIC ${CORE_SRCS})
target_include_directories(raftkv_core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src)
target_link_libraries(raftkv_core PUBLIC raftkv_proto)
if(HAVE_LEVELDB)
    target_include_directories(raftkv_core PRIVATE ${LEVELDB_INCLUDE_DIR})
    target_link_libraries(raftkv_core PUBLIC ${LEVELDB_LIBRARY})
    target_compile_definitions(raftkv_core PUBLIC RAFTKV_HAVE_LEVELDB=1)
endif()

# ---------------------------------------------------------------------------
# Server binary (requires gRPC)
# ---------------------------------------------------------------------------
if(HAVE_GRPC)
    add_executable(raftkv
        src/main.cpp
        src/rpc/raft_server.cpp
        src/rpc/kv_server.cpp
        src/rpc/client.cpp
    )
    target_link_libraries(raftkv PRIVATE raftkv_core raftkv_grpc ${GRPC_LIB_TARGET})
endif()

# ---------------------------------------------------------------------------
# Tests
# ---------------------------------------------------------------------------
if(RAFTKV_BUILD_TESTS)
    include(FetchContent)
    FetchContent_Declare(
        googletest
        URL https://github.com/google/googletest/archive/refs/tags/v1.15.2.tar.gz
        URL_HASH SHA256=7b42b4d6ed48810c5362c265a17faebe90dc2373c885e5216439d37927f02926
        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
    )
    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
    set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
    FetchContent_MakeAvailable(googletest)

    enable_testing()

    function(raftkv_add_test NAME SRC)
        add_executable(${NAME} ${SRC})
        target_link_libraries(${NAME} PRIVATE raftkv_core GTest::gtest GTest::gtest_main)
        target_include_directories(${NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
        add_test(NAME ${NAME} COMMAND ${NAME})
        set_tests_properties(${NAME} PROPERTIES TIMEOUT 120)
    endfunction()

    raftkv_add_test(log_test tests/unit/log_test.cpp)
    raftkv_add_test(state_machine_test tests/unit/state_machine_test.cpp)
    raftkv_add_test(persister_test tests/unit/persister_test.cpp)
    raftkv_add_test(election_test tests/unit/election_test.cpp)
    raftkv_add_test(replication_test tests/unit/replication_test.cpp)
    raftkv_add_test(membership_test tests/unit/membership_test.cpp)
    raftkv_add_test(log_invariants_test tests/unit/log_invariants_test.cpp)
    # The property tests drive a 3-node cluster through dozens of random
    # ops and check 4 invariants per step; allow more time than the
    # 120s default.
    set_tests_properties(log_invariants_test PROPERTIES TIMEOUT 300)

    raftkv_add_test(leader_election_integration tests/integration/leader_election_test.cpp)
    raftkv_add_test(replication_integration tests/integration/replication_test.cpp)
    raftkv_add_test(snapshot_integration tests/integration/snapshot_test.cpp)
    raftkv_add_test(client_ops_integration tests/integration/client_ops_test.cpp)
    raftkv_add_test(membership_integration tests/integration/membership_test.cpp)
    raftkv_add_test(lease_integration tests/integration/lease_test.cpp)
    # The lease test issues 10k timed reads plus a round-trip baseline;
    # allow more than the 120s default, especially under sanitizers.
    set_tests_properties(lease_integration PROPERTIES TIMEOUT 300)

    # The randomized chaos test runs only when RUN_CHAOS=1 in the env, or with
    # explicit ctest -L chaos. The smoke variant runs 20 scenarios.
    add_executable(chaos_test tests/chaos/randomized_test.cpp)
    target_link_libraries(chaos_test PRIVATE raftkv_core GTest::gtest GTest::gtest_main)
    target_include_directories(chaos_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
    add_test(NAME chaos_smoke COMMAND chaos_test --scenarios=20 --seed=1)
    set_tests_properties(chaos_smoke PROPERTIES TIMEOUT 600 LABELS "chaos")
    add_test(NAME chaos_full COMMAND chaos_test --scenarios=200 --seed=1 --json=${CMAKE_BINARY_DIR}/chaos_local.json)
    set_tests_properties(chaos_full PROPERTIES TIMEOUT 3600 LABELS "chaos_full" DISABLED TRUE)
endif()

# ---------------------------------------------------------------------------
# Benchmark
# ---------------------------------------------------------------------------
if(RAFTKV_BUILD_BENCH)
    add_executable(throughput_bench bench/throughput_bench.cpp)
    target_link_libraries(throughput_bench PRIVATE raftkv_core)

    # bench_regress carries no consensus dependency: it only diffs two
    # directories of scaling-result JSON against a drift tolerance.
    add_executable(bench_regress bench/bench_regress.cpp)
endif()