chore(plugin): delete the unwired capability-host health surface (#882)
* chore(plugin): delete the unwired capability-host health surface
plugin.Host.Health, plugin.Host.Manifests, ModuleStatus and their private
safeHealth helper were implemented, exhaustively tested, and called from nowhere
but their own tests. AGENTS.md forbids speculative surfaces, and no settled
design places plugin module status anywhere that exists:
- docs/prds/status-health-surface.md Phase 2 is self-described as "a proposed
resolution, awaiting Sam's sign-off -- not yet implemented", and does not
mention plugin status even in that unapproved list.
- The readiness subsystem enumerates exactly five probes -- state_db, config,
disk, model, gateway (internal/app/archied/readiness.go) -- with no plugin
probe.
- docs/architecture/plugins-and-extensions.md names no operator-visible plugin
status surface.
- The only bead naming it is closed.
plugin.Host itself stays: it is the daemon's live capability host, constructed
and Start/Stop-ed from internal/app/archied. Only the unconsumed observability
methods go.
host_contract_test.go encoded the defect -- it asserted plugin.Host *defines*
"Health" and "Manifests" -- so those two names are removed from its list, which
is now exactly the shipped lifecycle: Register, Start, Stop. The three tests
covering the deleted surface are removed with it.
The Yaegi symbol table (internal/plugin/pluginextract) was regenerated rather
than hand-edited, so ModuleStatus leaves the reflected type set with it.
Reachability evidence: Host.Health and Host.Manifests appear only in their own
tests; plugin.Host is otherwise reached from bootstrap.go and gateway.go for
Register/Start/Stop. Note that "task reachability" does NOT flag these -- the
address-taken constructor is a known blind spot of the whole-program RTA.
* chore(plugin): delete the dead Module.Health chain wired to nothing
Extends the capability-host observability deletion: plugin.Module.Health
was a required interface method with real implementations in
tools/provider/mcp and tools/provider/builtin, aggregated by
tools/provider.Registry.Health via a provider-package-local safeHealth,
and backed by per-module LifecycleState bookkeeping in plugin.Host
(registeredModule.state, setModuleState). None of it had a caller before
this change -- Host.Health was the only thing that would ever have read
a registered module's Health(), and Host.Health was already deleted as
unreachable. registeredModule.state was write-only: nothing ever read it.
Deleted:
- plugin.Module.Health, plugin.Health/HealthStatus (+ consts),
plugin.LifecycleState (+ consts), legacyModule.Health,
registeredModule.state, Host.setModuleState and its call sites.
- tools/provider.Registry.Health, tools/provider.safeHealth.
- tools/provider/mcp.Provider.Health, tools/provider/builtin.Provider.Health.
- Tests exclusively covering the above, and fakes' now-unnecessary Health
methods (plugin/host_test.go, pluginextract/reachability_test.go,
tools/provider/{provider,optional}_test.go, tools/provider/mcp/provider_test.go,
app/agentworker/mcp_providers_test.go).
internal/plugin/pluginextract's generated file was regenerated via
`go generate ./internal/plugin/...` and the yaegi wrapper nil-guards
(dropped by fresh generation, as documented in reachability_test.go)
were reapplied by hand to WManifest/WStart/WStop/WName/WVersion,
following this repo's established post-regen pattern.
This commit is contained in:
1 parent
10e7d0301c
commit
19b400bf07
12 files changed
+12
-463
No files matched your search
@@ -47,10 +47,6 @@ func (f *fakeMCPEngine) Discover(context.Context) ([]tools.ToolEntry, error) {
|
||||
return f.entries, f.discoverErr
|
||||
}
|
||||
|
||||
func (f *fakeMCPEngine) Health(context.Context) plugin.Health {
|
||||
return plugin.Health{Status: plugin.HealthHealthy}
|
||||
}
|
||||
|
||||
func (f *fakeMCPEngine) Stop(context.Context) error {
|
||||
f.stops++
|
||||
return f.stopErr
|
||||
|
||||
@@ -178,40 +178,11 @@ func validateIdentifiers(kind string, values []string, required bool) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// LifecycleState is the host-owned state of a module.
|
||||
type LifecycleState string
|
||||
|
||||
const (
|
||||
StateRegistered LifecycleState = "registered"
|
||||
StateStarting LifecycleState = "starting"
|
||||
StateRunning LifecycleState = "running"
|
||||
StateStopping LifecycleState = "stopping"
|
||||
StateStopped LifecycleState = "stopped"
|
||||
StateFailed LifecycleState = "failed"
|
||||
)
|
||||
|
||||
// HealthStatus is a module's self-reported operational health.
|
||||
type HealthStatus string
|
||||
|
||||
const (
|
||||
HealthUnknown HealthStatus = "unknown"
|
||||
HealthHealthy HealthStatus = "healthy"
|
||||
HealthDegraded HealthStatus = "degraded"
|
||||
HealthUnhealthy HealthStatus = "unhealthy"
|
||||
)
|
||||
|
||||
// Health is a point-in-time module health report.
|
||||
type Health struct {
|
||||
Status HealthStatus
|
||||
Message string
|
||||
}
|
||||
|
||||
// Module is the capability host's metadata and lifecycle contract. Domain
|
||||
// operations belong to typed capability-family interfaces, not here.
|
||||
type Module interface {
|
||||
Manifest() Manifest
|
||||
Start(context.Context) error
|
||||
Health(context.Context) Health
|
||||
Stop(context.Context) error
|
||||
}
|
||||
|
||||
@@ -249,21 +220,10 @@ func (m *legacyModule) Start(context.Context) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *legacyModule) Health(context.Context) Health {
|
||||
return Health{Status: HealthHealthy}
|
||||
}
|
||||
|
||||
func (m *legacyModule) Stop(context.Context) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// ModuleStatus combines host-owned lifecycle state with module-reported health.
|
||||
type ModuleStatus struct {
|
||||
Manifest Manifest
|
||||
State LifecycleState
|
||||
Health Health
|
||||
}
|
||||
|
||||
type hostState uint8
|
||||
|
||||
const (
|
||||
@@ -278,7 +238,6 @@ const (
|
||||
type registeredModule struct {
|
||||
module Module
|
||||
manifest Manifest
|
||||
state LifecycleState
|
||||
}
|
||||
|
||||
// Host validates module manifests and coordinates cross-family lifecycle.
|
||||
@@ -328,7 +287,6 @@ func (h *Host) Register(module Module) error {
|
||||
h.modules[manifest.ID] = ®isteredModule{
|
||||
module: module,
|
||||
manifest: manifest,
|
||||
state: StateRegistered,
|
||||
}
|
||||
h.registration = append(h.registration, manifest.ID)
|
||||
return nil
|
||||
@@ -360,22 +318,18 @@ func (h *Host) Start(ctx context.Context) error {
|
||||
|
||||
started := make([]string, 0, len(order))
|
||||
for _, id := range order {
|
||||
h.setModuleState(id, StateStarting)
|
||||
module := h.module(id)
|
||||
if err := safeStart(ctx, id, module); err != nil {
|
||||
h.setModuleState(id, StateFailed)
|
||||
rollback := append(append([]string(nil), started...), id)
|
||||
rollbackCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), rollbackTimeout)
|
||||
failedStops, rollbackErr := h.stopIDs(rollbackCtx, reverseClone(rollback))
|
||||
cancel()
|
||||
h.setModuleState(id, StateFailed)
|
||||
h.mu.Lock()
|
||||
h.started = reverseClone(failedStops)
|
||||
h.state = hostFailed
|
||||
h.mu.Unlock()
|
||||
return errors.Join(err, rollbackErr)
|
||||
}
|
||||
h.setModuleState(id, StateRunning)
|
||||
started = append(started, id)
|
||||
}
|
||||
|
||||
@@ -386,34 +340,6 @@ func (h *Host) Start(ctx context.Context) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Health returns an immutable snapshot of module lifecycle and health.
|
||||
func (h *Host) Health(ctx context.Context) []ModuleStatus {
|
||||
h.opMu.Lock()
|
||||
defer h.opMu.Unlock()
|
||||
|
||||
h.mu.RLock()
|
||||
statuses := make([]ModuleStatus, 0, len(h.registration))
|
||||
modules := make([]Module, 0, len(h.registration))
|
||||
for _, id := range h.registration {
|
||||
entry := h.modules[id]
|
||||
statuses = append(statuses, ModuleStatus{
|
||||
Manifest: entry.manifest.clone(),
|
||||
State: entry.state,
|
||||
Health: Health{Status: HealthUnknown},
|
||||
})
|
||||
modules = append(modules, entry.module)
|
||||
}
|
||||
h.mu.RUnlock()
|
||||
|
||||
for i := range statuses {
|
||||
if statuses[i].State != StateRunning {
|
||||
continue
|
||||
}
|
||||
statuses[i].Health = safeHealth(ctx, statuses[i].Manifest.ID, modules[i])
|
||||
}
|
||||
return statuses
|
||||
}
|
||||
|
||||
// Stop stops started modules in reverse dependency order. It attempts every
|
||||
// stop even when one module returns an error or panics.
|
||||
func (h *Host) Stop(ctx context.Context) error {
|
||||
@@ -442,18 +368,6 @@ func (h *Host) Stop(ctx context.Context) error {
|
||||
return err
|
||||
}
|
||||
|
||||
// Manifests returns immutable snapshots in registration order.
|
||||
func (h *Host) Manifests() []Manifest {
|
||||
h.mu.RLock()
|
||||
defer h.mu.RUnlock()
|
||||
|
||||
out := make([]Manifest, 0, len(h.registration))
|
||||
for _, id := range h.registration {
|
||||
out = append(out, h.modules[id].manifest.clone())
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (h *Host) startOrderLocked() ([]string, error) {
|
||||
const (
|
||||
unvisited uint8 = iota
|
||||
@@ -496,14 +410,11 @@ func (h *Host) stopIDs(ctx context.Context, ids []string) ([]string, error) {
|
||||
var errs []error
|
||||
var failed []string
|
||||
for _, id := range ids {
|
||||
h.setModuleState(id, StateStopping)
|
||||
if err := safeStop(ctx, id, h.module(id)); err != nil {
|
||||
h.setModuleState(id, StateFailed)
|
||||
failed = append(failed, id)
|
||||
errs = append(errs, err)
|
||||
continue
|
||||
}
|
||||
h.setModuleState(id, StateStopped)
|
||||
}
|
||||
return failed, errors.Join(errs...)
|
||||
}
|
||||
@@ -514,12 +425,6 @@ func (h *Host) module(id string) Module {
|
||||
return h.modules[id].module
|
||||
}
|
||||
|
||||
func (h *Host) setModuleState(id string, state LifecycleState) {
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
h.modules[id].state = state
|
||||
}
|
||||
|
||||
func (h *Host) ensureModulesLocked() {
|
||||
if h.modules == nil {
|
||||
h.modules = make(map[string]*registeredModule)
|
||||
@@ -577,27 +482,6 @@ func safeStart(ctx context.Context, id string, module Module) (err error) {
|
||||
return nil
|
||||
}
|
||||
|
||||
func safeHealth(ctx context.Context, id string, module Module) (health Health) {
|
||||
defer func() {
|
||||
if recovered := recover(); recovered != nil {
|
||||
health = Health{
|
||||
Status: HealthUnhealthy,
|
||||
Message: fmt.Sprintf("plugin module %q health panic: %v", id, recovered),
|
||||
}
|
||||
}
|
||||
}()
|
||||
health = module.Health(ctx)
|
||||
switch health.Status {
|
||||
case HealthUnknown, HealthHealthy, HealthDegraded, HealthUnhealthy:
|
||||
return health
|
||||
default:
|
||||
return Health{
|
||||
Status: HealthUnhealthy,
|
||||
Message: fmt.Sprintf("plugin module %q returned invalid health status %q", id, health.Status),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func safeStop(ctx context.Context, id string, module Module) (err error) {
|
||||
defer func() {
|
||||
if recovered := recover(); recovered != nil {
|
||||
|
||||
@@ -51,12 +51,12 @@ func TestCapabilityHostContractExists(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
for _, name := range []string{"Manifest", "Module", "LifecycleState", "Health", "Host"} {
|
||||
for _, name := range []string{"Manifest", "Module", "Host"} {
|
||||
if !types[name] {
|
||||
t.Errorf("plugin package does not define %s", name)
|
||||
}
|
||||
}
|
||||
for _, name := range []string{"Register", "Start", "Health", "Stop", "Manifests"} {
|
||||
for _, name := range []string{"Register", "Start", "Stop"} {
|
||||
if !hostMethods[name] {
|
||||
t.Errorf("plugin.Host does not define %s", name)
|
||||
}
|
||||
|
||||
@@ -87,34 +87,6 @@ func TestHostRegisterRejectsDuplicateAndMutationAfterStart(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostManifestsAreImmutableSnapshots(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
host := plugin.NewHost()
|
||||
manifest := validManifest("immutable")
|
||||
if err := host.Register(&fakeModule{manifest: manifest}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
manifest.Capabilities[0] = "mutated-at-source"
|
||||
manifest.Dependencies = append(manifest.Dependencies, "source-dependency")
|
||||
|
||||
first := host.Manifests()
|
||||
if len(first) != 1 {
|
||||
t.Fatalf("Manifests() length = %d, want 1", len(first))
|
||||
}
|
||||
first[0].Capabilities[0] = "mutated-at-caller"
|
||||
first[0].Dependencies = append(first[0].Dependencies, "caller-dependency")
|
||||
|
||||
second := host.Manifests()
|
||||
if got := second[0].Capabilities[0]; got != "tools" {
|
||||
t.Fatalf("stored capability = %q, want tools", got)
|
||||
}
|
||||
if len(second[0].Dependencies) != 0 {
|
||||
t.Fatalf("stored dependencies = %v, want empty", second[0].Dependencies)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostStartsInDependencyOrderAndStopsInReverse(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
@@ -273,26 +245,6 @@ func TestHostRegisterContainsManifestPanics(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostHealthRejectsInvalidProviderStatus(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
host := plugin.NewHost()
|
||||
module := &fakeModule{
|
||||
manifest: validManifest("invalid-health"),
|
||||
health: plugin.Health{Status: "surprising"},
|
||||
}
|
||||
if err := host.Register(module); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := host.Start(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
status := host.Health(context.Background())[0]
|
||||
if status.Health.Status != plugin.HealthUnhealthy || !strings.Contains(status.Health.Message, "invalid health status") {
|
||||
t.Fatalf("health status = %+v", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostStopContinuesAfterErrorsAndPanics(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
@@ -377,9 +329,6 @@ func TestHostStartupRollbackIsBoundedAndRetryable(t *testing.T) {
|
||||
if got := module.stopContextErrors[0]; got != nil {
|
||||
t.Fatalf("rollback Stop() context error = %v, want original cancellation detached", got)
|
||||
}
|
||||
if got := statusByID(host.Health(context.Background()), module.manifest.ID).State; got != plugin.StateFailed {
|
||||
t.Fatalf("failed module state = %q, want failed after successful or failed rollback cleanup", got)
|
||||
}
|
||||
if err := host.Stop(context.Background()); err != nil {
|
||||
t.Fatalf("Stop() retry error = %v", err)
|
||||
}
|
||||
@@ -388,46 +337,6 @@ func TestHostStartupRollbackIsBoundedAndRetryable(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostHealthIsPanicSafeAndSnapshotBased(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
host := plugin.NewHost()
|
||||
healthy := &fakeModule{
|
||||
manifest: validManifest("healthy"),
|
||||
health: plugin.Health{Status: plugin.HealthHealthy, Message: "ready"},
|
||||
}
|
||||
panicky := &fakeModule{manifest: validManifest("panicky"), healthPanic: true}
|
||||
for _, module := range []*fakeModule{healthy, panicky} {
|
||||
if err := host.Register(module); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
before := host.Health(context.Background())
|
||||
for _, status := range before {
|
||||
if status.State != plugin.StateRegistered || status.Health.Status != plugin.HealthUnknown {
|
||||
t.Fatalf("pre-start status = %+v, want registered/unknown", status)
|
||||
}
|
||||
}
|
||||
|
||||
if err := host.Start(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
after := host.Health(context.Background())
|
||||
if got := statusByID(after, "healthy"); got.State != plugin.StateRunning || got.Health.Status != plugin.HealthHealthy {
|
||||
t.Fatalf("healthy status = %+v", got)
|
||||
}
|
||||
if got := statusByID(after, "panicky"); got.State != plugin.StateRunning || got.Health.Status != plugin.HealthUnhealthy ||
|
||||
!strings.Contains(got.Health.Message, "panic") {
|
||||
t.Fatalf("panicky status = %+v", got)
|
||||
}
|
||||
|
||||
after[0].Manifest.Capabilities[0] = "caller-mutation"
|
||||
if got := host.Health(context.Background())[0].Manifest.Capabilities[0]; got != "tools" {
|
||||
t.Fatalf("stored health manifest capability = %q, want tools", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdaptLegacyCreatesMetadataOnlyLifecycleModule(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
@@ -446,9 +355,6 @@ func TestAdaptLegacyCreatesMetadataOnlyLifecycleModule(t *testing.T) {
|
||||
if err := module.Start(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if health := module.Health(context.Background()); health.Status != plugin.HealthHealthy {
|
||||
t.Fatalf("legacy health = %+v, want healthy", health)
|
||||
}
|
||||
if err := module.Stop(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -520,8 +426,6 @@ type fakeModule struct {
|
||||
stopContextErrors []error
|
||||
startPanic bool
|
||||
stopPanic bool
|
||||
healthPanic bool
|
||||
health plugin.Health
|
||||
manifestPanic bool
|
||||
}
|
||||
|
||||
@@ -561,13 +465,6 @@ func (m *fakeModule) Start(context.Context) error {
|
||||
return m.startErr
|
||||
}
|
||||
|
||||
func (m *fakeModule) Health(context.Context) plugin.Health {
|
||||
if m.healthPanic {
|
||||
panic("health panic")
|
||||
}
|
||||
return m.health
|
||||
}
|
||||
|
||||
func (m *fakeModule) Stop(ctx context.Context) error {
|
||||
m.events.add("stop:" + m.manifest.ID)
|
||||
m.stopCount++
|
||||
@@ -582,12 +479,3 @@ func (m *fakeModule) Stop(ctx context.Context) error {
|
||||
}
|
||||
return m.stopErr
|
||||
}
|
||||
|
||||
func statusByID(statuses []plugin.ModuleStatus, id string) plugin.ModuleStatus {
|
||||
for _, status := range statuses {
|
||||
if status.Manifest.ID == id {
|
||||
return status
|
||||
}
|
||||
}
|
||||
return plugin.ModuleStatus{}
|
||||
}
|
||||
+4
-25
@@ -13,30 +13,16 @@ import (
|
||||
func init() {
|
||||
Symbols["github.com/samcharles93/archie-core/internal/plugin/plugin"] = map[string]reflect.Value{
|
||||
// function, constant and variable definitions
|
||||
"AdaptLegacy": reflect.ValueOf(plugin.AdaptLegacy),
|
||||
"HealthDegraded": reflect.ValueOf(plugin.HealthDegraded),
|
||||
"HealthHealthy": reflect.ValueOf(plugin.HealthHealthy),
|
||||
"HealthUnhealthy": reflect.ValueOf(plugin.HealthUnhealthy),
|
||||
"HealthUnknown": reflect.ValueOf(plugin.HealthUnknown),
|
||||
"HostAPIVersion": reflect.ValueOf(constant.MakeFromLiteral("\"1.0.0\"", token.STRING, 0)),
|
||||
"LoadDir": reflect.ValueOf(plugin.LoadDir),
|
||||
"NewHost": reflect.ValueOf(plugin.NewHost),
|
||||
"StateFailed": reflect.ValueOf(plugin.StateFailed),
|
||||
"StateRegistered": reflect.ValueOf(plugin.StateRegistered),
|
||||
"StateRunning": reflect.ValueOf(plugin.StateRunning),
|
||||
"StateStarting": reflect.ValueOf(plugin.StateStarting),
|
||||
"StateStopped": reflect.ValueOf(plugin.StateStopped),
|
||||
"StateStopping": reflect.ValueOf(plugin.StateStopping),
|
||||
"AdaptLegacy": reflect.ValueOf(plugin.AdaptLegacy),
|
||||
"HostAPIVersion": reflect.ValueOf(constant.MakeFromLiteral("\"1.0.0\"", token.STRING, 0)),
|
||||
"LoadDir": reflect.ValueOf(plugin.LoadDir),
|
||||
"NewHost": reflect.ValueOf(plugin.NewHost),
|
||||
|
||||
// type definitions
|
||||
"CapabilityKind": reflect.ValueOf((*plugin.CapabilityKind)(nil)),
|
||||
"Health": reflect.ValueOf((*plugin.Health)(nil)),
|
||||
"HealthStatus": reflect.ValueOf((*plugin.HealthStatus)(nil)),
|
||||
"Host": reflect.ValueOf((*plugin.Host)(nil)),
|
||||
"LifecycleState": reflect.ValueOf((*plugin.LifecycleState)(nil)),
|
||||
"Manifest": reflect.ValueOf((*plugin.Manifest)(nil)),
|
||||
"Module": reflect.ValueOf((*plugin.Module)(nil)),
|
||||
"ModuleStatus": reflect.ValueOf((*plugin.ModuleStatus)(nil)),
|
||||
"Permission": reflect.ValueOf((*plugin.Permission)(nil)),
|
||||
"Plugin": reflect.ValueOf((*plugin.Plugin)(nil)),
|
||||
"Registry": reflect.ValueOf((*plugin.Registry)(nil)),
|
||||
@@ -50,18 +36,11 @@ func init() {
|
||||
// _github_com_samcharles93_archie_core_internal_plugin_Module is an interface wrapper for Module type
|
||||
type _github_com_samcharles93_archie_core_internal_plugin_Module struct {
|
||||
IValue interface{}
|
||||
WHealth func(a0 context.Context) plugin.Health
|
||||
WManifest func() plugin.Manifest
|
||||
WStart func(a0 context.Context) error
|
||||
WStop func(a0 context.Context) error
|
||||
}
|
||||
|
||||
func (W _github_com_samcharles93_archie_core_internal_plugin_Module) Health(a0 context.Context) plugin.Health {
|
||||
if W.WHealth == nil {
|
||||
return plugin.Health{}
|
||||
}
|
||||
return W.WHealth(a0)
|
||||
}
|
||||
func (W _github_com_samcharles93_archie_core_internal_plugin_Module) Manifest() plugin.Manifest {
|
||||
if W.WManifest == nil {
|
||||
return plugin.Manifest{}
|
||||
|
||||
@@ -13,11 +13,11 @@ import (
|
||||
// TestPreviouslyMissingSymbolsReachableFromInterpretedCode is the regression
|
||||
// test for the stale symbol-table drift (e7bo): the committed generated file
|
||||
// predated internal/plugin/host.go (f73b2d1) and was never regenerated, so
|
||||
// the Host/Module/Manifest/Permission/Health/CapabilityKind/LifecycleState/
|
||||
// ModuleStatus types and the NewHost/AdaptLegacy/HostAPIVersion identifiers
|
||||
// that plugin.go's LoadDir exposes to interpreted daemon plugins were absent
|
||||
// from the table. A daemon plugin written against the capability-host API
|
||||
// could not resolve them, silently.
|
||||
// the Host/Module/Manifest/Permission/CapabilityKind types and the
|
||||
// NewHost/AdaptLegacy/HostAPIVersion identifiers that plugin.go's LoadDir
|
||||
// exposes to interpreted daemon plugins were absent from the table. A daemon
|
||||
// plugin written against the capability-host API could not resolve them,
|
||||
// silently.
|
||||
//
|
||||
// This test interprets a plugin that references the previously-missing
|
||||
// symbols, resolves it, and calls it -- proving the symbols are wired.
|
||||
@@ -87,10 +87,7 @@ func (testModule) Manifest() plugin.Manifest {
|
||||
}
|
||||
|
||||
func (testModule) Start(context.Context) error { return nil }
|
||||
func (testModule) Health(context.Context) plugin.Health {
|
||||
return plugin.Health{Status: plugin.HealthHealthy}
|
||||
}
|
||||
func (testModule) Stop(context.Context) error { return nil }
|
||||
func (testModule) Stop(context.Context) error { return nil }
|
||||
|
||||
// TestWrapperNilGuardsPreserved follows the established pattern: yaegi's
|
||||
// fresh wrapper generation omits nil-guards on interface-wrappers, so they
|
||||
@@ -104,9 +101,6 @@ func TestWrapperNilGuardsPreserved(t *testing.T) {
|
||||
if got := mod.Manifest(); got.ID != "" || got.Name != "" || got.APIVersion != "" {
|
||||
t.Errorf("Manifest on nil WManifest = %#v, want empty", got)
|
||||
}
|
||||
if got := mod.Health(context.Background()); got.Status != "" || got.Message != "" {
|
||||
t.Errorf("Health on nil WHealth = %#v, want empty", got)
|
||||
}
|
||||
if err := mod.Stop(context.Background()); err != nil {
|
||||
t.Errorf("Stop on nil WStop = %v, want nil", err)
|
||||
}
|
||||
|
||||
@@ -119,23 +119,6 @@ func (p *Provider) Discover(ctx context.Context) ([]tools.ToolEntry, error) {
|
||||
return entries, nil
|
||||
}
|
||||
|
||||
// Health reports whether the tools were constructed.
|
||||
func (p *Provider) Health(context.Context) plugin.Health {
|
||||
if p.workspace == "" {
|
||||
return plugin.Health{
|
||||
Status: plugin.HealthUnhealthy,
|
||||
Message: "workspace directory is not configured",
|
||||
}
|
||||
}
|
||||
if p.registry == nil {
|
||||
return plugin.Health{
|
||||
Status: plugin.HealthUnhealthy,
|
||||
Message: "workspace tools are not started",
|
||||
}
|
||||
}
|
||||
return plugin.Health{Status: plugin.HealthHealthy}
|
||||
}
|
||||
|
||||
// Stop releases the constructed tools.
|
||||
func (p *Provider) Stop(context.Context) error {
|
||||
p.registry = nil
|
||||
|
||||
@@ -155,27 +155,6 @@ func (p *Provider) Discover(ctx context.Context) ([]tools.ToolEntry, error) {
|
||||
return entries, nil
|
||||
}
|
||||
|
||||
// Health reports transport state.
|
||||
func (p *Provider) Health(context.Context) plugin.Health {
|
||||
if p.name == "" || p.segment == "" {
|
||||
return plugin.Health{Status: plugin.HealthUnhealthy, Message: "MCP server name is invalid"}
|
||||
}
|
||||
if isNilTransport(p.transport) {
|
||||
return plugin.Health{Status: plugin.HealthUnhealthy, Message: "MCP transport is not configured"}
|
||||
}
|
||||
state := p.transport.State()
|
||||
switch state {
|
||||
case protocol.StateRunning:
|
||||
return plugin.Health{Status: plugin.HealthHealthy}
|
||||
case protocol.StateStarting, protocol.StateStopping:
|
||||
return plugin.Health{Status: plugin.HealthDegraded, Message: "MCP transport is " + state.String()}
|
||||
case protocol.StateStopped, protocol.StateError:
|
||||
return plugin.Health{Status: plugin.HealthUnhealthy, Message: "MCP transport is " + state.String()}
|
||||
default:
|
||||
return plugin.Health{Status: plugin.HealthUnhealthy, Message: "MCP transport state is unknown"}
|
||||
}
|
||||
}
|
||||
|
||||
// Stop stops the MCP transport and removes any media files written during
|
||||
// this provider's lifetime.
|
||||
func (p *Provider) Stop(ctx context.Context) error {
|
||||
|
||||
@@ -9,7 +9,6 @@ import (
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/plugin"
|
||||
"github.com/samcharles93/archie-core/internal/tools"
|
||||
protocol "github.com/samcharles93/archie-core/internal/tools/mcp"
|
||||
toolprovider "github.com/samcharles93/archie-core/internal/tools/provider"
|
||||
@@ -242,31 +241,6 @@ func TestProviderRejectsInvalidConfiguration(t *testing.T) {
|
||||
if err := provider.Start(context.Background()); err == nil {
|
||||
t.Fatal("Start() succeeded")
|
||||
}
|
||||
if provider.Health(context.Background()).Status != plugin.HealthUnhealthy {
|
||||
t.Fatal("invalid provider health is not unhealthy")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestProviderHealthMapsTransportState(t *testing.T) {
|
||||
tests := []struct {
|
||||
state protocol.TransportState
|
||||
want plugin.HealthStatus
|
||||
}{
|
||||
{state: protocol.StateRunning, want: plugin.HealthHealthy},
|
||||
{state: protocol.StateStarting, want: plugin.HealthDegraded},
|
||||
{state: protocol.StateStopping, want: plugin.HealthDegraded},
|
||||
{state: protocol.StateStopped, want: plugin.HealthUnhealthy},
|
||||
{state: protocol.StateError, want: plugin.HealthUnhealthy},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.state.String(), func(t *testing.T) {
|
||||
transport := newFakeTransport()
|
||||
transport.state = tt.state
|
||||
if got := New("health", transport).Health(context.Background()).Status; got != tt.want {
|
||||
t.Fatalf("Health().Status = %q, want %q", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -85,16 +85,6 @@ func TestOptionalProviderFailureDoesNotStopTheFamily(t *testing.T) {
|
||||
t.Error("tool \"desktop\" is registered despite its provider failing")
|
||||
}
|
||||
|
||||
// Degraded, not healthy: a silent failure is how this went
|
||||
// unnoticed until the daemon crash-looped.
|
||||
health := registry.Health(context.Background())
|
||||
if health.Status != plugin.HealthDegraded {
|
||||
t.Errorf("Health = %q, want %q", health.Status, plugin.HealthDegraded)
|
||||
}
|
||||
if !strings.Contains(health.Message, "mcp.desktop-commander") {
|
||||
t.Errorf("Health message %q does not name the failed provider", health.Message)
|
||||
}
|
||||
|
||||
skipped := registry.Skipped()
|
||||
if len(skipped) != 1 {
|
||||
t.Fatalf("Skipped() = %v, want exactly the failed provider", skipped)
|
||||
@@ -225,9 +215,6 @@ func TestEveryOptionalProviderFailing(t *testing.T) {
|
||||
if err := registry.Start(context.Background()); err != nil {
|
||||
t.Fatalf("Start: %v", err)
|
||||
}
|
||||
if got := registry.Health(context.Background()).Status; got != plugin.HealthDegraded {
|
||||
t.Errorf("Health = %q, want %q", got, plugin.HealthDegraded)
|
||||
}
|
||||
if len(registry.Skipped()) != 2 {
|
||||
t.Errorf("Skipped() = %v, want both providers", registry.Skipped())
|
||||
}
|
||||
@@ -296,13 +283,6 @@ func TestCarinaScenarioThroughCapabilityHost(t *testing.T) {
|
||||
t.Errorf("tool %q was lost to a third-party npm package", name)
|
||||
}
|
||||
}
|
||||
health := registry.Health(context.Background())
|
||||
if health.Status != plugin.HealthDegraded {
|
||||
t.Errorf("health = %q (%s), want degraded", health.Status, health.Message)
|
||||
}
|
||||
if !strings.Contains(health.Message, "unzip") {
|
||||
t.Errorf("health message %q does not carry the cause", health.Message)
|
||||
}
|
||||
if err := host.Stop(context.Background()); err != nil {
|
||||
t.Errorf("Stop: %v", err)
|
||||
}
|
||||
|
||||
@@ -7,7 +7,6 @@ import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
@@ -254,59 +253,6 @@ func (r *Registry) failFamily(ctx context.Context, started []runningProvider, ca
|
||||
return errors.Join(cause, rollbackErr)
|
||||
}
|
||||
|
||||
// Health reports aggregate provider health.
|
||||
func (r *Registry) Health(ctx context.Context) plugin.Health {
|
||||
r.mu.RLock()
|
||||
state := r.state
|
||||
running := append([]runningProvider(nil), r.running...)
|
||||
skipped := append([]SkippedProvider(nil), r.skipped...)
|
||||
r.mu.RUnlock()
|
||||
|
||||
switch state {
|
||||
case stateFailed:
|
||||
return plugin.Health{Status: plugin.HealthUnhealthy, Message: "tool-provider registry failed"}
|
||||
case stateRunning:
|
||||
default:
|
||||
return plugin.Health{Status: plugin.HealthUnknown, Message: "tool-provider registry is not running"}
|
||||
}
|
||||
|
||||
aggregate := plugin.Health{Status: plugin.HealthHealthy}
|
||||
var messages []string
|
||||
|
||||
// An excluded optional provider is a degradation, not a clean start.
|
||||
// Reporting healthy here is what let one broken npm package go unnoticed
|
||||
// until the daemon crash-looped.
|
||||
for _, s := range skipped {
|
||||
aggregate.Status = plugin.HealthDegraded
|
||||
message := s.ID + ": unavailable"
|
||||
if s.Err != nil {
|
||||
message = s.ID + ": " + s.Err.Error()
|
||||
}
|
||||
messages = append(messages, message)
|
||||
}
|
||||
|
||||
for _, provider := range running {
|
||||
health := safeHealth(ctx, provider.registration.engine)
|
||||
switch health.Status {
|
||||
case plugin.HealthHealthy:
|
||||
case plugin.HealthDegraded:
|
||||
if aggregate.Status == plugin.HealthHealthy {
|
||||
aggregate.Status = plugin.HealthDegraded
|
||||
}
|
||||
case plugin.HealthUnhealthy:
|
||||
aggregate.Status = plugin.HealthUnhealthy
|
||||
default:
|
||||
aggregate.Status = plugin.HealthUnhealthy
|
||||
health.Message = fmt.Sprintf("invalid health status %q", health.Status)
|
||||
}
|
||||
if health.Message != "" {
|
||||
messages = append(messages, provider.registration.manifest.ID+": "+health.Message)
|
||||
}
|
||||
}
|
||||
aggregate.Message = strings.Join(messages, "; ")
|
||||
return aggregate
|
||||
}
|
||||
|
||||
// Stop removes all provider-owned tools before stopping providers in reverse
|
||||
// startup order. It continues after provider failures and joins their errors.
|
||||
func (r *Registry) Stop(ctx context.Context) error {
|
||||
@@ -580,18 +526,6 @@ func safeDiscover(ctx context.Context, engine Engine) (entries []tools.ToolEntry
|
||||
return engine.Discover(ctx)
|
||||
}
|
||||
|
||||
func safeHealth(ctx context.Context, engine Engine) (health plugin.Health) {
|
||||
defer func() {
|
||||
if recovered := recover(); recovered != nil {
|
||||
health = plugin.Health{
|
||||
Status: plugin.HealthUnhealthy,
|
||||
Message: fmt.Sprintf("health panic: %v", recovered),
|
||||
}
|
||||
}
|
||||
}()
|
||||
return engine.Health(ctx)
|
||||
}
|
||||
|
||||
func safeStop(ctx context.Context, engine Engine) (err error) {
|
||||
defer func() {
|
||||
if recovered := recover(); recovered != nil {
|
||||
|
||||
@@ -354,38 +354,6 @@ func TestRegistryStartupRollbackUsesBoundedDetachedContext(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryHealthAggregatesProviderHealthAndPanics(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
health plugin.Health
|
||||
panic any
|
||||
want plugin.HealthStatus
|
||||
}{
|
||||
{name: "healthy", health: plugin.Health{Status: plugin.HealthHealthy}, want: plugin.HealthHealthy},
|
||||
{name: "degraded", health: plugin.Health{Status: plugin.HealthDegraded}, want: plugin.HealthDegraded},
|
||||
{name: "unhealthy", health: plugin.Health{Status: plugin.HealthUnhealthy}, want: plugin.HealthUnhealthy},
|
||||
{name: "panic", panic: "health panic", want: plugin.HealthUnhealthy},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
registry := NewRegistry(tools.NewRegistry())
|
||||
engine := newFakeEngine("health")
|
||||
engine.health = tt.health
|
||||
engine.healthPanic = tt.panic
|
||||
if err := registry.Register(engine); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := registry.Start(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := registry.Health(context.Background()).Status; got != tt.want {
|
||||
t.Fatalf("Health().Status = %q, want %q", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type fakeEngine struct {
|
||||
manifest plugin.Manifest
|
||||
tools []tools.ToolEntry
|
||||
@@ -396,8 +364,6 @@ type fakeEngine struct {
|
||||
startPanic any
|
||||
discoverPanic any
|
||||
stopPanic any
|
||||
healthPanic any
|
||||
health plugin.Health
|
||||
startCount int
|
||||
discoverCount int
|
||||
stopCount int
|
||||
@@ -409,7 +375,6 @@ type fakeEngine struct {
|
||||
func newFakeEngine(id string) *fakeEngine {
|
||||
return &fakeEngine{
|
||||
manifest: testManifest(id, []plugin.CapabilityKind{"tools"}, nil),
|
||||
health: plugin.Health{Status: plugin.HealthHealthy},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -456,13 +421,6 @@ func (e *fakeEngine) Discover(context.Context) ([]tools.ToolEntry, error) {
|
||||
return e.tools, e.discoverErr
|
||||
}
|
||||
|
||||
func (e *fakeEngine) Health(context.Context) plugin.Health {
|
||||
if e.healthPanic != nil {
|
||||
panic(e.healthPanic)
|
||||
}
|
||||
return e.health
|
||||
}
|
||||
|
||||
func (e *fakeEngine) Stop(ctx context.Context) error {
|
||||
e.stopCount++
|
||||
e.log("stop")
|
||||
|
||||
Reference in new issue
Block a user