mirror of
https://github.com/zap-proto/zip.git
synced 2026-10-19 15:38:57 +00:00
zeekayandHanzo Dev
5dfa4ef616
HIP-0106's plugin contract, in the framework rather than in 116 repositories. Declaration projects the LIVE ROUTER — every method+pattern, complete by construction, so a route a plugin serves and does not publish is still declared. That is the analytics-ingestion outage class: the published paths were listed, the four ingestion doors were not, and every product beacon in the fleet answered 405. Declaration/Route/(*App).Declaration what a host discovers /.well-known/zip/plugin.json the same value off a running child (*App).Described `<bin> openapi <f>` / `<bin> declare <f>` Tenant the tenancy read, with the real rule Delegate a continuation for another org Ask dial a peer by name, invoke one op (*App).Peer peer ops on their own app, own socket (*App).Ops /healthz + /readyz + /metrics Config.Eager the one fact a router cannot show App.claim a second claim of a prefix is an ERROR zip/runtime -> zip/js a language runtime is an adaptor Four things the reference plugin falsified while being built: - Describe was already taken. zip.Describe(methodPath, Doc) is the doc registry generated code calls. The projection writer is (*App).Described, one call, because argv is read in one place and a main cannot forget to forward it. - zip's control plane is NOT all under /.well-known/. /docs and the MCP path are not, so a prefix filter let a child declare them — paths outside /v1/ that every plugin serves and whose first claimant takes the HOST's document and agent door. App.control now registers and records in one call, so leaking one is impossible rather than unlikely. - OPS_PORT appeared in no Go file in the fleet. HIP-0119 named the paths and nobody implemented them, so conformance meant 116 repos hand-rolling three routes and a listener. It is one sibling app now, brought up by Listen. - There is deliberately NO default ops port. A default made every second app in a process die on "address already in use" — a plugin has two apps in it and a test process has many. The deployment states OPS_PORT; a host states none on a child, so a child correctly owns none. Load's duplicate claim used to return nil while the first registration kept answering: the losing plugin's whole surface served another plugin's 404 and nothing said so. It is now an error naming both claimants, all-or-nothing across a plugin's prefixes, taken before anything is spawned. a.ops was the op registry and is now a.registry — the ONE registry the OpenAPI document, the MCP tool, the CLI command and the plane op are all projected from. a.ops is the ops sibling. Co-authored-by: Hanzo Dev <[email protected]>
74 lines
1.7 KiB
Go
74 lines
1.7 KiB
Go
package js
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/dop251/goja"
|
|
)
|
|
|
|
// poolItem is one pre-warmed VM with a busy flag.
|
|
type poolItem struct {
|
|
mu sync.Mutex
|
|
busy bool
|
|
vm *goja.Runtime
|
|
}
|
|
|
|
// vmPool is a fixed-size pool of goja VMs. Lifted from
|
|
// hanzoai/base/plugins/gojavm and slimmed: zip needs run (borrow one)
|
|
// and forEach (apply a mutation to every pooled VM under its own lock so
|
|
// late RegisterHostFn / LoadModule reach already-warm VMs).
|
|
type vmPool struct {
|
|
factory func() *goja.Runtime
|
|
items []*poolItem
|
|
}
|
|
|
|
func newVMPool(size int, factory func() *goja.Runtime) *vmPool {
|
|
p := &vmPool{factory: factory}
|
|
if size > 0 {
|
|
p.items = make([]*poolItem, size)
|
|
for i := 0; i < size; i++ {
|
|
p.items[i] = &poolItem{vm: factory()}
|
|
}
|
|
}
|
|
return p
|
|
}
|
|
|
|
// run executes call with a pooled VM. If every slot is busy it builds a
|
|
// one-off VM (fully provisioned via factory) and discards it after the
|
|
// call. goja VMs are single-threaded, so a borrowed VM is never touched
|
|
// concurrently.
|
|
func (p *vmPool) run(call func(vm *goja.Runtime) error) error {
|
|
for _, item := range p.items {
|
|
item.mu.Lock()
|
|
if item.busy {
|
|
item.mu.Unlock()
|
|
continue
|
|
}
|
|
item.busy = true
|
|
item.mu.Unlock()
|
|
|
|
err := call(item.vm)
|
|
|
|
item.mu.Lock()
|
|
item.busy = false
|
|
item.mu.Unlock()
|
|
return err
|
|
}
|
|
// Pool saturated: one-off VM, factory provisions host fns + modules.
|
|
return call(p.factory())
|
|
}
|
|
|
|
// forEach applies mutate to every pooled VM, each under its own lock so
|
|
// it cannot race a concurrent run() on the same VM.
|
|
func (p *vmPool) forEach(mutate func(vm *goja.Runtime) error) error {
|
|
for _, item := range p.items {
|
|
item.mu.Lock()
|
|
err := mutate(item.vm)
|
|
item.mu.Unlock()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|