141 lines
4.8 KiB
Go
141 lines
4.8 KiB
Go
package archied
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"path/filepath"
|
|
"slices"
|
|
"sync"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
|
"github.com/samcharles93/archie-core/internal/forge"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/extension"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/forgeext"
|
|
)
|
|
|
|
// forgeExtensions opens forge instances served by installed forge extensions:
|
|
// the package named by forge.type, with its authority accepted and enabled in
|
|
// extension-settings. Changing which extension serves a forge takes a restart,
|
|
// as every forge setting does.
|
|
type forgeExtensions struct {
|
|
host *extension.Host
|
|
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 {
|
|
log.Warn("forge extensions unavailable: no cache directory", "err", err)
|
|
return nil
|
|
}
|
|
return &forgeExtensions{
|
|
host: extension.NewHost(log),
|
|
source: source,
|
|
cacheDir: filepath.Join(cache, "extensions", "forge"),
|
|
log: log,
|
|
running: make(map[string]runningForge),
|
|
binaries: make(map[string]materialized),
|
|
}
|
|
}
|
|
|
|
// open returns the instance's forge when an enabled extension named typ serves
|
|
// it. handled is false when none does, so the caller falls back to the
|
|
// compiled-in forge; an extension that is enabled but will not start is
|
|
// handled, as a forge that fails rather than a different one.
|
|
func (e *forgeExtensions) open(ctx context.Context, typ, instance, host, token string) (f forge.Forge, handled bool) {
|
|
if e == nil {
|
|
return nil, false
|
|
}
|
|
settings, _, err := e.source.Enabled(ctx)
|
|
if err != nil {
|
|
e.log.WarnContext(ctx, "forge extensions: extension settings unavailable", "err", err)
|
|
return nil, false
|
|
}
|
|
setting, ok := settings[typ]
|
|
if !ok || !setting.Enabled {
|
|
return nil, false
|
|
}
|
|
installed, err := e.source.Packages.ListInstalled(ctx)
|
|
if err != nil {
|
|
e.log.WarnContext(ctx, "forge extensions: installed packages unavailable", "err", err)
|
|
return nil, false
|
|
}
|
|
for _, pkg := range installed {
|
|
if pkg.Name != typ || pkg.AcceptedAuthority == nil {
|
|
continue
|
|
}
|
|
index := slices.IndexFunc(pkg.Descriptor.Contributes.Extensions, func(x storepkg.Extension) bool { return x.Surface == storepkg.SurfaceForge })
|
|
if index < 0 {
|
|
continue
|
|
}
|
|
forgeClient, err := e.start(ctx, pkg, pkg.Descriptor.Contributes.Extensions[index].Path, instance, host, token, setting.Settings)
|
|
if err != nil {
|
|
e.log.WarnContext(ctx, "forge disabled: extension did not start", "forge_type", typ, "instance", instance, "err", err)
|
|
return forge.NewNoop(e.log), true
|
|
}
|
|
return forgeClient, true
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func (e *forgeExtensions) start(ctx context.Context, pkg storepkg.Installed, file, instance, host, token string, settings map[string]string) (forge.Forge, error) {
|
|
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
|
|
}
|
|
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)
|
|
delete(e.binaries, binaryKey)
|
|
return nil, err
|
|
}
|
|
e.running[name] = runningForge{key: string(key), forge: opened}
|
|
return opened, nil
|
|
}
|
|
|
|
func (e *forgeExtensions) close() {
|
|
if e != nil {
|
|
e.host.Close()
|
|
}
|
|
}
|