package gatewayhttp import ( "context" "encoding/json" "errors" "fmt" "io" "log/slog" "net/http" "net/url" "regexp" "slices" "strconv" "strings" "time" "github.com/johnandersen777/socialweb-computer-kcp/internal/gateway" "github.com/johnandersen777/socialweb-computer-kcp/internal/kit/httpjson" "github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt" "github.com/johnandersen777/socialweb-computer-kcp/internal/xrpcserver" ) const ( NSIDCreateCluster = xrpcserver.NSIDPrefix + "createCluster" NSIDListClusters = xrpcserver.NSIDPrefix + "listClusters" NSIDGetKubeconfig = xrpcserver.NSIDPrefix + "getKubeconfig" NSIDControlPlaneUp = xrpcserver.NSIDPrefix + "controlPlaneUp" NSIDControlPlaneDown = xrpcserver.NSIDPrefix + "controlPlaneDown" NSIDDeleteCluster = xrpcserver.NSIDPrefix + "deleteCluster" NSIDListKubeconfigs = xrpcserver.NSIDPrefix + "listKubeconfigs" NSIDRevokeKubeconfig = xrpcserver.NSIDPrefix + "revokeKubeconfig" ClusterNameMax = 63 HourSec = int64(3600) DaySec = int64(86400) DefaultMaxBodyBytes = int64(4 * 1024) DefaultMaxKubeconfigTTL = 24 * HourSec ) var ( clusterNamePattern = regexp.MustCompile(`^[a-z0-9]([-a-z0-9]*[a-z0-9])?$`) ttlChoices = []int64{HourSec, 8 * HourSec, DaySec} ) type ClusterSummary struct { Name string `json:"name"` Phase string `json:"phase"` Running bool `json:"running"` Instance string `json:"instance,omitempty"` TeardownBlocked bool `json:"teardownBlocked,omitempty"` Server string `json:"server,omitempty"` } type ClusterPhaseResult struct { Phase string `json:"phase"` } type KubeconfigGrant struct { Kubeconfig string `json:"kubeconfig"` Instance string `json:"instance,omitempty"` } type ClusterCaller interface { DID() string ServiceAuth(ctx context.Context, audience, lxm string) (string, error) } type caller struct { did string fn func(context.Context, string, string) (string, error) } func (c caller) DID() string { return c.did } func (c caller) ServiceAuth(ctx context.Context, audience, lxm string) (string, error) { if c.fn == nil { return "", errors.New("gatewayhttp: no service auth source") } return c.fn(ctx, audience, lxm) } func NewCaller(did string, serviceAuth func(context.Context, string, string) (string, error)) ClusterCaller { return caller{did: did, fn: serviceAuth} } type ClusterGateway interface { List(ctx context.Context, caller ClusterCaller) ([]ClusterSummary, error) Create(ctx context.Context, caller ClusterCaller, name string) (ClusterPhaseResult, error) Kubeconfig(ctx context.Context, caller ClusterCaller, name string, ttlSeconds *int64, noExpiry bool) (KubeconfigGrant, error) Up(ctx context.Context, caller ClusterCaller, name string) (ClusterPhaseResult, error) Down(ctx context.Context, caller ClusterCaller, name string) (ClusterPhaseResult, error) Delete(ctx context.Context, caller ClusterCaller, name string) (ClusterPhaseResult, error) Kubeconfigs(ctx context.Context, caller ClusterCaller, name string) ([]gateway.KubeconfigView, error) RevokeKubeconfig(ctx context.Context, caller ClusterCaller, name, serial string) error } type ClusterGatewayError struct { Status int Code string Message string } func (e *ClusterGatewayError) Error() string { return fmt.Sprintf("gatewayhttp: cluster gateway: %s: %s", e.Code, e.Message) } type DirectClusterGateway struct { Server *gateway.Server } func (d DirectClusterGateway) server() (*gateway.Server, error) { if d.Server == nil { return nil, errors.New("gatewayhttp: no direct gateway server") } return d.Server, nil } func (d DirectClusterGateway) List(ctx context.Context, c ClusterCaller) ([]ClusterSummary, error) { server, err := d.server() if err != nil { return nil, err } views, err := server.ListClusters(ctx, gateway.Caller(c.DID())) if err != nil { return nil, err } out := make([]ClusterSummary, 0, len(views)) for _, v := range views { out = append(out, ClusterSummary{ Name: v.Name, Phase: v.Phase, Running: v.Running, Instance: v.Instance, TeardownBlocked: v.TeardownBlocked, Server: v.URL, }) } return out, nil } func (d DirectClusterGateway) Create(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { server, err := d.server() if err != nil { return ClusterPhaseResult{}, err } view, err := server.CreateCluster(ctx, gateway.Caller(c.DID()), gateway.NameRequest{Name: name}) return ClusterPhaseResult{Phase: view.Phase}, err } func (d DirectClusterGateway) Kubeconfig(ctx context.Context, c ClusterCaller, name string, ttlSeconds *int64, noExpiry bool) (KubeconfigGrant, error) { server, err := d.server() if err != nil { return KubeconfigGrant{}, err } grant, err := server.GetKubeconfig(ctx, gateway.Caller(c.DID()), gateway.KubeconfigRequest{ Name: name, TTLSeconds: ttlSeconds, NoExpiry: noExpiry, }) if err != nil { return KubeconfigGrant{}, err } return KubeconfigGrant{Kubeconfig: grant.Kubeconfig, Instance: grant.Instance}, nil } func (d DirectClusterGateway) Up(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { server, err := d.server() if err != nil { return ClusterPhaseResult{}, err } view, err := server.ControlPlaneUp(ctx, gateway.Caller(c.DID()), gateway.NameRequest{Name: name}) return ClusterPhaseResult{Phase: view.Phase}, err } func (d DirectClusterGateway) Down(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { server, err := d.server() if err != nil { return ClusterPhaseResult{}, err } view, err := server.ControlPlaneDown(ctx, gateway.Caller(c.DID()), gateway.NameRequest{Name: name}) return ClusterPhaseResult{Phase: view.Phase}, err } func (d DirectClusterGateway) Delete(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { server, err := d.server() if err != nil { return ClusterPhaseResult{}, err } view, err := server.DeleteCluster(ctx, gateway.Caller(c.DID()), gateway.NameRequest{Name: name}) return ClusterPhaseResult{Phase: view.Phase}, err } func (d DirectClusterGateway) Kubeconfigs(ctx context.Context, c ClusterCaller, name string) ([]gateway.KubeconfigView, error) { server, err := d.server() if err != nil { return nil, err } return server.ListKubeconfigs(ctx, gateway.Caller(c.DID()), gateway.NameRequest{Name: name}) } func (d DirectClusterGateway) RevokeKubeconfig(ctx context.Context, c ClusterCaller, name, serial string) error { server, err := d.server() if err != nil { return err } _, err = server.RevokeKubeconfig(ctx, gateway.Caller(c.DID()), gateway.RevokeKubeconfigRequest{Name: name, Serial: serial}) return err } type XRPCClusterGateway struct { BaseURL func(context.Context) (string, error) Audience string Client *http.Client Timeout time.Duration } func (x *XRPCClusterGateway) base(ctx context.Context) (string, error) { if x.BaseURL == nil { return "", errors.New("gatewayhttp: the cluster gateway has no URL") } raw, err := x.BaseURL(ctx) if err != nil { return "", err } return strings.TrimRight(raw, "/"), nil } func (x *XRPCClusterGateway) client() *http.Client { if x.Client != nil { return x.Client } return &http.Client{Timeout: 30 * time.Second} } func (x *XRPCClusterGateway) call(ctx context.Context, c ClusterCaller, nsid string, query bool, body any, out any) error { lxm, _, _ := strings.Cut(nsid, "?") token, err := c.ServiceAuth(ctx, x.Audience, lxm) if err != nil { return &ClusterGatewayError{Status: 401, Code: "ServiceAuthUnavailable", Message: "could not obtain service auth from the account's PDS: " + err.Error()} } base, err := x.base(ctx) if err != nil { return &ClusterGatewayError{Status: 502, Code: "GatewayUnreachable", Message: "cluster gateway did not answer: " + err.Error()} } method := http.MethodPost var reader io.Reader if query { method = http.MethodGet } else { raw, err := json.Marshal(bodyOrEmpty(body)) if err != nil { return fmt.Errorf("gatewayhttp: encoding %s: %w", nsid, err) } reader = strings.NewReader(string(raw)) } req, err := http.NewRequestWithContext(ctx, method, base+xrpcserver.XRPCPrefix+nsid, reader) if err != nil { return err } req.Header.Set("Authorization", "Bearer "+token) if !query { req.Header.Set("Content-Type", "application/json") } timeout := x.Timeout timeout = opt.Positive(timeout, 30*time.Second) cctx, cancel := context.WithTimeout(ctx, timeout) defer cancel() req = req.WithContext(cctx) resp, err := x.client().Do(req) if err != nil { return &ClusterGatewayError{Status: 502, Code: "GatewayUnreachable", Message: "cluster gateway did not answer: " + err.Error()} } defer resp.Body.Close() raw, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20)) if err != nil { return &ClusterGatewayError{Status: 502, Code: "GatewayUnreachable", Message: "cluster gateway answered unreadably: " + err.Error()} } var data map[string]any if len(strings.TrimSpace(string(raw))) > 0 { _ = json.Unmarshal(raw, &data) } if resp.StatusCode < 200 || resp.StatusCode > 299 { code, _ := data["error"].(string) if code == "" { code = "HTTP" + strconv.Itoa(resp.StatusCode) } message, _ := data["message"].(string) if message == "" { message = strings.TrimSpace(string(raw)) if len(message) > 500 { message = message[:500] } } return &ClusterGatewayError{Status: resp.StatusCode, Code: code, Message: message} } if out != nil { if err := json.Unmarshal(raw, out); err != nil { return fmt.Errorf("gatewayhttp: decoding %s: %w", nsid, err) } } return nil } func bodyOrEmpty(body any) any { if body == nil { return map[string]any{} } return body } func (x *XRPCClusterGateway) List(ctx context.Context, c ClusterCaller) ([]ClusterSummary, error) { var out struct { Clusters []ClusterSummary `json:"clusters"` } if err := x.call(ctx, c, NSIDListClusters, true, nil, &out); err != nil { return nil, err } if out.Clusters == nil { return []ClusterSummary{}, nil } return out.Clusters, nil } func (x *XRPCClusterGateway) name(ctx context.Context, c ClusterCaller, nsid, name string) (ClusterPhaseResult, error) { var out ClusterPhaseResult err := x.call(ctx, c, nsid, false, map[string]any{"name": name}, &out) return out, err } func (x *XRPCClusterGateway) Create(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { return x.name(ctx, c, NSIDCreateCluster, name) } func (x *XRPCClusterGateway) Up(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { return x.name(ctx, c, NSIDControlPlaneUp, name) } func (x *XRPCClusterGateway) Down(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { return x.name(ctx, c, NSIDControlPlaneDown, name) } func (x *XRPCClusterGateway) Delete(ctx context.Context, c ClusterCaller, name string) (ClusterPhaseResult, error) { return x.name(ctx, c, NSIDDeleteCluster, name) } func (x *XRPCClusterGateway) Kubeconfig(ctx context.Context, c ClusterCaller, name string, ttlSeconds *int64, noExpiry bool) (KubeconfigGrant, error) { body := map[string]any{"name": name} if ttlSeconds != nil { body["ttlSeconds"] = *ttlSeconds } if noExpiry { body["noExpiry"] = true } var out KubeconfigGrant err := x.call(ctx, c, NSIDGetKubeconfig, false, body, &out) return out, err } func (x *XRPCClusterGateway) Kubeconfigs(ctx context.Context, c ClusterCaller, name string) ([]gateway.KubeconfigView, error) { var out struct { Kubeconfigs []gateway.KubeconfigView `json:"kubeconfigs"` } err := x.call(ctx, c, NSIDListKubeconfigs+"?name="+url.QueryEscape(name), true, nil, &out) return out.Kubeconfigs, err } func (x *XRPCClusterGateway) RevokeKubeconfig(ctx context.Context, c ClusterCaller, name, serial string) error { return x.call(ctx, c, NSIDRevokeKubeconfig, false, map[string]any{"name": name, "serial": serial}, nil) } type ClusterOptions struct { Gateway ClusterGateway Caller func(context.Context, *http.Request) (ClusterCaller, error) MaxKubeconfigTTLSec int64 KCPPublicHost string MaxBodyBytes int64 Log *slog.Logger } type ClusterAPI struct { opts ClusterOptions maxBody int64 maxTTLSec int64 ttlChoices []int64 } func NewClusterAPI(opts ClusterOptions) (*ClusterAPI, error) { if opts.Gateway == nil { return nil, errors.New("gatewayhttp: no cluster gateway") } if opts.Caller == nil { return nil, errors.New("gatewayhttp: no caller authenticator") } opts.MaxKubeconfigTTLSec = opt.Positive(opts.MaxKubeconfigTTLSec, DefaultMaxKubeconfigTTL) opts.MaxBodyBytes = opt.Positive(opts.MaxBodyBytes, DefaultMaxBodyBytes) choices := make([]int64, 0, len(ttlChoices)) for _, c := range ttlChoices { if c <= opts.MaxKubeconfigTTLSec { choices = append(choices, c) } } if len(choices) == 0 { choices = []int64{opts.MaxKubeconfigTTLSec} } return &ClusterAPI{opts: opts, maxBody: opts.MaxBodyBytes, maxTTLSec: opts.MaxKubeconfigTTLSec, ttlChoices: choices}, nil } func (a *ClusterAPI) log() *slog.Logger { if a.opts.Log != nil { return a.opts.Log } return slog.Default() } func (a *ClusterAPI) Register(mux *http.ServeMux) { mux.HandleFunc("GET /api/config", a.config) mux.HandleFunc("POST /api/clusters/list", a.list) mux.HandleFunc("POST /api/clusters/create", a.nameAction("create")) mux.HandleFunc("POST /api/clusters/up", a.nameAction("up")) mux.HandleFunc("POST /api/clusters/down", a.nameAction("down")) mux.HandleFunc("POST /api/clusters/delete", a.nameAction("delete")) mux.HandleFunc("POST /api/clusters/kubeconfig", a.kubeconfig) mux.HandleFunc("POST /api/clusters/kubeconfigs", a.kubeconfigs) mux.HandleFunc("POST /api/clusters/kubeconfigs/revoke", a.revokeKubeconfig) } func (a *ClusterAPI) Handler() http.Handler { mux := http.NewServeMux() a.Register(mux) return mux } func (a *ClusterAPI) config(w http.ResponseWriter, r *http.Request) { var host any if a.opts.KCPPublicHost != "" { host = a.opts.KCPPublicHost } httpjson.Write(w, http.StatusOK, struct { TTLChoicesSec []int64 `json:"ttlChoicesSec"` MaxKubeconfigTTLSec int64 `json:"maxKubeconfigTtlSec"` NoExpiry bool `json:"noExpiry"` KCPPublicHost any `json:"kcpPublicHost"` }{a.ttlChoices, a.maxTTLSec, true, host}) } func (a *ClusterAPI) caller(r *http.Request) (ClusterCaller, *apiFailure) { who, err := a.opts.Caller(r.Context(), r) if err != nil { a.log().Error("cluster_api_auth_unavailable", "err", err) return nil, &apiFailure{Status: http.StatusServiceUnavailable, Error: "Unavailable", Message: "the vault is not answering; try again"} } if who == nil { return nil, &apiFailure{Status: http.StatusUnauthorized, Error: "Unauthorized", Message: "sign in again"} } return who, nil } func (a *ClusterAPI) body(r *http.Request) (map[string]any, *apiFailure) { if declared, err := strconv.ParseInt(r.Header.Get("Content-Length"), 10, 64); err == nil && declared > a.maxBody { return nil, &apiFailure{Status: http.StatusRequestEntityTooLarge, Error: "BodyTooLarge"} } raw, err := io.ReadAll(io.LimitReader(r.Body, a.maxBody+1)) if err != nil { return nil, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "expected a JSON object"} } if int64(len(raw)) > a.maxBody { return nil, &apiFailure{Status: http.StatusRequestEntityTooLarge, Error: "BodyTooLarge"} } if len(strings.TrimSpace(string(raw))) == 0 { return map[string]any{}, nil } dec := json.NewDecoder(strings.NewReader(string(raw))) dec.UseNumber() var out map[string]any if err := dec.Decode(&out); err != nil || out == nil { return nil, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "expected a JSON object"} } return out, nil } type namedInput struct { Caller ClusterCaller Name string Input map[string]any } func (a *ClusterAPI) named(w http.ResponseWriter, r *http.Request) (*namedInput, bool) { who, failure := a.caller(r) if failure != nil { writeFailure(w, failure) return nil, false } input, failure := a.body(r) if failure != nil { writeFailure(w, failure) return nil, false } name, _ := input["name"].(string) if !IsClusterName(name) { writeFailure(w, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "name must be a lowercase DNS label of at most 63 characters"}) return nil, false } return &namedInput{Caller: who, Name: name, Input: input}, true } func (a *ClusterAPI) list(w http.ResponseWriter, r *http.Request) { who, failure := a.caller(r) if failure != nil { writeFailure(w, failure) return } clusters, err := a.opts.Gateway.List(r.Context(), who) if err != nil { a.failure(w, who.DID(), "list", err) return } if clusters == nil { clusters = []ClusterSummary{} } httpjson.Write(w, http.StatusOK, struct { Clusters []ClusterSummary `json:"clusters"` }{clusters}) } func (a *ClusterAPI) nameAction(action string) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { req, ok := a.named(w, r) if !ok { return } var out ClusterPhaseResult var err error switch action { case "create": out, err = a.opts.Gateway.Create(r.Context(), req.Caller, req.Name) case "up": out, err = a.opts.Gateway.Up(r.Context(), req.Caller, req.Name) case "down": out, err = a.opts.Gateway.Down(r.Context(), req.Caller, req.Name) default: out, err = a.opts.Gateway.Delete(r.Context(), req.Caller, req.Name) } if err != nil { a.failure(w, req.Caller.DID(), action, err) return } a.log().Info("cluster_api_ok", "did", req.Caller.DID(), "action", action, "name", req.Name, "phase", out.Phase) httpjson.Write(w, http.StatusOK, struct { Name string `json:"name"` Phase string `json:"phase"` }{req.Name, out.Phase}) } } func (a *ClusterAPI) kubeconfig(w http.ResponseWriter, r *http.Request) { req, ok := a.named(w, r) if !ok { return } rawNoExpiry, present := req.Input["noExpiry"] if present { if _, isBool := rawNoExpiry.(bool); !isBool { writeFailure(w, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "noExpiry must be a boolean"}) return } } noExpiry, _ := rawNoExpiry.(bool) rawTTL, ttlPresent := req.Input["ttlSeconds"] if n, ok := rawTTL.(json.Number); ok && n.String() == "0" { noExpiry, ttlPresent = true, false } if noExpiry && ttlPresent { writeFailure(w, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "noExpiry and ttlSeconds are mutually exclusive"}) return } var ttl *int64 if ttlPresent { number, isNumber := rawTTL.(json.Number) value, err := number.Int64() if !isNumber || err != nil || !a.allowedTTL(value) { writeFailure(w, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "ttlSeconds must be one of " + joinInt64(a.ttlChoices, ", ")}) return } ttl = &value } grant, err := a.opts.Gateway.Kubeconfig(r.Context(), req.Caller, req.Name, ttl, noExpiry) if err != nil { a.failure(w, req.Caller.DID(), "kubeconfig", err) return } a.log().Info("cluster_api_ok", "did", req.Caller.DID(), "action", "kubeconfig", "name", req.Name, "ttlSeconds", ttl, "noExpiry", noExpiry) w.Header().Set("Cache-Control", "no-store") httpjson.Write(w, http.StatusOK, struct { Name string `json:"name"` Filename string `json:"filename"` Kubeconfig string `json:"kubeconfig"` }{req.Name, KubeconfigFilename(req.Name), grant.Kubeconfig}) } func (a *ClusterAPI) kubeconfigs(w http.ResponseWriter, r *http.Request) { req, ok := a.named(w, r) if !ok { return } views, err := a.opts.Gateway.Kubeconfigs(r.Context(), req.Caller, req.Name) if err != nil { a.failure(w, req.Caller.DID(), "kubeconfigs", err) return } if views == nil { views = []gateway.KubeconfigView{} } httpjson.Write(w, http.StatusOK, struct { Kubeconfigs []gateway.KubeconfigView `json:"kubeconfigs"` }{views}) } func (a *ClusterAPI) revokeKubeconfig(w http.ResponseWriter, r *http.Request) { req, ok := a.named(w, r) if !ok { return } serial, _ := req.Input["serial"].(string) if serial == "" || len(serial) > 64 { writeFailure(w, &apiFailure{Status: http.StatusBadRequest, Error: "InvalidRequest", Message: "serial is required"}) return } if err := a.opts.Gateway.RevokeKubeconfig(r.Context(), req.Caller, req.Name, serial); err != nil { a.failure(w, req.Caller.DID(), "revokeKubeconfig", err) return } a.log().Info("cluster_api_ok", "did", req.Caller.DID(), "action", "revokeKubeconfig", "name", req.Name, "serial", serial) httpjson.Write(w, http.StatusOK, gateway.RevokeKubeconfigResponse{Serial: serial, Revoked: true}) } func (a *ClusterAPI) allowedTTL(value int64) bool { return slices.Contains(a.ttlChoices, value) } func (a *ClusterAPI) failure(w http.ResponseWriter, did, action string, err error) { var ge *ClusterGatewayError if errors.As(err, &ge) { status := ge.Status if status < 400 || status > 599 { status = http.StatusBadGateway } a.log().Error("cluster_api_gateway_error", "did", did, "action", action, "status", ge.Status, "code", ge.Code, "message", ge.Message) writeFailure(w, &apiFailure{Status: status, Error: ge.Code, Message: ge.Message}) return } var xe *gateway.XRPCError if errors.As(err, &xe) { status := xe.Status if status < 400 || status > 599 { status = http.StatusBadGateway } a.log().Error("cluster_api_gateway_error", "did", did, "action", action, "status", xe.Status, "code", xe.Name, "message", xe.Message) writeFailure(w, &apiFailure{Status: status, Error: xe.Name, Message: xe.Message}) return } a.log().Error("cluster_api_failed", "did", did, "action", action, "err", err) writeFailure(w, &apiFailure{Status: http.StatusInternalServerError, Error: "InternalError", Message: "the cluster request failed"}) } type apiFailure struct { Status int Error string Message string } func writeFailure(w http.ResponseWriter, f *apiFailure) { httpjson.Write(w, f.Status, struct { Error string `json:"error"` Message string `json:"message,omitempty"` }{f.Error, f.Message}) } func IsClusterName(name string) bool { return len(name) > 0 && len(name) <= ClusterNameMax && clusterNamePattern.MatchString(name) } func KubeconfigFilename(cluster string) string { return cluster + ".kubeconfig.yaml" } func TTLChoicesUpTo(maxSec int64) []int64 { allowed := make([]int64, 0, len(ttlChoices)) for _, c := range ttlChoices { if c <= maxSec { allowed = append(allowed, c) } } if len(allowed) == 0 { return []int64{maxSec} } return allowed } func joinInt64(values []int64, sep string) string { parts := make([]string, len(values)) for i, v := range values { parts[i] = strconv.FormatInt(v, 10) } return strings.Join(parts, sep) }