Go and C++ HTTP

module pricing-go

go 1.21

require (
	github.com/backbay-labs/chio/sdks/go/chio-go-http v0.2.0
	github.com/go-chi/chi/v5 v5.2.3
)

package main

import (
	"encoding/json"
	"errors"
	"io"
	"log"
	"net/http"
	"os"
	"time"

	chio "github.com/backbay-labs/chio/sdks/go/chio-go-http"
	"github.com/go-chi/chi/v5"
)

func send(w http.ResponseWriter, status int, value any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(value)
}

func main() {
	store, err := openStore(".pricing/go-quotes.json")
	if err != nil {
		log.Fatal(err)
	}
	router := chi.NewRouter()
	router.Get("/v1/quotes", func(w http.ResponseWriter, r *http.Request) {
		send(w, http.StatusOK, map[string]any{"quotes": store.list()})
	})
	router.Post("/v1/quote", func(w http.ResponseWriter, r *http.Request) {
		var payload struct {
			SKU     *string  `json:"sku"`
			Percent *float64 `json:"percent"`
		}
		decoder := json.NewDecoder(r.Body)
		decoder.DisallowUnknownFields()
		if err := decoder.Decode(&payload); err != nil || payload.SKU == nil || payload.Percent == nil {
			send(w, http.StatusBadRequest, map[string]string{"error": "body must contain exactly sku and percent"})
			return
		}
		if err := decoder.Decode(new(any)); err != io.EOF {
			send(w, http.StatusBadRequest, map[string]string{"error": "expected one JSON object"})
			return
		}
		quote, err := store.issue(*payload.SKU, *payload.Percent)
		if err != nil {
			status := http.StatusInternalServerError
			if errors.Is(err, errInvalidQuote) {
				status = http.StatusBadRequest
			}
			send(w, status, map[string]string{"error": err.Error()})
			return
		}
		send(w, http.StatusCreated, map[string]any{
			"id": quote.ID, "sku": quote.SKU, "percent": quote.Percent,
			"price": quote.Price, "currency": "USD",
			"receipt_id": w.Header().Get("X-Chio-Receipt-Id"),
		})
	})
	sidecar := os.Getenv("CHIO_SIDECAR_URL")
	if sidecar == "" {
		sidecar = "http://127.0.0.1:9101"
	}
	protected := chio.Protect(router, chio.WithSidecarURL(sidecar))
	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/healthz" {
			send(w, http.StatusOK, map[string]string{"status": "ready", "framework": "go"})
			return
		}
		// Cap bytes before the adapter collects and hashes the body.
		r.Body = http.MaxBytesReader(w, r.Body, 8192)
		protected.ServeHTTP(w, r)
	})
	server := &http.Server{
		Addr: "127.0.0.1:8101", Handler: handler,
		ReadHeaderTimeout: 5 * time.Second,
	}
	log.Print("Go pricing: http://127.0.0.1:8101")
	log.Fatal(server.ListenAndServe())
}

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"sync"
)

var errInvalidQuote = errors.New("invalid quote request")

// Larkfield list prices in cents, as main holds them after the Quickstart.
var prices = map[string]int64{"sku-118": 2400, "sku-204": 5800, "sku-301": 14000}

type Quote struct {
	ID      int     `json:"id"`
	SKU     string  `json:"sku"`
	Percent float64 `json:"percent"`
	Price   string  `json:"price"`
}

type QuoteStore struct {
	sync.Mutex
	path   string
	quotes []Quote
}

func openStore(path string) (*QuoteStore, error) {
	if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
		return nil, err
	}
	store := &QuoteStore{path: path, quotes: []Quote{}}
	data, err := os.ReadFile(path)
	if errors.Is(err, os.ErrNotExist) {
		return store, nil
	}
	if err != nil {
		return nil, err
	}
	return store, json.Unmarshal(data, &store.quotes)
}

func (s *QuoteStore) list() []Quote {
	s.Lock()
	defer s.Unlock()
	return append([]Quote{}, s.quotes...)
}

func (s *QuoteStore) issue(sku string, percent float64) (Quote, error) {
	cents, ok := prices[sku]
	if !ok {
		return Quote{}, fmt.Errorf("%w: unknown sku %s", errInvalidQuote, sku)
	}
	if percent < 0 || percent > 100 {
		return Quote{}, fmt.Errorf("%w: percent must be between 0 and 100", errInvalidQuote)
	}
	// Basis points keep the arithmetic exact; the last step rounds half up to the cent.
	basis := int64(math.Round(percent * 100))
	price := (cents*(10000-basis) + 5000) / 10000
	s.Lock()
	defer s.Unlock()
	quote := Quote{ID: len(s.quotes) + 1, SKU: sku, Percent: percent, Price: fmt.Sprintf("%d.%02d", price/100, price%100)}
	next := append(append([]Quote{}, s.quotes...), quote)
	data, err := json.MarshalIndent(next, "", "  ")
	if err != nil {
		return Quote{}, err
	}
	file, err := os.CreateTemp(filepath.Dir(s.path), "quotes-*.tmp")
	if err != nil {
		return Quote{}, err
	}
	defer os.Remove(file.Name())
	if _, err = file.Write(data); err != nil {
		file.Close()
		return Quote{}, err
	}
	if err = file.Sync(); err != nil {
		file.Close()
		return Quote{}, err
	}
	if err = file.Close(); err != nil {
		return Quote{}, err
	}
	if err = os.Rename(file.Name(), s.path); err != nil {
		return Quote{}, err
	}
	s.quotes = next
	return quote, nil
}

