Task containers log in with their run credential on an external broker and reach only their own subjects, decided by the embedded broker's authenticator. The broker token is never put in a container environment.
142 lines
4.4 KiB
Go
142 lines
4.4 KiB
Go
// Command archie-agent runs Archie's NATS-connected agent worker.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/samcharles93/archie-core/internal/app/agentworker"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/egress"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
)
|
|
|
|
type workerRunner func(context.Context, agentworker.Settings, *slog.Logger) error
|
|
|
|
func main() {
|
|
os.Exit(run())
|
|
}
|
|
|
|
func run() int {
|
|
return runCommand(os.Args[1:], os.Getenv, os.Stderr, agentworker.Run)
|
|
}
|
|
|
|
func runCommand(args []string, getenv func(string) string, stderr io.Writer, runWorker workerRunner) int {
|
|
if len(args) > 0 && args[0] == "relay" {
|
|
return runRelay(args[1:], stderr, agentworker.RunRelay)
|
|
}
|
|
flags := flag.NewFlagSet("archie-agent", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
natsURLFlag := flags.String("nats-url", "", "NATS server URL (defaults to NATS_URL)")
|
|
stateStoreURLFlag := flags.String("state-store-url", "", "State Store gRPC target (defaults to STATE_STORE_URL; required -- the legacy NATS storerpc path is deleted)")
|
|
stateStoreTokenFlag := flags.String("state-store-token", "", "State Store bearer token (defaults to STATE_STORE_TOKEN)")
|
|
showVersion := flags.Bool("version", false, "print the version and exit")
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
// The release and its updater read this line to prove a shipped
|
|
// archie-agent belongs to the release being installed.
|
|
if *showVersion {
|
|
fmt.Printf("archie-agent %s\n", agentworker.Version())
|
|
return 0
|
|
}
|
|
|
|
natsURL := *natsURLFlag
|
|
if natsURL == "" {
|
|
natsURL = getenv("NATS_URL")
|
|
}
|
|
if natsURL == "" {
|
|
_, _ = fmt.Fprintln(stderr, "error: -nats-url or NATS_URL is required")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
|
|
log := slog.New(logging.WithTrace(slog.NewJSONHandler(stderr, nil)))
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
|
|
stateStoreURL := *stateStoreURLFlag
|
|
if stateStoreURL == "" {
|
|
stateStoreURL = getenv("STATE_STORE_URL")
|
|
}
|
|
if stateStoreURL == "" {
|
|
_, _ = fmt.Fprintln(stderr, "error: -state-store-url or STATE_STORE_URL is required (the legacy NATS storerpc path is deleted)")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
stateStoreToken := *stateStoreTokenFlag
|
|
if stateStoreToken == "" {
|
|
stateStoreToken = getenv("STATE_STORE_TOKEN")
|
|
}
|
|
|
|
if err := runWorker(ctx, agentworker.Settings{
|
|
NATSURL: natsURL,
|
|
StateStoreTarget: stateStoreURL,
|
|
StateStoreToken: stateStoreToken,
|
|
StateStoreCA: []byte(getenv("STATE_STORE_CA")),
|
|
ModelProxy: getenv(egress.ModelProxyEnv),
|
|
ModelProxyHosts: egress.ParseHosts(getenv(egress.ModelProxyHostsEnv)),
|
|
ModelProxyCA: getenv(egress.ModelProxyCAEnv),
|
|
}, log); err != nil {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type relayServer func(ctx context.Context, forwards map[string]string) error
|
|
|
|
// runRelay is the sandbox egress relay: the container on both a sandbox's
|
|
// isolated network and the host-reachable one, forwarding a fixed set of
|
|
// ports to the proxy, NATS and the State Store.
|
|
func runRelay(args []string, stderr io.Writer, serve relayServer) int {
|
|
flags := flag.NewFlagSet("archie-agent relay", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
forwards := map[string]string{}
|
|
flags.Func("forward", "listen=target: forward connections on listen to target (repeatable)", func(v string) error {
|
|
listen, target, ok := strings.Cut(v, "=")
|
|
if !ok || listen == "" || target == "" {
|
|
return fmt.Errorf("%q is not listen=target", v)
|
|
}
|
|
if _, _, err := net.SplitHostPort(listen); err != nil {
|
|
return fmt.Errorf("listen address %q: %w", listen, err)
|
|
}
|
|
if _, _, err := net.SplitHostPort(target); err != nil {
|
|
return fmt.Errorf("target %q: %w", target, err)
|
|
}
|
|
if _, dup := forwards[listen]; dup {
|
|
return fmt.Errorf("listen address %q is forwarded twice", listen)
|
|
}
|
|
forwards[listen] = target
|
|
return nil
|
|
})
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
if len(forwards) == 0 {
|
|
_, _ = fmt.Fprintln(stderr, "error: at least one -forward is required")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
if err := serve(ctx, forwards); err != nil {
|
|
_, _ = fmt.Fprintln(stderr, "error:", err)
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|