From c07ccc22ff637d6bfdd67232c1821857637f7552 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 25 Oct 2026 21:46:04 +1100 Subject: [PATCH] perf(archied): reuse running forge extension instances and materialized binaries --- internal/app/archied/forge_extensions.go | 51 ++++++++++++++++++++++-- 1 file changed, 48 insertions(+), 3 deletions(-) diff --git a/internal/app/archied/forge_extensions.go b/internal/app/archied/forge_extensions.go index e3d8124e4..d5d1bae93 100644 --- a/internal/app/archied/forge_extensions.go +++ b/internal/app/archied/forge_extensions.go @@ -2,9 +2,11 @@ package archied import ( "context" + "encoding/json" "log/slog" "path/filepath" "slices" + "sync" "github.com/hashicorp/go-hclog" @@ -24,8 +26,25 @@ type forgeExtensions struct { source extension.Source cacheDir string log *slog.Logger + + // mu guards the maps below and serialises starts, so concurrent opens of + // one instance share a process. + mu sync.Mutex + // running holds the live forge per instance name with the key it started + // under. Nothing closes a forge it is handed, so sharing is safe. + running map[string]runningForge + // binaries holds each package digest's materialized binary, so the layer + // is fetched once per digest rather than on every open. + binaries map[string]materialized } +type runningForge struct { + key string + forge forge.Forge +} + +type materialized struct{ path, sum string } + func newForgeExtensions(source extension.Source, log *slog.Logger) *forgeExtensions { cache, err := configuration.DefaultCacheDir() if err != nil { @@ -37,6 +56,8 @@ func newForgeExtensions(source extension.Source, log *slog.Logger) *forgeExtensi source: source, cacheDir: filepath.Join(cache, "extensions", "forge"), log: log, + running: make(map[string]runningForge), + binaries: make(map[string]materialized), } } @@ -81,12 +102,36 @@ func (e *forgeExtensions) open(ctx context.Context, typ, instance, host, token s } func (e *forgeExtensions) start(ctx context.Context, pkg storepkg.Installed, file, instance, host, token string, settings map[string]string) (forge.Forge, error) { - binary, sum, err := extension.Materialize(ctx, e.source.Packages, e.cacheDir, pkg, file) + name := "forge/" + instance + key, err := json.Marshal([]any{pkg.Digest, file, host, token, settings, pkg.AcceptedAuthority.Env, pkg.AcceptedAuthority.EgressHosts}) if err != nil { return nil, err } - spec := extension.Spec{Name: "forge/" + instance, Path: binary, SHA256: sum, Env: slices.Clone(pkg.AcceptedAuthority.Env), Egress: slices.Clone(pkg.AcceptedAuthority.EgressHosts)} - return forgeext.Open(ctx, e.host, forgeext.Instance{Spec: spec, Host: host, Token: token, Settings: settings}, e.log) + e.mu.Lock() + defer e.mu.Unlock() + if have, ok := e.running[name]; ok && have.key == string(key) { + return have.forge, nil + } + binaryKey := pkg.Digest + "\x00" + file + bin, ok := e.binaries[binaryKey] + if !ok { + path, sum, err := extension.Materialize(ctx, e.source.Packages, e.cacheDir, pkg, file) + if err != nil { + return nil, err + } + bin = materialized{path: path, sum: sum} + e.binaries[binaryKey] = bin + } + spec := extension.Spec{Name: name, Path: bin.path, SHA256: bin.sum, Env: slices.Clone(pkg.AcceptedAuthority.Env), Egress: slices.Clone(pkg.AcceptedAuthority.EgressHosts)} + // Host.Start stops the process still running under this name, so a changed + // digest, token or setting replaces the old instance. + opened, err := forgeext.Open(ctx, e.host, forgeext.Instance{Spec: spec, Host: host, Token: token, Settings: settings}, e.log) + if err != nil { + delete(e.running, name) + return nil, err + } + e.running[name] = runningForge{key: string(key), forge: opened} + return opened, nil } func (e *forgeExtensions) close() {