~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
234 lines · 6.4 KB Raw History
package opsread

import (
	"context"
	"crypto/sha256"
	"crypto/subtle"
	"errors"
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"strings"
	"time"

	contract "github.com/johnandersen777/socialweb-computer-kcp/internal/contract/opsread"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/httpjson"
)

const SecretFileName = "ops-read-secret"

type Secret struct {
	sum [sha256.Size]byte

	set bool
}

func LoadSecret(path string) (Secret, error) {
	if strings.TrimSpace(path) == "" {
		return Secret{}, nil
	}
	info, err := os.Stat(path)
	if errors.Is(err, os.ErrNotExist) {
		return Secret{}, nil
	}
	if err != nil {
		return Secret{}, fmt.Errorf("opsread: the secret file: %w", err)
	}
	if !info.Mode().IsRegular() || info.Mode().Perm()&0o077 != 0 {
		return Secret{}, fmt.Errorf("opsread: the secret file %s must be a regular file of mode 0600", path)
	}
	raw, err := os.ReadFile(path)
	if err != nil {
		return Secret{}, fmt.Errorf("opsread: the secret file: %w", err)
	}
	value := strings.TrimSpace(string(raw))
	if value == "" {
		return Secret{}, nil
	}
	return Secret{sum: sha256.Sum256([]byte(value)), set: true}, nil
}

func (s Secret) Configured() bool {
	return s.set
}

func (s Secret) matches(header string) bool {
	token, ok := strings.CutPrefix(header, "Bearer ")
	if !ok {
		return false
	}
	got := sha256.Sum256([]byte(strings.TrimSpace(token)))
	return subtle.ConstantTimeCompare(got[:], s.sum[:]) == 1
}

type Objects func(ctx context.Context) (contract.Objects, error)

func fail(w http.ResponseWriter, status int, code, message string) {
	httpjson.Write(w, status, map[string]any{"error": code, "message": message})
}

type routes struct {
	mux *http.ServeMux

	secret Secret

	log *slog.Logger
}

func (rt routes) failed(w http.ResponseWriter, nsid string, err error) {
	switch {
	case errors.Is(err, contract.ErrInvalid):
		fail(w, http.StatusBadRequest, "InvalidRequest", "the request is not valid")
	case errors.Is(err, contract.ErrNotFound):
		fail(w, http.StatusNotFound, "NotFound", "there is no such object on this host")
	default:
		rt.log.Warn("an ops read route failed", "nsid", nsid, "err", err.Error())
		fail(w, http.StatusBadGateway, "ReadFailed", "the read failed; the host's log has the detail")
	}
}

func (s Secret) guard(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if !s.matches(r.Header.Get("Authorization")) {
			fail(w, http.StatusUnauthorized, "AuthenticationRequired", "the ops read secret is required")
			return
		}
		next(w, r)
	}
}

func (rt routes) query(nsid string, handler func(w http.ResponseWriter, r *http.Request) error) {
	rt.mux.HandleFunc("GET /xrpc/"+nsid, rt.secret.guard(func(w http.ResponseWriter, r *http.Request) {
		if err := handler(w, r); err != nil {
			rt.failed(w, nsid, err)
		}
	}))
}

func newRoutes(mux *http.ServeMux, secret Secret, log *slog.Logger) routes {
	if log == nil {
		log = slog.New(slog.DiscardHandler)
	}
	return routes{mux: mux, secret: secret, log: log}
}

func RegisterBidder(mux *http.ServeMux, secret Secret, objects Objects, host contract.Host, log *slog.Logger) {
	if !secret.Configured() {
		return
	}
	rt := newRoutes(mux, secret, log)
	open := func(w http.ResponseWriter, r *http.Request) contract.Objects {
		o, err := objects(r.Context())
		if err != nil {
			rt.log.Warn("the bidder's objects are not readable", "err", err.Error())
			fail(w, http.StatusServiceUnavailable, "Unavailable", "the bidder's objects are not readable yet")
			return nil
		}
		return o
	}
	invalid := func(w http.ResponseWriter, message string) error {
		fail(w, http.StatusBadRequest, "InvalidRequest", message)
		return nil
	}
	rt.query(contract.ListVMsNSID, func(w http.ResponseWriter, r *http.Request) error {
		o := open(w, r)
		if o == nil {
			return nil
		}
		items, err := o.VMs(r.Context())
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, map[string]any{"items": items})
		return nil
	})
	rt.query(contract.GetVMNSID, func(w http.ResponseWriter, r *http.Request) error {
		name := r.URL.Query().Get("name")
		if !contract.ValidVMName(name) {
			return invalid(w, "name is a ComputeVM name")
		}
		o := open(w, r)
		if o == nil {
			return nil
		}
		detail, err := o.VM(r.Context(), name)
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, detail)
		return nil
	})
	rt.query(contract.GetBidderNSID, func(w http.ResponseWriter, r *http.Request) error {
		o := open(w, r)
		if o == nil {
			return nil
		}
		state, err := o.Bidder(r.Context())
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, state)
		return nil
	})
	rt.query(contract.GetHealthNSID, func(w http.ResponseWriter, r *http.Request) error {
		health, err := host.Health(r.Context())
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, health)
		return nil
	})
	rt.query(contract.GetLogNSID, func(w http.ResponseWriter, r *http.Request) error {
		q := contract.LogQuery{Message: r.URL.Query().Get("msg"), Subject: r.URL.Query().Get("subject")}
		if _, ok := contract.Messages[q.Message]; !ok {
			return invalid(w, "msg is one of the known message names")
		}
		if q.Subject != "" && !contract.ValidSubject(q.Subject) {
			return invalid(w, "subject is a ComputeVM name or an at:// URI")
		}
		result, err := host.Log(r.Context(), q)
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, result)
		return nil
	})
	rt.query(contract.GetVMMemoryNSID, func(w http.ResponseWriter, r *http.Request) error {
		name := r.URL.Query().Get("name")
		if !contract.ValidVMName(name) {
			return invalid(w, "name is a ComputeVM name")
		}
		memory, err := host.VMMemory(r.Context(), name)
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, memory)
		return nil
	})
}

func RegisterGateway(mux *http.ServeMux, secret Secret, host contract.Host, log *slog.Logger) {
	if !secret.Configured() {
		return
	}
	rt := newRoutes(mux, secret, log)
	rt.query(contract.GetRequesterLogNSID, func(w http.ResponseWriter, r *http.Request) error {
		did := r.URL.Query().Get("did")
		if !contract.ValidDID(did) {
			fail(w, http.StatusBadRequest, "InvalidRequest", "did is a DID")
			return nil
		}
		since, err := time.Parse(time.RFC3339Nano, r.URL.Query().Get("since"))
		if err != nil {
			fail(w, http.StatusBadRequest, "InvalidRequest", "since is an RFC 3339 time")
			return nil
		}
		lines, err := host.RequesterLog(r.Context(), did, since)
		if err != nil {
			return err
		}
		httpjson.Write(w, http.StatusOK, map[string]any{"lines": lines})
		return nil
	})
}