102 lines
4.5 KiB
Go
102 lines
4.5 KiB
Go
// Package workflowsteps is the compiled-in workflow step-type provider set:
|
|
// the one place a step type is bundled into the Archie binaries that resolve
|
|
// one, so no such binary can keep a provider set of its own.
|
|
//
|
|
// Two composition roots register it, both of them roots that resolve a step
|
|
// type: archied's RunStateStore (the State Store's validating side) and
|
|
// archied's daemon root (openDaemonWorkflowDefinitions, the executing side's
|
|
// workflow-definitions client, alongside agentworker's
|
|
// productionWorkerDependencies). Sharing one package is what keeps them
|
|
// registering the same vocabulary. Processes that resolve no step type do not
|
|
// import it and register nothing: archie-gateway, archie-messaging,
|
|
// archie-playbooks and archie-ui.
|
|
package workflowsteps
|
|
|
|
import (
|
|
"fmt"
|
|
"maps"
|
|
"slices"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
)
|
|
|
|
// shippedStages is the provider that contributes every stage of the shipped
|
|
// workflows (bootstrap, implement, tdd, feasibility, triage, remediate) as a
|
|
// workflow step type. It is what makes the shipped vocabulary arrive by
|
|
// registration rather than by the manager implying it, so the vocabulary a
|
|
// process resolves is always the vocabulary a provider set claimed.
|
|
type shippedStages struct{}
|
|
|
|
func (shippedStages) Name() string { return "shipped" }
|
|
|
|
func (shippedStages) StepTypes() []workflow.StepType {
|
|
registry := workflow.BuiltinStepRegistry()
|
|
stepTypes := make([]workflow.StepType, 0, len(registry))
|
|
for _, name := range slices.Sorted(maps.Keys(registry)) {
|
|
stepTypes = append(stepTypes, workflow.StepType{Name: name, Factory: registry[name]})
|
|
}
|
|
return stepTypes
|
|
}
|
|
|
|
// repoHooks is the provider that contributes the step types replacing the
|
|
// repository-authored hooks that were deleted with the interpreted workflow
|
|
// engine -- .archie/gate.go, whose rules now arrive as settings on
|
|
// workflow.DiffRulesStepName instead of as Go read out of the worktree being
|
|
// worked on.
|
|
//
|
|
// It is a provider of its own rather than part of shippedStages, which is
|
|
// scoped to the stages of the shipped workflows: a repository's migration target
|
|
// is not part of any shipped workflow, and a root that bundles one set should be
|
|
// able to tell which set a step type came from.
|
|
type repoHooks struct{}
|
|
|
|
func (repoHooks) Name() string { return "repo-hooks" }
|
|
|
|
func (repoHooks) StepTypes() []workflow.StepType {
|
|
return []workflow.StepType{workflow.DiffRulesStepType()}
|
|
}
|
|
|
|
// eventSteps is the provider for step types that event-started workflows
|
|
// use: steps that need no repository, so a workflow declaring repository none
|
|
// or optional has something to run.
|
|
type eventSteps struct{}
|
|
|
|
func (eventSteps) Name() string { return "event" }
|
|
|
|
func (eventSteps) StepTypes() []workflow.StepType {
|
|
return []workflow.StepType{workflow.AgentRunStepType(), workflow.WorkflowCallStepType()}
|
|
}
|
|
|
|
// Providers returns the provider set the roots that resolve a workflow step
|
|
// type register at their composition root, before the first resolution: it is
|
|
// what NewManager registers, and what the roots' guards read to hold a
|
|
// registered vocabulary to the set it came from. A step type added here becomes
|
|
// reachable from the validating side and the executing side at once.
|
|
//
|
|
// The set is a compiled-in constant rather than a directory scan: a step type
|
|
// is a Go factory, and no bridge has been built from the Yaegi-interpreted
|
|
// plugins internal/plugin loads to workflow.StepFactory -- those plugins
|
|
// satisfy plugin.Plugin's metadata contract only. Such a bridge is possible:
|
|
// internal/secret/secretextract wraps an interpreted Engine into the typed
|
|
// contract secret.Registry.LoadDir registers (internal/app/archied/
|
|
// provider_secrets.go). Until one exists for step types, adding a step type
|
|
// means adding a provider here.
|
|
func Providers() []workflow.StepTypeProvider {
|
|
return []workflow.StepTypeProvider{shippedStages{}, repoHooks{}, eventSteps{}}
|
|
}
|
|
|
|
// NewManager builds this process's workflow step-type manager by registering
|
|
// the provider set. Every call constructs an independent manager: there is no
|
|
// package-level registry and nothing registers at init(), so building the
|
|
// vocabulary twice in one process — as `-count=2` does — cannot collide with
|
|
// the first build.
|
|
func NewManager() (*workflow.Manager, error) {
|
|
manager := workflow.NewManager()
|
|
for _, provider := range Providers() {
|
|
if err := manager.Register(provider); err != nil {
|
|
return nil, fmt.Errorf("register workflow step type provider %q: %w", provider.Name(), err)
|
|
}
|
|
}
|
|
return manager, nil
|
|
}
|