0
0
package requester
import (
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
atpmarket "github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/market"
atprotooauth "github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/oauth"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/httpjson"
"github.com/johnandersen777/socialweb-computer-kcp/internal/market/participant"
role "github.com/johnandersen777/socialweb-computer-kcp/internal/market/requester"
)
const healthPath = "/xrpc/_health"
func (s *Service) handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET "+healthPath, s.health)
mux.HandleFunc("GET /xrpc/com.atproto.repo.getRecord", s.repoGetRecord)
mux.HandleFunc("GET /xrpc/com.atproto.repo.listRecords", s.repoListRecords)
mux.HandleFunc("GET /xrpc/com.atproto.repo.describeRepo", s.repoDescribe)
mux.HandleFunc("GET /xrpc/com.atproto.server.describeServer", s.serverDescribe)
if s.cfg.InboundXRPC() {
mux.HandleFunc("POST /xrpc/"+atpmarket.SubmitBidNSID, s.submitBid)
mux.HandleFunc("POST /xrpc/"+atpmarket.SubmitEventNSID, s.submitEvent)
}
mux.HandleFunc("GET "+role.SecretsRoute+"/{contract}", s.getSecrets)
mux.HandleFunc("GET /oauth-client-metadata.json", s.oauthClientMetadata)
mux.HandleFunc("GET /oauth/callback/{identity}", s.oauthCallback)
return mux
}
func writeRequestError(w http.ResponseWriter, err error) {
if failure, ok := errors.AsType[*role.RequestError](err); ok {
participant.WriteXRPCError(w, failure.Status, failure.Code, failure.Message)
return
}
participant.WriteXRPCError(w, http.StatusInternalServerError, "InternalError", err.Error())
}
func (s *Service) unavailable(w http.ResponseWriter) {
participant.WriteXRPCError(w, http.StatusServiceUnavailable, "Unavailable", "the requester is starting")
}
func (s *Service) health(w http.ResponseWriter, r *http.Request) {
core := s.healthy()
if core == nil {
httpjson.Write(w, http.StatusServiceUnavailable, map[string]any{"ok": false})
return
}
httpjson.Write(w, http.StatusOK, map[string]any{"ok": true, "did": core.DID()})
}
func (s *Service) repoGetRecord(w http.ResponseWriter, r *http.Request) {
core := s.role()
if core == nil {
s.unavailable(w)
return
}
query := r.URL.Query()
repoDID := cmp.Or(query.Get("repo"), core.RepoDID())
record, err := core.Records().GetRecord(r.Context(), repoDID, query.Get("collection"), query.Get("rkey"))
if err != nil {
status := http.StatusNotFound
if !errors.Is(err, atpmarket.ErrNotFound) {
status = http.StatusBadGateway
}
httpjson.Write(w, status, map[string]any{"error": "RecordNotFound", "message": err.Error()})
return
}
httpjson.Write(w, http.StatusOK, map[string]any{"uri": record.URI, "cid": record.CID, "value": record.Value})
}
func (s *Service) repoListRecords(w http.ResponseWriter, r *http.Request) {
core := s.role()
if core == nil {
s.unavailable(w)
return
}
query := r.URL.Query()
repoDID := cmp.Or(query.Get("repo"), core.RepoDID())
limit := 50
if raw := query.Get("limit"); raw != "" {
fmt.Sscanf(raw, "%d", &limit)
}
page, err := core.Records().ListRecords(r.Context(), repoDID, query.Get("collection"), limit, query.Get("cursor"))
if err != nil {
httpjson.Write(w, http.StatusBadGateway, map[string]any{"error": "RepoError", "message": err.Error()})
return
}
records := make([]any, 0, len(page.Records))
for _, record := range page.Records {
records = append(records, map[string]any{"uri": record.URI, "cid": record.CID, "value": record.Value})
}
body := map[string]any{"records": records}
if page.Cursor != "" {
body["cursor"] = page.Cursor
}
httpjson.Write(w, http.StatusOK, body)
}
func (s *Service) repoDescribe(w http.ResponseWriter, r *http.Request) {
core := s.role()
if core == nil {
s.unavailable(w)
return
}
httpjson.Write(w, http.StatusOK, map[string]any{"did": core.RepoDID(), "handle": core.Handle(), "collections": []string{}})
}
func (s *Service) serverDescribe(w http.ResponseWriter, r *http.Request) {
core := s.role()
if core == nil {
s.unavailable(w)
return
}
httpjson.Write(w, http.StatusOK, map[string]any{"did": core.RepoDID(), "version": "socialweb-computer"})
}
func (s *Service) submitBid(w http.ResponseWriter, r *http.Request) {
s.submitRecord(w, r, atpmarket.SubmitBidNSID, atpmarket.DefaultMarketServiceID, (*role.Requester).SubmitBid)
}
func (s *Service) submitEvent(w http.ResponseWriter, r *http.Request) {
s.submitRecord(w, r, atpmarket.SubmitEventNSID, atpmarket.DefaultComputeEventServiceID, (*role.Requester).SubmitEvent)
}
type submitFunc func(core *role.Requester, ctx context.Context, issuer string, body role.SubmittedRecord) error
func (s *Service) submitRecord(w http.ResponseWriter, r *http.Request, nsid, serviceID string, submit submitFunc) {
core := s.role()
if core == nil {
s.unavailable(w)
return
}
issuer, err := core.AuthorizeCallback(r.Context(), r.Host, r.Header.Get("Authorization"), nsid, serviceID)
if err != nil {
writeRequestError(w, err)
return
}
var body role.SubmittedRecord
if err := participant.ReadSubmitBody(r, &body); err != nil {
participant.WriteXRPCError(w, http.StatusBadRequest, "InvalidRequest", err.Error())
return
}
if err := submit(core, r.Context(), issuer, body); err != nil {
writeRequestError(w, err)
return
}
response := map[string]any{"ok": true}
if refs := core.IngressRecords(r.Context()); len(refs) > 0 {
response["ingress"] = refs
}
httpjson.Write(w, http.StatusOK, response)
}
func (s *Service) getSecrets(w http.ResponseWriter, r *http.Request) {
core := s.role()
if core == nil {
http.Error(w, `{"error":"NotReady"}`, http.StatusServiceUnavailable)
return
}
entries, err := core.Secrets(r.Context(), r.PathValue("contract"), r.Header.Get("Authorization"))
if err != nil {
if failure, ok := errors.AsType[*role.RequestError](err); ok {
http.Error(w, `{"error":"`+failure.Code+`"}`, failure.Status)
return
}
http.Error(w, `{"error":"InternalError"}`, http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(entries)
}
func (s *Service) oauthClientMetadata(w http.ResponseWriter, r *http.Request) {
base := "https://" + r.Host
httpjson.Write(w, http.StatusOK, map[string]any{
"client_id": base + "/oauth-client-metadata.json",
"client_name": "socialweb-computer requester",
"redirect_uris": []string{base + "/oauth/callback/requester"},
"grant_types": []string{"authorization_code", "refresh_token"},
"response_types": []string{"code"},
"scope": atprotooauth.ScopeString(atprotooauth.RequesterOAuthScope),
"token_endpoint_auth_method": "none",
"application_type": "web",
"dpop_bound_access_tokens": true,
})
}
func (s *Service) oauthCallback(w http.ResponseWriter, r *http.Request) {
handler, ok := s.deps.OAuthCallbacks.Lookup(r.PathValue("identity"))
if !ok {
http.Error(w, "unknown identity", http.StatusNotFound)
return
}
if err := handler(r.Context(), w, r); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte("signed in"))
}