feat: wire coder client options into aggregated apiserver

Author: ThomasK33

app_dispatch.go

@@ -1,8 +1,10 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"fmt"
+	"time"
 
 	ctrl "sigs.k8s.io/controller-runtime"
 
@@ -15,15 +17,40 @@ const supportedAppModes = "controller, aggregated-apiserver, mcp-http"
 
 var (
 	runControllerApp          = controllerapp.Run
-	runAggregatedAPIServerApp = apiserverapp.Run
-	runMCPHTTPApp             = mcpapp.RunHTTP
-	setupSignalHandler        = ctrl.SetupSignalHandler
+	runAggregatedAPIServerApp = func(ctx context.Context, opts apiserverapp.Options) error {
+		return apiserverapp.RunWithOptions(ctx, opts)
+	}
+	runMCPHTTPApp      = mcpapp.RunHTTP
+	setupSignalHandler = ctrl.SetupSignalHandler
 )
 
 func run(args []string) error {
 	fs := flag.NewFlagSet("coder-k8s", flag.ContinueOnError)
-	var appMode string
+	var (
+		appMode             string
+		coderURL            string
+		coderSessionToken   string
+		coderRequestTimeout time.Duration
+	)
 	fs.StringVar(&appMode, "app", "", "Application mode (controller, aggregated-apiserver, mcp-http)")
+	fs.StringVar(
+		&coderSessionToken,
+		"coder-session-token",
+		"",
+		"Admin session token for the backing Coder deployment",
+	)
+	fs.StringVar(
+		&coderURL,
+		"coder-url",
+		"",
+		"Coder deployment URL (fallback when CoderControlPlane status URL is unavailable)",
+	)
+	fs.DurationVar(
+		&coderRequestTimeout,
+		"coder-request-timeout",
+		30*time.Second,
+		"Timeout for Coder SDK API requests",
+	)
 	if err := fs.Parse(args); err != nil {
 		return err
 	}
@@ -32,7 +59,12 @@ func run(args []string) error {
 	case "controller":
 		return runControllerApp(setupSignalHandler())
 	case "aggregated-apiserver":
-		return runAggregatedAPIServerApp(setupSignalHandler())
+		opts := apiserverapp.Options{
+			CoderURL:            coderURL,
+			CoderSessionToken:   coderSessionToken,
+			CoderRequestTimeout: coderRequestTimeout,
+		}
+		return runAggregatedAPIServerApp(setupSignalHandler(), opts)
 	case "mcp-http":
 		return runMCPHTTPApp(setupSignalHandler())
 	case "":

internal/app/apiserverapp/apiserverapp.go

@@ -4,6 +4,9 @@ package apiserverapp
 import (
 	"context"
 	"fmt"
+	"net"
+	"net/url"
+	"time"
 
 	metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -23,6 +26,7 @@ import (
 	"k8s.io/kube-openapi/pkg/validation/spec"
 
 	aggregationv1alpha1 "github.com/coder/coder-k8s/api/aggregation/v1alpha1"
+	"github.com/coder/coder-k8s/internal/aggregated/coder"
 	"github.com/coder/coder-k8s/internal/aggregated/storage"
 )
 
@@ -32,6 +36,20 @@ const (
 	serverName               = "coder-k8s-aggregated-apiserver"
 )
 
+// Options configures aggregated-apiserver bootstrap behavior.
+type Options struct {
+	// SecureServingPort used when Listener is nil. Default: DefaultSecureServingPort.
+	SecureServingPort int
+	// Listener allows tests to bind to 127.0.0.1:0.
+	Listener net.Listener
+	// CoderURL is an optional fallback URL when CoderControlPlane status has no URL.
+	CoderURL string
+	// CoderSessionToken is the admin session token.
+	CoderSessionToken string
+	// CoderRequestTimeout for SDK calls. Default 30s.
+	CoderRequestTimeout time.Duration
+}
+
 // NewScheme builds the runtime scheme used by the aggregated API server.
 func NewScheme() *runtime.Scheme {
 	scheme := runtime.NewScheme()
@@ -96,10 +114,17 @@ func NewRecommendedConfig(
 }
 
 // NewAPIGroupInfo creates APIGroupInfo for the aggregation.coder.com API group.
-func NewAPIGroupInfo(scheme *runtime.Scheme, codecs serializer.CodecFactory) (*genericapiserver.APIGroupInfo, error) {
+func NewAPIGroupInfo(
+	scheme *runtime.Scheme,
+	codecs serializer.CodecFactory,
+	provider coder.ClientProvider,
+) (*genericapiserver.APIGroupInfo, error) {
 	if scheme == nil {
 		return nil, fmt.Errorf("assertion failed: scheme must not be nil")
 	}
+	if provider == nil {
+		return nil, fmt.Errorf("assertion failed: coder client provider must not be nil")
+	}
 
 	parameterCodec := runtime.NewParameterCodec(scheme)
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(
@@ -109,8 +134,8 @@ func NewAPIGroupInfo(scheme *runtime.Scheme, codecs serializer.CodecFactory) (*g
 		codecs,
 	)
 	apiGroupInfo.VersionedResourcesStorageMap[aggregationv1alpha1.SchemeGroupVersion.Version] = map[string]rest.Storage{
-		"coderworkspaces": storage.NewWorkspaceStorage(),
-		"codertemplates":  storage.NewTemplateStorage(),
+		"coderworkspaces": storage.NewWorkspaceStorage(provider),
+		"codertemplates":  storage.NewTemplateStorage(provider),
 	}
 	return &apiGroupInfo, nil
 }
@@ -146,9 +171,48 @@ func NewGenericAPIServer(recommendedConfig *genericapiserver.RecommendedConfig)
 
 // Run starts the aggregated API server application mode.
 func Run(ctx context.Context) error {
+	return RunWithOptions(ctx, Options{})
+}
+
+// RunWithOptions starts the aggregated API server application mode.
+func RunWithOptions(ctx context.Context, opts Options) error {
 	if ctx == nil {
 		return fmt.Errorf("assertion failed: context must not be nil")
 	}
+	if opts.CoderURL == "" {
+		return fmt.Errorf("assertion failed: coder URL must not be empty")
+	}
+	if opts.CoderSessionToken == "" {
+		return fmt.Errorf("assertion failed: coder session token must not be empty")
+	}
+	if opts.CoderRequestTimeout < 0 {
+		return fmt.Errorf("assertion failed: coder request timeout must not be negative")
+	}
+
+	parsedCoderURL, err := url.Parse(opts.CoderURL)
+	if err != nil {
+		return fmt.Errorf("parse coder URL %q: %w", opts.CoderURL, err)
+	}
+	if parsedCoderURL == nil {
+		return fmt.Errorf("assertion failed: parsed coder URL must not be nil")
+	}
+
+	requestTimeout := opts.CoderRequestTimeout
+	if requestTimeout == 0 {
+		requestTimeout = 30 * time.Second
+	}
+
+	provider, err := coder.NewStaticClientProvider(coder.Config{
+		CoderURL:       parsedCoderURL,
+		SessionToken:   opts.CoderSessionToken,
+		RequestTimeout: requestTimeout,
+	})
+	if err != nil {
+		return fmt.Errorf("build coder client provider: %w", err)
+	}
+	if provider == nil {
+		return fmt.Errorf("assertion failed: coder client provider is nil after successful construction")
+	}
 
 	scheme := NewScheme()
 	if scheme == nil {
@@ -157,7 +221,18 @@ func Run(ctx context.Context) error {
 
 	codecs := serializer.NewCodecFactory(scheme)
 	secureServingOptions := genericoptions.NewSecureServingOptions()
-	secureServingOptions.BindPort = DefaultSecureServingPort
+	secureServingPort := opts.SecureServingPort
+	if secureServingPort == 0 {
+		secureServingPort = DefaultSecureServingPort
+	}
+	if secureServingPort < 0 {
+		return fmt.Errorf("assertion failed: secure serving port must not be negative")
+	}
+	secureServingOptions.BindPort = secureServingPort
+	if opts.Listener != nil {
+		secureServingOptions.Listener = opts.Listener
+		secureServingOptions.BindPort = 0
+	}
 	secureServingOptions.ServerCert.CertDirectory = ""
 	secureServingOptions.ServerCert.PairName = ""
 
@@ -171,7 +246,7 @@ func Run(ctx context.Context) error {
 		return err
 	}
 
-	apiGroupInfo, err := NewAPIGroupInfo(scheme, codecs)
+	apiGroupInfo, err := NewAPIGroupInfo(scheme, codecs, provider)
 	if err != nil {
 		return fmt.Errorf("build API group info: %w", err)
 	}

internal/app/apiserverapp/apiserverapp_test.go

@@ -4,13 +4,15 @@ import (
 	"context"
 	"net"
 	"net/http/httptest"
+	"net/url"
 	"testing"
 
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	genericoptions "k8s.io/apiserver/pkg/server/options"
 
 	aggregationv1alpha1 "github.com/coder/coder-k8s/api/aggregation/v1alpha1"
+	coderhelper "github.com/coder/coder-k8s/internal/aggregated/coder"
 )
 
 func TestNewSchemeRegistersAggregationKinds(t *testing.T) {
@@ -67,7 +69,19 @@ func TestInstallAPIGroupRegistersDiscovery(t *testing.T) {
 	}
 	defer server.Destroy()
 
-	apiGroupInfo, err := NewAPIGroupInfo(scheme, codecs)
+	coderURL, err := url.Parse("http://localhost:8080")
+	if err != nil {
+		t.Fatalf("parse test coder URL: %v", err)
+	}
+	provider, err := coderhelper.NewStaticClientProvider(coderhelper.Config{
+		CoderURL:     coderURL,
+		SessionToken: "test-session-token",
+	})
+	if err != nil {
+		t.Fatalf("build static client provider: %v", err)
+	}
+
+	apiGroupInfo, err := NewAPIGroupInfo(scheme, codecs, provider)
 	if err != nil {
 		t.Fatalf("build API group info: %v", err)
 	}

main_test.go

@@ -5,10 +5,12 @@ import (
 	"errors"
 	"strings"
 	"testing"
+	"time"
 
 	"k8s.io/apimachinery/pkg/runtime/schema"
 
 	coderv1alpha1 "github.com/coder/coder-k8s/api/v1alpha1"
+	"github.com/coder/coder-k8s/internal/app/apiserverapp"
 	"github.com/coder/coder-k8s/internal/app/controllerapp"
 	"github.com/coder/coder-k8s/internal/controller"
 )
@@ -102,15 +104,29 @@ func TestRunDispatchesAggregatedAPIServerMode(t *testing.T) {
 
 	expectedErr := errors.New("sentinel aggregated-apiserver error")
 	called := false
-	runAggregatedAPIServerApp = func(ctx context.Context) error {
+	runAggregatedAPIServerApp = func(ctx context.Context, opts apiserverapp.Options) error {
 		called = true
 		if ctx == nil {
 			t.Fatal("expected non-nil context passed to aggregated apiserver runner")
 		}
+		if got, want := opts.CoderURL, "https://coder.example.com"; got != want {
+			t.Fatalf("expected coder URL %q, got %q", want, got)
+		}
+		if got, want := opts.CoderSessionToken, "test-token"; got != want {
+			t.Fatalf("expected coder session token %q, got %q", want, got)
+		}
+		if got, want := opts.CoderRequestTimeout, 45*time.Second; got != want {
+			t.Fatalf("expected coder request timeout %v, got %v", want, got)
+		}
 		return expectedErr
 	}
 
-	err := run([]string{"--app=aggregated-apiserver"})
+	err := run([]string{
+		"--app=aggregated-apiserver",
+		"--coder-url=https://coder.example.com",
+		"--coder-session-token=test-token",
+		"--coder-request-timeout=45s",
+	})
 	if !called {
 		t.Fatal("expected aggregated apiserver runner to be called")
 	}