giles
2aeab806fb
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 29s
131 lines
4.9 KiB
Erlang
131 lines
4.9 KiB
Erlang
-module(http_server).
|
|
-export([route/1, ok_response/1, not_found_response/0,
|
|
welcome_body/0, capabilities_body/0,
|
|
capabilities_path/0,
|
|
match_prefix/2, actors_prefix/0, actor_doc_response/1,
|
|
artifacts_prefix/0, artifact_response/1]).
|
|
|
|
%% HTTP request router per design §16.1.
|
|
%%
|
|
%% Request shape (mirrors what the SX-side `http-listen` builds and
|
|
%% the http:listen/2 BIF bridge marshals into a proplist):
|
|
%% [{method, Binary}, {path, Binary}, {query, Binary},
|
|
%% {headers, [{Name, Value}, ...]}, {body, Binary}]
|
|
%%
|
|
%% Response shape:
|
|
%% [{status, Integer}, {headers, [{Name, Value}, ...]}, {body, Binary}]
|
|
%%
|
|
%% Real dispatch (actor docs, outbox listings, /activity POST,
|
|
%% /.well-known/sx-capabilities, etc.) lands in Step 8c+. Step 8b
|
|
%% wires the route/1 shape and a single hello-world handler that
|
|
%% proves the request→response round-trip.
|
|
%%
|
|
%% Method/path comparison uses integer-segment binaries because
|
|
%% `<<"GET">>` truncates to a single byte in this port.
|
|
|
|
route(Req) ->
|
|
M = field(method, Req),
|
|
P = field(path, Req),
|
|
dispatch(M, P).
|
|
|
|
%% 71 69 84 = "GET" | 47 = "/"
|
|
dispatch(<<71, 69, 84>>, <<47>>) ->
|
|
ok_response(welcome_body());
|
|
%% GET /.well-known/sx-capabilities
|
|
dispatch(<<71, 69, 84>>,
|
|
<<47,46,119,101,108,108,45,107,110,111,119,110,
|
|
47,115,120,45,99,97,112,97,98,105,108,105,116,105,101,115>>) ->
|
|
ok_response(capabilities_body());
|
|
%% GET /actors/{id} or /artifacts/{cid}
|
|
dispatch(<<71, 69, 84>>, Path) ->
|
|
case match_prefix(actors_prefix(), Path) of
|
|
{ok, Id} when byte_size(Id) > 0 ->
|
|
actor_doc_response(Id);
|
|
_ ->
|
|
case match_prefix(artifacts_prefix(), Path) of
|
|
{ok, Cid} when byte_size(Cid) > 0 ->
|
|
artifact_response(Cid);
|
|
_ ->
|
|
not_found_response()
|
|
end
|
|
end;
|
|
dispatch(_, _) ->
|
|
not_found_response().
|
|
|
|
%% "fed-sx kernel m1\n" — 17 bytes, hand-spelled.
|
|
%% f e d - s x _ k e r n e l _ m 1 \n
|
|
welcome_body() ->
|
|
<<102,101,100,45,115,120,32,107,101,114,110,101,108,32,109,49,10>>.
|
|
|
|
%% "/.well-known/sx-capabilities" — exposed for callers that build
|
|
%% requests in tests or that need the canonical path string.
|
|
capabilities_path() ->
|
|
<<47,46,119,101,108,108,45,107,110,111,119,110,
|
|
47,115,120,45,99,97,112,97,98,105,108,105,116,105,101,115>>.
|
|
|
|
%% Capability descriptor body. Returned as plain text per design
|
|
%% §16; future content-negotiation work (Step 8d) layers JSON /
|
|
%% dag-cbor / SX representations on top.
|
|
%%
|
|
%% Lines (each terminated by \n = 10):
|
|
%% "kernel: fed-sx-m1\n"
|
|
%% "version: 0.0.1\n"
|
|
%% "verbs: Create Update Delete\n"
|
|
capabilities_body() ->
|
|
<<107,101,114,110,101,108,58,32,102,101,100,45,115,120,45,109,49,10,
|
|
118,101,114,115,105,111,110,58,32,48,46,48,46,49,10,
|
|
118,101,114,98,115,58,32,67,114,101,97,116,101,32,85,112,100,97,116,101,32,68,101,108,101,116,101,10>>.
|
|
|
|
ok_response(Body) ->
|
|
[{status, 200}, {headers, []}, {body, Body}].
|
|
|
|
not_found_response() ->
|
|
[{status, 404}, {headers, []},
|
|
{body, <<110,111,116,32,102,111,117,110,100,10>>}]. % "not found\n"
|
|
|
|
%% Internal property-list field lookup. Returns nil when missing
|
|
%% so the route falls into the not_found arm gracefully.
|
|
field(K, [{K, V} | _]) -> V;
|
|
field(K, [_ | Rest]) -> field(K, Rest);
|
|
field(_, []) -> nil.
|
|
|
|
%% ── Dynamic-segment routing ─────────────────────────────────────
|
|
%%
|
|
%% match_prefix(Prefix, Path) — if Path starts with the entire
|
|
%% Prefix binary, return {ok, Rest} where Rest is the remaining
|
|
%% bytes; else return nomatch. Pure byte-level pattern match,
|
|
%% no regex / no parsing. Path-segment splitting comes in later
|
|
%% sub-deliverables (8c-art, 8c-proj) where it's needed.
|
|
|
|
match_prefix(<<>>, Rest) -> {ok, Rest};
|
|
match_prefix(<<B, PRest/binary>>, <<B, PathRest/binary>>) ->
|
|
match_prefix(PRest, PathRest);
|
|
match_prefix(_, _) -> nomatch.
|
|
|
|
%% "/actors/" — 8 bytes: 47 97 99 116 111 114 115 47
|
|
actors_prefix() ->
|
|
<<47,97,99,116,111,114,115,47>>.
|
|
|
|
%% Actor doc stub. Real implementation (Step 8c continuation) will
|
|
%% fetch the actor-state projection entry and serialise it; v1
|
|
%% returns the id as the body so route resolution can be exercised
|
|
%% end-to-end without the projection wiring.
|
|
actor_doc_response(Id) ->
|
|
%% "actor: " — 7 bytes
|
|
Pre = <<97,99,116,111,114,58,32>>,
|
|
Body = <<Pre/binary, Id/binary, 10>>,
|
|
ok_response(Body).
|
|
|
|
%% "/artifacts/" — 11 bytes
|
|
artifacts_prefix() ->
|
|
<<47,97,114,116,105,102,97,99,116,115,47>>.
|
|
|
|
%% Artifact stub. Real implementation will fetch the bytes from
|
|
%% the registry (or a CID-keyed store) and content-negotiate.
|
|
%% v1 echoes the CID so route resolution can be tested.
|
|
artifact_response(Cid) ->
|
|
%% "artifact: " — 10 bytes
|
|
Pre = <<97,114,116,105,102,97,99,116,58,32>>,
|
|
Body = <<Pre/binary, Cid/binary, 10>>,
|
|
ok_response(Body).
|