JVM and .NET HTTP Frameworks

cd examples/hello-spring-boot   # or hello-dotnet
./run.sh

# Full smoke (sidecar + trust + deny + allow)
./smoke.sh

includeBuild("../../sdks/jvm")

dependencies {
    implementation(platform("org.springframework.boot:spring-boot-dependencies:3.2.2"))
    implementation("world.chio:chio-spring-boot:0.1.0")
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")

    testImplementation(platform("org.springframework.boot:spring-boot-dependencies:3.2.2"))
    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
}

package example.hello

import world.chio.ChioFilter
import world.chio.ChioFilterConfig
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.boot.web.servlet.FilterRegistrationBean
import org.springframework.context.annotation.Bean
import org.springframework.core.Ordered

@SpringBootApplication
class HelloSpringBootApplication {
    @Bean
    fun chioFilterRegistration(): FilterRegistrationBean<ChioFilter> {
        val filter = ChioFilter(
            ChioFilterConfig(
                sidecarUrl = System.getenv("CHIO_SIDECAR_URL") ?: "http://127.0.0.1:9090",
            ),
        )

        return FilterRegistrationBean<ChioFilter>().apply {
            setFilter(filter)
            addUrlPatterns("/hello", "/echo")
            order = Ordered.HIGHEST_PRECEDENCE
        }
    }
}

fun main(args: Array<String>) {
    runApplication<HelloSpringBootApplication>(*args)
}

package example.hello

import org.springframework.http.HttpStatus
import org.springframework.http.MediaType
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController

@RestController
class HelloController {
    @GetMapping("/healthz")
    fun healthz(): Map<String, String> = mapOf("status" to "ok")

    @GetMapping("/hello")
    fun hello(): Map<String, String> = mapOf("message" to "hello from spring-boot")

    @PostMapping("/echo", consumes = [MediaType.APPLICATION_JSON_VALUE])
    fun echo(@RequestBody payload: Any?): EchoResponse = parseEchoPayload(payload)

    @ExceptionHandler(EchoPayloadError::class)
    fun echoPayloadError(error: EchoPayloadError): ResponseEntity<Map<String, String>> =
        ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(mapOf("error" to (error.message ?: "invalid echo payload")))
}

data class EchoResponse(
    val message: String,
    val count: Int,
)

class EchoPayloadError(message: String) : RuntimeException(message)

internal fun parseEchoPayload(payload: Any?): EchoResponse {
    if (payload !is Map<*, *>) {
        throw EchoPayloadError("body must be a JSON object")
    }

    val allowedKeys = setOf("message", "count")
    val extraKeys =
        payload.keys
            .map { it.toString() }
            .filter { it !in allowedKeys }
            .sorted()
    if (extraKeys.isNotEmpty()) {
        throw EchoPayloadError("unexpected fields: ${extraKeys.joinToString(", ")}")
    }

    val message = payload["message"]
    if (message !is String || message.isEmpty()) {
        throw EchoPayloadError("message must be a non-empty string")
    }

    val count = payload["count"] ?: 1
    if (count !is Int || count < 1) {
        throw EchoPayloadError("count must be an integer greater than or equal to 1")
    }

    return EchoResponse(
        message = message,
        count = count,
    )
}

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="../../sdks/dotnet/ChioMiddleware/src/ChioMiddleware.csproj" />
  </ItemGroup>

  <ItemGroup>
    <Compile Remove="tests/**/*.cs" />
  </ItemGroup>

  <ItemGroup>
    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
      <_Parameter1>HelloChio.Tests</_Parameter1>
    </AssemblyAttribute>
  </ItemGroup>

</Project>

using Backbay.Chio;

namespace HelloDotnet;

internal static class HelloApp
{
    internal static WebApplication Create(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        builder.Services.AddChioProtection();

        var app = builder.Build();
        app.MapGet("/healthz", HelloEndpoints.Health);
        app.UseWhen(
            context => RequiresChioProtection(context.Request.Path),
            branch => branch.UseChioProtection());
        app.MapHelloEndpoints();
        return app;
    }

