243 lines
8.3 KiB
Go
243 lines
8.3 KiB
Go
package chat
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"encoding/json/jsontext"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/samcharles93/archie-core/internal/platform/hub"
|
|
"github.com/samcharles93/archie-core/modules/approvals"
|
|
"github.com/samcharles93/archie-core/modules/chat/internal/store"
|
|
"github.com/samcharles93/archie-core/modules/connectors"
|
|
"github.com/samcharles93/archie-core/modules/deliveries"
|
|
"github.com/samcharles93/archie-core/modules/governance"
|
|
"github.com/samcharles93/archie-core/modules/judgement"
|
|
)
|
|
|
|
// Action states.
|
|
const (
|
|
actionWaiting = "waiting"
|
|
actionApproved = "approved"
|
|
actionRunning = "running"
|
|
actionSucceeded = "succeeded"
|
|
actionFailed = "failed"
|
|
actionUnknown = "unknown"
|
|
actionDenied = "denied"
|
|
actionExpired = "expired"
|
|
)
|
|
|
|
// Signal takes the answer to an approval a chat turn asked for. It reports
|
|
// false when id is not a chat turn, so the caller passes the answer on to the
|
|
// run waiting on it. The answer is stored before anything runs; the work loop
|
|
// runs an approved action once.
|
|
func (m *Module) Signal(ctx context.Context, id uuid.UUID, key string, payload jsontext.Value) (bool, error) {
|
|
owner, ours, err := m.store.TurnOwner(ctx, id)
|
|
if err != nil || !ours {
|
|
return false, err
|
|
}
|
|
var answer approvals.Answer
|
|
if err := json.Unmarshal(payload, &answer); err != nil {
|
|
return true, fmt.Errorf("decode approval answer: %w", err)
|
|
}
|
|
state := actionDenied
|
|
if answer.Approved {
|
|
state = actionApproved
|
|
}
|
|
answered, err := m.store.Answer(ctx, id, key, state, payload)
|
|
if err != nil || !answered {
|
|
return true, err
|
|
}
|
|
if !answer.Approved {
|
|
m.record(ctx, id, kindAction, ActionDone{RequestID: answer.RequestID, State: actionDenied})
|
|
m.hub.Publish(hub.Note{Topic: OwnerTopic(owner)})
|
|
}
|
|
m.poke()
|
|
return true, nil
|
|
}
|
|
|
|
// settleActions escalates or expires actions nobody answered in time and runs
|
|
// the approved ones. An action found running was started by a process that
|
|
// stopped: it may have taken effect, so it is never started again.
|
|
func (m *Module) settleActions(ctx context.Context) {
|
|
d, ok := m.uses()
|
|
if !ok {
|
|
return
|
|
}
|
|
open, err := m.store.Open(ctx)
|
|
if err != nil {
|
|
if ctx.Err() == nil {
|
|
m.log.ErrorContext(ctx, "list held chat actions", "error", err)
|
|
}
|
|
return
|
|
}
|
|
for _, a := range open {
|
|
var err error
|
|
switch a.State {
|
|
case actionWaiting:
|
|
if time.Now().After(a.StepDue) {
|
|
err = m.escalate(ctx, d, a)
|
|
}
|
|
case actionApproved:
|
|
err = m.runApproved(ctx, d, a)
|
|
case actionRunning:
|
|
err = m.settled(ctx, d, a, actionRunning, actionUnknown,
|
|
"It was started before Archie restarted and its outcome is unknown; it may have taken effect and won't run again.")
|
|
}
|
|
if err != nil {
|
|
m.log.ErrorContext(ctx, "settle chat action", "action", a.ID, "request", a.RequestID, "error", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// escalate passes an unanswered action to the next step of its path, or
|
|
// expires it after the last.
|
|
func (m *Module) escalate(ctx context.Context, d Deps, a store.Action) error {
|
|
var path []governance.PathStep
|
|
if err := json.Unmarshal(a.Path, &path); err != nil {
|
|
return fmt.Errorf("decode escalation path: %w", err)
|
|
}
|
|
next := a.Step + 1
|
|
if next < len(path) {
|
|
if err := d.Approver.Escalate(ctx, a.RequestID, next, path[next]); err != nil {
|
|
return err
|
|
}
|
|
return m.store.Escalated(ctx, a.ID, next, time.Now().Add(path[next].Deadline()))
|
|
}
|
|
if err := d.Approver.Expire(ctx, a.RequestID); err != nil {
|
|
return err
|
|
}
|
|
return m.settled(ctx, d, a, actionWaiting, actionExpired, "Nobody answered before the last deadline, so it didn't run.")
|
|
}
|
|
|
|
// runApproved judges an approved action again and runs it once. An approval
|
|
// whose binding no longer matches the action, or for an action that has become
|
|
// stricter, is discarded, and the operator asks again. Whatever can't be
|
|
// checked stops the action.
|
|
func (m *Module) runApproved(ctx context.Context, d Deps, a store.Action) error {
|
|
var (
|
|
held judgement.Decision
|
|
answer approvals.Answer
|
|
)
|
|
if err := json.Unmarshal(a.Decision, &held); err != nil {
|
|
return fmt.Errorf("decode decision: %w", err)
|
|
}
|
|
if err := json.Unmarshal(a.Answer, &answer); err != nil {
|
|
return fmt.Errorf("decode answer: %w", err)
|
|
}
|
|
ctx, err := m.actingAs(ctx, d, a.Owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := m.allowed(ctx, d, governance.ActionRun, governance.KindConnector, held.Action.Connector); err != nil {
|
|
if derr := d.Approver.Discard(ctx, a.RequestID, err.Error()); derr != nil {
|
|
return derr
|
|
}
|
|
return m.settled(ctx, d, a, actionApproved, actionFailed, err.Error())
|
|
}
|
|
fresh, why, err := m.recheck(ctx, d, a, held, answer)
|
|
if err != nil {
|
|
// Nothing runs that couldn't be checked again; the operator asks again.
|
|
return m.settled(ctx, d, a, actionApproved, actionFailed, "It couldn't be checked again before running: "+err.Error())
|
|
}
|
|
if why != "" {
|
|
if err := d.Approver.Discard(ctx, a.RequestID, why); err != nil {
|
|
return err
|
|
}
|
|
return m.settled(ctx, d, a, actionApproved, actionFailed, "The approval no longer holds: "+why+". Ask Archie again.")
|
|
}
|
|
started, err := m.store.Move(ctx, a.ID, actionApproved, actionRunning, "")
|
|
if err != nil || !started {
|
|
return err
|
|
}
|
|
var out string
|
|
if fresh.Level.Runs() {
|
|
out, err = d.Judge.Execute(ctx, fresh, fresh.Action.Input, a.Key)
|
|
} else {
|
|
if err := d.Approver.Accept(ctx, a.RequestID); err != nil {
|
|
return err
|
|
}
|
|
out, err = d.Judge.ExecuteApproved(ctx, held, answer.Approval(held), held.Action.Input, a.Key)
|
|
}
|
|
switch {
|
|
case errors.Is(err, connectors.ErrOutcomeUnknown):
|
|
return m.settled(ctx, d, a, actionRunning, actionUnknown, "It was started and its outcome is unknown; it may have taken effect: "+err.Error())
|
|
case err != nil:
|
|
return m.settled(ctx, d, a, actionRunning, actionFailed, err.Error())
|
|
}
|
|
return m.settled(ctx, d, a, actionRunning, actionSucceeded, out)
|
|
}
|
|
|
|
// recheck judges an approved action again and says why its approval no longer
|
|
// holds, or nothing when it still does. An error means it couldn't be checked.
|
|
func (m *Module) recheck(ctx context.Context, d Deps, a store.Action, held judgement.Decision, answer approvals.Answer) (judgement.Decision, string, error) {
|
|
fresh, err := d.Judge.Assess(ctx, judgement.Request{
|
|
RunID: a.TurnID, Key: held.Key + ":again", Connector: held.Action.Connector, Action: held.Action.Name,
|
|
Input: held.Action.Input, Workflow: principal,
|
|
})
|
|
if err != nil {
|
|
return fresh, "", fmt.Errorf("judge it: %w", err)
|
|
}
|
|
path, err := d.Settings.EscalationPath(ctx, held.Owner(), held.Level == judgement.Escalate)
|
|
if err != nil {
|
|
return fresh, "", fmt.Errorf("find who may approve it: %w", err)
|
|
}
|
|
why := stale(a, answer, held, fresh, approverIDs(path), time.Now())
|
|
if why == "" {
|
|
why = invalidated(held, fresh)
|
|
}
|
|
return fresh, why, nil
|
|
}
|
|
|
|
// invalidated says why an approval no longer covers the action's level as
|
|
// judged now, or nothing when it still does. What the action is and acts on
|
|
// is checked against its binding.
|
|
func invalidated(approved, fresh judgement.Decision) string {
|
|
switch {
|
|
case fresh.Level == judgement.Never:
|
|
return "it is now refused: " + fresh.Reason
|
|
case fresh.Level.Runs():
|
|
return ""
|
|
case fresh.Level > approved.Level:
|
|
return "judgement is stricter than when it was approved: now " + fresh.Level.String()
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// settled records what became of an action, shows it in its conversation and
|
|
// tells the people notifications go to. The notification names no run: a
|
|
// chat turn isn't one.
|
|
func (m *Module) settled(ctx context.Context, d Deps, a store.Action, from, to, result string) error {
|
|
moved, err := m.store.Move(ctx, a.ID, from, to, result)
|
|
if err != nil || !moved {
|
|
return err
|
|
}
|
|
done := ActionDone{RequestID: a.RequestID, State: to, Result: truncateRunes(result, outputMaxRunes)}
|
|
m.record(ctx, a.TurnID, kindAction, done)
|
|
m.hub.Publish(hub.Note{Topic: OwnerTopic(a.Owner)})
|
|
var held judgement.Decision
|
|
_ = json.Unmarshal(a.Decision, &held)
|
|
return d.Notifier.Notify(ctx, deliveries.Notification{
|
|
Key: "chat:" + a.ID.String() + ":" + to,
|
|
Title: actionTitle(to) + ": " + held.Action.Connector + " " + held.Action.Name,
|
|
Body: result,
|
|
})
|
|
}
|
|
|
|
func actionTitle(state string) string {
|
|
switch state {
|
|
case actionSucceeded:
|
|
return "Approved action ran"
|
|
case actionExpired:
|
|
return "Approval timed out"
|
|
case actionUnknown:
|
|
return "An action's outcome is unknown"
|
|
default:
|
|
return "Approved action didn't run"
|
|
}
|
|
}
|