Files
archie/internal/webui/api_workflows.go
T
sam 403ace1cef fix(webui): the workflow handlers act in the caller's org
The definitions query was built by hand, so it carried no org and the server
resolved the default one, while the enablement document read beside it and the
enablement write went to the default org outright. A caller in a non-default
org therefore read one org's definitions beside another org's enablement, and
toggled that other org's workflows.

workflowCollection now builds its query with controlplanerpc.QueryRequest, and
the three enablement reads and the write use org.OrgFromContext, so every one of
them names the org the principal put on the request context.
2026-09-30 07:33:16 +10:00

196 lines
7.0 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"strings"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
)
const workflowDefinitionsKind = "workflow-definitions"
// handleWorkflows returns per-workflow and per-stage statistics: run counts,
// outcome breakdowns and spend per workflow, plus duration and failure counts
// per stage -- "where does it get stuck" for the workflows page.
func (s *Server) handleWorkflows(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
workflows, err := s.Store.WorkflowStats(ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
stages, err := s.Store.StageStats(ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
definitions, err := s.workflowDefinitions(ctx)
if err != nil {
http.Error(w, "workflow definitions unavailable", http.StatusServiceUnavailable)
return
}
writeJSON(w, map[string]any{
"workflows": workflows,
"stages": stages,
"definitions": definitions,
})
}
type workRequest struct {
Identity string `json:"identity"`
Repository string `json:"repository"`
Workflow string `json:"workflow"`
Title string `json:"title"`
Instructions string `json:"instructions"`
// Inputs assigns the inputs the named workflow declares -- pr-review's
// pr_number, for instance. The handler checks the assignment against the
// declaration before the task is admitted, so a request that could only
// fail at the workflow's first stage is refused here instead
// (archie-core-06nq).
Inputs map[string]any `json:"inputs"`
}
func (s *Server) handleWorkRequest(w http.ResponseWriter, r *http.Request) {
if !s.authorizeTaskMutation(w, r) {
return
}
if s.WorkRequests == nil {
http.Error(w, "work intake unavailable", http.StatusServiceUnavailable)
return
}
r.Body = http.MaxBytesReader(w, r.Body, 32<<10)
var request workRequest
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&request); err != nil {
if _, ok := errors.AsType[*http.MaxBytesError](err); ok {
http.Error(w, "work request body too large", http.StatusRequestEntityTooLarge)
return
}
http.Error(w, "invalid work request", http.StatusBadRequest)
return
}
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
http.Error(w, "invalid work request", http.StatusBadRequest)
return
}
request.Identity = strings.TrimSpace(request.Identity)
request.Repository = strings.TrimSpace(request.Repository)
request.Workflow = strings.TrimSpace(request.Workflow)
request.Title = strings.TrimSpace(request.Title)
request.Instructions = strings.TrimSpace(request.Instructions)
if request.Identity == "" || request.Repository == "" || request.Workflow == "" || request.Title == "" || request.Instructions == "" {
http.Error(w, "identity, repository, workflow, title, and instructions are required", http.StatusBadRequest)
return
}
iface, enabled, err := s.enabledWorkflowInterface(r.Context(), request.Workflow)
if err != nil {
http.Error(w, "workflow definitions unavailable", http.StatusServiceUnavailable)
return
}
if !enabled {
http.Error(w, "workflow is not enabled", http.StatusConflict)
return
}
if err := iface.CheckInputs(request.Inputs); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
taskID, err := s.WorkRequests.CreateTask(r.Context(), messaging.SpawnRequest{
Identity: request.Identity, Repo: request.Repository, Workflow: request.Workflow,
Title: request.Title, Body: request.Instructions, Inputs: request.Inputs,
})
if err != nil {
http.Error(w, "work request rejected", http.StatusBadRequest)
return
}
s.emit(r.Context(), events.Event{Kind: events.KindWorkRequestSubmitted, TaskID: taskID, Repo: request.Repository, Workflow: request.Workflow, Detail: request.Title})
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"ok": true, "task_id": taskID})
}
// enabledWorkflowInterface returns the interface workflow id declares, and
// whether it is defined and enabled for the caller's org. The interface is what
// the work-request handler checks a request's inputs against, so a task whose
// workflow declaration the request cannot satisfy is refused before it is
// admitted.
func (s *Server) enabledWorkflowInterface(ctx context.Context, id string) (task.WorkflowInterface, bool, error) {
entry, found, err := s.workflowEntry(ctx, id)
if err != nil || !found {
return task.WorkflowInterface{}, false, err
}
enablement, _, err := s.workflowEnablement(ctx)
if err != nil || !enablement.Enabled(org.OrgFromContext(ctx), id) {
return task.WorkflowInterface{}, false, err
}
iface, err := task.ParseWorkflowInterface(entry.YAML)
if err != nil {
return task.WorkflowInterface{}, false, err
}
return iface, true, nil
}
func (s *Server) hasWorkflowDefinition(ctx context.Context, id string) (bool, error) {
_, found, err := s.workflowEntry(ctx, id)
return found, err
}
// workflowEntry returns the stored definition of workflow id.
func (s *Server) workflowEntry(ctx context.Context, id string) (task.WorkflowDefinitionEntry, bool, error) {
collection, err := s.workflowCollection(ctx)
if err != nil {
return task.WorkflowDefinitionEntry{}, false, err
}
entry, found := collection.DefinitionByID(id)
return entry, found, nil
}
func (s *Server) workflowCollection(ctx context.Context) (task.WorkflowDefinitionCollection, error) {
if s.ControlPlane == nil {
return task.WorkflowDefinitionCollection{}, nil
}
response, err := s.ControlPlane.Query(ctx, controlplanerpc.QueryRequest(ctx, workflowDefinitionsKind))
if err != nil {
return task.WorkflowDefinitionCollection{}, err
}
if response.Resource == nil {
return task.WorkflowDefinitionCollection{}, errors.New("workflow definitions missing")
}
var collection task.WorkflowDefinitionCollection
if err := json.Unmarshal(response.Resource.ValueJson, &collection); err != nil {
return task.WorkflowDefinitionCollection{}, err
}
return collection, nil
}
func (s *Server) workflowDefinitions(ctx context.Context) ([]task.Definition, error) {
if s.ControlPlane == nil {
return nil, nil
}
collection, err := s.workflowCollection(ctx)
if err != nil {
return nil, err
}
enablement, _, err := s.workflowEnablement(ctx)
if err != nil {
return nil, err
}
definitions := make([]task.Definition, 0, len(collection.Definitions))
for _, entry := range collection.Definitions {
definition := task.Definition{ID: entry.ID, Name: entry.ID, Origin: "database", Enabled: enablement.Enabled(org.OrgFromContext(ctx), entry.ID), Repository: task.RepositoryRequired}
if iface, err := task.ParseWorkflowInterface(entry.YAML); err == nil {
definition.Inputs, definition.Repository = iface.Inputs, iface.RepositoryMode()
}
definitions = append(definitions, definition)
}
return definitions, nil
}