feat: support for containers routes to multi server

raghavyuva · raghavyuva · commit 228ae5e20e55 · 2025-12-11T14:58:16.000+05:30
diff --git a/api/api/versions.json b/api/api/versions.json
@@ -3,7 +3,7 @@
     {
       "version": "v1",
       "status": "active",
-      "release_date": "2025-12-11T14:46:46.935266+05:30",
+      "release_date": "2025-12-11T14:57:08.042103+05:30",
       "end_of_life": "0001-01-01T00:00:00Z",
       "changes": [
         "Initial API version"
diff --git a/api/internal/features/container/controller/get_container.go b/api/internal/features/container/controller/get_container.go
@@ -13,7 +13,7 @@ import (
 func (c *ContainerController) GetContainer(f fuego.ContextNoBody) (*shared_types.Response, error) {
 	containerID := f.PathParam("container_id")
 
-	containerInfo, err := c.dockerService.GetContainerById(containerID)
+	containerInfo, err := c.getDockerService(f.Request().Context()).GetContainerById(containerID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{
diff --git a/api/internal/features/container/controller/get_container_logs.go b/api/internal/features/container/controller/get_container_logs.go
@@ -23,7 +23,7 @@ func (c *ContainerController) GetContainerLogs(f fuego.ContextWithBody[types.Con
 		}
 	}
 
-	logsReader, err := c.dockerService.GetContainerLogs(req.ID, container.LogsOptions{
+	logsReader, err := c.getDockerService(f.Request().Context()).GetContainerLogs(req.ID, container.LogsOptions{
 		Follow:     req.Follow,
 		Tail:       strconv.Itoa(req.Tail),
 		Since:      req.Since,
diff --git a/api/internal/features/container/controller/init.go b/api/internal/features/container/controller/init.go
@@ -10,14 +10,14 @@ import (
 	"github.com/raghavyuva/nixopus-api/internal/features/notification"
 	shared_storage "github.com/raghavyuva/nixopus-api/internal/storage"
 	shared_types "github.com/raghavyuva/nixopus-api/internal/types"
+	"github.com/raghavyuva/nixopus-api/internal/utils"
 )
 
 type ContainerController struct {
-	store         *shared_storage.Store
-	dockerService *docker.DockerService
-	ctx           context.Context
-	logger        logger.Logger
-	notification  *notification.NotificationManager
+	store        *shared_storage.Store
+	ctx          context.Context
+	logger       logger.Logger
+	notification *notification.NotificationManager
 }
 
 func NewContainerController(
@@ -27,16 +27,22 @@ func NewContainerController(
 	notificationManager *notification.NotificationManager,
 ) *ContainerController {
 	return &ContainerController{
-		store:         store,
-		dockerService: docker.NewDockerService(),
-		ctx:           ctx,
-		logger:        l,
-		notification:  notificationManager,
+		store:        store,
+		ctx:          ctx,
+		logger:       l,
+		notification: notificationManager,
 	}
 }
 
-func (c *ContainerController) isProtectedContainer(containerID string, action string) (*shared_types.Response, bool) {
-	details, err := c.dockerService.GetContainerById(containerID)
+// getDockerService creates a DockerService using the active server from the database
+// It extracts the organization ID from the request context (set by supertokens middleware)
+func (c *ContainerController) getDockerService(ctx context.Context) *docker.DockerService {
+	organizationID := utils.GetOrganizationIDFromContext(ctx)
+	return docker.NewDockerServiceWithServer(c.store.DB, ctx, organizationID)
+}
+
+func (c *ContainerController) isProtectedContainer(ctx context.Context, containerID string, action string) (*shared_types.Response, bool) {
+	details, err := c.getDockerService(ctx).GetContainerById(containerID)
 	if err != nil {
 		return nil, false
 	}
diff --git a/api/internal/features/container/controller/list_containers.go b/api/internal/features/container/controller/list_containers.go
@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"context"
 	"net/http"
 	"sort"
 	"strconv"
@@ -19,7 +20,7 @@ func (c *ContainerController) ListContainers(fuegoCtx fuego.ContextNoBody) (*sha
 	params := parseContainerListParams(fuegoCtx.Request())
 
 	// Get pre-filtered summaries from Docker
-	containers, err := c.dockerService.ListContainers(container.ListOptions{
+	containers, err := c.getDockerService(fuegoCtx.Request().Context()).ListContainers(container.ListOptions{
 		All:     true,
 		Filters: buildDockerFilters(params),
 	})
@@ -34,7 +35,7 @@ func (c *ContainerController) ListContainers(fuegoCtx fuego.ContextNoBody) (*sha
 	rows := summarizeContainers(containers)
 	pageRows, totalCount := applySearchSortPaginate(rows, params)
 
-	result := c.appendContainerInfo(pageRows, containers)
+	result := c.appendContainerInfo(fuegoCtx.Request().Context(), pageRows, containers)
 
 	return &shared_types.Response{
 		Status:  "success",
@@ -186,10 +187,11 @@ func applySearchSortPaginate(rows []containertypes.ContainerListRow, p container
 	return rows[start:end], totalCount
 }
 
-func (c *ContainerController) appendContainerInfo(pageRows []containertypes.ContainerListRow, summaries []container.Summary) []containertypes.Container {
+func (c *ContainerController) appendContainerInfo(ctx context.Context, pageRows []containertypes.ContainerListRow, summaries []container.Summary) []containertypes.Container {
+	dockerService := c.getDockerService(ctx)
 	result := make([]containertypes.Container, 0, len(pageRows))
 	for _, r := range pageRows {
-		info, err := c.dockerService.GetContainerById(r.ID)
+		info, err := dockerService.GetContainerById(r.ID)
 		if err != nil {
 			c.logger.Log(logger.Error, "Error inspecting container", r.ID)
 			continue
diff --git a/api/internal/features/container/controller/list_images.go b/api/internal/features/container/controller/list_images.go
@@ -26,9 +26,10 @@ func (c *ContainerController) ListImages(f fuego.ContextWithBody[ListImagesReque
 		}
 	}
 
+	dockerService := c.getDockerService(f.Request().Context())
 	filterArgs := filters.NewArgs()
 	if req.ContainerID != "" {
-		_, err := c.dockerService.GetContainerById(req.ContainerID)
+		_, err := dockerService.GetContainerById(req.ContainerID)
 		if err != nil {
 			return nil, fuego.HTTPError{
 				Err:    err,
@@ -45,7 +46,7 @@ func (c *ContainerController) ListImages(f fuego.ContextWithBody[ListImagesReque
 		filterArgs.Add("reference", pattern)
 	}
 
-	images := c.dockerService.ListAllImages(image.ListOptions{
+	images := dockerService.ListAllImages(image.ListOptions{
 		All:     req.All,
 		Filters: filterArgs,
 	})
diff --git a/api/internal/features/container/controller/prune_build_cache.go b/api/internal/features/container/controller/prune_build_cache.go
@@ -22,7 +22,7 @@ func (c *ContainerController) PruneBuildCache(f fuego.ContextWithBody[PruneBuild
 			Status: http.StatusBadRequest,
 		}
 	}
-	err = c.dockerService.PruneBuildCache(types.BuildCachePruneOptions{
+	err = c.getDockerService(f.Request().Context()).PruneBuildCache(types.BuildCachePruneOptions{
 		All: req.All,
 	})
 	if err != nil {
diff --git a/api/internal/features/container/controller/prune_images.go b/api/internal/features/container/controller/prune_images.go
@@ -34,7 +34,7 @@ func (c *ContainerController) PruneImages(f fuego.ContextWithBody[PruneImagesReq
 		filterArgs.Add("dangling", "true")
 	}
 
-	pruneReport, err := c.dockerService.PruneImages(filterArgs)
+	pruneReport, err := c.getDockerService(f.Request().Context()).PruneImages(filterArgs)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{
diff --git a/api/internal/features/container/controller/remove_container.go b/api/internal/features/container/controller/remove_container.go
@@ -11,12 +11,13 @@ import (
 
 func (c *ContainerController) RemoveContainer(f fuego.ContextNoBody) (*shared_types.Response, error) {
 	containerID := f.PathParam("container_id")
+	ctx := f.Request().Context()
 
-	if resp, skipped := c.isProtectedContainer(containerID, "remove"); skipped {
+	if resp, skipped := c.isProtectedContainer(ctx, containerID, "remove"); skipped {
 		return resp, nil
 	}
 
-	err := c.dockerService.RemoveContainer(containerID, container.RemoveOptions{Force: true})
+	err := c.getDockerService(ctx).RemoveContainer(containerID, container.RemoveOptions{Force: true})
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{
diff --git a/api/internal/features/container/controller/restart_container.go b/api/internal/features/container/controller/restart_container.go
@@ -12,7 +12,7 @@ import (
 func (c *ContainerController) RestartContainer(f fuego.ContextNoBody) (*shared_types.Response, error) {
 	containerID := f.PathParam("container_id")
 
-	err := c.dockerService.RestartContainer(containerID, container.StopOptions{})
+	err := c.getDockerService(f.Request().Context()).RestartContainer(containerID, container.StopOptions{})
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{
diff --git a/api/internal/features/container/controller/start_container.go b/api/internal/features/container/controller/start_container.go
@@ -11,12 +11,13 @@ import (
 
 func (c *ContainerController) StartContainer(f fuego.ContextNoBody) (*shared_types.Response, error) {
 	containerID := f.PathParam("container_id")
+	ctx := f.Request().Context()
 
-	if resp, skipped := c.isProtectedContainer(containerID, "start"); skipped {
+	if resp, skipped := c.isProtectedContainer(ctx, containerID, "start"); skipped {
 		return resp, nil
 	}
 
-	err := c.dockerService.StartContainer(containerID, container.StartOptions{})
+	err := c.getDockerService(ctx).StartContainer(containerID, container.StartOptions{})
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{
diff --git a/api/internal/features/container/controller/stop_container.go b/api/internal/features/container/controller/stop_container.go
@@ -11,12 +11,13 @@ import (
 
 func (c *ContainerController) StopContainer(f fuego.ContextNoBody) (*shared_types.Response, error) {
 	containerID := f.PathParam("container_id")
+	ctx := f.Request().Context()
 
-	if resp, skipped := c.isProtectedContainer(containerID, "stop"); skipped {
+	if resp, skipped := c.isProtectedContainer(ctx, containerID, "stop"); skipped {
 		return resp, nil
 	}
 
-	err := c.dockerService.StopContainer(containerID, container.StopOptions{})
+	err := c.getDockerService(ctx).StopContainer(containerID, container.StopOptions{})
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{
diff --git a/api/internal/features/deploy/controller/init.go b/api/internal/features/deploy/controller/init.go
@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 
+	"github.com/google/uuid"
 	"github.com/raghavyuva/nixopus-api/internal/features/deploy/docker"
 	"github.com/raghavyuva/nixopus-api/internal/features/deploy/service"
 	"github.com/raghavyuva/nixopus-api/internal/features/deploy/storage"
@@ -38,7 +39,7 @@ func NewDeployController(
 	notificationManager *notification.NotificationManager,
 ) *DeployController {
 	storage := storage.DeployStorage{DB: store.DB, Ctx: ctx}
-	docker_repo := docker.NewDockerService()
+	docker_repo := docker.NewDockerServiceWithServer(store.DB, ctx, uuid.Nil)
 	github_service := github_service.NewGithubConnectorService(store, ctx, l, &github_storage.GithubConnectorStorage{DB: store.DB, Ctx: ctx})
 	taskService := tasks.NewTaskService(&storage, l, docker_repo, github_service, store)
 	taskService.SetupCreateDeploymentQueue()
diff --git a/api/internal/features/deploy/docker/init.go b/api/internal/features/deploy/docker/init.go
@@ -15,9 +15,12 @@ import (
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/api/types/volume"
 	"github.com/docker/docker/client"
+	"github.com/google/uuid"
 	v1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/raghavyuva/nixopus-api/internal/features/logger"
 	"github.com/raghavyuva/nixopus-api/internal/features/ssh"
+	"github.com/raghavyuva/nixopus-api/internal/utils"
+	"github.com/uptrace/bun"
 )
 
 type DockerService struct {
@@ -87,9 +90,17 @@ type DockerClient struct {
 }
 
 // NewDockerService creates a new instance of DockerService using the default docker client.
+// For server-specific SSH configuration, use NewDockerServiceWithServer instead.
 func NewDockerService() *DockerService {
+	return NewDockerServiceWithServer(nil, nil, uuid.Nil)
+}
+
+// NewDockerServiceWithServer creates a new instance of DockerService using server SSH configuration when available.
+// If db, ctx, and organizationID are provided, it will use the active server from the database.
+// Otherwise, it falls back to the default SSH configuration.
+func NewDockerServiceWithServer(db *bun.DB, ctx context.Context, organizationID uuid.UUID) *DockerService {
 	lgr := logger.NewLogger()
-	cli, tunnel := newDockerClientWithOptionalSSHTunnel(lgr)
+	cli, tunnel := newDockerClientWithOptionalSSHTunnel(lgr, db, ctx, organizationID)
 	svc := &DockerService{Cli: cli, Ctx: context.Background(), logger: lgr, sshTunnel: tunnel}
 
 	if !isClusterInitialized(svc.Cli) {
@@ -105,8 +116,30 @@ func NewDockerService() *DockerService {
 	return svc
 }
 
-func newDockerClientWithOptionalSSHTunnel(lgr logger.Logger) (*client.Client, *SSHTunnel) {
-	sshClient := ssh.NewSSH()
+func newDockerClientWithOptionalSSHTunnel(lgr logger.Logger, db *bun.DB, ctx context.Context, organizationID uuid.UUID) (*client.Client, *SSHTunnel) {
+	var sshClient *ssh.SSH
+
+	// Try to use server SSH configuration if db, ctx, and organizationID are available
+	if db != nil && ctx != nil {
+		// If organizationID is not provided, try to get it from context
+		if organizationID == uuid.Nil {
+			organizationID = utils.GetOrganizationIDFromContext(ctx)
+		}
+
+		// If we have organizationID, use server SSH configuration
+		if organizationID != uuid.Nil {
+			lgr.Log(logger.Info, "Using SSH with server configuration", fmt.Sprintf("organizationID: %s", organizationID.String()))
+			sshClient = ssh.NewSSHWithServer(db, ctx, organizationID)
+		} else {
+			lgr.Log(logger.Info, "No organization ID available, using default SSH config", "")
+			sshClient = ssh.NewSSH()
+		}
+	} else {
+		// Fall back to default SSH configuration
+		lgr.Log(logger.Info, "Using default SSH configuration", "")
+		sshClient = ssh.NewSSH()
+	}
+
 	// Try to create an SSH tunnel to the remote Docker daemon socket, if it fails, use the local docker socket
 	tunnel, err := CreateSSHTunnel(sshClient, lgr)
 	if err != nil || tunnel == nil {
diff --git a/api/internal/features/update/service/update_service.go b/api/internal/features/update/service/update_service.go
@@ -45,7 +45,7 @@ func NewUpdateService(storage *storage.App, logger *logger.Logger, ctx context.C
 		storage: storage,
 		logger:  logger,
 		ctx:     ctx,
-		docker:  docker.NewDockerService(),
+		docker:  docker.NewDockerServiceWithServer(storage.Store.DB, ctx, uuid.Nil),
 		env:     getEnvironment(),
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`{`
`4`	`4`	`"version": "v1",`
`5`	`5`	`"status": "active",`
`6`		`- "release_date": "2025-12-11T14:46:46.935266+05:30",`
	`6`	`+ "release_date": "2025-12-11T14:57:08.042103+05:30",`
`7`	`7`	`"end_of_life": "0001-01-01T00:00:00Z",`
`8`	`8`	`"changes": [`
`9`	`9`	`"Initial API version"`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ func (c *ContainerController) GetContainerLogs(f fuego.ContextWithBody[types.Con`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`		`- logsReader, err := c.dockerService.GetContainerLogs(req.ID, container.LogsOptions{`
	`26`	`+ logsReader, err := c.getDockerService(f.Request().Context()).GetContainerLogs(req.ID, container.LogsOptions{`
`27`	`27`	`Follow: req.Follow,`
`28`	`28`	`Tail: strconv.Itoa(req.Tail),`
`29`	`29`	`Since: req.Since,`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,10 @@ func (c *ContainerController) ListImages(f fuego.ContextWithBody[ListImagesReque`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
	`29`	`+ dockerService := c.getDockerService(f.Request().Context())`
`29`	`30`	`filterArgs := filters.NewArgs()`
`30`	`31`	`if req.ContainerID != "" {`
`31`		`- _, err := c.dockerService.GetContainerById(req.ContainerID)`
	`32`	`+ _, err := dockerService.GetContainerById(req.ContainerID)`
`32`	`33`	`if err != nil {`
`33`	`34`	`return nil, fuego.HTTPError{`
`34`	`35`	`Err: err,`
`@@ -45,7 +46,7 @@ func (c *ContainerController) ListImages(f fuego.ContextWithBody[ListImagesReque`
`45`	`46`	`filterArgs.Add("reference", pattern)`
`46`	`47`	`}`
`47`	`48`
`48`		`- images := c.dockerService.ListAllImages(image.ListOptions{`
	`49`	`+ images := dockerService.ListAllImages(image.ListOptions{`
`49`	`50`	`All: req.All,`
`50`	`51`	`Filters: filterArgs,`
`51`	`52`	`})`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func (c *ContainerController) PruneBuildCache(f fuego.ContextWithBody[PruneBuild`
`22`	`22`	`Status: http.StatusBadRequest,`
`23`	`23`	`}`
`24`	`24`	`}`
`25`		`- err = c.dockerService.PruneBuildCache(types.BuildCachePruneOptions{`
	`25`	`+ err = c.getDockerService(f.Request().Context()).PruneBuildCache(types.BuildCachePruneOptions{`
`26`	`26`	`All: req.All,`
`27`	`27`	`})`
`28`	`28`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ func (c *ContainerController) PruneImages(f fuego.ContextWithBody[PruneImagesReq`
`34`	`34`	`filterArgs.Add("dangling", "true")`
`35`	`35`	`}`
`36`	`36`
`37`		`- pruneReport, err := c.dockerService.PruneImages(filterArgs)`
	`37`	`+ pruneReport, err := c.getDockerService(f.Request().Context()).PruneImages(filterArgs)`
`38`	`38`	`if err != nil {`
`39`	`39`	`c.logger.Log(logger.Error, err.Error(), "")`
`40`	`40`	`return nil, fuego.HTTPError{`