cmake_minimum_required(VERSION 3.24)
project(LarkfieldPricingNative LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CHIO_DROGON_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(CHIO_DROGON_REQUIRE_DEPS ON CACHE BOOL "" FORCE)
include(FetchContent)
# The Drogon adapter and its Rust FFI come from the released Chio tag.
FetchContent_Declare(chio_drogon
  GIT_REPOSITORY https://github.com/backbay-labs/chio.git
  GIT_TAG v0.2.0
  GIT_SHALLOW TRUE
  SOURCE_SUBDIR sdks/cpp/chio-drogon)
FetchContent_MakeAvailable(chio_drogon)
add_executable(pricing-drogon cpp/main.cpp)
target_link_libraries(pricing-drogon PRIVATE ChioDrogon::chio_drogon)

#include <drogon/drogon.h>
#include <chio/drogon.hpp>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <map>
#include <mutex>
#include <stdexcept>

namespace fs = std::filesystem;

// Larkfield list prices in cents, as main holds them after the Quickstart.
const std::map<std::string, long long> prices{{"sku-118", 2400}, {"sku-204", 5800}, {"sku-301", 14000}};

class QuoteStore {
    std::mutex gate;
    fs::path path = ".pricing/drogon-quotes.json";
    Json::Value quotes{Json::arrayValue};
public:
    QuoteStore() {
        if (fs::create_directories(path.parent_path())) {
            fs::permissions(path.parent_path(), fs::perms::owner_all);
        }
        if (fs::exists(path)) {
            std::ifstream input(path);
            Json::CharReaderBuilder reader;
            std::string errors;
            if (!Json::parseFromStream(reader, input, &quotes, &errors) || !quotes.isArray()) {
                throw std::runtime_error("Cannot read issued quotes: " + errors);
            }
        }
    }
    Json::Value list() {
        std::lock_guard<std::mutex> lock(gate);
        return quotes;
    }
    Json::Value issue(const std::string& sku, double percent) {
        // Basis points keep the arithmetic exact; the last step rounds half up to the cent.
        const auto basis = static_cast<long long>(std::llround(percent * 100));
        const auto cents = (prices.at(sku) * (10000 - basis) + 5000) / 10000;
        char price[32];
        std::snprintf(price, sizeof price, "%lld.%02lld", cents / 100, cents % 100);
        std::lock_guard<std::mutex> lock(gate);
        Json::Value quote;
        quote["id"] = quotes.size() + 1;
        quote["sku"] = sku;
        quote["percent"] = percent;
        quote["price"] = price;
        quote["currency"] = "USD";
        auto next = quotes;
        next.append(quote);
        const auto temporary = path.string() + ".tmp";
        try {
            std::ofstream output(temporary, std::ios::trunc | std::ios::binary);
            output.exceptions(std::ios::failbit | std::ios::badbit);
            Json::StreamWriterBuilder writer;
            output << Json::writeString(writer, next);
            output.close();
            fs::rename(temporary, path);
        } catch (...) {
            fs::remove(temporary);
            throw;
        }
        quotes = next;
        return quote;
    }
};

using Reply = std::function<void(const drogon::HttpResponsePtr&)>;
void reply(Reply& callback, Json::Value body, drogon::HttpStatusCode status) {
    auto response = drogon::HttpResponse::newHttpJsonResponse(body);
    response->setStatusCode(status);
    callback(response);
}
void error(Reply& callback, const std::string& message, drogon::HttpStatusCode status) {
    Json::Value body;
    body["error"] = message;
    reply(callback, body, status);
}

int main() {
    auto store = std::make_shared<QuoteStore>();
    chio::drogon::Options options;
    const auto sidecar = std::getenv("CHIO_SIDECAR_URL");
    options.sidecar_url = sidecar ? sidecar : "http://127.0.0.1:9101";
    chio::drogon::configure(std::move(options));

    drogon::app().registerHandler("/healthz",
        [](const drogon::HttpRequestPtr&, Reply&& callback) {
            Json::Value body;
            body["status"] = "ready";
            body["framework"] = "drogon";
            reply(callback, body, drogon::k200OK);
        }, {drogon::Get});
    drogon::app().registerHandler("/v1/quotes",
        [store](const drogon::HttpRequestPtr&, Reply&& callback) {
            Json::Value body;
            body["quotes"] = store->list();
            reply(callback, body, drogon::k200OK);
        }, {drogon::Get, "chio::drogon::ChioMiddleware"});
    drogon::app().registerHandler("/v1/quote",
        [store](const drogon::HttpRequestPtr& request, Reply&& callback) {
            const auto payload = request->getJsonObject();
            if (!payload || !payload->isObject() || payload->size() != 2
                || !(*payload)["sku"].isString() || !(*payload)["percent"].isNumeric()) {
                error(callback, "body must contain exactly sku and percent", drogon::k400BadRequest);
                return;
            }
            const auto sku = (*payload)["sku"].asString();
            const auto percent = (*payload)["percent"].asDouble();
            if (prices.find(sku) == prices.end()) {
                error(callback, "unknown sku " + sku, drogon::k400BadRequest);
                return;
            }
            if (percent < 0 || percent > 100) {
                error(callback, "percent must be between 0 and 100", drogon::k400BadRequest);
                return;
            }
            try {
                auto quote = store->issue(sku, percent);
                quote["receipt_id"] = chio::drogon::receipt_id(request);
                reply(callback, quote, drogon::k201Created);
            } catch (const std::exception& failure) {
                error(callback, failure.what(), drogon::k500InternalServerError);
            }
        }, {drogon::Post, "chio::drogon::ChioMiddleware"});

    drogon::app().setClientMaxBodySize(8192).addListener("127.0.0.1", 8102).run();
}