The Web UI and messaging channels now read and write Archie's runtime settings through one versioned, audited control-plane API hosted on the State Store's existing gRPC server: catalog, query, command, watch. Each feature owns its resource, validation and commands; storage only writes versions and audit records. Workflows move with it. Definitions become portable YAML compiled through a closed, typed step registry and stored as a control-plane resource, so the yaegi interpretation paths (internal/gate, wfeval, wfextract, gateeval, gateextract, skillbuild) are deleted rather than carried. The UI process reads definitions as data: the JSON projection lives in internal/domain/workflow/task so a dashboard decodes the stored collection without linking the workflow engine, which cmd/archie-ui's deletion gate forbids. Shipped definitions ride the catalog descriptor rather than a bespoke REST route, keeping the API to its four operations. archie-messaging gains -state-store-target/-state-store-token and reads channel settings from the database, failing closed when the State Store is unreachable: the database is authoritative for those settings.
191 lines
6.4 KiB
Go
191 lines
6.4 KiB
Go
package archied
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/app/controlplane"
|
|
"github.com/samcharles93/archie-core/internal/domain/scheduling"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/gateway"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/crondelivery"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/cronevents"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/cronstore"
|
|
)
|
|
|
|
// schedulingConfig translates external input into the domain-owned engine
|
|
// configuration and connects the selected event infrastructure.
|
|
func schedulingConfig(input configuration.SchedulingInput, bus *events.Bus) (scheduling.EngineConfig, error) {
|
|
cfg := scheduling.DefaultEngineConfig()
|
|
if input.Interval != 0 {
|
|
cfg.Interval = input.Interval.Std()
|
|
}
|
|
if input.MaxParallel != 0 {
|
|
cfg.MaxParallel = input.MaxParallel
|
|
}
|
|
if input.JobTimeout != 0 {
|
|
cfg.JobTimeout = input.JobTimeout.Std()
|
|
}
|
|
|
|
switch input.EventsSink {
|
|
case "", configuration.EventsSinkNone:
|
|
case configuration.EventsSinkBus:
|
|
cfg.Events = cronevents.New(bus)
|
|
default:
|
|
return scheduling.EngineConfig{}, fmt.Errorf("%w: scheduling.events_sink %q (want %q or %q)",
|
|
configuration.ErrInvalidInput, input.EventsSink, configuration.EventsSinkBus, configuration.EventsSinkNone)
|
|
}
|
|
if err := cfg.Validate(); err != nil {
|
|
return scheduling.EngineConfig{}, fmt.Errorf("%w: %w", configuration.ErrInvalidInput, err)
|
|
}
|
|
return cfg, nil
|
|
}
|
|
|
|
// setupScheduling builds the cron/scheduling composition site: a job store,
|
|
// a delivery router over the kind runners this composition root can back
|
|
// with a real production dependency, and the ticker engine itself. It does
|
|
// not start the engine -- startServices does that alongside every other
|
|
// subsystem, and the corresponding Stop is registered here via addCleanup so
|
|
// shutdown ordering matches every other daemon-lifecycle subsystem.
|
|
//
|
|
// Only the "workflow" kind is wired: it rides gateway.TaskCreator, the same
|
|
// non-forge-backed task creation path chat's /spawn uses, which is the one
|
|
// production capability here that does not require inventing a channel
|
|
// courier or a synthetic forge owner/repo. A deployment with no chat task
|
|
// creator configured (no [chat] identity profiles) leaves the engine
|
|
// unstarted rather than running with no reachable job kind.
|
|
func (b *boot) setupScheduling() error {
|
|
cfg, err := schedulingConfig(b.doc.Scheduling, b.bus)
|
|
if err != nil {
|
|
return fmt.Errorf("scheduling: %w", err)
|
|
}
|
|
|
|
if b.chatTasks == nil {
|
|
b.log.Warn("scheduling: no chat task creator configured; ticker engine not started")
|
|
return nil
|
|
}
|
|
|
|
store := scheduleResourceStore{client: b.controlPlane}
|
|
|
|
workflowRunner, err := crondelivery.NewWorkflowTask(store, spawnTaskSubmitter{creator: b.chatTasks, identity: b.defaultChatIdentity})
|
|
if err != nil {
|
|
return fmt.Errorf("scheduling: build workflow runner: %w", err)
|
|
}
|
|
router, err := crondelivery.NewRouter(store, map[string]scheduling.Runner{cronstore.KindWorkflow: workflowRunner}, cfg.Events)
|
|
if err != nil {
|
|
return fmt.Errorf("scheduling: build router: %w", err)
|
|
}
|
|
engine, err := scheduling.NewEngine(store, router, cfg)
|
|
if err != nil {
|
|
return fmt.Errorf("scheduling: build engine: %w", err)
|
|
}
|
|
|
|
b.schedulingEngine = engine
|
|
b.addCleanup(shutdownSchedulingEngine(engine, b.log))
|
|
return nil
|
|
}
|
|
|
|
type scheduleResourceStore struct {
|
|
client *controlplane.Client
|
|
}
|
|
|
|
func (s scheduleResourceStore) Get(ctx context.Context, id string) (cronstore.JobSpec, bool, error) {
|
|
jobs, _, err := s.client.Schedules(ctx)
|
|
if err != nil {
|
|
return cronstore.JobSpec{}, false, err
|
|
}
|
|
for _, job := range jobs {
|
|
if job.ID == id {
|
|
return job, true, nil
|
|
}
|
|
}
|
|
return cronstore.JobSpec{}, false, nil
|
|
}
|
|
|
|
func (s scheduleResourceStore) Due(ctx context.Context, now time.Time) ([]scheduling.Job, error) {
|
|
jobs, _, err := s.client.Schedules(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
due := make([]scheduling.Job, 0, len(jobs))
|
|
for _, job := range jobs {
|
|
if !job.NextRun.After(now) {
|
|
due = append(due, scheduling.Job{ID: job.ID, Pool: scheduling.Pool(job.Pool), Detail: job.Detail})
|
|
}
|
|
}
|
|
return due, nil
|
|
}
|
|
|
|
func (s scheduleResourceStore) MarkRun(ctx context.Context, id string, runAt time.Time) error {
|
|
for range 4 {
|
|
jobs, version, err := s.client.Schedules(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
found := false
|
|
for index := range jobs {
|
|
if jobs[index].ID != id {
|
|
continue
|
|
}
|
|
found = true
|
|
if jobs[index].Schedule.Resolved().Kind == cronstore.ScheduleOnce {
|
|
jobs = append(jobs[:index], jobs[index+1:]...)
|
|
break
|
|
}
|
|
next, nextErr := jobs[index].Schedule.NextRun(runAt)
|
|
if nextErr != nil {
|
|
return nextErr
|
|
}
|
|
at := runAt.UTC()
|
|
jobs[index].LastRun = &at
|
|
jobs[index].NextRun = next.UTC()
|
|
break
|
|
}
|
|
if !found {
|
|
return fmt.Errorf("%w: id %q", cronstore.ErrJobNotFound, id)
|
|
}
|
|
_, err = s.client.ReplaceSchedules(ctx, jobs, version, "system:scheduler", "scheduler", fmt.Sprintf("schedule-run:%s:%d", id, runAt.UnixNano()))
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if !errors.Is(err, controlplane.ErrVersionConflict) {
|
|
return err
|
|
}
|
|
}
|
|
return controlplane.ErrVersionConflict
|
|
}
|
|
|
|
// shutdownSchedulingEngine returns a cleanup that stops the ticker engine.
|
|
// The stop path derives its own timeout budget from Background rather than
|
|
// the boot context, which is already cancelled by the time shutdown runs --
|
|
// the same reasoning as shutdownCuratorRuntime.
|
|
//
|
|
//nolint:contextcheck
|
|
func shutdownSchedulingEngine(e *scheduling.Engine, log *slog.Logger) func() {
|
|
return func() {
|
|
stopCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := e.Stop(stopCtx); err != nil {
|
|
log.Error("scheduling engine shutdown", "err", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// spawnTaskSubmitter adapts gateway.TaskCreator to crondelivery.TaskSubmitter.
|
|
// The job's own id is only a dispatch key to the ticker engine, not an archie
|
|
// identity, so it is dropped rather than threaded into the spawn request;
|
|
// identity is fixed at construction to the daemon's default chat identity.
|
|
type spawnTaskSubmitter struct {
|
|
creator gateway.TaskCreator
|
|
identity string
|
|
}
|
|
|
|
func (s spawnTaskSubmitter) Submit(ctx context.Context, _, title, body string) error {
|
|
_, err := s.creator.CreateTask(ctx, gateway.SpawnRequest{Title: title, Body: body, Identity: s.identity})
|
|
return err
|
|
}
|