Add idle container support (scale-to-zero)

internal/cmd/deploy.go

@@ -52,6 +52,9 @@ func newDeployCommand() *deployCommand {
 	deployCommand.cmd.Flags().DurationVar(&deployCommand.args.ServiceOptions.WriterAffinityTimeout, "writer-affinity-timeout", server.DefaultWriterAffinityTimeout, "Time after a write before read requests will be routed to readers")
 	deployCommand.cmd.Flags().BoolVar(&deployCommand.args.ServiceOptions.ReadTargetsAcceptWebsockets, "read-target-websockets", false, "Route WebSocket traffic to read targets, when available")
 
+	deployCommand.cmd.Flags().DurationVar(&deployCommand.args.ServiceOptions.IdleTimeout, "idle-timeout", 0, "Stop container after this duration of inactivity (0 to disable)")
+	deployCommand.cmd.Flags().DurationVar(&deployCommand.args.ServiceOptions.IdleWakeTimeout, "idle-wake-timeout", server.DefaultIdleWakeTimeout, "Max time to hold request while waking container")
+
 	deployCommand.cmd.Flags().DurationVar(&deployCommand.args.TargetOptions.ResponseTimeout, "target-timeout", server.DefaultTargetTimeout, "Maximum time to wait for the target server to respond when serving requests")
 
 	deployCommand.cmd.Flags().BoolVar(&deployCommand.args.TargetOptions.BufferRequests, "buffer-requests", false, "Buffer requests before forwarding to target")

internal/cmd/run.go

@@ -29,14 +29,15 @@ func newRunCommand() *runCommand {
 	runCommand.cmd.Flags().IntVar(&globalConfig.HttpsPort, "https-port", getEnvInt("HTTPS_PORT", server.DefaultHttpsPort), "Port to serve HTTPS traffic on")
 	runCommand.cmd.Flags().IntVar(&globalConfig.MetricsPort, "metrics-port", getEnvInt("METRICS_PORT", 0), "Publish metrics on the specified port (default zero to disable)")
 	runCommand.cmd.Flags().BoolVar(&globalConfig.HTTP3Enabled, "http3", false, "Enable HTTP/3")
+	runCommand.cmd.Flags().StringVar(&globalConfig.DockerSocketPath, "docker-socket", getEnvString("DOCKER_SOCKET", server.DefaultDockerSocketPath), "Path to Docker socket")
 
 	return runCommand
 }
 
 func (c *runCommand) run(cmd *cobra.Command, args []string) error {
 	c.setLogger()
 
-	router := server.NewRouter(globalConfig.StatePath())
+	router := server.NewRouter(globalConfig.StatePath(), globalConfig.DockerSocketPath)
 	router.RestoreLastSavedState()
 
 	s := server.NewServer(&globalConfig, router)

internal/server/config.go

@@ -10,6 +10,7 @@ import (
 const (
 	DefaultHttpPort  = 80
 	DefaultHttpsPort = 443
+	DefaultDockerSocketPath = "/var/run/docker.sock"
 )
 
 type Config struct {
@@ -20,6 +21,7 @@ type Config struct {
 	HTTP3Enabled bool
 
 	AlternateConfigDir string
+	DockerSocketPath   string
 }
 
 func (c Config) SocketPath() string {

internal/server/docker_client.go

@@ -0,0 +1,64 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+)
+
+type DockerClient struct {
+	httpClient *http.Client
+}
+
+func NewDockerClient(socketPath string) *DockerClient {
+	return &DockerClient{
+		httpClient: &http.Client{
+			Transport: &http.Transport{
+				DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+					return (&net.Dialer{}).DialContext(ctx, "unix", socketPath)
+				},
+			},
+		},
+	}
+}
+
+func (c *DockerClient) StopContainer(ctx context.Context, name string) error {
+	url := fmt.Sprintf("http://localhost/v1.41/containers/%s/stop", name)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, nil)
+	if err != nil {
+		return err
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusNotModified {
+		return fmt.Errorf("unexpected status code from docker stop: %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+func (c *DockerClient) StartContainer(ctx context.Context, name string) error {
+	url := fmt.Sprintf("http://localhost/v1.41/containers/%s/start", name)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, nil)
+	if err != nil {
+		return err
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusNotModified {
+		return fmt.Errorf("unexpected status code from docker start: %d", resp.StatusCode)
+	}
+
+	return nil
+}

internal/server/docker_client_test.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDockerClient_StopStart(t *testing.T) {
+	stopCalled := false
+	startCalled := false
+
+	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/v1.41/containers/test-container/stop" {
+			stopCalled = true
+			w.WriteHeader(http.StatusNoContent)
+		} else if r.URL.Path == "/v1.41/containers/test-container/start" {
+			startCalled = true
+			w.WriteHeader(http.StatusNoContent)
+		}
+	}))
+
+	socketPath := t.TempDir() + "/docker.sock"
+	l, err := net.Listen("unix", socketPath)
+	require.NoError(t, err)
+	server.Listener = l
+	server.Start()
+	defer server.Close()
+
+	client := NewDockerClient(socketPath)
+
+	err = client.StopContainer(context.Background(), "test-container")
+	assert.NoError(t, err)
+	assert.True(t, stopCalled)
+
+	err = client.StartContainer(context.Background(), "test-container")
+	assert.NoError(t, err)
+	assert.True(t, startCalled)
+}