* fix(postgres): scope OpenPRs to the caller's org A principal-carrying caller read every org's pr_open tasks. The query now honours the request scope; the daemon's unscoped review scan still sees all orgs. Issue: archie-core-kgxw.23 * fix(statestore): serve task logs only to the task's org ReadTaskLog and StreamTaskLogContent took a task ID and read the file with no org check. The State Store's task-log reader now confirms the task is visible under the caller's scope first; unscoped services read as before. Issue: archie-core-kgxw.24 * fix(postgres): scope ListPolicies to the caller's org Every org's policy text reached any principal-carrying caller. A scoped read now sees its own org's policies, plus instance policies when scoped to the system org. The engines and the lockout guard decide for every org, so they read the full chain unscoped: the dashboard engine loads without the request's principal and the guard lifts the caller's scope. Issue: archie-core-kgxw.25 * fix(postgres): scope identity reads to the caller's org ListIdentities and GetIdentity (and its alias fallback) returned every identity to any caller. A caller scoped to an org now sees only that org's members and assigned agents; the system org and unscoped services still see the whole instance. Issue: archie-core-kgxw.26 * fix(postgres): hide instance status from other orgs ListPresence, ListChannelStatus, ListApplyStatus and GetConfigSnapshot answered any org principal with instance-wide state. They now return nothing unless the request is unscoped or scoped to the system org. The dashboard reads the published config as itself, since its handlers project it for callers of every org. Issue: archie-core-kgxw.27 * feat(postgres): assign new agents an org and role at creation A bot or service account created through the API served no org until the next State Store boot granted it one. Create now assigns it to the org the request acts in with the developer role in the same transaction, so it is authorized immediately. Issue: archie-core-kgxw.14 * feat(edastore): create event records in a chosen workspace Sources are created in a workspace of the caller's org, the default one when none is named; event types and bindings take their source's workspace and mappings their event type's, the same rule the org backfill applied. The binding, mapping and event type contracts carry the workspace, the four list endpoints accept ?workspace=, and the Events page has a workspace selector that filters every step and picks where a new source goes. Issue: archie-core-kgxw.11 * feat(webui): authorize a record in its workspace The API built every access request with no workspace, so workspace policies and per-workspace roles never applied. A request naming a source, binding, mapping, event type or task now reads the record's workspace under the caller's scope and authorizes in it; tasks carry their workspace on the State Store contract for this. Issue: archie-core-kgxw.9 * feat(access): expose workspace environment to policies Policies can test resource.workspace.environment. The workspace attribute is the workspace entity, which carries its environment; the principal brings its org's workspaces from the State Store, so the dashboard and the daemon's run checks describe a resource's workspace without another lookup, and the daemon now authorizes runs in the task's or binding's workspace. Issue: archie-core-kgxw.10 * fix(webui): ask read_secret when a source secret is read Rotating a source's secret returns its value, but the route asked update, which every developer holds, so no policy could narrow who reads a secret. It now asks read_secret on the secret, which the shipped roles give admins and an object policy can narrow further. Issue: archie-core-kgxw.17 * refactor(org): delete the unused upgrade-incomplete sentinel Nothing returns org.ErrUpgradeIncomplete: the State Store finishes the org upgrade before it serves. Issue: archie-core-kgxw.18
368 lines
12 KiB
Go
368 lines
12 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/binding"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
)
|
|
|
|
// bindingRequest is the wire shape POST /api/bindings and
|
|
// PATCH /api/bindings/{id} both accept. ID/Version/Status/CreatedAt/UpdatedAt
|
|
// are server-assigned (or server-driven), never taken from the request body.
|
|
type bindingRequest struct {
|
|
Name string `json:"name"`
|
|
Matcher binding.Matcher `json:"matcher"`
|
|
MappingID string `json:"mapping_id"`
|
|
Filter string `json:"filter"`
|
|
Workflow string `json:"workflow"`
|
|
// Owner and Repo optionally pin the binding to one configured repo,
|
|
// for multi-repo deployments. Both empty is valid (falls back to the
|
|
// daemon's single-configured-repo behaviour); binding.Validate
|
|
// rejects setting only one.
|
|
Owner string `json:"owner"`
|
|
Repo string `json:"repo"`
|
|
// RepoParam takes the repository from a mapped parameter instead.
|
|
RepoParam string `json:"repo_param"`
|
|
Inputs map[string]binding.InputSource `json:"inputs"`
|
|
}
|
|
|
|
// bindingView is a listed binding with its source's signing state, so the
|
|
// list can flag a binding that dispatches unsigned events.
|
|
type bindingView struct {
|
|
binding.Binding
|
|
Unsigned bool `json:"unsigned"`
|
|
// WorkflowDisabled marks a binding whose org has disabled the workflow it
|
|
// targets; it does not dispatch until the workflow is enabled again.
|
|
WorkflowDisabled bool `json:"workflow_disabled"`
|
|
// LastOutcome is the binding's newest ledger row: the task it started or
|
|
// the reason it started none.
|
|
LastOutcome *storecontract.Dispatch `json:"last_outcome,omitempty"`
|
|
}
|
|
|
|
func (s *Server) handleBindingsList(w http.ResponseWriter, r *http.Request) {
|
|
if s.Bindings == nil {
|
|
http.Error(w, "bindings not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
bindings, err := s.Bindings.ListBindings(r.Context())
|
|
if err != nil {
|
|
s.Log.Error("list bindings", "err", err)
|
|
http.Error(w, "list bindings failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
unsigned, err := s.unsignedSources(r.Context())
|
|
if err != nil {
|
|
s.Log.Error("list sources", "err", err)
|
|
http.Error(w, "list bindings failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
enablement, _, err := s.workflowEnablement(r.Context())
|
|
if err != nil {
|
|
s.Log.Error("workflow enablement", "err", err)
|
|
http.Error(w, "list bindings failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
views := make([]bindingView, 0, len(bindings))
|
|
for _, b := range bindings {
|
|
if !listedIn(r, b.WorkspaceID) {
|
|
continue
|
|
}
|
|
views = append(views, bindingView{
|
|
Binding: b, Unsigned: unsigned[b.Matcher.Source], WorkflowDisabled: !enablement.Enabled(b.OrgID, b.Workflow),
|
|
LastOutcome: s.lastOutcome(r.Context(), b.ID),
|
|
})
|
|
}
|
|
writeJSON(w, map[string]any{"bindings": views})
|
|
}
|
|
|
|
// lastOutcome returns a binding's newest dispatch, or nil when it has none or
|
|
// the ledger is unreadable.
|
|
func (s *Server) lastOutcome(ctx context.Context, bindingID string) *storecontract.Dispatch {
|
|
if s.Dispatches == nil {
|
|
return nil
|
|
}
|
|
rows, err := s.Dispatches.ListDispatches(ctx, storecontract.DispatchFilter{BindingID: bindingID, Limit: 1})
|
|
if err != nil {
|
|
s.Log.Warn("binding last outcome", "binding", bindingID, "err", err)
|
|
return nil
|
|
}
|
|
if len(rows) == 0 {
|
|
return nil
|
|
}
|
|
return &rows[0]
|
|
}
|
|
|
|
func (s *Server) handleBindingCreate(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorizeTaskMutation(w, r) {
|
|
return
|
|
}
|
|
if s.Bindings == nil {
|
|
http.Error(w, "bindings not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
req, ok := decodeBody[bindingRequest](w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
b, ok := s.checkedBinding(w, r, "", req)
|
|
if !ok {
|
|
return
|
|
}
|
|
id, err := s.Bindings.InsertBinding(r.Context(), b)
|
|
if err != nil {
|
|
s.Log.Error("insert binding", "err", err)
|
|
http.Error(w, "create binding failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
created, err := s.Bindings.GetBinding(r.Context(), id)
|
|
if err != nil || created == nil {
|
|
s.Log.Error("get binding after insert", "err", err, "id", id)
|
|
http.Error(w, "create binding failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
writeJSON(w, created)
|
|
}
|
|
|
|
func (s *Server) handleBindingGet(w http.ResponseWriter, r *http.Request) {
|
|
if s.Bindings == nil {
|
|
http.Error(w, "bindings not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
id := r.PathValue("id")
|
|
if id == "" {
|
|
http.Error(w, "invalid binding id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
b, err := s.Bindings.GetBinding(r.Context(), id)
|
|
if err != nil {
|
|
s.Log.Error("get binding", "err", err, "id", id)
|
|
http.Error(w, "get binding failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if b == nil {
|
|
http.Error(w, "binding not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
writeJSON(w, b)
|
|
}
|
|
|
|
// handleDispatches serves the newest dispatch ledger rows for the resource the
|
|
// path names, linking bindings, captures and tasks to each other.
|
|
func (s *Server) handleDispatches(filterFor func(id string) (storecontract.DispatchFilter, bool)) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if s.Dispatches == nil {
|
|
http.Error(w, "dispatch ledger not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
filter, ok := filterFor(r.PathValue("id"))
|
|
if !ok {
|
|
http.Error(w, "invalid id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
filter.Limit = 50
|
|
dispatches, err := s.Dispatches.ListDispatches(r.Context(), filter)
|
|
if err != nil {
|
|
s.Log.Error("list dispatches", "err", err)
|
|
http.Error(w, "list dispatches failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
writeJSON(w, dispatches)
|
|
}
|
|
}
|
|
|
|
func (s *Server) handleBindingUpdate(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorizeTaskMutation(w, r) {
|
|
return
|
|
}
|
|
if s.Bindings == nil {
|
|
http.Error(w, "bindings not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
id := r.PathValue("id")
|
|
if id == "" {
|
|
http.Error(w, "invalid binding id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
req, ok := decodeBody[bindingRequest](w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
b, ok := s.checkedBinding(w, r, id, req)
|
|
if !ok {
|
|
return
|
|
}
|
|
if err := s.Bindings.UpdateBinding(r.Context(), b); err != nil {
|
|
switch {
|
|
case errors.Is(err, storecontract.ErrBindingNotFound):
|
|
http.Error(w, "binding not found", http.StatusNotFound)
|
|
default:
|
|
s.Log.Error("update binding", "err", err, "id", id)
|
|
http.Error(w, "update binding failed", http.StatusInternalServerError)
|
|
}
|
|
return
|
|
}
|
|
updated, err := s.Bindings.GetBinding(r.Context(), id)
|
|
if err != nil || updated == nil {
|
|
s.Log.Error("get binding after update", "err", err, "id", id)
|
|
http.Error(w, "update binding failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
writeJSON(w, updated)
|
|
}
|
|
|
|
func (s *Server) handleBindingDelete(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorizeTaskMutation(w, r) {
|
|
return
|
|
}
|
|
if s.Bindings == nil {
|
|
http.Error(w, "bindings not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
id := r.PathValue("id")
|
|
if id == "" {
|
|
http.Error(w, "invalid binding id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := s.Bindings.DeleteBinding(r.Context(), id); err != nil {
|
|
if errors.Is(err, storecontract.ErrBindingNotFound) {
|
|
http.Error(w, "binding not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
s.Log.Error("delete binding", "err", err, "id", id)
|
|
http.Error(w, "delete binding failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
// handleBindingTransition serves one binding lifecycle command (approve,
|
|
// pause, resume) and answers the binding as it now stands.
|
|
func (s *Server) handleBindingTransition(verb string, apply func(storecontract.BindingStore, context.Context, string) error) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorizeTaskMutation(w, r) {
|
|
return
|
|
}
|
|
if s.Bindings == nil {
|
|
http.Error(w, "bindings not configured", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
id := r.PathValue("id")
|
|
if id == "" {
|
|
http.Error(w, "invalid binding id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := apply(s.Bindings, r.Context(), id); err != nil {
|
|
switch {
|
|
case errors.Is(err, storecontract.ErrBindingNotFound):
|
|
http.Error(w, "binding not found", http.StatusNotFound)
|
|
case errors.Is(err, storecontract.ErrBindingTransition):
|
|
http.Error(w, "binding cannot "+verb+" from its current state", http.StatusConflict)
|
|
default:
|
|
s.Log.Error(verb+" binding", "err", err, "id", id)
|
|
http.Error(w, verb+" binding failed", http.StatusInternalServerError)
|
|
}
|
|
return
|
|
}
|
|
updated, err := s.Bindings.GetBinding(r.Context(), id)
|
|
if err != nil || updated == nil {
|
|
s.Log.Error("get binding after "+verb, "err", err, "id", id)
|
|
http.Error(w, verb+" binding failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
writeJSON(w, updated)
|
|
}
|
|
}
|
|
|
|
// checkedBinding builds the binding a create or update request describes and
|
|
// refuses it, having written the error, unless it is well-formed, its mapping
|
|
// exists, its filter compiles against the mapping's parameters, and its inputs
|
|
// and repository satisfy the workflow it targets.
|
|
func (s *Server) checkedBinding(w http.ResponseWriter, r *http.Request, id string, req bindingRequest) (binding.Binding, bool) {
|
|
b := binding.Binding{
|
|
ID: id,
|
|
Name: req.Name,
|
|
Matcher: req.Matcher,
|
|
MappingID: req.MappingID,
|
|
Filter: req.Filter,
|
|
Workflow: req.Workflow,
|
|
Owner: req.Owner,
|
|
Repo: req.Repo,
|
|
RepoParam: req.RepoParam,
|
|
Inputs: req.Inputs,
|
|
Status: binding.StatusPendingApproval,
|
|
}
|
|
if err := b.Validate(); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return binding.Binding{}, false
|
|
}
|
|
entry, found, err := s.workflowEntry(r.Context(), req.Workflow)
|
|
if err != nil {
|
|
http.Error(w, "workflow definitions unavailable", http.StatusServiceUnavailable)
|
|
return binding.Binding{}, false
|
|
}
|
|
if !found {
|
|
http.Error(w, "binding: workflow not found: "+req.Workflow, http.StatusBadRequest)
|
|
return binding.Binding{}, false
|
|
}
|
|
enabled, err := s.bindingWorkflowEnabled(r.Context(), id, req.Workflow)
|
|
if err != nil {
|
|
http.Error(w, "workflow enablement unavailable", http.StatusServiceUnavailable)
|
|
return binding.Binding{}, false
|
|
}
|
|
if !enabled {
|
|
http.Error(w, "binding: workflow is disabled: "+req.Workflow, http.StatusConflict)
|
|
return binding.Binding{}, false
|
|
}
|
|
iface, err := task.ParseWorkflowInterface(entry.YAML)
|
|
if err != nil {
|
|
http.Error(w, "binding: workflow "+req.Workflow+": "+err.Error(), http.StatusBadRequest)
|
|
return binding.Binding{}, false
|
|
}
|
|
if s.Mappings == nil {
|
|
http.Error(w, "mappings not configured", http.StatusServiceUnavailable)
|
|
return binding.Binding{}, false
|
|
}
|
|
m, err := s.Mappings.GetMapping(r.Context(), b.MappingID)
|
|
if err != nil {
|
|
s.Log.Error("get mapping for binding", "err", err, "mapping", b.MappingID)
|
|
http.Error(w, "get mapping failed", http.StatusInternalServerError)
|
|
return binding.Binding{}, false
|
|
}
|
|
if m == nil {
|
|
http.Error(w, "binding: mapping not found: "+b.MappingID, http.StatusBadRequest)
|
|
return binding.Binding{}, false
|
|
}
|
|
if _, err := binding.CompileFilter(b.Filter, m.Fields); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return binding.Binding{}, false
|
|
}
|
|
if err := b.CheckWorkflow(iface, m.Fields); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return binding.Binding{}, false
|
|
}
|
|
return b, true
|
|
}
|
|
|
|
// bindingWorkflowEnabled reports whether the org owning binding id (the
|
|
// default org for a binding not yet created) has workflow enabled.
|
|
func (s *Server) bindingWorkflowEnabled(ctx context.Context, id, workflow string) (bool, error) {
|
|
owner := org.DefaultOrgID
|
|
if id != "" {
|
|
existing, err := s.Bindings.GetBinding(ctx, id)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if existing != nil {
|
|
owner = existing.OrgID
|
|
}
|
|
}
|
|
enablement, _, err := s.workflowEnablement(ctx)
|
|
return enablement.Enabled(owner, workflow), err
|
|
}
|