Initial commit, C++ client, CLI (CMake, CI, sanitizers)

Author: iSwiin

.gitattributes

@@ -0,0 +1,2 @@
+* text=auto eol=lf
+*.sh text eol=lf

.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build-test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [gcc, clang]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake g++ clang libcurl4-openssl-dev
+
+      - name: Configure
+        run: |
+          if [ "${{ matrix.compiler }}" = "gcc" ]; then
+            export CXX=g++
+          else
+            export CXX=clang++
+          fi
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -DENABLE_UBSAN=ON
+
+      - name: Build
+        run: cmake --build build -j
+
+      - name: Test
+        run: ctest --test-dir build --output-on-failure

.gitignore

@@ -0,0 +1,4 @@
+build/
+.vscode/
+.idea/
+.DS_Store

CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.20)
+project(mini_dynamo_cpp LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+option(ENABLE_ASAN "Enable AddressSanitizer" OFF)
+option(ENABLE_UBSAN "Enable UndefinedBehaviorSanitizer" OFF)
+
+include(cmake/Sanitizers.cmake)
+
+add_library(dynamo_client
+  src/client.cpp
+  src/config.cpp
+  src/hash.cpp
+  src/http.cpp
+  src/ring.cpp
+)
+
+target_include_directories(dynamo_client PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+# Warnings (keep reasonable)
+if (MSVC)
+  target_compile_options(dynamo_client PRIVATE /W4)
+else()
+  target_compile_options(dynamo_client PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+# libcurl for HTTP
+find_package(CURL REQUIRED)
+target_link_libraries(dynamo_client PUBLIC CURL::libcurl)
+
+enable_sanitizers(dynamo_client)
+
+add_executable(dynamoctl tools/dynamoctl.cpp)
+target_link_libraries(dynamoctl PRIVATE dynamo_client)
+enable_sanitizers(dynamoctl)
+
+# ---- tests ----
+include(CTest)
+if (BUILD_TESTING)
+  add_executable(unit_tests
+    tests/test_main.cpp
+    tests/test_hash.cpp
+    tests/test_ring.cpp
+    tests/test_config.cpp
+  )
+  target_link_libraries(unit_tests PRIVATE dynamo_client)
+  enable_sanitizers(unit_tests)
+  add_test(NAME unit_tests COMMAND unit_tests)
+endif()

Jenkinsfile

@@ -0,0 +1,25 @@
+pipeline {
+  agent any
+  stages {
+    stage('Checkout') {
+      steps { checkout scm }
+    }
+    stage('Configure') {
+      steps {
+        sh '''
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -DENABLE_UBSAN=ON
+        '''
+      }
+    }
+    stage('Build') {
+      steps {
+        sh 'cmake --build build -j'
+      }
+    }
+    stage('Test') {
+      steps {
+        sh 'ctest --test-dir build --output-on-failure'
+      }
+    }
+  }
+}

README.md

@@ -0,0 +1,81 @@
+# mini-dynamo-cpp
+
+A small C++17 client library + CLI (`dynamoctl`) for the Mini Dynamo Go cluster.
+
+This repo is designed to hit the job-posting requirements:
+- C++ project using **CMake**
+- Builds on Linux with **clang/gcc**
+- Runs tests under **sanitizers** in CI (ASan/UBSan)
+- Shows “production discipline”: retries, timeouts, tests, CI
+
+## What it does
+- `libdynamo_client`: C++ client that can `PUT` and `GET` keys from a Mini Dynamo cluster
+- `dynamoctl`: CLI for quick interaction (put/get/health)
+
+The client implements simple routing using a consistent-hash ring (primary node first), and falls back to other nodes if the primary fails.
+
+## Prereqs
+- CMake >= 3.20
+- A C++17 compiler (clang or gcc)
+- libcurl development headers
+
+On Ubuntu:
+```bash
+sudo apt-get update
+sudo apt-get install -y cmake g++ clang libcurl4-openssl-dev
+```
+
+## Build + test (Linux/macOS)
+```bash
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -DENABLE_UBSAN=ON
+cmake --build build -j
+ctest --test-dir build --output-on-failure
+```
+
+## Run against your Mini Dynamo cluster
+Start your Go cluster (from your Go repo):
+```bash
+docker compose up -d --build
+```
+
+Then from this repo:
+```bash
+./build/dynamoctl health
+./build/dynamoctl put hello world
+./build/dynamoctl get hello
+```
+
+## Config
+By default, `dynamoctl` looks for `nodes.docker.json` in the current directory.
+If it doesn't exist, it falls back to `localhost:9001-9003`.
+
+You can pass a config:
+```bash
+./build/dynamoctl --config nodes.local.json put k v
+```
+
+Supported formats:
+
+### Minimal JSON
+```json
+{ "vnodes": 128, "nodes": [
+  { "id": "n1", "host": "localhost", "port": 9001 },
+  { "id": "n2", "host": "localhost", "port": 9002 },
+  { "id": "n3", "host": "localhost", "port": 9003 }
+]}
+```
+
+### Minimal text
+```txt
+vnodes=128
+n1 localhost 9001
+n2 localhost 9002
+n3 localhost 9003
+```
+
+> Note: This project intentionally uses a tiny JSON parser (regex-based) for a narrow schema to keep the repo self-contained.
+
+## What to put on your resume
+- “Built a C++17 client SDK + CLI for a Dynamo-style KV store; implemented consistent-hash routing, timeouts, and retries.”
+- “Configured CMake builds for clang/gcc; added ASan/UBSan builds in CI to catch memory and UB issues early.”
+- “Wrote unit tests and automated them in CI (GitHub Actions / Jenkinsfile).”

cmake/Sanitizers.cmake

@@ -0,0 +1,16 @@
+function(enable_sanitizers target_name)
+  if (MSVC)
+    # Sanitizers via MSVC/clang-cl are different; keep simple for now.
+    return()
+  endif()
+
+  if (ENABLE_ASAN)
+    target_compile_options(${target_name} PRIVATE -fsanitize=address -fno-omit-frame-pointer)
+    target_link_options(${target_name} PRIVATE -fsanitize=address)
+  endif()
+
+  if (ENABLE_UBSAN)
+    target_compile_options(${target_name} PRIVATE -fsanitize=undefined -fno-omit-frame-pointer)
+    target_link_options(${target_name} PRIVATE -fsanitize=undefined)
+  endif()
+endfunction()

include/dynamo/client.hpp

@@ -0,0 +1,47 @@
+#pragma once
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "dynamo/config.hpp"
+#include "dynamo/http.hpp"
+#include "dynamo/ring.hpp"
+
+namespace dynamo {
+
+struct RetryPolicy {
+  int max_retries{2};         // number of retries (not counting first attempt)
+  uint32_t base_delay_ms{80}; // exponential backoff base
+};
+
+class DynamoClient {
+public:
+  DynamoClient(ClusterConfig cfg,
+               HttpClient http = HttpClient(),
+               RetryPolicy retry = RetryPolicy());
+
+  // PUT /kv/<key> body=<value>
+  // Returns true if any node returns 2xx.
+  bool put(const std::string& key, const std::string& value);
+
+  // GET /kv/<key>
+  // Returns value if any node returns 200.
+  std::optional<std::string> get(const std::string& key);
+
+  // GET /health (best-effort)
+  // Returns per-node status lines.
+  std::vector<std::string> health_all() const;
+
+private:
+  HttpResponse request_with_retry(const std::string& url,
+                                 const std::string& method,
+                                 const std::string& body = "") const;
+
+  ClusterConfig cfg_;
+  HttpClient http_;
+  RetryPolicy retry_;
+  ConsistentHashRing ring_;
+};
+
+} // namespace dynamo

include/dynamo/config.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace dynamo {
+
+struct Node {
+  std::string id;
+  std::string host;
+  uint16_t port{0};
+
+  std::string base_url() const; // e.g., http://localhost:9001
+};
+
+struct ClusterConfig {
+  std::vector<Node> nodes;
+  int vnodes{128}; // virtual nodes per physical node
+
+  // Loads a minimal subset of JSON or a simple text config.
+  // JSON supported shapes:
+  //   { "vnodes": 128, "nodes": [ {"id":"n1","host":"localhost","port":9001}, ... ] }
+  //   { "nodes": [ {"id":"n1","address":"localhost:9001"}, ... ] }
+  //
+  // Text supported shape:
+  //   vnodes=128
+  //   n1 localhost 9001
+  //   n2 localhost 9002
+  //   n3 localhost 9003
+  static ClusterConfig load_from_file(const std::string& path);
+
+  // Convenience default for local dev if no config file exists.
+  static ClusterConfig local_default();
+};
+
+} // namespace dynamo

include/dynamo/hash.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <cstdint>
+#include <string_view>
+
+namespace dynamo {
+
+// Stable 64-bit FNV-1a hash (deterministic across platforms/compilers).
+uint64_t fnv1a_64(std::string_view s);
+
+} // namespace dynamo