299 lines
11 KiB
Go
299 lines
11 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"unicode/utf8"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
)
|
|
|
|
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 {
|
|
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
|
|
Inputs map[string]any `json:"inputs"`
|
|
// Draft is an unsaved definition of Workflow to test-run instead of the
|
|
// stored one. The stored definition is untouched and the run writes
|
|
// nothing to a forge.
|
|
Draft string `json:"draft"`
|
|
}
|
|
|
|
func (s *Server) handleWorkRequest(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorizeTaskMutation(w, r) {
|
|
return
|
|
}
|
|
principal, ok := access.PrincipalFromContext(r.Context())
|
|
if !ok || principal.IdentityID == "" {
|
|
http.Error(w, "authenticated requester required", http.StatusUnauthorized)
|
|
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.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.Workflow == "" || request.Title == "" || request.Instructions == "" {
|
|
http.Error(w, "workflow, title, and instructions are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if utf8.RuneCountInString(request.Title) > 80 {
|
|
http.Error(w, "title must be 80 characters or fewer; put details in instructions", http.StatusBadRequest)
|
|
return
|
|
}
|
|
iface, code, err := s.workRequestInterface(r.Context(), request)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), code)
|
|
return
|
|
}
|
|
if err := iface.CheckInputs(request.Inputs); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
owner, repo, status, err := s.workRequestRepository(r.Context(), iface.RepositoryMode(), request.Repository)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), status)
|
|
return
|
|
}
|
|
created, err := s.Store.EnqueueChatTask(r.Context(), owner, repo, request.Title, request.Instructions, request.Workflow, string(principal.IdentityID), "", request.Draft, request.Inputs)
|
|
if err != nil {
|
|
s.logf("work request enqueue failed", "err", err)
|
|
http.Error(w, "work request rejected", http.StatusBadRequest)
|
|
return
|
|
}
|
|
s.emit(r.Context(), events.Event{Kind: events.KindWorkRequestSubmitted, TaskID: created.ID, Repo: request.Repository, Workflow: request.Workflow, Detail: request.Title})
|
|
w.WriteHeader(http.StatusCreated)
|
|
writeJSON(w, map[string]any{"ok": true, "task_id": created.ID})
|
|
}
|
|
|
|
// workRequestInterface returns the interface a request runs against: the
|
|
// draft's when it carries one, else the stored definition's. The workflow must
|
|
// be defined and enabled either way.
|
|
func (s *Server) workRequestInterface(ctx context.Context, request workRequest) (task.WorkflowInterface, int, error) {
|
|
iface, enabled, err := s.enabledWorkflowInterface(ctx, request.Workflow)
|
|
switch {
|
|
case err != nil:
|
|
return iface, http.StatusServiceUnavailable, errors.New("workflow definitions unavailable")
|
|
case !enabled:
|
|
return iface, http.StatusConflict, errors.New("workflow is not enabled")
|
|
case request.Draft != "":
|
|
return s.checkDraft(ctx, request.Workflow, request.Draft)
|
|
}
|
|
return iface, 0, nil
|
|
}
|
|
|
|
// checkDraft refuses a draft a save of the same document would refuse, and
|
|
// returns the interface the draft declares.
|
|
func (s *Server) checkDraft(ctx context.Context, id, draft string) (task.WorkflowInterface, int, error) {
|
|
if declared, err := workflow.DefinitionID(draft); err != nil || declared != id {
|
|
return task.WorkflowInterface{}, http.StatusBadRequest, errors.New("the draft must be a definition of the workflow being run")
|
|
}
|
|
collection, err := s.workflowCollection(ctx)
|
|
if err != nil {
|
|
return task.WorkflowInterface{}, http.StatusServiceUnavailable, errors.New("workflow definitions unavailable")
|
|
}
|
|
replaced := collection.Definitions[:0:0]
|
|
for _, entry := range collection.Definitions {
|
|
if entry.ID == id {
|
|
entry.YAML = draft
|
|
}
|
|
replaced = append(replaced, entry)
|
|
}
|
|
value, err := json.Marshal(task.WorkflowDefinitionCollection{Definitions: replaced})
|
|
if err != nil {
|
|
return task.WorkflowInterface{}, http.StatusInternalServerError, err
|
|
}
|
|
if _, err := s.ControlPlane.Command(ctx, &controlpb.CommandRequest{Kind: workflowDefinitionsKind, Command: "validate", ValueJson: value}); err != nil {
|
|
if status.Code(err) == codes.InvalidArgument {
|
|
return task.WorkflowInterface{}, http.StatusBadRequest, errors.New(status.Convert(err).Message())
|
|
}
|
|
return task.WorkflowInterface{}, http.StatusServiceUnavailable, errors.New("workflow definitions unavailable")
|
|
}
|
|
iface, err := task.ParseWorkflowInterface(draft)
|
|
if err != nil {
|
|
return task.WorkflowInterface{}, http.StatusBadRequest, err
|
|
}
|
|
return iface, 0, nil
|
|
}
|
|
|
|
// workRequestRepository checks a requested "owner/name" against the
|
|
// workflow's repository mode and the configured repositories, and returns it
|
|
// split. A workflow that takes none refuses one; one that requires it refuses
|
|
// its absence.
|
|
func (s *Server) workRequestRepository(ctx context.Context, mode task.RepositoryMode, requested string) (owner, repo string, status int, err error) {
|
|
switch {
|
|
case requested == "" && mode == task.RepositoryRequired:
|
|
return "", "", http.StatusBadRequest, errors.New("this workflow needs a repository")
|
|
case requested == "":
|
|
return "", "", 0, nil
|
|
case mode == task.RepositoryNone:
|
|
return "", "", http.StatusBadRequest, errors.New("this workflow takes no repository")
|
|
}
|
|
owner, repo, ok := strings.Cut(requested, "/")
|
|
if !ok || owner == "" || repo == "" || strings.Contains(repo, "/") {
|
|
return "", "", http.StatusBadRequest, errors.New("repository must be owner/name")
|
|
}
|
|
view, found, err := s.configSource()(ctx)
|
|
if err != nil || !found {
|
|
return "", "", http.StatusServiceUnavailable, errors.New("configured repositories unavailable")
|
|
}
|
|
if !viewHasRepo(view, owner, repo) {
|
|
return "", "", http.StatusBadRequest, fmt.Errorf("repository %s/%s is not configured", owner, repo)
|
|
}
|
|
return owner, repo, 0, nil
|
|
}
|
|
|
|
// viewHasRepo reports whether the default identity or any named identity
|
|
// manages owner/repo.
|
|
func viewHasRepo(view ConfigView, owner, repo string) bool {
|
|
for _, r := range view.Repositories {
|
|
if strings.EqualFold(r.Owner, owner) && strings.EqualFold(r.Name, repo) {
|
|
return true
|
|
}
|
|
}
|
|
for _, identity := range view.Identities {
|
|
for _, r := range identity.Repos {
|
|
if strings.EqualFold(r.Owner, owner) && strings.EqualFold(r.Name, repo) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// enabledWorkflowInterface returns a workflow's declared interface and whether
|
|
// it is defined and enabled for the caller's org.
|
|
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, &controlpb.QueryRequest{Kind: 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
|
|
}
|