Operations register through httpapi.Register with Public, Authorized or AdminAuthorized, and the guard asks the policy chain for the declared action and resource kind before the handler runs. An undeclared operation and an undecidable chain are refused. The workload principal, its shipped policy, a self-service policy and Recording for denials are added in governance.
84 lines
2.8 KiB
Go
84 lines
2.8 KiB
Go
package dashboard
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/danielgtaylor/huma/v2"
|
|
|
|
"github.com/samcharles93/archie-core/internal/platform/httpapi"
|
|
"github.com/samcharles93/archie-core/internal/platform/hub"
|
|
chatpkg "github.com/samcharles93/archie-core/modules/chat"
|
|
"github.com/samcharles93/archie-core/modules/governance"
|
|
)
|
|
|
|
// keepalive is how often an idle stream writes a comment, so proxies keep
|
|
// the connection open and the browser notices one that died.
|
|
const keepalive = 25 * time.Second
|
|
|
|
// chatOutcome is the frame the dashboard re-reads the open conversation on.
|
|
const chatOutcome = `data: {"topic":"tasks","data":{"kind":"chat_outcome"}}` + "\n\n"
|
|
|
|
// Register adds the dashboard's live stream: the one EventSource the SPA
|
|
// keeps open, framing each update as `data: {"topic":…,"data":…}`. A settled
|
|
// chat action is the only update with a dashboard reader; a turn's own reply
|
|
// streams from the chat API. Keepalives tell the connection indicator the
|
|
// server is up, and a reconnect makes every mounted page re-read.
|
|
func Register(api huma.API, h *hub.Hub) {
|
|
httpapi.Register(api, httpapi.Authorized(governance.ActionRead, governance.KindDashboard), huma.Operation{
|
|
OperationID: "stream-dashboard", Method: http.MethodGet, Path: "/api/stream",
|
|
Summary: "Stream live dashboard updates", Tags: []string{"Dashboard"},
|
|
Responses: map[string]*huma.Response{"200": {
|
|
Description: "Server-sent events: one data frame of {\"topic\", \"data\"} per update, and a keepalive comment while idle",
|
|
Content: map[string]*huma.MediaType{"text/event-stream": {Schema: &huma.Schema{Type: huma.TypeString}}},
|
|
}},
|
|
}, func(ctx context.Context, _ *struct{}) (*huma.StreamResponse, error) {
|
|
// A conversation is its owner's; nobody else hears that it changed.
|
|
var chat <-chan hub.Note
|
|
stop := func() {}
|
|
if p, ok := governance.PrincipalFromContext(ctx); ok && p.IdentityID != "" {
|
|
chat, stop = h.Subscribe(chatpkg.OwnerTopic(string(p.IdentityID)))
|
|
}
|
|
return &huma.StreamResponse{Body: func(hc huma.Context) {
|
|
defer stop()
|
|
serve(hc, chat)
|
|
}}, nil
|
|
})
|
|
}
|
|
|
|
func serve(hc huma.Context, chat <-chan hub.Note) {
|
|
w := hc.BodyWriter()
|
|
flusher, ok := w.(http.Flusher)
|
|
if !ok {
|
|
hc.SetStatus(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
hc.SetHeader("Content-Type", "text/event-stream")
|
|
hc.SetHeader("Cache-Control", "no-store")
|
|
hc.SetStatus(http.StatusOK)
|
|
flusher.Flush()
|
|
tick := time.NewTicker(keepalive)
|
|
defer tick.Stop()
|
|
for {
|
|
frame := ": keepalive\n\n"
|
|
select {
|
|
case <-hc.Context().Done():
|
|
return
|
|
case <-tick.C:
|
|
case _, ok := <-chat:
|
|
if !ok {
|
|
// The hub dropped a reader that fell behind; it reconnects
|
|
// and re-reads.
|
|
return
|
|
}
|
|
frame = chatOutcome
|
|
}
|
|
if _, err := fmt.Fprint(w, frame); err != nil {
|
|
return
|
|
}
|
|
flusher.Flush()
|
|
}
|
|
}
|