    internal static bool RequiresChioProtection(PathString path) =>
        !path.Equals("/healthz", StringComparison.OrdinalIgnoreCase);
}

internal static class HelloEndpoints
{
    internal static IEndpointRouteBuilder MapHelloEndpoints(this IEndpointRouteBuilder app)
    {
        app.MapGet("/hello", Hello);
        app.MapPost("/echo", Echo);
        return app;
    }

    internal static IResult Health() => Results.Json(new HealthResponse("ok"));

    internal static IResult Hello() => Results.Json(new HelloResponse("hello from dotnet"));

    internal static IResult Echo(EchoRequest payload)
    {
        if (!EchoContract.TryCreateResponse(payload, out var response, out var error))
        {
            return Results.BadRequest(error);
        }

        return Results.Json(response);
    }
}

internal static class EchoContract
{
    internal static bool TryCreateResponse(
        EchoRequest payload,
        out EchoResponse? response,
        out EchoErrorResponse? error)
    {
        if (string.IsNullOrWhiteSpace(payload.Message))
        {
            response = null;
            error = new EchoErrorResponse(
                "invalid_echo_request",
                "message must contain at least one non-whitespace character");
            return false;
        }

        if (payload.Count < 1)
        {
            response = null;
            error = new EchoErrorResponse(
                "invalid_echo_request",
                "count must be greater than or equal to 1");
            return false;
        }

        response = new EchoResponse(payload.Message, payload.Count);
        error = null;
        return true;
    }
}

internal sealed record HealthResponse(string Status);

internal sealed record HelloResponse(string Message);

internal sealed record EchoRequest(string Message, int Count = 1);

internal sealed record EchoResponse(string Message, int Count);

internal sealed record EchoErrorResponse(string Error, string Message);

./run.sh
# starts dotnet on http://127.0.0.1:8019 (override with HELLO_DOTNET_PORT)

@Bean
fun chioFilterRegistration(): FilterRegistrationBean<ChioFilter> {
    val filter = ChioFilter(
        ChioFilterConfig(
            sidecarUrl = System.getenv("CHIO_SIDECAR_URL") ?: "http://127.0.0.1:9090",
        ),
    )

    return FilterRegistrationBean<ChioFilter>().apply {
        setFilter(filter)
        addUrlPatterns("/hello", "/echo")
        order = Ordered.HIGHEST_PRECEDENCE
    }
}

internal static WebApplication Create(string[] args)
{
    var builder = WebApplication.CreateBuilder(args);
    builder.Services.AddChioProtection();

    var app = builder.Build();
    app.MapGet("/healthz", HelloEndpoints.Health);
    app.UseWhen(
        context => RequiresChioProtection(context.Request.Path),
        branch => branch.UseChioProtection());
    app.MapHelloEndpoints();
    return app;
}

python3 - "${ARTIFACT_ROOT}/deny.json" <<'PY'
import json
import sys
from pathlib import Path

body = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert body["error"] == "chio_access_denied", body
assert body["receipt_id"], body
PY

cd .artifacts/$(ls -t .artifacts | head -1)

# The two allows carry X-Chio-Receipt-Id; the 403 does not, so this
# prints two lines, not three.
grep -i x-chio-receipt-id hello.headers deny.headers allow.headers

# 3 persisted receipts in the sidecar SQLite store
wc -l receipts.ndjson                   # expect: 3
jq -r '.verdict.verdict' receipts.ndjson | sort | uniq -c
# expect: 2 allow, 1 deny

# The deny id lives in the body, and resolves in the store like the allows
jq -r '.receipt_id' deny.json
jq -r 'select(.verdict.verdict=="deny") | .id' receipts.ndjson

# Direct SQLite peek
sqlite3 state/sidecar-receipts.sqlite3 \
  "select id, json_extract(receipt_json, '$.method') as method, json_extract(receipt_json, '$.route_pattern') as route_pattern from http_receipts order by rowid;"