From c98c9dcc2256f665caf3fa40900bb06908a5428a Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sat, 26 Sep 2026 02:33:41 +1000 Subject: [PATCH] feat(egress): relay forwarding a sandbox network to the egress proxy archie-agent relay listens on the sandbox's isolated network and joins every connection to one fixed target, the proxy. The relay holds no secrets and can reach nothing else, so the host needs no address on a sandbox network at all. --- cmd/archie-agent/architecture_test.go | 1 + cmd/archie-agent/main.go | 32 ++++++ cmd/archie-agent/main_relay_test.go | 43 ++++++++ internal/app/agentworker/relay.go | 18 ++++ internal/infrastructure/egress/relay/relay.go | 70 +++++++++++++ .../infrastructure/egress/relay/relay_test.go | 98 +++++++++++++++++++ 6 files changed, 262 insertions(+) create mode 100644 cmd/archie-agent/main_relay_test.go create mode 100644 internal/app/agentworker/relay.go create mode 100644 internal/infrastructure/egress/relay/relay.go create mode 100644 internal/infrastructure/egress/relay/relay_test.go diff --git a/cmd/archie-agent/architecture_test.go b/cmd/archie-agent/architecture_test.go index c5a337a23..2566633df 100644 --- a/cmd/archie-agent/architecture_test.go +++ b/cmd/archie-agent/architecture_test.go @@ -53,6 +53,7 @@ func TestCommandBoundary(t *testing.T) { "run": true, "runCommand": true, "natsConnectionSettings": true, + "runRelay": true, } for _, declaration := range file.Decls { function, ok := declaration.(*ast.FuncDecl) diff --git a/cmd/archie-agent/main.go b/cmd/archie-agent/main.go index 86248b3a8..d7606b951 100644 --- a/cmd/archie-agent/main.go +++ b/cmd/archie-agent/main.go @@ -26,6 +26,9 @@ func run() int { } 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)") @@ -81,3 +84,32 @@ func natsConnectionSettings(flagURL string, getenv func(string) string) (url, to } return url, getenv("NATS_TOKEN") } + +type relayServer func(ctx context.Context, listen, target string) error + +// runRelay is the sandbox egress relay: the container on both a sandbox's +// isolated network and the host-reachable one, forwarding to the proxy. +func runRelay(args []string, stderr io.Writer, serve relayServer) int { + flags := flag.NewFlagSet("archie-agent relay", flag.ContinueOnError) + flags.SetOutput(stderr) + listen := flags.String("listen", ":3128", "address sandbox containers connect to") + target := flags.String("to", "", "the egress proxy address every connection is forwarded to") + if err := flags.Parse(args); err != nil { + if errors.Is(err, flag.ErrHelp) { + return 0 + } + return 2 + } + if *target == "" { + fmt.Fprintln(stderr, "error: -to is required") + flags.Usage() + return 1 + } + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer stop() + if err := serve(ctx, *listen, *target); err != nil { + fmt.Fprintln(stderr, "error:", err) + return 1 + } + return 0 +} diff --git a/cmd/archie-agent/main_relay_test.go b/cmd/archie-agent/main_relay_test.go new file mode 100644 index 000000000..a042c4860 --- /dev/null +++ b/cmd/archie-agent/main_relay_test.go @@ -0,0 +1,43 @@ +package main + +import ( + "bytes" + "context" + "strings" + "testing" +) + +func TestRunRelay(t *testing.T) { + t.Run("-to is required", func(t *testing.T) { + var stderr bytes.Buffer + called := false + serve := func(context.Context, string, string) error { called = true; return nil } + if code := runRelay([]string{"-listen", "127.0.0.1:0"}, &stderr, serve); code != 1 { + t.Fatalf("exit %d, want 1", code) + } + if called || !strings.Contains(stderr.String(), "-to is required") { + t.Fatalf("served=%v stderr=%q", called, stderr.String()) + } + }) + t.Run("serves the named target on the listen address", func(t *testing.T) { + var gotTarget, gotAddr string + serve := func(_ context.Context, listen, target string) error { + gotTarget, gotAddr = target, listen + return nil + } + if code := runRelay([]string{"-listen", "127.0.0.1:0", "-to", "172.17.0.1:3129"}, &bytes.Buffer{}, serve); code != 0 { + t.Fatalf("exit %d, want 0", code) + } + if gotTarget != "172.17.0.1:3129" || gotAddr != "127.0.0.1:0" { + t.Fatalf("served %q on %q", gotTarget, gotAddr) + } + }) +} + +func TestRelaySubcommandRoutes(t *testing.T) { + var stderr bytes.Buffer + code := runCommand([]string{"relay"}, func(string) string { return "" }, &stderr, nil) + if code != 1 || !strings.Contains(stderr.String(), "-to is required") { + t.Fatalf("relay subcommand exit %d stderr %q; want the relay's own usage error", code, stderr.String()) + } +} diff --git a/internal/app/agentworker/relay.go b/internal/app/agentworker/relay.go new file mode 100644 index 000000000..1b327d5bc --- /dev/null +++ b/internal/app/agentworker/relay.go @@ -0,0 +1,18 @@ +package agentworker + +import ( + "context" + "net" + + "github.com/samcharles93/archie-core/internal/infrastructure/egress/relay" +) + +// RunRelay listens on listen and forwards every connection to target, the +// egress proxy, until ctx is cancelled. +func RunRelay(ctx context.Context, listen, target string) error { + ln, err := (&net.ListenConfig{}).Listen(ctx, "tcp", listen) + if err != nil { + return err + } + return relay.Serve(ctx, ln, target) +} diff --git a/internal/infrastructure/egress/relay/relay.go b/internal/infrastructure/egress/relay/relay.go new file mode 100644 index 000000000..99ec58489 --- /dev/null +++ b/internal/infrastructure/egress/relay/relay.go @@ -0,0 +1,70 @@ +// Package relay forwards a sandbox's proxy connections to archie's egress +// proxy. It runs in the one container that is on both a sandbox's isolated +// network and the host-reachable network, and it can reach exactly one +// address: it moves bytes to its fixed target and nothing else. +package relay + +import ( + "context" + "errors" + "io" + "net" + "sync" + "time" +) + +const dialTimeout = 10 * time.Second + +// Serve accepts connections on ln and joins each to a new connection to +// target until ctx is cancelled. +func Serve(ctx context.Context, ln net.Listener, target string) error { + stop := context.AfterFunc(ctx, func() { _ = ln.Close() }) + defer stop() + var wg sync.WaitGroup + defer wg.Wait() + for { + client, err := ln.Accept() + if err != nil { + if ctx.Err() != nil { + return nil + } + return err + } + wg.Add(1) + go func() { + defer wg.Done() + join(ctx, client, target) + }() + } +} + +func join(ctx context.Context, client net.Conn, target string) { + defer client.Close() + upstream, err := (&net.Dialer{Timeout: dialTimeout}).DialContext(ctx, "tcp", target) + if err != nil { + return + } + defer upstream.Close() + stop := context.AfterFunc(ctx, func() { + _ = client.Close() + _ = upstream.Close() + }) + defer stop() + done := make(chan struct{}, 2) + go pipe(upstream, client, done) + go pipe(client, upstream, done) + <-done + <-done +} + +// pipe copies src to dst, then half-closes dst so the far side sees EOF +// while the other direction keeps flowing. +func pipe(dst, src net.Conn, done chan<- struct{}) { + _, err := io.Copy(dst, src) + if tcp, ok := dst.(*net.TCPConn); ok && (err == nil || errors.Is(err, net.ErrClosed)) { + _ = tcp.CloseWrite() + } else { + _ = dst.Close() + } + done <- struct{}{} +} diff --git a/internal/infrastructure/egress/relay/relay_test.go b/internal/infrastructure/egress/relay/relay_test.go new file mode 100644 index 000000000..38077dbe9 --- /dev/null +++ b/internal/infrastructure/egress/relay/relay_test.go @@ -0,0 +1,98 @@ +package relay + +import ( + "bufio" + "context" + "errors" + "io" + "net" + "testing" + "time" +) + +func listen(t *testing.T) net.Listener { + t.Helper() + ln, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = ln.Close() }) + return ln +} + +func echoServer(t *testing.T) string { + t.Helper() + ln := listen(t) + go func() { + for { + c, err := ln.Accept() + if err != nil { + return + } + go func() { + defer c.Close() + _, _ = io.Copy(c, c) + }() + } + }() + return ln.Addr().String() +} + +func startRelay(t *testing.T, target string) (string, context.CancelFunc, <-chan error) { + t.Helper() + ln := listen(t) + ctx, cancel := context.WithCancel(t.Context()) + done := make(chan error, 1) + go func() { done <- Serve(ctx, ln, target) }() + return ln.Addr().String(), cancel, done +} + +func TestRelayForwardsBothWays(t *testing.T) { + addr, cancel, _ := startRelay(t, echoServer(t)) + defer cancel() + c, err := (&net.Dialer{}).DialContext(t.Context(), "tcp", addr) + if err != nil { + t.Fatal(err) + } + defer c.Close() + _ = c.SetDeadline(time.Now().Add(5 * time.Second)) + for _, line := range []string{"first\n", "second\n"} { + if _, err := io.WriteString(c, line); err != nil { + t.Fatal(err) + } + got, err := bufio.NewReader(c).ReadString('\n') + if err != nil || got != line { + t.Fatalf("echo %q, want %q (%v)", got, line, err) + } + } +} + +func TestRelayClosesTheClientWhenTheTargetIsDown(t *testing.T) { + dead := listen(t) + target := dead.Addr().String() + _ = dead.Close() + addr, cancel, _ := startRelay(t, target) + defer cancel() + c, err := (&net.Dialer{}).DialContext(t.Context(), "tcp", addr) + if err != nil { + t.Fatal(err) + } + defer c.Close() + _ = c.SetReadDeadline(time.Now().Add(5 * time.Second)) + if _, err := c.Read(make([]byte, 1)); !errors.Is(err, io.EOF) { + t.Fatalf("read from a relay with no target: %v, want EOF", err) + } +} + +func TestRelayStopsOnCancel(t *testing.T) { + _, cancel, done := startRelay(t, echoServer(t)) + cancel() + select { + case err := <-done: + if err != nil { + t.Fatalf("Serve returned %v after cancel, want nil", err) + } + case <-time.After(5 * time.Second): + t.Fatal("Serve did not return after its context was cancelled") + } +}