Skip to content

Modern Docker Management, Designed for Everyone

fix: correct swarm resource scoping and stack deploy conformance (#3385)

Kyle Mendell03298d5166cf
diff --git a/backend/api/handlers/swarm.go b/backend/api/handlers/swarm.go
index 833007833..ef598da66 100644
--- a/backend/api/handlers/swarm.go
+++ b/backend/api/handlers/swarm.go
@@ -486,16 +486,6 @@ type CreateSwarmConfigOutput struct {
Body base.ApiResponse[swarmtypes.ConfigSummary]
}
-type UpdateSwarmConfigInput struct {
- EnvironmentID string `path:"id" doc:"Environment ID"`
- ConfigID string `path:"configId" doc:"Config ID"`
- Body swarmtypes.ConfigUpdateRequest
-}
-
-type UpdateSwarmConfigOutput struct {
- Status int `status:"204"`
-}
-
type DeleteSwarmConfigInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ConfigID string `path:"configId" doc:"Config ID"`
@@ -531,16 +521,6 @@ type CreateSwarmSecretOutput struct {
Body base.ApiResponse[swarmtypes.SecretSummary]
}
-type UpdateSwarmSecretInput struct {
- EnvironmentID string `path:"id" doc:"Environment ID"`
- SecretID string `path:"secretId" doc:"Secret ID"`
- Body swarmtypes.SecretUpdateRequest
-}
-
-type UpdateSwarmSecretOutput struct {
- Status int `status:"204"`
-}
-
type DeleteSwarmSecretInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
SecretID string `path:"secretId" doc:"Secret ID"`
@@ -590,7 +570,7 @@ func RegisterSwarm(api huma.API, swarmSvc *services.SwarmService, environmentSvc
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "promote-swarm-node", Method: http.MethodPost, Path: "/environments/{id}/swarm/nodes/{nodeId}/promote", Summary: "Promote swarm node", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmNodes, h.PromoteNode)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "demote-swarm-node", Method: http.MethodPost, Path: "/environments/{id}/swarm/nodes/{nodeId}/demote", Summary: "Demote swarm node", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmNodes, h.DemoteNode)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "list-swarm-node-tasks", Method: http.MethodGet, Path: "/environments/{id}/swarm/nodes/{nodeId}/tasks", Summary: "List tasks for a swarm node", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.ListNodeTasks)
- huma.Register(api, huma.Operation{OperationID: "get-swarm-node-identity", Method: http.MethodGet, Path: "/swarm/node-identity", Summary: "Get local swarm node identity", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal(), Middlewares: humamw.RequirePermission(api, authz.PermSwarmRead)}, h.GetNodeIdentity)
+ humamw.RegisterWithPermission(api, huma.Operation{OperationID: "get-swarm-node-identity", Method: http.MethodGet, Path: "/swarm/node-identity", Summary: "Get local swarm node identity", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.GetNodeIdentity)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "list-swarm-tasks", Method: http.MethodGet, Path: "/environments/{id}/swarm/tasks", Summary: "List swarm tasks", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.ListTasks)
@@ -620,13 +600,11 @@ func RegisterSwarm(api huma.API, swarmSvc *services.SwarmService, environmentSvc
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "list-swarm-configs", Method: http.MethodGet, Path: "/environments/{id}/swarm/configs", Summary: "List swarm configs", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.ListConfigs)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "get-swarm-config", Method: http.MethodGet, Path: "/environments/{id}/swarm/configs/{configId}", Summary: "Get swarm config", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.GetConfig)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "create-swarm-config", Method: http.MethodPost, Path: "/environments/{id}/swarm/configs", Summary: "Create swarm config", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmConfigs, h.CreateConfig)
- humamw.RegisterWithPermission(api, huma.Operation{OperationID: "update-swarm-config", Method: http.MethodPut, Path: "/environments/{id}/swarm/configs/{configId}", Summary: "Update swarm config", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmConfigs, h.UpdateConfig)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "delete-swarm-config", Method: http.MethodDelete, Path: "/environments/{id}/swarm/configs/{configId}", Summary: "Delete swarm config", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmConfigs, h.DeleteConfig)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "list-swarm-secrets", Method: http.MethodGet, Path: "/environments/{id}/swarm/secrets", Summary: "List swarm secrets", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.ListSecrets)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "get-swarm-secret", Method: http.MethodGet, Path: "/environments/{id}/swarm/secrets/{secretId}", Summary: "Get swarm secret", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmRead, h.GetSecret)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "create-swarm-secret", Method: http.MethodPost, Path: "/environments/{id}/swarm/secrets", Summary: "Create swarm secret", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmSecrets, h.CreateSecret)
- humamw.RegisterWithPermission(api, huma.Operation{OperationID: "update-swarm-secret", Method: http.MethodPut, Path: "/environments/{id}/swarm/secrets/{secretId}", Summary: "Update swarm secret", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmSecrets, h.UpdateSecret)
humamw.RegisterWithPermission(api, huma.Operation{OperationID: "delete-swarm-secret", Method: http.MethodDelete, Path: "/environments/{id}/swarm/secrets/{secretId}", Summary: "Delete swarm secret", Tags: []string{"Swarm"}, Security: defaultOperationSecurityInternal()}, authz.PermSwarmSecrets, h.DeleteSecret)
}
@@ -1342,7 +1320,7 @@ func (h *SwarmHandler) ListStackTasks(ctx context.Context, input *ListSwarmStack
// Returns the rendered compose content together with discovered resource names.
// Returns a mapped HTTP error when parsing, interpolation, or rendering fails.
func (h *SwarmHandler) RenderStackConfig(ctx context.Context, input *RenderSwarmStackConfigInput) (*RenderSwarmStackConfigOutput, error) {
- resp, err := h.swarmService.RenderStackConfig(ctx, input.Body)
+ resp, err := h.swarmService.RenderStackConfig(ctx, input.EnvironmentID, input.Body)
if err != nil {
return nil, mapSwarmServiceError(err, "Failed to render swarm stack config")
}
@@ -1715,25 +1693,6 @@ func (h *SwarmHandler) CreateConfig(ctx context.Context, input *CreateSwarmConfi
return &CreateSwarmConfigOutput{Body: base.ApiResponse[swarmtypes.ConfigSummary]{Success: true, Data: *cfg}}, nil
}
-// UpdateConfig rejects updates to an existing swarm config.
-//
-// It requires admin privileges and delegates the update request to the swarm
-// service. Docker swarm configs are immutable, so the current service behavior
-// returns a mapped validation error instead of a replacement config.
-//
-// ctx carries request-scoped cancellation, auth, and audit context.
-// input identifies the config to update and contains the replacement specification.
-//
-// Returns no content if a future service implementation completes the update.
-// Returns an authorization error for non-admin callers or mapped HTTP errors
-// when the update fails.
-func (h *SwarmHandler) UpdateConfig(ctx context.Context, input *UpdateSwarmConfigInput) (*UpdateSwarmConfigOutput, error) {
- if err := h.swarmService.UpdateConfig(ctx, input.ConfigID, input.Body); err != nil {
- return nil, mapSwarmServiceError(err, "Failed to update swarm config")
- }
- return &UpdateSwarmConfigOutput{}, nil
-}
-
// DeleteConfig removes a swarm config.
//
// It requires admin privileges, delegates removal to the swarm service, maps
@@ -1825,25 +1784,6 @@ func (h *SwarmHandler) CreateSecret(ctx context.Context, input *CreateSwarmSecre
return &CreateSwarmSecretOutput{Body: base.ApiResponse[swarmtypes.SecretSummary]{Success: true, Data: *secret}}, nil
}
-// UpdateSecret rejects updates to an existing swarm secret.
-//
-// It requires admin privileges and delegates the update request to the swarm
-// service. Docker swarm secrets are immutable, so the current service behavior
-// returns a mapped validation error instead of a replacement secret.
-//
-// ctx carries request-scoped cancellation, auth, and audit context.
-// input identifies the secret to update and contains the replacement specification.
-//
-// Returns no content if a future service implementation completes the update.
-// Returns an authorization error for non-admin callers or mapped HTTP errors
-// when the update fails.
-func (h *SwarmHandler) UpdateSecret(ctx context.Context, input *UpdateSwarmSecretInput) (*UpdateSwarmSecretOutput, error) {
- if err := h.swarmService.UpdateSecret(ctx, input.SecretID, input.Body); err != nil {
- return nil, mapSwarmServiceError(err, "Failed to update swarm secret")
- }
- return &UpdateSwarmSecretOutput{}, nil
-}
-
// DeleteSecret removes a swarm secret.
//
// It requires admin privileges, delegates removal to the swarm service, maps
@@ -1953,7 +1893,7 @@ func mapSwarmServiceError(err error, fallback string) error {
if errors.Is(err, common.ErrSwarmManagerRequired) {
return huma.Error403Forbidden("Swarm manager access required")
}
- if errors.Is(err, common.ErrSwarmConfigImmutable) || errors.Is(err, common.ErrSwarmSecretImmutable) {
+ if errors.Is(err, common.ErrBadRequest) {
return huma.Error400BadRequest(err.Error())
}
if errdefs.IsNotFound(err) {
@@ -1966,7 +1906,7 @@ func mapSwarmServiceError(err error, fallback string) error {
return huma.Error409Conflict(err.Error())
}
errText := strings.ToLower(err.Error())
- if strings.Contains(errText, "required") || strings.Contains(errText, "invalid") || strings.Contains(errText, "immutable") {
+ if strings.Contains(errText, "required") || strings.Contains(errText, "invalid") {
return huma.Error400BadRequest(err.Error())
}
return huma.Error500InternalServerError(fallback)
diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.go
index a5a281e1a..fefde84f6 100644
--- a/backend/internal/common/errors.go
+++ b/backend/internal/common/errors.go
@@ -67,8 +67,6 @@ var (
ErrGlobalVariableSecretValueRequired = Classify(ErrValidation, errors.Sentinel("A new value is required when making a secret variable readable"))
ErrSwarmNotEnabled = Classify(ErrBadRequest, errors.Sentinel("Swarm mode is not enabled"))
ErrSwarmManagerRequired = Classify(ErrForbidden, errors.Sentinel("Swarm manager access required"))
- ErrSwarmConfigImmutable = Classify(ErrConflict, errors.Sentinel("Swarm configs are immutable; create a new config and update services to use it"))
- ErrSwarmSecretImmutable = Classify(ErrConflict, errors.Sentinel("Swarm secrets are immutable; create a new secret and update services to use it"))
ErrRoleNotFound = Classify(ErrNotFound, errors.Sentinel("Role not found"))
ErrRoleBuiltIn = Classify(ErrForbidden, errors.Sentinel("Built-in role cannot be modified"))
ErrRoleNameTaken = Classify(ErrConflict, errors.Sentinel("Role name already in use"))
diff --git a/backend/internal/services/gitops_sync_service.go b/backend/internal/services/gitops_sync_service.go
index 5aef45f0b..4cdae98a0 100644
--- a/backend/internal/services/gitops_sync_service.go
+++ b/backend/internal/services/gitops_sync_service.go
@@ -26,6 +26,7 @@ import (
projecttypes "github.com/getarcaneapp/arcane/types/v2/project"
schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler"
"github.com/getarcaneapp/arcane/types/v2/swarm"
+ "github.com/moby/moby/client"
"github.com/samber/mo"
"gorm.io/gorm"
)
@@ -2310,7 +2311,16 @@ func (s *GitOpsSyncService) validateDirectorySyncStageInternal(ctx context.Conte
return 0, err
}
- pathMapper := s.projectService.getPathMapperInternal(ctx)
+ var dockerClient *client.Client
+ if s.projectService.dockerService != nil {
+ dockerClient, _ = s.projectService.dockerService.GetClient(ctx)
+ }
+ pathMapper := projects.NewPathMapperForConfiguredDirectory(
+ ctx,
+ s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"),
+ "/app/data/projects",
+ dockerClient,
+ )
autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
project, err := projects.LoadComposeProjectLenient(
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 157d3297e..75ea7a51a 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -136,59 +136,6 @@ func (s *ProjectService) composeRegistryAuthConfigsInternal(ctx context.Context)
return authConfigs
}
-func (s *ProjectService) getPathMapperInternal(ctx context.Context) *projects.PathMapper {
- configuredPath := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
-
- var containerDir, hostDir string
-
- // Handle mapping format: "container_path:host_path"
- if parts := strings.SplitN(configuredPath, ":", 2); len(parts) == 2 {
- // Only treat as mapping if first part is absolute Linux path (not Windows drive)
- if !projects.IsWindowsDrivePath(configuredPath) && strings.HasPrefix(parts[0], "/") {
- containerDir = parts[0]
- hostDir = parts[1]
- }
- }
-
- if containerDir == "" {
- containerDir = configuredPath
- }
-
- // Resolve container directory to absolute path
- containerDirResolved, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(containerDir))
- if err != nil {
- slog.WarnContext(ctx, "unable to resolve container projects directory, using default", "error", err)
- containerDirResolved = "/app/data/projects"
- }
-
- // Explicit "container:host" mapping: honor the user-declared prefix directly.
- if strings.TrimSpace(hostDir) != "" {
- hostDirResolved := filepath.Clean(strings.TrimSpace(hostDir))
- pm := projects.NewPathMapper(containerDirResolved, hostDirResolved)
- if !pm.IsNonMatchingMount() {
- return nil
- }
- return pm
- }
-
- // Auto-discovery: resolve each bind-mount source against Arcane's real container
- // mount table (longest-prefix match) so independently bind-mounted project
- // directories map to their own host path instead of a single projects-root prefix.
- if s.dockerService != nil {
- if dockerCli, derr := s.dockerService.GetClient(ctx); derr == nil {
- if mounts, merr := projects.GetCurrentContainerMounts(ctx, dockerCli); merr == nil && len(mounts) > 0 {
- pm := projects.NewPathMapperFromMounts(mounts)
- if !pm.IsNonMatchingMount() {
- return nil
- }
- return pm
- }
- }
- }
-
- return nil
-}
-
func (s *ProjectService) getProjectsDirectoryInternal(ctx context.Context) (string, error) {
projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
projectsDir, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
@@ -495,7 +442,16 @@ func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Contex
}
projectsDirectory := s.getProjectsDirectoryOrDefaultInternal(ctx, cfg)
- pathMapper := s.getPathMapperInternal(ctx)
+ var dockerClient *client.Client
+ if s.dockerService != nil {
+ dockerClient, _ = s.dockerService.GetClient(ctx)
+ }
+ pathMapper := projects.NewPathMapperForConfiguredDirectory(
+ ctx,
+ s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"),
+ "/app/data/projects",
+ dockerClient,
+ )
composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, projects.NormalizeProjectName(proj.Name), projectsDirectory, utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false), pathMapper)
if loadErr != nil {
@@ -2818,7 +2774,16 @@ func (s *ProjectService) RestartProject(ctx context.Context, projectID string, s
cfg := s.settingsService.GetSettingsOrDefaults(ctx)
projectsDirectory := s.getProjectsDirectoryOrDefaultInternal(ctx, cfg)
- pathMapper := s.getPathMapperInternal(ctx)
+ var dockerClient *client.Client
+ if s.dockerService != nil {
+ dockerClient, _ = s.dockerService.GetClient(ctx)
+ }
+ pathMapper := projects.NewPathMapperForConfiguredDirectory(
+ ctx,
+ s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"),
+ "/app/data/projects",
+ dockerClient,
+ )
compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, projects.NormalizeProjectName(proj.Name), projectsDirectory, utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false), pathMapper)
if lerr != nil {
@@ -4906,7 +4871,16 @@ func (s *ProjectService) loadComposeMetadataForSyncInternal(ctx context.Context,
return meta, pErr
}
- pathMapper := s.getPathMapperInternal(ctx)
+ var dockerClient *client.Client
+ if s.dockerService != nil {
+ dockerClient, _ = s.dockerService.GetClient(ctx)
+ }
+ pathMapper := projects.NewPathMapperForConfiguredDirectory(
+ ctx,
+ s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"),
+ "/app/data/projects",
+ dockerClient,
+ )
autoInjectEnv := utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false)
diff --git a/backend/internal/services/swarm_service.go b/backend/internal/services/swarm_service.go
index 418fb20e1..a455d26c5 100644
--- a/backend/internal/services/swarm_service.go
+++ b/backend/internal/services/swarm_service.go
@@ -34,7 +34,6 @@ import (
"github.com/moby/moby/api/types/system"
dockerclient "github.com/moby/moby/client"
"github.com/samber/hot"
- "go.getarcane.app/sys/atomic"
"golang.org/x/sync/errgroup"
)
@@ -1272,7 +1271,12 @@ func (s *SwarmService) DeployStack(ctx context.Context, environmentID string, re
workingDir = stackSourceDir
}
- pm := s.getPathMapperInternal(ctx)
+ pm := appfs.NewPathMapperForConfiguredDirectory(
+ ctx,
+ s.settingsService.GetStringSetting(ctx, "swarmStackSourcesDirectory", defaultSwarmStackSourceRootDir),
+ defaultSwarmStackSourceRootDir,
+ dockerClient,
+ )
if err := libswarm.DeployStack(ctx, dockerClient, libswarm.StackDeployOptions{
Name: stackName,
@@ -1291,7 +1295,7 @@ func (s *SwarmService) DeployStack(ctx context.Context, environmentID string, re
WorkingDir: workingDir,
PathMapper: pm,
}); err != nil {
- return nil, err
+ return nil, classifySwarmStackErrorInternal(err)
}
return &swarmtypes.StackDeployResponse{Name: stackName}, nil
@@ -1931,22 +1935,20 @@ func (s *SwarmService) RemoveStack(ctx context.Context, environmentID, stackName
return err
}
if len(services) == 0 {
- return s.removeSourceOnlyStackInternal(ctx, environmentID, stackName)
- }
-
- if err := s.removeStackServicesInternal(ctx, dockerClient, services); err != nil {
- return err
+ if _, err := s.getPersistedStackSourceSummaryInternal(ctx, environmentID, stackName); err != nil {
+ if cerrdefs.IsNotFound(err) {
+ return cerrdefs.ErrNotFound
+ }
+ return err
+ }
+ } else {
+ if err := s.removeStackServicesInternal(ctx, dockerClient, services); err != nil {
+ return err
+ }
}
- stackLabel := fmt.Sprintf("%s=%s", swarmtypes.StackNamespaceLabel, stackName)
- if err := s.removeStackConfigsInternal(ctx, dockerClient, stackLabel); err != nil {
- return err
- }
- if err := s.removeStackSecretsInternal(ctx, dockerClient, stackLabel); err != nil {
- return err
- }
- if err := s.removeStackNetworksInternal(ctx, dockerClient, stackLabel); err != nil {
- return err
+ if err := libswarm.RemoveStackResources(ctx, dockerClient, stackName); err != nil {
+ return classifySwarmStackErrorInternal(err)
}
if err := s.deleteStackSourceInternal(ctx, environmentID, stackName); err != nil {
@@ -1956,17 +1958,6 @@ func (s *SwarmService) RemoveStack(ctx context.Context, environmentID, stackName
return nil
}
-func (s *SwarmService) removeSourceOnlyStackInternal(ctx context.Context, environmentID, stackName string) error {
- if _, err := s.getPersistedStackSourceSummaryInternal(ctx, environmentID, stackName); err != nil {
- if cerrdefs.IsNotFound(err) {
- return cerrdefs.ErrNotFound
- }
- return err
- }
-
- return s.deleteStackSourceInternal(ctx, environmentID, stackName)
-}
-
func (s *SwarmService) removeStackServicesInternal(ctx context.Context, dockerClient *dockerclient.Client, services []swarm.Service) error {
serviceIDs := make(map[string]struct{}, len(services))
for _, service := range services {
@@ -1983,54 +1974,6 @@ func (s *SwarmService) removeStackServicesInternal(ctx context.Context, dockerCl
return nil
}
-func (s *SwarmService) removeStackConfigsInternal(ctx context.Context, dockerClient *dockerclient.Client, stackLabel string) error {
- configFilter := make(dockerclient.Filters).Add("label", stackLabel)
- configsResult, err := dockerClient.ConfigList(ctx, dockerclient.ConfigListOptions{Filters: configFilter})
- if err != nil {
- return errors.WrapIf(err, "failed to list stack configs")
- }
- for _, cfg := range configsResult.Items {
- if _, err := dockerClient.ConfigRemove(ctx, cfg.ID, dockerclient.ConfigRemoveOptions{}); err != nil && !cerrdefs.IsNotFound(err) {
- return errors.WrapIff(err, "failed to remove stack config %s", cfg.Spec.Name)
- }
- }
-
- return nil
-}
-
-func (s *SwarmService) removeStackSecretsInternal(ctx context.Context, dockerClient *dockerclient.Client, stackLabel string) error {
- secretFilter := make(dockerclient.Filters).Add("label", stackLabel)
- secretsResult, err := dockerClient.SecretList(ctx, dockerclient.SecretListOptions{Filters: secretFilter})
- if err != nil {
- return errors.WrapIf(err, "failed to list stack secrets")
- }
- for _, secret := range secretsResult.Items {
- if _, err := dockerClient.SecretRemove(ctx, secret.ID, dockerclient.SecretRemoveOptions{}); err != nil && !cerrdefs.IsNotFound(err) {
- return errors.WrapIff(err, "failed to remove stack secret %s", secret.Spec.Name)
- }
- }
-
- return nil
-}
-
-func (s *SwarmService) removeStackNetworksInternal(ctx context.Context, dockerClient *dockerclient.Client, stackLabel string) error {
- networkFilter := make(dockerclient.Filters).Add("label", stackLabel)
- networksResult, err := dockerClient.NetworkList(ctx, dockerclient.NetworkListOptions{Filters: networkFilter})
- if err != nil {
- return errors.WrapIf(err, "failed to list stack networks")
- }
- for _, network := range networksResult.Items {
- if network.Ingress {
- continue
- }
- if _, err := dockerClient.NetworkRemove(ctx, network.ID, dockerclient.NetworkRemoveOptions{}); err != nil && !cerrdefs.IsNotFound(err) {
- return errors.WrapIff(err, "failed to remove stack network %s", network.Name)
- }
- }
-
- return nil
-}
-
func (s *SwarmService) ListStackServicesPaginated(ctx context.Context, stackName string, params pagination.QueryParams) ([]swarmtypes.ServiceSummary, pagination.Response, error) {
if err := s.ensureSwarmManagerInternal(ctx); err != nil {
return nil, pagination.Response{}, err
@@ -2086,22 +2029,36 @@ func (s *SwarmService) ListStackTasksPaginated(ctx context.Context, stackName st
return s.listTasksPaginatedWithFiltersInternal(ctx, filters, params)
}
-func (s *SwarmService) RenderStackConfig(ctx context.Context, req swarmtypes.StackRenderConfigRequest) (*swarmtypes.StackRenderConfigResponse, error) {
+func (s *SwarmService) RenderStackConfig(ctx context.Context, environmentID string, req swarmtypes.StackRenderConfigRequest) (*swarmtypes.StackRenderConfigResponse, error) {
if err := s.ensureSwarmManagerInternal(ctx); err != nil {
return nil, err
}
- pm := s.getPathMapperInternal(ctx)
+ _, stackSourceDir, err := s.resolveSwarmStackSourceDirInternal(ctx, environmentID, req.Name)
+ if err != nil {
+ return nil, err
+ }
+ dockerClient, err := s.dockerService.GetClient(ctx)
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to connect to Docker")
+ }
+ pm := appfs.NewPathMapperForConfiguredDirectory(
+ ctx,
+ s.settingsService.GetStringSetting(ctx, "swarmStackSourcesDirectory", defaultSwarmStackSourceRootDir),
+ defaultSwarmStackSourceRootDir,
+ dockerClient,
+ )
result, err := libswarm.RenderStackConfig(ctx, libswarm.StackRenderOptions{
Name: req.Name,
ComposeContent: req.ComposeContent,
OverrideContent: req.OverrideContent,
EnvContent: req.EnvContent,
+ WorkingDir: stackSourceDir,
PathMapper: pm,
})
if err != nil {
- return nil, err
+ return nil, classifySwarmStackErrorInternal(err)
}
return &swarmtypes.StackRenderConfigResponse{
@@ -2115,6 +2072,13 @@ func (s *SwarmService) RenderStackConfig(ctx context.Context, req swarmtypes.Sta
}, nil
}
+func classifySwarmStackErrorInternal(err error) error {
+ if errors.Is(err, libswarm.ErrInvalidStack) {
+ return common.Classify(common.ErrBadRequest, err)
+ }
+ return err
+}
+
func (s *SwarmService) ListConfigs(ctx context.Context) ([]swarmtypes.ConfigSummary, error) {
if err := s.ensureSwarmManagerInternal(ctx); err != nil {
return nil, err
@@ -2178,12 +2142,6 @@ func (s *SwarmService) CreateConfig(ctx context.Context, req swarmtypes.ConfigCr
return s.GetConfig(ctx, createResult.ID)
}
-func (s *SwarmService) UpdateConfig(ctx context.Context, configID string, req swarmtypes.ConfigUpdateRequest) error {
- _ = configID
- _ = req
- return common.Classify(common.ErrSwarmConfigImmutable, errors.New("Swarm configs are immutable; create a new config and update services to use it"))
-}
-
func (s *SwarmService) RemoveConfig(ctx context.Context, configID string) error {
if err := s.ensureSwarmManagerInternal(ctx); err != nil {
return err
@@ -2264,12 +2222,6 @@ func (s *SwarmService) CreateSecret(ctx context.Context, req swarmtypes.SecretCr
return s.GetSecret(ctx, createResult.ID)
}
-func (s *SwarmService) UpdateSecret(ctx context.Context, secretID string, req swarmtypes.SecretUpdateRequest) error {
- _ = secretID
- _ = req
- return common.Classify(common.ErrSwarmSecretImmutable, errors.New("Swarm secrets are immutable; create a new secret and update services to use it"))
-}
-
func (s *SwarmService) RemoveSecret(ctx context.Context, secretID string) error {
if err := s.ensureSwarmManagerInternal(ctx); err != nil {
return err
@@ -2545,7 +2497,7 @@ func (s *SwarmService) upsertStackSourceInternal(ctx context.Context, environmen
return errors.New("stack name is required")
}
- _, stackSourceDir, err := s.resolveSwarmStackSourceDirInternal(ctx, environmentID, stackName)
+ rootDir, stackSourceDir, err := s.resolveSwarmStackSourceDirInternal(ctx, environmentID, stackName)
if err != nil {
return err
}
@@ -2554,48 +2506,55 @@ func (s *SwarmService) upsertStackSourceInternal(ctx context.Context, environmen
return errors.WrapIf(err, "failed to create swarm stack source directory")
}
- if err := atomic.WriteFile(filepath.Join(stackSourceDir, swarmStackComposeFilename), []byte(composeContent), common.FilePerm); err != nil {
- return errors.WrapIf(err, "failed to write swarm stack compose source")
+ syncFiles := make([]appfs.SyncFile, 0, len(files)+3)
+ syncFiles = append(syncFiles, appfs.SyncFile{
+ RelativePath: swarmStackComposeFilename,
+ Content: []byte(composeContent),
+ })
+ if overrideContent != "" {
+ syncFiles = append(syncFiles, appfs.SyncFile{
+ RelativePath: swarmStackOverrideFilename,
+ Content: []byte(overrideContent),
+ })
+ }
+ if envContent != "" {
+ syncFiles = append(syncFiles, appfs.SyncFile{
+ RelativePath: swarmStackEnvFilename,
+ Content: []byte(envContent),
+ })
}
- overridePath := filepath.Join(stackSourceDir, swarmStackOverrideFilename)
- if overrideContent != "" {
- if err := atomic.WriteFile(overridePath, []byte(overrideContent), common.FilePerm); err != nil {
- return errors.WrapIf(err, "failed to write swarm stack override source")
+ for _, file := range files {
+ relativePath := filepath.ToSlash(filepath.Clean(file.RelativePath))
+ if relativePath == "." {
+ return errors.New("swarm stack file path is required")
}
- } else {
- if err := os.Remove(overridePath); err != nil && !errors.Is(err, os.ErrNotExist) {
- return errors.WrapIf(err, "failed to clear swarm stack override source")
+ if relativePath == swarmStackComposeFilename || relativePath == swarmStackOverrideFilename || relativePath == swarmStackEnvFilename {
+ continue
}
+ syncFiles = append(syncFiles, appfs.SyncFile{RelativePath: relativePath, Content: file.Content})
}
- envPath := filepath.Join(stackSourceDir, swarmStackEnvFilename)
- if envContent != "" {
- if err := atomic.WriteFile(envPath, []byte(envContent), common.FilePerm); err != nil {
- return errors.WrapIf(err, "failed to write swarm stack env source")
+ existingFiles := make([]string, 0)
+ if err := fs.WalkDir(os.DirFS(stackSourceDir), ".", func(path string, entry fs.DirEntry, walkErr error) error {
+ if walkErr != nil {
+ return walkErr
}
- } else {
- if err := os.Remove(envPath); err != nil && !errors.Is(err, os.ErrNotExist) {
- return errors.WrapIf(err, "failed to clear swarm stack env source")
+ if path == "." || entry.IsDir() || entry.Type()&os.ModeSymlink != 0 {
+ return nil
}
+ existingFiles = append(existingFiles, path)
+ return nil
+ }); err != nil {
+ return errors.WrapIf(err, "failed to inspect existing swarm stack files")
}
- // Write additional files
- for _, f := range files {
- if f.RelativePath == swarmStackComposeFilename || f.RelativePath == swarmStackOverrideFilename || f.RelativePath == swarmStackEnvFilename {
- continue
- }
- fPath := filepath.Join(stackSourceDir, f.RelativePath)
- // Prevent path traversal
- if !appfs.IsSafeSubdirectory(stackSourceDir, fPath) {
- return errors.Errorf("invalid file path %q: must be inside stack directory", f.RelativePath)
- }
- if err := os.MkdirAll(filepath.Dir(fPath), common.DirPerm); err != nil {
- return errors.WrapIff(err, "failed to create directory for %s", f.RelativePath)
- }
- if err := atomic.WriteFile(fPath, f.Content, common.FilePerm); err != nil {
- return errors.WrapIff(err, "failed to write %s", f.RelativePath)
- }
+ writtenFiles, err := appfs.WriteSyncedDirectory(rootDir, stackSourceDir, syncFiles)
+ if err != nil {
+ return errors.WrapIf(err, "failed to write swarm stack files")
+ }
+ if err := appfs.CleanupRemovedFiles(rootDir, stackSourceDir, existingFiles, writtenFiles); err != nil {
+ return errors.WrapIf(err, "failed to remove stale swarm stack files")
}
return nil
@@ -2690,58 +2649,6 @@ func (s *SwarmService) resolveSwarmStackSourceEnvironmentDirInternal(ctx context
return rootDir, environmentDir, nil
}
-func (s *SwarmService) getPathMapperInternal(ctx context.Context) *appfs.PathMapper {
- configuredPath := s.settingsService.GetStringSetting(ctx, "swarmStackSourcesDirectory", defaultSwarmStackSourceRootDir)
-
- var containerDir, hostDir string
-
- // Handle mapping format: "container_path:host_path"
- if parts := strings.SplitN(configuredPath, ":", 2); len(parts) == 2 {
- if !appfs.IsWindowsDrivePath(configuredPath) && strings.HasPrefix(parts[0], "/") {
- containerDir = parts[0]
- hostDir = parts[1]
- }
- }
-
- if containerDir == "" {
- containerDir = configuredPath
- }
-
- // Resolve container directory to absolute path
- containerDirResolved, err := appfs.GetProjectsDirectory(ctx, strings.TrimSpace(containerDir))
- if err != nil {
- slog.WarnContext(ctx, "unable to resolve container swarm sources directory, using default", "error", err)
- containerDirResolved = defaultSwarmStackSourceRootDir
- }
-
- // Explicit "container:host" mapping: honor the user-declared prefix directly.
- if strings.TrimSpace(hostDir) != "" {
- hostDirResolved := filepath.Clean(strings.TrimSpace(hostDir))
- pm := appfs.NewPathMapper(containerDirResolved, hostDirResolved)
- if !pm.IsNonMatchingMount() {
- return nil
- }
- return pm
- }
-
- // Auto-discovery: resolve each bind-mount source against Arcane's real container
- // mount table (longest-prefix match) so an independently bind-mounted stack
- // directory maps to its own host path instead of a single sources-root prefix.
- if s.dockerService != nil {
- if dockerCli, derr := s.dockerService.GetClient(ctx); derr == nil {
- if mounts, merr := appfs.GetCurrentContainerMounts(ctx, dockerCli); merr == nil && len(mounts) > 0 {
- pm := appfs.NewPathMapperFromMounts(mounts)
- if !pm.IsNonMatchingMount() {
- return nil
- }
- return pm
- }
- }
- }
-
- return nil
-}
-
func (s *SwarmService) ensureSwarmManagerInternal(ctx context.Context) error {
info, err := s.getDockerInfoInternal(ctx)
if err != nil {
diff --git a/backend/internal/services/swarm_service_test.go b/backend/internal/services/swarm_service_test.go
index d6e9a85a8..8b593b4a1 100644
--- a/backend/internal/services/swarm_service_test.go
+++ b/backend/internal/services/swarm_service_test.go
@@ -119,6 +119,19 @@ func TestSwarmService_UpdateAndGetStackSource_UsesStoredFilesWithoutSwarmManager
source, err = svc.GetStackSource(ctx, "0", "demo-stack")
require.NoError(t, err)
require.Len(t, source.Files, 2)
+
+ _, err = svc.UpdateStackSource(ctx, "0", "demo-stack", swarmtypes.StackSourceUpdateRequest{
+ ComposeContent: "services:\n web:\n image: nginx:alpine\n",
+ Files: []swarmtypes.SyncFile{
+ {RelativePath: "config/nginx.conf", Content: []byte("worker_processes auto;")},
+ },
+ })
+ require.NoError(t, err)
+ require.NoFileExists(t, filepath.Join(rootDir, "0", "demo-stack", "scripts", "setup.sh"))
+ source, err = svc.GetStackSource(ctx, "0", "demo-stack")
+ require.NoError(t, err)
+ require.Len(t, source.Files, 1)
+ require.Equal(t, []byte("worker_processes auto;"), source.Files[0].Content)
}
func TestSwarmService_UpdateAndGetStackSource_RoundTripsOverride(t *testing.T) {
@@ -160,38 +173,6 @@ func TestSwarmService_UpdateAndGetStackSource_RoundTripsOverride(t *testing.T) {
require.Empty(t, source.OverrideContent)
}
-func TestSwarmService_getPathMapperInternal(t *testing.T) {
- ctx := context.Background()
- db := setupSettingsTestDB(t)
- settingsSvc, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- svc := NewSwarmService(nil, settingsSvc, nil, nil, nil)
-
- t.Run("returns nil when paths match", func(t *testing.T) {
- pm := svc.getPathMapperInternal(ctx)
- require.Nil(t, pm) // Default is /app/data/swarm/sources which matches itself
- })
-
- t.Run("returns mapper when mapping configured", func(t *testing.T) {
- containerDir := filepath.Join(t.TempDir(), "container")
- hostDir := "/host/path"
- err := settingsSvc.UpdateSetting(ctx, "swarmStackSourcesDirectory", containerDir+":"+hostDir)
- require.NoError(t, err)
-
- pm := svc.getPathMapperInternal(ctx)
- require.NotNil(t, pm)
- require.True(t, pm.IsNonMatchingMount())
-
- testFile := filepath.Join(containerDir, "0/stack/compose.yaml")
- expected := filepath.Join(hostDir, "0/stack/compose.yaml")
-
- translated, err := pm.ContainerToHost(testFile)
- require.NoError(t, err)
- require.Equal(t, filepath.ToSlash(expected), filepath.ToSlash(translated))
- })
-}
-
func TestSwarmService_ScaleService_HandlesServiceModesInternal(t *testing.T) {
ctx := context.Background()
replicas := uint64(5)
diff --git a/backend/pkg/libarcane/swarm/cleanup.go b/backend/pkg/libarcane/swarm/cleanup.go
new file mode 100644
index 000000000..53a209bbf
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/cleanup.go
@@ -0,0 +1,208 @@
+package swarm
+
+import (
+ "context"
+ stderrors "errors"
+ "fmt"
+ "sort"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ cerrdefs "github.com/containerd/errdefs"
+ swarmtypes "github.com/getarcaneapp/arcane/types/v2/swarm"
+ dockerclient "github.com/moby/moby/client"
+)
+
+// Swarm tears tasks down asynchronously, so a config, secret, or network can
+// stay referenced for a short window after the owning services are removed.
+const staleSwarmResourceRemoveAttemptsInternal = 5
+
+var staleSwarmResourceRemoveBackoffInternal = 500 * time.Millisecond
+
+func cleanupStackResourcesInternal(
+ ctx context.Context,
+ dockerClient *dockerclient.Client,
+ stackName string,
+ configMetaByKey map[string]resourceMeta,
+ secretMetaByKey map[string]resourceMeta,
+) error {
+ desiredConfigNames := make(map[string]struct{}, len(configMetaByKey))
+ for _, meta := range configMetaByKey {
+ desiredConfigNames[meta.Name] = struct{}{}
+ }
+ if err := cleanupStaleManagedResourcesInternal(
+ ctx,
+ stackName,
+ desiredConfigNames,
+ configFileResourceAdapterInternal(dockerClient),
+ true,
+ true,
+ ); err != nil {
+ return err
+ }
+
+ desiredSecretNames := make(map[string]struct{}, len(secretMetaByKey))
+ for _, meta := range secretMetaByKey {
+ desiredSecretNames[meta.Name] = struct{}{}
+ }
+ if err := cleanupStaleManagedResourcesInternal(
+ ctx,
+ stackName,
+ desiredSecretNames,
+ secretFileResourceAdapterInternal(dockerClient),
+ true,
+ true,
+ ); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func collectStaleManagedResourcesInternal[T any](items []T, convert func(T) staleManagedResourceInternal) []staleManagedResourceInternal {
+ resources := make([]staleManagedResourceInternal, 0, len(items))
+ for _, item := range items {
+ resources = append(resources, convert(item))
+ }
+ return resources
+}
+
+type staleManagedResourceInternal struct {
+ ID string
+ Name string
+}
+
+func cleanupStaleManagedResourcesInternal(
+ ctx context.Context,
+ stackName string,
+ desiredNames map[string]struct{},
+ adapter fileResourceAdapterInternal,
+ managedOnly bool,
+ tolerateInUse bool,
+) error {
+ resourceTypeLabels := []string{""}
+ if managedOnly {
+ resourceTypeLabels = []string{resourceTypeLabel, legacyResourceTypeLabel}
+ }
+
+ resources := make([]staleManagedResourceInternal, 0)
+ seenResourceIDs := make(map[string]struct{})
+ for _, typeLabel := range resourceTypeLabels {
+ filters := make(dockerclient.Filters)
+ filters.Add("label", fmt.Sprintf("%s=%s", swarmtypes.StackNamespaceLabel, stackName))
+ if typeLabel != "" {
+ filters.Add("label", typeLabel+"="+adapter.ResourceType)
+ }
+
+ listedResources, err := adapter.List(ctx, filters)
+ if err != nil {
+ return err
+ }
+ for _, resource := range listedResources {
+ if _, seen := seenResourceIDs[resource.ID]; seen {
+ continue
+ }
+ seenResourceIDs[resource.ID] = struct{}{}
+ resources = append(resources, resource)
+ }
+ }
+
+ for _, resource := range resources {
+ if _, ok := desiredNames[resource.Name]; ok {
+ continue
+ }
+ if err := removeStaleSwarmResourceInternal(ctx, tolerateInUse, func(ctx context.Context) error {
+ return adapter.Remove(ctx, resource.ID)
+ }); err != nil {
+ return errors.WrapIff(err, "failed to remove stale stack %s %s", adapter.ResourceType, resource.Name)
+ }
+ }
+
+ return nil
+}
+
+// removeStaleSwarmResourceInternal removes a resource, retrying while Swarm still
+// reports it as in use. When tolerateInUse is set the caller is reconciling a live
+// stack and a later cleanup pass picks the resource up, so a single attempt is enough;
+// otherwise the stack is being deleted and a lingering resource must surface as an error
+// instead of being silently orphaned.
+func removeStaleSwarmResourceInternal(ctx context.Context, tolerateInUse bool, remove func(context.Context) error) error {
+ attempts := staleSwarmResourceRemoveAttemptsInternal
+ if tolerateInUse {
+ attempts = 1
+ }
+
+ var err error
+ for attempt := range attempts {
+ err = remove(ctx)
+ if err == nil || cerrdefs.IsNotFound(err) {
+ return nil
+ }
+ if !isStaleSwarmResourceStillInUseInternal(err) {
+ return err
+ }
+ if attempt == attempts-1 {
+ break
+ }
+ select {
+ case <-ctx.Done():
+ return stderrors.Join(ctx.Err(), err)
+ case <-time.After(staleSwarmResourceRemoveBackoffInternal):
+ }
+ }
+
+ if tolerateInUse {
+ return nil
+ }
+ return err
+}
+
+// RemoveStackResources removes configs, secrets, and networks owned by a stack.
+func RemoveStackResources(ctx context.Context, dockerClient *dockerclient.Client, stackName string) error {
+ stackName = strings.TrimSpace(stackName)
+ if stackName == "" {
+ return invalidStackErrorInternal(errors.New("stack name is required"))
+ }
+
+ emptyDesiredSet := map[string]struct{}{}
+ if err := cleanupStaleManagedResourcesInternal(ctx, stackName, emptyDesiredSet, configFileResourceAdapterInternal(dockerClient), false, false); err != nil {
+ return err
+ }
+ if err := cleanupStaleManagedResourcesInternal(ctx, stackName, emptyDesiredSet, secretFileResourceAdapterInternal(dockerClient), false, false); err != nil {
+ return err
+ }
+
+ filters := make(dockerclient.Filters).Add("label", fmt.Sprintf("%s=%s", swarmtypes.StackNamespaceLabel, stackName))
+ networksResult, err := dockerClient.NetworkList(ctx, dockerclient.NetworkListOptions{Filters: filters})
+ if err != nil {
+ return errors.WrapIf(err, "failed to list stack networks")
+ }
+ networks := networksResult.Items
+ sort.Slice(networks, func(i, j int) bool {
+ return networks[i].Name < networks[j].Name
+ })
+ for _, stackNetwork := range networks {
+ if stackNetwork.Ingress {
+ continue
+ }
+ if err := removeStaleSwarmResourceInternal(ctx, false, func(ctx context.Context) error {
+ _, err := dockerClient.NetworkRemove(ctx, stackNetwork.ID, dockerclient.NetworkRemoveOptions{})
+ return err
+ }); err != nil {
+ return errors.WrapIff(err, "failed to remove stack network %s", stackNetwork.Name)
+ }
+ }
+
+ return nil
+}
+
+func isStaleSwarmResourceStillInUseInternal(err error) bool {
+ if cerrdefs.IsConflict(err) {
+ return true
+ }
+
+ message := strings.ToLower(err.Error())
+ return strings.Contains(message, "in use")
+}
diff --git a/backend/pkg/libarcane/swarm/cleanup_test.go b/backend/pkg/libarcane/swarm/cleanup_test.go
new file mode 100644
index 000000000..a1b98dc48
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/cleanup_test.go
@@ -0,0 +1,86 @@
+package swarm
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ cerrdefs "github.com/containerd/errdefs"
+ swarmtypes "github.com/getarcaneapp/arcane/types/v2/swarm"
+ dockerclient "github.com/moby/moby/client"
+ "github.com/stretchr/testify/require"
+)
+
+func TestCleanupStaleManagedResourcesMatchesCurrentAndLegacyLabels(t *testing.T) {
+ t.Parallel()
+
+ listCalls := 0
+ removedIDs := make([]string, 0, 2)
+ adapter := fileResourceAdapterInternal{
+ ResourceType: "config",
+ List: func(_ context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
+ listCalls++
+ labels := filters["label"]
+ require.True(t, labels[swarmtypes.StackNamespaceLabel+"=stack"])
+
+ switch {
+ case labels[resourceTypeLabel+"=config"]:
+ return []staleManagedResourceInternal{
+ {ID: "current", Name: "desired"},
+ {ID: "both", Name: "stale-both"},
+ }, nil
+ case labels[legacyResourceTypeLabel+"=config"]:
+ return []staleManagedResourceInternal{
+ {ID: "legacy", Name: "stale-legacy"},
+ {ID: "both", Name: "stale-both"},
+ }, nil
+ default:
+ require.FailNow(t, "unexpected managed-resource label filter")
+ return nil, nil
+ }
+ },
+ Remove: func(_ context.Context, id string) error {
+ removedIDs = append(removedIDs, id)
+ return nil
+ },
+ }
+
+ err := cleanupStaleManagedResourcesInternal(
+ context.Background(),
+ "stack",
+ map[string]struct{}{"desired": {}},
+ adapter,
+ true,
+ true,
+ )
+ require.NoError(t, err)
+ require.Equal(t, 2, listCalls)
+ require.ElementsMatch(t, []string{"both", "legacy"}, removedIDs)
+}
+
+func TestCleanupStaleManagedResourcesFailsWhenResourceStaysInUse(t *testing.T) {
+ previousBackoff := staleSwarmResourceRemoveBackoffInternal
+ staleSwarmResourceRemoveBackoffInternal = time.Millisecond
+ t.Cleanup(func() { staleSwarmResourceRemoveBackoffInternal = previousBackoff })
+
+ removeCalls := 0
+ adapter := fileResourceAdapterInternal{
+ ResourceType: "config",
+ List: func(_ context.Context, _ dockerclient.Filters) ([]staleManagedResourceInternal, error) {
+ return []staleManagedResourceInternal{{ID: "stale", Name: "stale"}}, nil
+ },
+ Remove: func(_ context.Context, _ string) error {
+ removeCalls++
+ return cerrdefs.ErrConflict.WithMessage("config is in use by task")
+ },
+ }
+
+ err := cleanupStaleManagedResourcesInternal(context.Background(), "stack", map[string]struct{}{}, adapter, false, false)
+ require.Error(t, err)
+ require.Equal(t, staleSwarmResourceRemoveAttemptsInternal, removeCalls)
+
+ removeCalls = 0
+ err = cleanupStaleManagedResourcesInternal(context.Background(), "stack", map[string]struct{}{}, adapter, false, true)
+ require.NoError(t, err)
+ require.Equal(t, 1, removeCalls)
+}
diff --git a/backend/pkg/libarcane/swarm/convert_mounts.go b/backend/pkg/libarcane/swarm/convert_mounts.go
new file mode 100644
index 000000000..9e86db10f
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/convert_mounts.go
@@ -0,0 +1,245 @@
+package swarm
+
+import (
+ "math"
+ "os"
+ "sort"
+ "strings"
+
+ "emperror.dev/errors"
+
+ composegotypes "github.com/compose-spec/compose-go/v2/types"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
+ "github.com/moby/moby/api/types/mount"
+ "github.com/moby/moby/api/types/swarm"
+)
+
+func convertServiceMountsInternal(
+ volumes []composegotypes.ServiceVolumeConfig,
+ ns namespace,
+ projectVolumes composegotypes.Volumes,
+ stackLabels map[string]string,
+) ([]mount.Mount, error) {
+ if len(volumes) == 0 {
+ return nil, nil
+ }
+ result := make([]mount.Mount, 0, len(volumes))
+ for _, vol := range volumes {
+ mountType := mapVolumeTypeInternal(vol.Type)
+ source, projectVolume, err := resolveServiceMountSourceInternal(vol.Source, mountType, ns, projectVolumes)
+ if err != nil {
+ return nil, err
+ }
+ entry := mount.Mount{
+ Type: mountType,
+ Source: source,
+ Target: vol.Target,
+ ReadOnly: vol.ReadOnly,
+ Consistency: mount.Consistency(vol.Consistency),
+ }
+ if vol.Bind != nil {
+ entry.BindOptions = &mount.BindOptions{
+ Propagation: mount.Propagation(vol.Bind.Propagation),
+ CreateMountpoint: bool(vol.Bind.CreateHostPath),
+ }
+ }
+ if vol.Volume != nil {
+ entry.VolumeOptions = &mount.VolumeOptions{
+ NoCopy: vol.Volume.NoCopy,
+ Labels: vol.Volume.Labels,
+ Subpath: vol.Volume.Subpath,
+ }
+ }
+ if mountType == mount.TypeVolume && vol.Source != "" {
+ if entry.VolumeOptions == nil {
+ entry.VolumeOptions = &mount.VolumeOptions{}
+ }
+ if !bool(projectVolume.External) {
+ entry.VolumeOptions.Labels = mergeLabelsInternal(entry.VolumeOptions.Labels, mergeLabelsInternal(projectVolume.Labels, stackLabels))
+ entry.VolumeOptions.DriverConfig = &mount.Driver{
+ Name: projectVolume.Driver,
+ Options: projectVolume.DriverOpts,
+ }
+ }
+ }
+ if vol.Tmpfs != nil {
+ entry.TmpfsOptions = &mount.TmpfsOptions{
+ SizeBytes: int64(vol.Tmpfs.Size),
+ Mode: os.FileMode(vol.Tmpfs.Mode),
+ }
+ }
+ if vol.Image != nil {
+ entry.ImageOptions = &mount.ImageOptions{Subpath: vol.Image.SubPath}
+ }
+ result = append(result, entry)
+ }
+ return result, nil
+}
+
+func resolveServiceMountSourceInternal(
+ source string,
+ mountType mount.Type,
+ ns namespace,
+ projectVolumes composegotypes.Volumes,
+) (string, composegotypes.VolumeConfig, error) {
+ if source == "" {
+ return "", composegotypes.VolumeConfig{}, nil
+ }
+ if mountType != mount.TypeVolume && (mountType != mount.TypeCluster || strings.HasPrefix(source, "group:")) {
+ return source, composegotypes.VolumeConfig{}, nil
+ }
+
+ projectVolume, ok := projectVolumes[source]
+ if !ok {
+ return "", composegotypes.VolumeConfig{}, errors.Errorf("undefined volume %q", source)
+ }
+ return ns.Resolve(source, projectVolume.Name), projectVolume, nil
+}
+
+type resolvedFileReferenceInternal struct {
+ meta resourceMeta
+ target string
+ uid string
+ gid string
+ mode os.FileMode
+}
+
+func resolveServiceFileReferencesInternal(
+ references []composegotypes.FileReferenceConfig,
+ metaByKey map[string]resourceMeta,
+ resourceType string,
+) ([]resolvedFileReferenceInternal, error) {
+ resolved := make([]resolvedFileReferenceInternal, 0, len(references))
+ for _, reference := range references {
+ meta, ok := metaByKey[reference.Source]
+ if !ok {
+ return nil, errors.Errorf("undefined %s %q", resourceType, reference.Source)
+ }
+ target := reference.Target
+ if target == "" {
+ target = reference.Source
+ }
+ mode, err := fileModeOrDefaultInternal(reference.Mode)
+ if err != nil {
+ return nil, errors.WrapIff(err, "invalid %s %q mode", resourceType, reference.Source)
+ }
+ resolved = append(resolved, resolvedFileReferenceInternal{
+ meta: meta,
+ target: target,
+ uid: utils.StringOrDefault(reference.UID, "0"),
+ gid: utils.StringOrDefault(reference.GID, "0"),
+ mode: mode,
+ })
+ }
+ sort.Slice(resolved, func(i, j int) bool {
+ return resolved[i].meta.Name < resolved[j].meta.Name
+ })
+ return resolved, nil
+}
+
+func convertServiceSecretRefsInternal(secrets []composegotypes.ServiceSecretConfig, secretMetaByKey map[string]resourceMeta) ([]*swarm.SecretReference, error) {
+ references := make([]composegotypes.FileReferenceConfig, len(secrets))
+ for i, secret := range secrets {
+ references[i] = composegotypes.FileReferenceConfig(secret)
+ }
+ resolved, err := resolveServiceFileReferencesInternal(references, secretMetaByKey, "secret")
+ if err != nil {
+ return nil, err
+ }
+
+ result := make([]*swarm.SecretReference, 0, len(resolved))
+ for _, reference := range resolved {
+ result = append(result, &swarm.SecretReference{
+ SecretID: reference.meta.ID,
+ SecretName: reference.meta.Name,
+ File: &swarm.SecretReferenceFileTarget{
+ Name: reference.target,
+ UID: reference.uid,
+ GID: reference.gid,
+ Mode: reference.mode,
+ },
+ })
+ }
+ return result, nil
+}
+
+func convertServiceConfigRefsInternal(configs []composegotypes.ServiceConfigObjConfig, configMetaByKey map[string]resourceMeta) ([]*swarm.ConfigReference, error) {
+ references := make([]composegotypes.FileReferenceConfig, len(configs))
+ for i, config := range configs {
+ references[i] = composegotypes.FileReferenceConfig(config)
+ }
+ resolved, err := resolveServiceFileReferencesInternal(references, configMetaByKey, "config")
+ if err != nil {
+ return nil, err
+ }
+
+ result := make([]*swarm.ConfigReference, 0, len(resolved))
+ for _, reference := range resolved {
+ result = append(result, &swarm.ConfigReference{
+ ConfigID: reference.meta.ID,
+ ConfigName: reference.meta.Name,
+ File: &swarm.ConfigReferenceFileTarget{
+ Name: reference.target,
+ UID: reference.uid,
+ GID: reference.gid,
+ Mode: reference.mode,
+ },
+ })
+ }
+ return result, nil
+}
+
+func resolveFileObjectContentInternal(
+ fileConfig composegotypes.FileObjectConfig,
+ workingDir string,
+ environment composegotypes.Mapping,
+) ([]byte, error) {
+ if fileConfig.Content != "" {
+ return []byte(fileConfig.Content), nil
+ }
+ if fileConfig.Environment != "" {
+ value, ok := environment.Resolve(fileConfig.Environment)
+ if !ok {
+ return nil, errors.Errorf("environment variable %s not set", fileConfig.Environment)
+ }
+ return []byte(value), nil
+ }
+ if fileConfig.File != "" {
+ path, err := projects.ResolvePathWithinDir(workingDir, fileConfig.File)
+ if err != nil {
+ return nil, err
+ }
+ return os.ReadFile(path)
+ }
+ return nil, errors.New("config or secret content is required")
+}
+
+func fileModeOrDefaultInternal(mode *composegotypes.FileMode) (os.FileMode, error) {
+ if mode == nil {
+ return 0444, nil
+ }
+ if *mode < 0 || *mode > composegotypes.FileMode(math.MaxUint32) {
+ return 0, errors.Errorf("file mode %d is outside the uint32 range", *mode)
+ }
+ return os.FileMode(uint32(*mode)), nil
+}
+
+func mapVolumeTypeInternal(value string) mount.Type {
+ switch strings.ToLower(value) {
+ case "bind":
+ return mount.TypeBind
+ case "tmpfs":
+ return mount.TypeTmpfs
+ case "npipe":
+ return mount.TypeNamedPipe
+ case "cluster":
+ return mount.TypeCluster
+ case "image":
+ return mount.TypeImage
+ case "volume", "":
+ return mount.TypeVolume
+ default:
+ return mount.TypeVolume
+ }
+}
diff --git a/backend/pkg/libarcane/swarm/convert_service.go b/backend/pkg/libarcane/swarm/convert_service.go
new file mode 100644
index 000000000..c59a43bb3
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/convert_service.go
@@ -0,0 +1,711 @@
+package swarm
+
+import (
+ "cmp"
+ "fmt"
+ "log/slog"
+ "maps"
+ "math"
+ "net/netip"
+ "slices"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+
+ "emperror.dev/errors"
+
+ composegotypes "github.com/compose-spec/compose-go/v2/types"
+ dockeropts "github.com/docker/cli/opts"
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/api/types/network"
+ "github.com/moby/moby/api/types/swarm"
+ "github.com/samber/mo"
+)
+
+func buildServiceSpecInternal(
+ service composegotypes.ServiceConfig,
+ ns namespace,
+ stackLabels map[string]string,
+ networkNameByKey map[string]string,
+ configMetaByKey map[string]resourceMeta,
+ secretMetaByKey map[string]resourceMeta,
+ projectVolumes composegotypes.Volumes,
+) (swarm.ServiceSpec, error) {
+ serviceName := ns.Scope(service.Name)
+ serviceLabels := mergeLabelsInternal(nil, stackLabels)
+ if service.Deploy != nil {
+ serviceLabels = mergeLabelsInternal(service.Deploy.Labels, serviceLabels)
+ }
+
+ mounts, err := convertServiceMountsInternal(service.Volumes, ns, projectVolumes, stackLabels)
+ if err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ secretRefs, err := convertServiceSecretRefsInternal(service.Secrets, secretMetaByKey)
+ if err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ configRefs, err := convertServiceConfigRefsInternal(service.Configs, configMetaByKey)
+ if err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ privileges, runtimeConfigRef, err := convertPrivilegesInternal(service.CredentialSpec, service.SecurityOpt, configMetaByKey)
+ if err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ if runtimeConfigRef != nil {
+ configRefs = append(configRefs, runtimeConfigRef)
+ sort.Slice(configRefs, func(i, j int) bool {
+ return configRefs[i].ConfigName < configRefs[j].ConfigName
+ })
+ }
+ healthcheck, err := convertHealthcheckInternal(service.HealthCheck)
+ if err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ networks, err := buildServiceNetworksInternal(service, networkNameByKey)
+ if err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ capabilityAdd, capabilityDrop := dockeropts.EffectiveCapAddCapDrop(service.CapAdd, service.CapDrop)
+
+ spec := swarm.ServiceSpec{
+ Annotations: swarm.Annotations{
+ Name: serviceName,
+ Labels: serviceLabels,
+ },
+ TaskTemplate: swarm.TaskSpec{
+ ContainerSpec: &swarm.ContainerSpec{
+ Image: service.Image,
+ Command: toStringSliceInternal(service.Entrypoint),
+ Args: toStringSliceInternal(service.Command),
+ Env: convertEnvInternal(service.Environment),
+ Dir: service.WorkingDir,
+ User: service.User,
+ Groups: service.GroupAdd,
+ Hostname: service.Hostname,
+ Init: service.Init,
+ StopSignal: service.StopSignal,
+ StopGracePeriod: convertDurationPtrInternal(service.StopGracePeriod),
+ ReadOnly: service.ReadOnly,
+ TTY: service.Tty,
+ OpenStdin: service.StdinOpen,
+ Labels: mergeLabelsInternal(service.Labels, stackLabels),
+ Mounts: mounts,
+ Secrets: secretRefs,
+ Configs: configRefs,
+ Hosts: convertExtraHostsInternal(service.ExtraHosts),
+ Healthcheck: healthcheck,
+ Privileges: privileges,
+ Isolation: container.Isolation(service.Isolation),
+ Sysctls: map[string]string(service.Sysctls),
+ CapabilityAdd: capabilityAdd,
+ CapabilityDrop: capabilityDrop,
+ Ulimits: convertUlimitsInternal(service.Ulimits),
+ OomScoreAdj: service.OomScoreAdj,
+ },
+ Networks: networks,
+ Runtime: swarm.RuntimeType(service.Runtime),
+ },
+ }
+
+ if service.Logging != nil {
+ spec.TaskTemplate.LogDriver = &swarm.Driver{
+ Name: service.Logging.Driver,
+ Options: service.Logging.Options,
+ }
+ }
+
+ if len(service.DNS) > 0 || len(service.DNSSearch) > 0 || len(service.DNSOpts) > 0 {
+ spec.TaskTemplate.ContainerSpec.DNSConfig = &swarm.DNSConfig{
+ Nameservers: parseIPListInternal(service.DNS),
+ Search: []string(service.DNSSearch),
+ Options: service.DNSOpts,
+ }
+ }
+
+ if err := applyDeployConfigInternal(&spec, service.Deploy, service.Scale, service.Restart); err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+ if err := applyServicePortsInternal(&spec, service.Ports); err != nil {
+ return swarm.ServiceSpec{}, err
+ }
+
+ return spec, nil
+}
+
+func convertExtraHostsInternal(extraHosts composegotypes.HostsList) []string {
+ hosts := make([]string, 0, len(extraHosts))
+ for hostName, addresses := range extraHosts {
+ for _, address := range addresses {
+ hosts = append(hosts, address+" "+hostName)
+ }
+ }
+ slices.Sort(hosts)
+ return hosts
+}
+
+func convertHealthcheckInternal(healthcheck *composegotypes.HealthCheckConfig) (*container.HealthConfig, error) {
+ if healthcheck == nil {
+ return nil, nil
+ }
+ if healthcheck.Disable {
+ if len(healthcheck.Test) > 0 ||
+ healthcheck.Timeout != nil ||
+ healthcheck.Interval != nil ||
+ healthcheck.Retries != nil ||
+ healthcheck.StartPeriod != nil ||
+ healthcheck.StartInterval != nil {
+ return nil, errors.New("healthcheck disable cannot be combined with other healthcheck fields")
+ }
+ return &container.HealthConfig{Test: []string{"NONE"}}, nil
+ }
+
+ result := &container.HealthConfig{Test: healthcheck.Test}
+ if healthcheck.Timeout != nil {
+ result.Timeout = time.Duration(*healthcheck.Timeout)
+ }
+ if healthcheck.Interval != nil {
+ result.Interval = time.Duration(*healthcheck.Interval)
+ }
+ if healthcheck.Retries != nil {
+ if *healthcheck.Retries > uint64(math.MaxInt) {
+ return nil, errors.Errorf("healthcheck retries %d exceeds the platform int range", *healthcheck.Retries)
+ }
+ result.Retries = int(*healthcheck.Retries)
+ }
+ if healthcheck.StartPeriod != nil {
+ result.StartPeriod = time.Duration(*healthcheck.StartPeriod)
+ }
+ if healthcheck.StartInterval != nil {
+ result.StartInterval = time.Duration(*healthcheck.StartInterval)
+ }
+ return result, nil
+}
+
+func convertPrivilegesInternal(
+ credentialSpec *composegotypes.CredentialSpecConfig,
+ securityOptions []string,
+ configMetaByKey map[string]resourceMeta,
+) (*swarm.Privileges, *swarm.ConfigReference, error) {
+ convertedCredentialSpec, runtimeConfigRef, err := convertCredentialSpecInternal(credentialSpec, configMetaByKey)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ privileges := &swarm.Privileges{CredentialSpec: convertedCredentialSpec}
+ hasPrivileges := convertedCredentialSpec != nil
+ for _, securityOption := range securityOptions {
+ applied, err := applySecurityOptionInternal(privileges, securityOption)
+ if err != nil {
+ return nil, nil, err
+ }
+ if applied {
+ hasPrivileges = true
+ }
+ }
+
+ if !hasPrivileges {
+ return nil, runtimeConfigRef, nil
+ }
+ return privileges, runtimeConfigRef, nil
+}
+
+func convertCredentialSpecInternal(
+ credentialSpec *composegotypes.CredentialSpecConfig,
+ configMetaByKey map[string]resourceMeta,
+) (*swarm.CredentialSpec, *swarm.ConfigReference, error) {
+ if credentialSpec == nil {
+ return nil, nil, nil
+ }
+
+ configured := 0
+ if credentialSpec.Config != "" {
+ configured++
+ }
+ if credentialSpec.File != "" {
+ configured++
+ }
+ if credentialSpec.Registry != "" {
+ configured++
+ }
+ if configured > 1 {
+ return nil, nil, errors.New("credential spec can only set one of config, file, or registry")
+ }
+ if configured == 0 {
+ return nil, nil, nil
+ }
+
+ converted := &swarm.CredentialSpec{
+ File: credentialSpec.File,
+ Registry: credentialSpec.Registry,
+ }
+ if credentialSpec.Config == "" {
+ return converted, nil, nil
+ }
+
+ meta, ok := configMetaByKey[credentialSpec.Config]
+ if !ok {
+ return nil, nil, errors.Errorf("undefined config %q for credential spec", credentialSpec.Config)
+ }
+ converted.Config = meta.ID
+ return converted, &swarm.ConfigReference{
+ ConfigID: meta.ID,
+ ConfigName: meta.Name,
+ Runtime: &swarm.ConfigReferenceRuntimeTarget{},
+ }, nil
+}
+
+func applySecurityOptionInternal(privileges *swarm.Privileges, securityOption string) (bool, error) {
+ option := strings.TrimSpace(securityOption)
+ if option == "" {
+ return false, nil
+ }
+ key, value, found := strings.Cut(option, "=")
+ if !found {
+ key, value, found = strings.Cut(option, ":")
+ }
+ key = strings.ToLower(strings.TrimSpace(key))
+ value = strings.TrimSpace(value)
+
+ switch key {
+ case "no-new-privileges":
+ enabled := true
+ if found && value != "" {
+ parsed, err := strconv.ParseBool(value)
+ if err != nil {
+ return false, errors.WrapIff(err, "invalid no-new-privileges value %q", value)
+ }
+ enabled = parsed
+ }
+ privileges.NoNewPrivileges = enabled
+ case "seccomp":
+ switch strings.ToLower(value) {
+ case "", "default":
+ privileges.Seccomp = &swarm.SeccompOpts{Mode: swarm.SeccompModeDefault}
+ case "unconfined":
+ privileges.Seccomp = &swarm.SeccompOpts{Mode: swarm.SeccompModeUnconfined}
+ default:
+ return false, errors.Errorf("custom seccomp profile %q is not supported for swarm stacks", value)
+ }
+ case "apparmor":
+ switch strings.ToLower(value) {
+ case "", "default":
+ privileges.AppArmor = &swarm.AppArmorOpts{Mode: swarm.AppArmorModeDefault}
+ case "unconfined", "disabled":
+ privileges.AppArmor = &swarm.AppArmorOpts{Mode: swarm.AppArmorModeDisabled}
+ default:
+ return false, errors.Errorf("custom AppArmor profile %q is not supported for swarm stacks", value)
+ }
+ case "label":
+ if err := applySELinuxOptionInternal(privileges, value, securityOption); err != nil {
+ return false, err
+ }
+ default:
+ return false, errors.Errorf("unsupported swarm security option %q", securityOption)
+ }
+ return true, nil
+}
+
+func applySELinuxOptionInternal(privileges *swarm.Privileges, value, securityOption string) error {
+ selinux := privileges.SELinuxContext
+ if selinux == nil {
+ selinux = &swarm.SELinuxContext{}
+ privileges.SELinuxContext = selinux
+ }
+ labelKey, labelValue, hasLabelValue := strings.Cut(value, ":")
+ switch strings.ToLower(labelKey) {
+ case "disable":
+ selinux.Disable = true
+ case "user":
+ selinux.User = labelValue
+ case "role":
+ selinux.Role = labelValue
+ case "type":
+ selinux.Type = labelValue
+ case "level":
+ selinux.Level = labelValue
+ default:
+ return errors.Errorf("invalid SELinux security option %q", securityOption)
+ }
+ if strings.ToLower(labelKey) != "disable" && !hasLabelValue {
+ return errors.Errorf("invalid SELinux security option %q", securityOption)
+ }
+ return nil
+}
+
+func convertUlimitsInternal(ulimits map[string]*composegotypes.UlimitsConfig) []*container.Ulimit {
+ result := make([]*container.Ulimit, 0, len(ulimits))
+ for _, name := range slices.Sorted(maps.Keys(ulimits)) {
+ limit := ulimits[name]
+ if limit == nil {
+ continue
+ }
+ soft, hard := int64(limit.Soft), int64(limit.Hard)
+ if limit.Single != 0 {
+ soft = int64(limit.Single)
+ hard = int64(limit.Single)
+ }
+ result = append(result, &container.Ulimit{Name: name, Soft: soft, Hard: hard})
+ }
+ slices.SortFunc(result, func(a, b *container.Ulimit) int {
+ return cmp.Compare(a.Name, b.Name)
+ })
+ return result
+}
+
+func applyDeployConfigInternal(spec *swarm.ServiceSpec, deploy *composegotypes.DeployConfig, scale *int, restart string) error {
+ if deploy == nil {
+ if err := applyServiceModeInternal(spec, "", scale); err != nil {
+ return err
+ }
+ restartPolicy, err := convertRestartPolicyInternal(restart, nil)
+ if err != nil {
+ return err
+ }
+ spec.TaskTemplate.RestartPolicy = restartPolicy
+ return nil
+ }
+
+ replicas := scale
+ if deploy.Replicas != nil {
+ replicas = deploy.Replicas
+ }
+ if err := applyServiceModeInternal(spec, deploy.Mode, replicas); err != nil {
+ return err
+ }
+
+ if deploy.EndpointMode != "" {
+ if spec.EndpointSpec == nil {
+ spec.EndpointSpec = &swarm.EndpointSpec{}
+ }
+ spec.EndpointSpec.Mode = swarm.ResolutionMode(strings.ToLower(deploy.EndpointMode))
+ }
+
+ spec.UpdateConfig = convertUpdateConfigInternal(deploy.UpdateConfig)
+ spec.RollbackConfig = convertUpdateConfigInternal(deploy.RollbackConfig)
+
+ restartPolicy, err := convertRestartPolicyInternal(restart, deploy.RestartPolicy)
+ if err != nil {
+ return err
+ }
+ spec.TaskTemplate.RestartPolicy = restartPolicy
+
+ if deploy.Resources.Limits != nil || deploy.Resources.Reservations != nil {
+ spec.TaskTemplate.Resources = &swarm.ResourceRequirements{}
+ }
+ if deploy.Resources.Limits != nil {
+ spec.TaskTemplate.Resources.Limits = &swarm.Limit{
+ NanoCPUs: int64(deploy.Resources.Limits.NanoCPUs * 1e9),
+ MemoryBytes: int64(deploy.Resources.Limits.MemoryBytes),
+ Pids: deploy.Resources.Limits.Pids,
+ }
+ }
+ if deploy.Resources.Reservations != nil {
+ spec.TaskTemplate.Resources.Reservations = &swarm.Resources{
+ NanoCPUs: int64(deploy.Resources.Reservations.NanoCPUs * 1e9),
+ MemoryBytes: int64(deploy.Resources.Reservations.MemoryBytes),
+ }
+ }
+
+ if len(deploy.Placement.Constraints) > 0 || len(deploy.Placement.Preferences) > 0 || deploy.Placement.MaxReplicas > 0 {
+ spec.TaskTemplate.Placement = &swarm.Placement{
+ Constraints: deploy.Placement.Constraints,
+ MaxReplicas: deploy.Placement.MaxReplicas,
+ }
+ if len(deploy.Placement.Preferences) > 0 {
+ preferences := make([]swarm.PlacementPreference, 0, len(deploy.Placement.Preferences))
+ for _, preference := range deploy.Placement.Preferences {
+ if spread := strings.TrimSpace(preference.Spread); spread != "" {
+ preferences = append(preferences, swarm.PlacementPreference{
+ Spread: &swarm.SpreadOver{SpreadDescriptor: spread},
+ })
+ }
+ }
+ spec.TaskTemplate.Placement.Preferences = preferences
+ }
+ }
+
+ return nil
+}
+
+func convertUpdateConfigInternal(source *composegotypes.UpdateConfig) *swarm.UpdateConfig {
+ if source == nil {
+ return nil
+ }
+ parallelism := uint64(1)
+ if source.Parallelism != nil {
+ parallelism = *source.Parallelism
+ }
+ return &swarm.UpdateConfig{
+ Parallelism: parallelism,
+ Delay: time.Duration(source.Delay),
+ FailureAction: swarm.FailureAction(source.FailureAction),
+ Monitor: time.Duration(source.Monitor),
+ MaxFailureRatio: source.MaxFailureRatio,
+ Order: swarm.UpdateOrder(source.Order),
+ }
+}
+
+func convertRestartPolicyInternal(restart string, deployPolicy *composegotypes.RestartPolicy) (*swarm.RestartPolicy, error) {
+ if deployPolicy != nil {
+ return &swarm.RestartPolicy{
+ Condition: swarm.RestartPolicyCondition(deployPolicy.Condition),
+ Delay: convertDurationPtrInternal(deployPolicy.Delay),
+ MaxAttempts: deployPolicy.MaxAttempts,
+ Window: convertDurationPtrInternal(deployPolicy.Window),
+ }, nil
+ }
+ if strings.TrimSpace(restart) == "" {
+ return nil, nil
+ }
+
+ policy, err := dockeropts.ParseRestartPolicy(restart)
+ if err != nil {
+ return nil, err
+ }
+ if policy.MaximumRetryCount < 0 {
+ return nil, errors.New("invalid restart policy: maximum retry count cannot be negative")
+ }
+ switch policy.Name {
+ case container.RestartPolicyDisabled, "":
+ return nil, nil
+ case container.RestartPolicyAlways, container.RestartPolicyUnlessStopped:
+ return &swarm.RestartPolicy{Condition: swarm.RestartPolicyConditionAny}, nil
+ case container.RestartPolicyOnFailure:
+ maxAttempts := uint64(policy.MaximumRetryCount)
+ return &swarm.RestartPolicy{Condition: swarm.RestartPolicyConditionOnFailure, MaxAttempts: &maxAttempts}, nil
+ default:
+ return nil, errors.Errorf("invalid restart policy %q", policy.Name)
+ }
+}
+
+func applyServiceModeInternal(spec *swarm.ServiceSpec, mode string, replicas *int) error {
+ mode = strings.ToLower(strings.TrimSpace(mode))
+ switch mode {
+ case "global":
+ if replicas != nil {
+ return errors.New("replicas can only be used with replicated or replicated-job mode")
+ }
+ spec.Mode = swarm.ServiceMode{Global: &swarm.GlobalService{}}
+ case "global-job":
+ if replicas != nil {
+ return errors.New("replicas can only be used with replicated or replicated-job mode")
+ }
+ spec.Mode = swarm.ServiceMode{GlobalJob: &swarm.GlobalJob{}}
+ case "replicated-job":
+ replicaCount := toUint64PointerFromOptionalIntInternal(replicas)
+ spec.Mode = swarm.ServiceMode{ReplicatedJob: &swarm.ReplicatedJob{
+ MaxConcurrent: replicaCount,
+ TotalCompletions: replicaCount,
+ }}
+ case "replicated", "":
+ replicaCount := uint64(1)
+ if replicasInput := replicas; replicasInput != nil {
+ if *replicasInput <= 0 {
+ replicaCount = 0
+ } else {
+ replicaCount = uint64(*replicasInput)
+ }
+ }
+ spec.Mode = swarm.ServiceMode{Replicated: &swarm.ReplicatedService{Replicas: &replicaCount}}
+ default:
+ return errors.Errorf("unknown service mode %q", mode)
+ }
+ return nil
+}
+
+func toUint64PointerFromOptionalIntInternal(value *int) *uint64 {
+ if value == nil || *value < 0 {
+ return nil
+ }
+ return new(uint64(*value))
+}
+
+func applyServicePortsInternal(spec *swarm.ServiceSpec, ports []composegotypes.ServicePortConfig) error {
+ if len(ports) == 0 {
+ return nil
+ }
+
+ endpoint := spec.EndpointSpec
+ if endpoint == nil {
+ endpoint = &swarm.EndpointSpec{}
+ }
+
+ converted := make([]swarm.PortConfig, 0, len(ports))
+ for _, port := range ports {
+ if strings.TrimSpace(port.HostIP) != "" {
+ slog.Warn("swarm ignores a compose port host IP", "hostIP", port.HostIP, "targetPort", port.Target)
+ }
+ entry := swarm.PortConfig{
+ Name: port.Name,
+ Protocol: network.IPProtocol(strings.ToLower(port.Protocol)),
+ TargetPort: port.Target,
+ }
+ if port.Mode != "" {
+ entry.PublishMode = swarm.PortConfigPublishMode(strings.ToLower(port.Mode))
+ }
+ if port.Published != "" {
+ published, err := strconv.ParseUint(port.Published, 10, 32)
+ if err != nil {
+ return errors.WrapIff(err, "invalid published port %q", port.Published)
+ }
+ entry.PublishedPort = uint32(published)
+ }
+ converted = append(converted, entry)
+ }
+
+ slices.SortFunc(converted, swarm.PortConfig.Compare)
+ endpoint.Ports = converted
+ spec.EndpointSpec = endpoint
+ return nil
+}
+
+func buildServiceNetworksInternal(service composegotypes.ServiceConfig, networkNameByKey map[string]string) ([]swarm.NetworkAttachmentConfig, error) {
+ var attachments []swarm.NetworkAttachmentConfig
+ if len(service.Networks) == 0 {
+ defaultNetwork, ok := networkNameByKey["default"]
+ if !ok {
+ return nil, errors.New("undefined network \"default\"")
+ }
+ return []swarm.NetworkAttachmentConfig{{
+ Target: defaultNetwork,
+ Aliases: []string{service.Name},
+ }}, nil
+ }
+
+ for name, cfg := range service.Networks {
+ networkName, ok := networkNameByKey[name]
+ if !ok {
+ return nil, errors.Errorf("undefined network %q", name)
+ }
+ aliases := []string{service.Name}
+ if cfg == nil {
+ attachments = append(attachments, swarm.NetworkAttachmentConfig{Target: networkName, Aliases: aliases})
+ continue
+ }
+ aliases = append(slices.Clone(cfg.Aliases), service.Name)
+ slices.Sort(aliases)
+ aliases = slices.Compact(aliases)
+ attachments = append(attachments, swarm.NetworkAttachmentConfig{
+ Target: networkName,
+ Aliases: aliases,
+ DriverOpts: cfg.DriverOpts,
+ })
+ }
+ sort.Slice(attachments, func(i, j int) bool {
+ return attachments[i].Target < attachments[j].Target
+ })
+ return attachments, nil
+}
+
+func convertIPAMInternal(cfg composegotypes.IPAMConfig) *network.IPAM {
+ if cfg.Driver == "" && len(cfg.Config) == 0 && len(cfg.Options) == 0 {
+ return nil
+ }
+ result := &network.IPAM{
+ Driver: cfg.Driver,
+ Options: cfg.Options,
+ }
+ if len(cfg.Config) > 0 {
+ pools := make([]network.IPAMConfig, 0, len(cfg.Config))
+ for _, pool := range cfg.Config {
+ if pool == nil {
+ continue
+ }
+ subnet := parsePrefixInternal(pool.Subnet)
+ ipRange := parsePrefixInternal(pool.IPRange)
+ gateway := parseAddrInternal(pool.Gateway).OrEmpty()
+ pools = append(pools, network.IPAMConfig{
+ Subnet: subnet,
+ Gateway: gateway,
+ IPRange: ipRange,
+ AuxAddress: parseAuxAddressesInternal(pool.AuxiliaryAddresses),
+ })
+ }
+ result.Config = pools
+ }
+ return result
+}
+
+func parseIPListInternal(values []string) []netip.Addr {
+ if len(values) == 0 {
+ return nil
+ }
+ out := make([]netip.Addr, 0, len(values))
+ for _, value := range values {
+ addr, ok := parseAddrInternal(value).Get()
+ if ok {
+ out = append(out, addr)
+ }
+ }
+ return out
+}
+
+func parseAddrInternal(value string) mo.Option[netip.Addr] {
+ value = strings.TrimSpace(value)
+ if value == "" {
+ return mo.None[netip.Addr]()
+ }
+ addr, err := netip.ParseAddr(value)
+ if err != nil {
+ return mo.None[netip.Addr]()
+ }
+ return mo.Some(addr)
+}
+
+func parsePrefixInternal(value string) netip.Prefix {
+ value = strings.TrimSpace(value)
+ if value == "" {
+ return netip.Prefix{}
+ }
+ prefix, err := netip.ParsePrefix(value)
+ if err != nil {
+ return netip.Prefix{}
+ }
+ return prefix
+}
+
+func parseAuxAddressesInternal(values map[string]string) map[string]netip.Addr {
+ if len(values) == 0 {
+ return nil
+ }
+ out := make(map[string]netip.Addr, len(values))
+ for key, value := range values {
+ if addr, ok := parseAddrInternal(value).Get(); ok {
+ out[key] = addr
+ }
+ }
+ return out
+}
+
+func convertEnvInternal(env composegotypes.MappingWithEquals) []string {
+ if env == nil {
+ return nil
+ }
+ result := make([]string, 0, len(env))
+ for key, value := range env {
+ if value == nil {
+ result = append(result, key)
+ continue
+ }
+ result = append(result, fmt.Sprintf("%s=%s", key, *value))
+ }
+ slices.Sort(result)
+ return result
+}
+
+func toStringSliceInternal(command composegotypes.ShellCommand) []string {
+ if len(command) == 0 {
+ return nil
+ }
+ return []string(command)
+}
+
+func convertDurationPtrInternal(duration *composegotypes.Duration) *time.Duration {
+ if duration == nil {
+ return nil
+ }
+ return new(time.Duration(*duration))
+}
diff --git a/backend/pkg/libarcane/swarm/convert_test.go b/backend/pkg/libarcane/swarm/convert_test.go
new file mode 100644
index 000000000..2eb4187b9
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/convert_test.go
@@ -0,0 +1,317 @@
+package swarm
+
+import (
+ "context"
+ "os"
+ "path/filepath"
+ "testing"
+
+ composegotypes "github.com/compose-spec/compose-go/v2/types"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
+ projecttypes "github.com/getarcaneapp/arcane/backend/v2/pkg/projects/types"
+ swarmtypes "github.com/getarcaneapp/arcane/types/v2/swarm"
+ "github.com/moby/moby/api/types/mount"
+ "github.com/moby/moby/api/types/swarm"
+ "github.com/stretchr/testify/require"
+)
+
+func TestConvertServiceMountsResolvesComposeResourceNames(t *testing.T) {
+ mounts, err := convertServiceMountsInternal(
+ []composegotypes.ServiceVolumeConfig{
+ {Type: "volume", Source: "plain", Target: "/plain"},
+ {Type: "volume", Source: "driver", Target: "/driver"},
+ {Type: "volume", Source: "named", Target: "/named"},
+ {Type: "volume", Source: "external", Target: "/external"},
+ },
+ namespace{name: "stack"},
+ composegotypes.Volumes{
+ "plain": {Name: "stack_plain"},
+ "driver": {Name: "stack_driver", Driver: "local"},
+ "named": {Name: "custom"},
+ "external": {Name: "external", External: true},
+ },
+ map[string]string{swarmtypes.StackNamespaceLabel: "stack"},
+ )
+ require.NoError(t, err)
+ require.Len(t, mounts, 4)
+ require.Equal(t, mount.TypeVolume, mounts[0].Type)
+ require.Equal(t, "stack_plain", mounts[0].Source)
+ require.NotNil(t, mounts[0].VolumeOptions)
+ require.NotNil(t, mounts[0].VolumeOptions.DriverConfig)
+ require.Equal(t, "stack_driver", mounts[1].Source)
+ require.Equal(t, "local", mounts[1].VolumeOptions.DriverConfig.Name)
+ require.Equal(t, "custom", mounts[2].Source)
+ require.Equal(t, "external", mounts[3].Source)
+ require.NotNil(t, mounts[3].VolumeOptions)
+ require.Nil(t, mounts[3].VolumeOptions.DriverConfig)
+}
+
+func TestApplyDeployConfigConvertsCPUFractionToNanoCPUs(t *testing.T) {
+ spec := &swarm.ServiceSpec{}
+ deploy := &composegotypes.DeployConfig{
+ Resources: composegotypes.Resources{
+ Limits: &composegotypes.Resource{
+ NanoCPUs: 0.5,
+ MemoryBytes: 536870912,
+ },
+ Reservations: &composegotypes.Resource{
+ NanoCPUs: 0.25,
+ MemoryBytes: 268435456,
+ },
+ },
+ }
+
+ require.NoError(t, applyDeployConfigInternal(spec, deploy, nil, ""))
+ require.Equal(t, int64(500_000_000), spec.TaskTemplate.Resources.Limits.NanoCPUs)
+ require.Equal(t, int64(536870912), spec.TaskTemplate.Resources.Limits.MemoryBytes)
+ require.Equal(t, int64(250_000_000), spec.TaskTemplate.Resources.Reservations.NanoCPUs)
+ require.Equal(t, int64(268435456), spec.TaskTemplate.Resources.Reservations.MemoryBytes)
+}
+
+func TestPlanConfigsUsesComposeProjectEnvironment(t *testing.T) {
+ t.Setenv("ARCANE_SWARM_CONFIG_SOURCE", "process-value")
+
+ project, err := projects.LoadComposeProjectFromContent(context.Background(), projecttypes.ComposeContentOptions{
+ ProjectName: "stack",
+ ComposeContent: `
+services:
+ app:
+ image: alpine
+ configs:
+ - source: app_config
+configs:
+ app_config:
+ environment: ARCANE_SWARM_CONFIG_SOURCE
+`,
+ EnvContent: "ARCANE_SWARM_CONFIG_SOURCE=\n",
+ })
+ require.NoError(t, err)
+
+ plans, err := planConfigsInternal(project, namespace{name: "stack"})
+ require.NoError(t, err)
+ require.Empty(t, plans["app_config"].Data)
+ require.Equal(t, managedResourceNameInternal("stack_app_config", hashManagedResourceInternal(nil)), plans["app_config"].Meta.Name)
+}
+
+func TestBuildServiceSpecConformance(t *testing.T) {
+ type testCase struct {
+ name string
+ configure func(*composegotypes.ServiceConfig)
+ check func(*testing.T, swarm.ServiceSpec, error)
+ }
+
+ tests := []testCase{
+ {
+ name: "extra hosts use swarm notation",
+ configure: func(service *composegotypes.ServiceConfig) {
+ service.ExtraHosts = composegotypes.HostsList{"api.local": {"127.0.0.1"}}
+ },
+ check: func(t *testing.T, spec swarm.ServiceSpec, err error) {
+ require.NoError(t, err)
+ require.Equal(t, []string{"127.0.0.1 api.local"}, spec.TaskTemplate.ContainerSpec.Hosts)
+ },
+ },
+ {
+ name: "network has service alias",
+ configure: func(service *composegotypes.ServiceConfig) {
+ service.Networks = map[string]*composegotypes.ServiceNetworkConfig{"default": nil}
+ },
+ check: func(t *testing.T, spec swarm.ServiceSpec, err error) {
+ require.NoError(t, err)
+ require.Equal(t, []string{"web"}, spec.TaskTemplate.Networks[0].Aliases)
+ },
+ },
+ {
+ name: "update parallelism defaults to one",
+ configure: func(service *composegotypes.ServiceConfig) {
+ service.Deploy = &composegotypes.DeployConfig{UpdateConfig: &composegotypes.UpdateConfig{}}
+ },
+ check: func(t *testing.T, spec swarm.ServiceSpec, err error) {
+ require.NoError(t, err)
+ require.Equal(t, uint64(1), spec.UpdateConfig.Parallelism)
+ },
+ },
+ {
+ name: "legacy restart policy is converted",
+ configure: func(service *composegotypes.ServiceConfig) {
+ service.Restart = "on-failure:3"
+ },
+ check: func(t *testing.T, spec swarm.ServiceSpec, err error) {
+ require.NoError(t, err)
+ require.Equal(t, swarm.RestartPolicyConditionOnFailure, spec.TaskTemplate.RestartPolicy.Condition)
+ require.Equal(t, uint64(3), *spec.TaskTemplate.RestartPolicy.MaxAttempts)
+ },
+ },
+ {
+ name: "disabled healthcheck uses none",
+ configure: func(service *composegotypes.ServiceConfig) {
+ service.HealthCheck = &composegotypes.HealthCheckConfig{Disable: true}
+ },
+ check: func(t *testing.T, spec swarm.ServiceSpec, err error) {
+ require.NoError(t, err)
+ require.Equal(t, []string{"NONE"}, spec.TaskTemplate.ContainerSpec.Healthcheck.Test)
+ },
+ },
+ {
+ name: "disabled healthcheck rejects other fields",
+ configure: func(service *composegotypes.ServiceConfig) {
+ retries := uint64(1)
+ service.HealthCheck = &composegotypes.HealthCheckConfig{Disable: true, Retries: &retries}
+ },
+ check: func(t *testing.T, _ swarm.ServiceSpec, err error) {
+ require.ErrorContains(t, err, "cannot be combined")
+ },
+ },
+ {
+ name: "global mode rejects replicas",
+ configure: func(service *composegotypes.ServiceConfig) {
+ replicas := 2
+ service.Deploy = &composegotypes.DeployConfig{Mode: "global", Replicas: &replicas}
+ },
+ check: func(t *testing.T, _ swarm.ServiceSpec, err error) {
+ require.ErrorContains(t, err, "replicas can only be used")
+ },
+ },
+ {
+ name: "invalid published port fails",
+ configure: func(service *composegotypes.ServiceConfig) {
+ service.Ports = []composegotypes.ServicePortConfig{{Target: 80, Published: "invalid"}}
+ },
+ check: func(t *testing.T, _ swarm.ServiceSpec, err error) {
+ require.ErrorContains(t, err, "invalid published port")
+ },
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ service := composegotypes.ServiceConfig{Name: "web", Image: "nginx:alpine"}
+ test.configure(&service)
+ spec, err := buildServiceSpecInternal(
+ service,
+ namespace{name: "stack"},
+ map[string]string{swarmtypes.StackNamespaceLabel: "stack"},
+ map[string]string{"default": "stack_default"},
+ nil,
+ nil,
+ nil,
+ )
+ test.check(t, spec, err)
+ })
+ }
+}
+
+func TestStackConversionEndToEnd(t *testing.T) {
+ workingDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(workingDir, "db_pw.txt"), []byte("secret"), 0o600))
+
+ project, err := projects.LoadComposeProjectFromContent(context.Background(), projecttypes.ComposeContentOptions{
+ ProjectName: "stack",
+ ComposeContent: `
+services:
+ web:
+ image: nginx:alpine
+ extra_hosts:
+ api.local: 127.0.0.1
+ volumes:
+ - data:/var/lib/app
+ networks:
+ default:
+ aliases:
+ - frontend
+ configs:
+ - source: app_config
+ secrets:
+ - source: db_pw
+ deploy:
+ update_config: {}
+volumes:
+ data: {}
+networks:
+ default:
+ ipam:
+ options:
+ source: fixture
+configs:
+ app_config:
+ content: enabled=true
+secrets:
+ db_pw:
+ file: db_pw.txt
+`,
+ WorkingDir: workingDir,
+ })
+ require.NoError(t, err)
+
+ ns := namespace{name: "stack"}
+ networkNames := planNetworksInternal(project, ns)
+ volumeNames := planVolumesInternal(project, ns)
+ configPlans, err := planConfigsInternal(project, ns)
+ require.NoError(t, err)
+ secretPlans, err := planSecretsInternal(project, ns)
+ require.NoError(t, err)
+ configMeta := make(map[string]resourceMeta, len(configPlans))
+ for key, plan := range configPlans {
+ configMeta[key] = resourceMeta{ID: "config-id", Name: plan.Meta.Name}
+ }
+ secretMeta := make(map[string]resourceMeta, len(secretPlans))
+ for key, plan := range secretPlans {
+ secretMeta[key] = resourceMeta{ID: "secret-id", Name: plan.Meta.Name}
+ }
+ stackLabels := map[string]string{swarmtypes.StackNamespaceLabel: "stack"}
+
+ build := func() swarm.ServiceSpec {
+ spec, buildErr := buildServiceSpecInternal(
+ project.Services["web"],
+ ns,
+ stackLabels,
+ networkNames,
+ configMeta,
+ secretMeta,
+ project.Volumes,
+ )
+ require.NoError(t, buildErr)
+ return spec
+ }
+ spec := build()
+
+ checks := []struct {
+ aspect string
+ check func(*testing.T)
+ }{
+ {"names", func(t *testing.T) {
+ require.Equal(t, "stack_web", spec.Name)
+ require.Equal(t, "stack_default", networkNames["default"])
+ require.Equal(t, "stack_data", volumeNames["data"])
+ }},
+ {"extra hosts", func(t *testing.T) {
+ require.Equal(t, []string{"127.0.0.1 api.local"}, spec.TaskTemplate.ContainerSpec.Hosts)
+ }},
+ {"network alias", func(t *testing.T) {
+ require.Contains(t, spec.TaskTemplate.Networks[0].Aliases, "web")
+ }},
+ {"volume options", func(t *testing.T) {
+ volumeMount := spec.TaskTemplate.ContainerSpec.Mounts[0]
+ require.Equal(t, "stack_data", volumeMount.Source)
+ require.Equal(t, "stack", volumeMount.VolumeOptions.Labels[swarmtypes.StackNamespaceLabel])
+ require.NotNil(t, volumeMount.VolumeOptions.DriverConfig)
+ }},
+ {"file targets", func(t *testing.T) {
+ require.Equal(t, "app_config", spec.TaskTemplate.ContainerSpec.Configs[0].File.Name)
+ require.Equal(t, "/run/secrets/db_pw", spec.TaskTemplate.ContainerSpec.Secrets[0].File.Name)
+ }},
+ {"update defaults", func(t *testing.T) {
+ require.Equal(t, uint64(1), spec.UpdateConfig.Parallelism)
+ }},
+ {"ipam options", func(t *testing.T) {
+ require.Equal(t, "fixture", convertIPAMInternal(project.Networks["default"].Ipam).Options["source"])
+ }},
+ {"determinism", func(t *testing.T) {
+ require.Equal(t, spec, build())
+ }},
+ }
+
+ for _, check := range checks {
+ t.Run(check.aspect, check.check)
+ }
+}
diff --git a/backend/pkg/libarcane/swarm/deploy.go b/backend/pkg/libarcane/swarm/deploy.go
new file mode 100644
index 000000000..3ec6ad3e3
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/deploy.go
@@ -0,0 +1,355 @@
+package swarm
+
+import (
+ "context"
+ "fmt"
+ "maps"
+ "slices"
+ "strings"
+
+ "emperror.dev/errors"
+
+ composegotypes "github.com/compose-spec/compose-go/v2/types"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
+ projecttypes "github.com/getarcaneapp/arcane/backend/v2/pkg/projects/types"
+ swarmtypes "github.com/getarcaneapp/arcane/types/v2/swarm"
+ "github.com/moby/moby/api/types/swarm"
+ dockerclient "github.com/moby/moby/client"
+)
+
+// StackDeployOptions controls how a swarm stack is deployed.
+type StackDeployOptions struct {
+ RegistryAuthForImage func(context.Context, string) (string, error)
+ PathMapper *projects.PathMapper
+ Name string
+ ComposeContent string
+ OverrideContent string
+ EnvContent string
+ ResolveImage string
+ WorkingDir string
+ WithRegistryAuth bool
+ Prune bool
+}
+
+// DeployStack deploys a Compose-defined stack to Docker Swarm using the Engine API.
+//
+// It validates the stack name, loads the Compose project with environment
+// interpolation, ensures required swarm-scoped networks, configs, and secrets
+// exist, creates or updates services to match the desired state, optionally
+// prunes services no longer declared by the stack, and removes stale managed
+// configs and secrets after reconciliation.
+//
+// ctx controls cancellation for Compose loading and Docker API calls.
+// dockerClient must target a swarm manager capable of creating and updating stack resources.
+// opts provides the stack name, compose content, optional env content, registry-auth behavior, pruning, and image-resolution mode.
+//
+// Returns nil when the stack has been reconciled successfully.
+// Returns an error if the stack name is empty, the compose or env content is
+// invalid, a referenced resource cannot be inspected or created, or any Docker
+// API call required to reconcile the stack fails.
+func DeployStack(ctx context.Context, dockerClient *dockerclient.Client, opts StackDeployOptions) error {
+ stackName := strings.TrimSpace(opts.Name)
+ if err := validateStackNameInternal(stackName); err != nil {
+ return invalidStackErrorInternal(err)
+ }
+ ns := namespace{name: stackName}
+ resolveMode, err := normalizeResolveImageModeInternal(opts.ResolveImage)
+ if err != nil {
+ return invalidStackErrorInternal(err)
+ }
+
+ project, err := projects.LoadComposeProjectFromContent(ctx, projecttypes.ComposeContentOptions{
+ ProjectName: stackName,
+ ComposeContent: opts.ComposeContent,
+ OverrideContent: opts.OverrideContent,
+ EnvContent: opts.EnvContent,
+ WorkingDir: opts.WorkingDir,
+ PathMapper: opts.PathMapper,
+ })
+ if err != nil {
+ return invalidStackErrorInternal(err)
+ }
+ if project.Name == "" {
+ project.Name = stackName
+ }
+
+ stackLabels := map[string]string{swarmtypes.StackNamespaceLabel: stackName}
+
+ networkNameByKey, err := ensureSwarmNetworksInternal(ctx, dockerClient, project, ns, stackLabels)
+ if err != nil {
+ return err
+ }
+
+ if err := ensureSwarmVolumesInternal(ctx, dockerClient, project, ns, stackLabels); err != nil {
+ return err
+ }
+
+ configPlans, err := planConfigsInternal(project, ns)
+ if err != nil {
+ return invalidStackErrorInternal(err)
+ }
+ configMetaByKey, err := ensurePlannedFileResourcesInternal(
+ ctx,
+ configPlans,
+ stackLabels,
+ configFileResourceAdapterInternal(dockerClient),
+ )
+ if err != nil {
+ return err
+ }
+
+ secretPlans, err := planSecretsInternal(project, ns)
+ if err != nil {
+ return invalidStackErrorInternal(err)
+ }
+ secretMetaByKey, err := ensurePlannedFileResourcesInternal(
+ ctx,
+ secretPlans,
+ stackLabels,
+ secretFileResourceAdapterInternal(dockerClient),
+ )
+ if err != nil {
+ return err
+ }
+
+ existingServices, err := listStackServicesInternal(ctx, dockerClient, stackName)
+ if err != nil {
+ return err
+ }
+
+ desiredServices, err := reconcileStackServicesInternal(
+ ctx,
+ dockerClient,
+ project,
+ ns,
+ stackLabels,
+ networkNameByKey,
+ configMetaByKey,
+ secretMetaByKey,
+ existingServices,
+ opts,
+ resolveMode,
+ )
+ if err != nil {
+ return err
+ }
+
+ if opts.Prune {
+ for _, name := range slices.Sorted(maps.Keys(existingServices)) {
+ svc := existingServices[name]
+ if _, ok := desiredServices[name]; ok {
+ continue
+ }
+ if _, err := dockerClient.ServiceRemove(ctx, svc.ID, dockerclient.ServiceRemoveOptions{}); err != nil {
+ return errors.WrapIff(err, "failed to remove swarm service %s", name)
+ }
+ }
+ }
+
+ if err := cleanupStackResourcesInternal(ctx, dockerClient, stackName, configMetaByKey, secretMetaByKey); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func reconcileStackServicesInternal(
+ ctx context.Context,
+ dockerClient *dockerclient.Client,
+ project *composegotypes.Project,
+ ns namespace,
+ stackLabels map[string]string,
+ networkNameByKey map[string]string,
+ configMetaByKey map[string]resourceMeta,
+ secretMetaByKey map[string]resourceMeta,
+ existingServices map[string]swarm.Service,
+ opts StackDeployOptions,
+ resolveMode string,
+) (map[string]struct{}, error) {
+ desiredServices := map[string]struct{}{}
+
+ for _, key := range slices.Sorted(maps.Keys(project.Services)) {
+ service := project.Services[key]
+ if service.Name == "" {
+ service.Name = key
+ }
+ spec, err := buildServiceSpecInternal(service, ns, stackLabels, networkNameByKey, configMetaByKey, secretMetaByKey, project.Volumes)
+ if err != nil {
+ return nil, invalidStackErrorInternal(errors.WrapIff(err, "service %s", service.Name))
+ }
+ desiredServices[spec.Name] = struct{}{}
+
+ if existing, ok := existingServices[spec.Name]; ok {
+ if err := updateSwarmServiceInternal(ctx, dockerClient, existing, spec, opts.WithRegistryAuth, opts.RegistryAuthForImage, resolveMode); err != nil {
+ return nil, err
+ }
+ continue
+ }
+
+ if err := createSwarmServiceInternal(ctx, dockerClient, spec, opts.WithRegistryAuth, opts.RegistryAuthForImage, resolveMode); err != nil {
+ return nil, err
+ }
+ }
+
+ return desiredServices, nil
+}
+
+func listStackServicesInternal(ctx context.Context, dockerClient *dockerclient.Client, stackName string) (map[string]swarm.Service, error) {
+ filter := make(dockerclient.Filters).Add("label", fmt.Sprintf("%s=%s", swarmtypes.StackNamespaceLabel, stackName))
+ servicesResult, err := dockerClient.ServiceList(ctx, dockerclient.ServiceListOptions{Filters: filter})
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to list swarm services")
+ }
+ services := servicesResult.Items
+
+ byName := make(map[string]swarm.Service, len(services))
+ for _, service := range services {
+ byName[service.Spec.Name] = service
+ }
+ return byName, nil
+}
+
+func createSwarmServiceInternal(
+ ctx context.Context,
+ dockerClient *dockerclient.Client,
+ spec swarm.ServiceSpec,
+ withRegistryAuth bool,
+ registryAuthForImage func(context.Context, string) (string, error),
+ resolveMode string,
+) error {
+ encodedRegistryAuth, err := resolveRegistryAuthForSpecInternal(ctx, spec, withRegistryAuth, registryAuthForImage)
+ if err != nil {
+ return err
+ }
+ queryRegistry := encodedRegistryAuth != "" || shouldQueryRegistryOnCreateInternal(resolveMode)
+ opts := dockerclient.ServiceCreateOptions{
+ Spec: spec,
+ QueryRegistry: queryRegistry,
+ }
+ if encodedRegistryAuth != "" {
+ opts.EncodedRegistryAuth = encodedRegistryAuth
+ }
+ if _, err := dockerClient.ServiceCreate(ctx, opts); err != nil {
+ return errors.WrapIff(err, "failed to create swarm service %s", spec.Name)
+ }
+ return nil
+}
+
+func updateSwarmServiceInternal(
+ ctx context.Context,
+ dockerClient *dockerclient.Client,
+ existing swarm.Service,
+ spec swarm.ServiceSpec,
+ withRegistryAuth bool,
+ registryAuthForImage func(context.Context, string) (string, error),
+ resolveMode string,
+) error {
+ encodedRegistryAuth, err := resolveRegistryAuthForSpecInternal(ctx, spec, withRegistryAuth, registryAuthForImage)
+ if err != nil {
+ return err
+ }
+ queryRegistry := encodedRegistryAuth != "" || shouldQueryRegistryOnUpdateInternal(resolveMode, existing, spec)
+ if !queryRegistry {
+ preserveExistingResolvedImageInternal(&spec, existing)
+ }
+ // Do not force task rescheduling on no-op updates.
+ spec.TaskTemplate.ForceUpdate = existing.Spec.TaskTemplate.ForceUpdate
+
+ opts := dockerclient.ServiceUpdateOptions{
+ Version: existing.Version,
+ Spec: spec,
+ QueryRegistry: queryRegistry,
+ }
+ if encodedRegistryAuth != "" {
+ opts.EncodedRegistryAuth = encodedRegistryAuth
+ opts.RegistryAuthFrom = swarm.RegistryAuthFromSpec
+ } else {
+ opts.RegistryAuthFrom = swarm.RegistryAuthFromPreviousSpec
+ }
+
+ if _, err := dockerClient.ServiceUpdate(ctx, existing.ID, opts); err != nil {
+ if strings.Contains(err.Error(), "service does not have a previous spec") {
+ opts.RegistryAuthFrom = ""
+ if _, retryErr := dockerClient.ServiceUpdate(ctx, existing.ID, opts); retryErr != nil {
+ return errors.WrapIff(retryErr, "failed to update swarm service %s", spec.Name)
+ }
+ return nil
+ }
+ return errors.WrapIff(err, "failed to update swarm service %s", spec.Name)
+ }
+ return nil
+}
+
+func normalizeResolveImageModeInternal(value string) (string, error) {
+ mode := strings.ToLower(strings.TrimSpace(value))
+ if mode == "" {
+ return resolveImageAlways, nil
+ }
+ switch mode {
+ case resolveImageAlways, resolveImageChanged, resolveImageNever:
+ return mode, nil
+ default:
+ return "", errors.Errorf("invalid resolve image mode %q: expected always, changed, or never", value)
+ }
+}
+
+func shouldQueryRegistryOnCreateInternal(resolveMode string) bool {
+ return resolveMode == resolveImageAlways || resolveMode == resolveImageChanged
+}
+
+func shouldQueryRegistryOnUpdateInternal(resolveMode string, existing swarm.Service, desired swarm.ServiceSpec) bool {
+ switch resolveMode {
+ case resolveImageAlways:
+ return true
+ case resolveImageChanged:
+ desiredImage := stripImageDigestInternal(resolveServiceImageInternal(desired))
+ existingImage := stripImageDigestInternal(resolveServiceImageInternal(existing.Spec))
+ return desiredImage != "" && desiredImage != existingImage
+ default:
+ return false
+ }
+}
+
+func resolveServiceImageInternal(spec swarm.ServiceSpec) string {
+ if spec.TaskTemplate.ContainerSpec == nil {
+ return ""
+ }
+ return spec.TaskTemplate.ContainerSpec.Image
+}
+
+func preserveExistingResolvedImageInternal(spec *swarm.ServiceSpec, existing swarm.Service) {
+ if spec.TaskTemplate.ContainerSpec == nil || existing.Spec.TaskTemplate.ContainerSpec == nil {
+ return
+ }
+ if stripImageDigestInternal(resolveServiceImageInternal(*spec)) == stripImageDigestInternal(resolveServiceImageInternal(existing.Spec)) {
+ spec.TaskTemplate.ContainerSpec.Image = existing.Spec.TaskTemplate.ContainerSpec.Image
+ }
+}
+
+func stripImageDigestInternal(image string) string {
+ image, _, _ = strings.Cut(strings.TrimSpace(image), "@")
+ return image
+}
+
+func resolveRegistryAuthForSpecInternal(
+ ctx context.Context,
+ spec swarm.ServiceSpec,
+ withRegistryAuth bool,
+ registryAuthForImage func(context.Context, string) (string, error),
+) (string, error) {
+ if !withRegistryAuth || registryAuthForImage == nil {
+ return "", nil
+ }
+
+ image := resolveServiceImageInternal(spec)
+ if strings.TrimSpace(image) == "" {
+ return "", nil
+ }
+
+ encodedRegistryAuth, err := registryAuthForImage(ctx, image)
+ if err != nil {
+ return "", errors.WrapIff(err, "failed to resolve registry auth for image %s", image)
+ }
+
+ return encodedRegistryAuth, nil
+}
diff --git a/backend/pkg/libarcane/swarm/load_test.go b/backend/pkg/libarcane/swarm/load_test.go
new file mode 100644
index 000000000..15edf827e
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/load_test.go
@@ -0,0 +1,79 @@
+package swarm
+
+import (
+ "context"
+ "testing"
+
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
+ projecttypes "github.com/getarcaneapp/arcane/backend/v2/pkg/projects/types"
+ "github.com/stretchr/testify/require"
+)
+
+func TestLoadComposeProjectMergesOverrideContent(t *testing.T) {
+ base := "services:\n app:\n image: nginx:alpine\n environment:\n FROM_BASE: \"1\"\n"
+ override := "services:\n app:\n image: busybox:latest\n environment:\n FROM_OVERRIDE: \"1\"\n"
+
+ project, err := projects.LoadComposeProjectFromContent(context.Background(), projecttypes.ComposeContentOptions{
+ ProjectName: "stack",
+ ComposeContent: base,
+ OverrideContent: override,
+ })
+ require.NoError(t, err)
+
+ app := project.Services["app"]
+ require.Equal(t, "busybox:latest", app.Image)
+ require.Contains(t, app.Environment, "FROM_BASE")
+ require.Contains(t, app.Environment, "FROM_OVERRIDE")
+}
+
+func TestLoadComposeProjectWithoutOverrideContent(t *testing.T) {
+ project, err := projects.LoadComposeProjectFromContent(context.Background(), projecttypes.ComposeContentOptions{
+ ProjectName: "stack",
+ ComposeContent: "services:\n app:\n image: nginx:alpine\n",
+ })
+ require.NoError(t, err)
+ require.Equal(t, "nginx:alpine", project.Services["app"].Image)
+}
+
+func TestLoadComposeProjectNamespacesResourceNames(t *testing.T) {
+ composeContent := `
+services:
+ app:
+ image: alpine
+ volumes:
+ - data:/data
+ - named:/named
+ - external:/external
+ networks:
+ - default
+ - named
+ - external
+volumes:
+ data: {}
+ named:
+ name: custom
+ external:
+ name: external
+ external: true
+networks:
+ default: {}
+ named:
+ name: custom-network
+ external:
+ name: external-network
+ external: true
+`
+
+ project, err := projects.LoadComposeProjectFromContent(context.Background(), projecttypes.ComposeContentOptions{
+ ProjectName: "stack",
+ ComposeContent: composeContent,
+ })
+ require.NoError(t, err)
+
+ require.Equal(t, "stack_data", project.Volumes["data"].Name)
+ require.Equal(t, "custom", project.Volumes["named"].Name)
+ require.Equal(t, "external", project.Volumes["external"].Name)
+ require.Equal(t, "stack_default", project.Networks["default"].Name)
+ require.Equal(t, "custom-network", project.Networks["named"].Name)
+ require.Equal(t, "external-network", project.Networks["external"].Name)
+}
diff --git a/backend/pkg/libarcane/swarm/namespace.go b/backend/pkg/libarcane/swarm/namespace.go
new file mode 100644
index 000000000..bf2b1a39b
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/namespace.go
@@ -0,0 +1,107 @@
+package swarm
+
+import (
+ "crypto/sha256"
+ "encoding/hex"
+ "fmt"
+ "maps"
+ "regexp"
+ "slices"
+ "strings"
+
+ "emperror.dev/errors"
+
+ composegotypes "github.com/compose-spec/compose-go/v2/types"
+)
+
+const (
+ resolveImageAlways = "always"
+ resolveImageChanged = "changed"
+ resolveImageNever = "never"
+ resourceTypeLabel = "app.getarcane.swarm.resource.type"
+ resourceNameLabel = "app.getarcane.swarm.resource.name"
+ resourceHashLabel = "app.getarcane.swarm.resource.hash"
+ legacyResourceTypeLabel = "io.getarcane.swarm.resource.type"
+ resourceNameMaxHash = 12
+)
+
+var stackNamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]*$`)
+
+// ErrInvalidStack identifies invalid stack source or conversion input.
+var ErrInvalidStack = errors.Sentinel("invalid swarm stack")
+
+type namespace struct {
+ name string
+}
+
+func (n namespace) Scope(key string) string {
+ return n.name + "_" + key
+}
+
+func (n namespace) Resolve(key, configuredName string) string {
+ if name := strings.TrimSpace(configuredName); name != "" {
+ return name
+ }
+ return n.Scope(key)
+}
+
+func mergeLabelsInternal(primary map[string]string, secondary map[string]string) map[string]string {
+ out := map[string]string{}
+ maps.Copy(out, primary)
+ maps.Copy(out, secondary)
+ return out
+}
+
+func validateStackNameInternal(stackName string) error {
+ switch {
+ case stackName == "":
+ return errors.New("stack name is required")
+ case !stackNamePattern.MatchString(stackName):
+ return errors.Errorf("invalid stack name %q: use lowercase letters, numbers, hyphens, and underscores, starting with a letter or number", stackName)
+ default:
+ return nil
+ }
+}
+
+func invalidStackErrorInternal(err error) error {
+ if err == nil || errors.Is(err, ErrInvalidStack) {
+ return err
+ }
+ return fmt.Errorf("%w: %w", ErrInvalidStack, err)
+}
+
+func hashManagedResourceInternal(data []byte) string {
+ sum := sha256.Sum256(data)
+ return hex.EncodeToString(sum[:])
+}
+
+func hashManagedFileResourceInternal(config composegotypes.FileObjectConfig, data []byte) string {
+ if config.Driver == "" && config.TemplateDriver == "" && len(config.DriverOpts) == 0 {
+ return hashManagedResourceInternal(data)
+ }
+
+ hasher := sha256.New()
+ _, _ = hasher.Write(data)
+ _, _ = hasher.Write([]byte{0})
+ _, _ = hasher.Write([]byte(config.Driver))
+ _, _ = hasher.Write([]byte{0})
+ _, _ = hasher.Write([]byte(config.TemplateDriver))
+ for _, key := range slices.Sorted(maps.Keys(config.DriverOpts)) {
+ _, _ = hasher.Write([]byte{0})
+ _, _ = hasher.Write([]byte(key))
+ _, _ = hasher.Write([]byte{0})
+ _, _ = hasher.Write([]byte(config.DriverOpts[key]))
+ }
+ return hex.EncodeToString(hasher.Sum(nil))
+}
+
+func managedResourceNameInternal(logicalName, hash string) string {
+ hash = strings.TrimSpace(hash)
+ if len(hash) > resourceNameMaxHash {
+ hash = hash[:resourceNameMaxHash]
+ }
+ if hash == "" {
+ return logicalName
+ }
+ return fmt.Sprintf("%s_%s", logicalName, hash)
+}
diff --git a/backend/pkg/libarcane/swarm/namespace_test.go b/backend/pkg/libarcane/swarm/namespace_test.go
new file mode 100644
index 000000000..087753b19
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/namespace_test.go
@@ -0,0 +1,21 @@
+package swarm
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestNamespaceResolve(t *testing.T) {
+ ns := namespace{name: "stack"}
+
+ require.Equal(t, "stack_data", ns.Scope("data"))
+ require.Equal(t, "stack_data", ns.Resolve("data", ""))
+ require.Equal(t, "custom", ns.Resolve("data", " custom "))
+}
+
+func TestValidateStackNameInternal(t *testing.T) {
+ require.NoError(t, validateStackNameInternal("stack-1"))
+ require.Error(t, validateStackNameInternal("Stack-1"))
+ require.Error(t, validateStackNameInternal("../stack"))
+}
diff --git a/backend/pkg/libarcane/swarm/render.go b/backend/pkg/libarcane/swarm/render.go
new file mode 100644
index 000000000..775e8bce3
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/render.go
@@ -0,0 +1,117 @@
+package swarm
+
+import (
+ "context"
+ "maps"
+ "slices"
+ "strings"
+
+ "emperror.dev/errors"
+
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
+ projecttypes "github.com/getarcaneapp/arcane/backend/v2/pkg/projects/types"
+)
+
+type StackRenderOptions struct {
+ Name string
+ ComposeContent string
+ OverrideContent string
+ EnvContent string
+ WorkingDir string
+ PathMapper *projects.PathMapper
+}
+
+type StackRenderResult struct {
+ Name string
+ RenderedCompose string
+ Services []string
+ Networks []string
+ Volumes []string
+ Configs []string
+ Secrets []string
+}
+
+// RenderStackConfig renders a Compose-defined stack without deploying it.
+//
+// It validates the stack name, loads and interpolates the Compose project using
+// the provided environment content, marshals the normalized project back to
+// YAML, and reports the discovered service, network, volume, config, and secret
+// names that would participate in deployment.
+//
+// ctx controls cancellation for Compose loading.
+// opts provides the stack name, compose content, and optional env content to render.
+//
+// Returns the rendered compose YAML and related resource names.
+// Returns an error if the stack name is empty, the compose or env content is
+// invalid, or the normalized Compose project cannot be marshaled.
+func RenderStackConfig(ctx context.Context, opts StackRenderOptions) (*StackRenderResult, error) {
+ stackName := strings.TrimSpace(opts.Name)
+ if err := validateStackNameInternal(stackName); err != nil {
+ return nil, invalidStackErrorInternal(err)
+ }
+ ns := namespace{name: stackName}
+
+ project, err := projects.LoadComposeProjectFromContent(ctx, projecttypes.ComposeContentOptions{
+ ProjectName: stackName,
+ ComposeContent: opts.ComposeContent,
+ OverrideContent: opts.OverrideContent,
+ EnvContent: opts.EnvContent,
+ WorkingDir: opts.WorkingDir,
+ PathMapper: opts.PathMapper,
+ })
+ if err != nil {
+ return nil, invalidStackErrorInternal(err)
+ }
+ if project.Name == "" {
+ project.Name = stackName
+ }
+
+ configMetaByKey, err := planConfigsInternal(project, ns)
+ if err != nil {
+ return nil, invalidStackErrorInternal(err)
+ }
+ secretMetaByKey, err := planSecretsInternal(project, ns)
+ if err != nil {
+ return nil, invalidStackErrorInternal(err)
+ }
+
+ rendered, err := project.MarshalYAML()
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to render compose project")
+ }
+
+ serviceNames := make([]string, 0, len(project.Services))
+ for _, key := range slices.Sorted(maps.Keys(project.Services)) {
+ service := project.Services[key]
+ name := service.Name
+ if name == "" {
+ name = key
+ }
+ serviceNames = append(serviceNames, ns.Scope(name))
+ }
+
+ return &StackRenderResult{
+ Name: stackName,
+ RenderedCompose: string(rendered),
+ Services: serviceNames,
+ Networks: sortedStringValuesInternal(planNetworksInternal(project, ns)),
+ Volumes: sortedStringValuesInternal(planVolumesInternal(project, ns)),
+ Configs: sortedPlannedResourceNamesInternal(configMetaByKey),
+ Secrets: sortedPlannedResourceNamesInternal(secretMetaByKey),
+ }, nil
+}
+
+func sortedStringValuesInternal(valuesByKey map[string]string) []string {
+ values := slices.Collect(maps.Values(valuesByKey))
+ slices.Sort(values)
+ return values
+}
+
+func sortedPlannedResourceNamesInternal(plansByKey map[string]plannedFileResourceInternal) []string {
+ names := make([]string, 0, len(plansByKey))
+ for _, plan := range plansByKey {
+ names = append(names, plan.Meta.Name)
+ }
+ slices.Sort(names)
+ return names
+}
diff --git a/backend/pkg/libarcane/swarm/resources.go b/backend/pkg/libarcane/swarm/resources.go
new file mode 100644
index 000000000..9ae0e9acf
--- /dev/null
+++ b/backend/pkg/libarcane/swarm/resources.go
@@ -0,0 +1,362 @@
+package swarm
+
+import (
+ "context"
+ "maps"
+ "slices"
+ "strings"
+
+ "emperror.dev/errors"
+
+ composegotypes "github.com/compose-spec/compose-go/v2/types"
+ cerrdefs "github.com/containerd/errdefs"
+ "github.com/moby/moby/api/types/swarm"
+ dockerclient "github.com/moby/moby/client"
+)
+
+type resourceMeta struct {
+ ID string
+ Name string
+}
+
+type managedFileResourceSpecInternal struct {
+ Name string
+ Labels map[string]string
+ Data []byte
+ Driver string
+ DriverOpts map[string]string
+ TemplateDriver string
+}
+
+type plannedFileResourceInternal struct {
+ Meta resourceMeta
+ BaseName string
+ Hash string
+ Config composegotypes.FileObjectConfig
+ Labels map[string]string
+ Data []byte
+ IsExternal bool
+}
+
+type fileResourceAdapterInternal struct {
+ ResourceType string
+ Inspect func(context.Context, string) (resourceMeta, error)
+ Create func(context.Context, managedFileResourceSpecInternal) (resourceMeta, error)
+ List func(context.Context, dockerclient.Filters) ([]staleManagedResourceInternal, error)
+ Remove func(context.Context, string) error
+}
+
+func planNetworksInternal(project *composegotypes.Project, ns namespace) map[string]string {
+ result := make(map[string]string, len(project.Networks))
+ for key, config := range project.Networks {
+ result[key] = ns.Resolve(key, config.Name)
+ }
+ return result
+}
+
+func planVolumesInternal(project *composegotypes.Project, ns namespace) map[string]string {
+ result := make(map[string]string, len(project.Volumes))
+ for key, config := range project.Volumes {
+ result[key] = ns.Resolve(key, config.Name)
+ }
+ return result
+}
+
+func planConfigsInternal(project *composegotypes.Project, ns namespace) (map[string]plannedFileResourceInternal, error) {
+ configs := make(map[string]composegotypes.FileObjectConfig, len(project.Configs))
+ for key, config := range project.Configs {
+ configs[key] = composegotypes.FileObjectConfig(config)
+ }
+ return planManagedFileResourcesInternal(configs, ns, project.WorkingDir, project.Environment, "config")
+}
+
+func planSecretsInternal(project *composegotypes.Project, ns namespace) (map[string]plannedFileResourceInternal, error) {
+ secrets := make(map[string]composegotypes.FileObjectConfig, len(project.Secrets))
+ for key, secret := range project.Secrets {
+ secrets[key] = composegotypes.FileObjectConfig(secret)
+ }
+ return planManagedFileResourcesInternal(secrets, ns, project.WorkingDir, project.Environment, "secret")
+}
+
+func planManagedFileResourcesInternal(
+ resources map[string]composegotypes.FileObjectConfig,
+ ns namespace,
+ workingDir string,
+ environment composegotypes.Mapping,
+ resourceType string,
+) (map[string]plannedFileResourceInternal, error) {
+ result := make(map[string]plannedFileResourceInternal, len(resources))
+ for _, key := range slices.Sorted(maps.Keys(resources)) {
+ resource := resources[key]
+ baseName := ns.Resolve(key, resource.Name)
+ plan := plannedFileResourceInternal{
+ Meta: resourceMeta{Name: baseName},
+ BaseName: baseName,
+ Config: resource,
+ Labels: resource.Labels,
+ IsExternal: bool(resource.External),
+ }
+ if bool(resource.External) {
+ result[key] = plan
+ continue
+ }
+ if resourceType == "config" && resource.Driver != "" {
+ return nil, errors.Errorf("config driver %q is not supported by the Docker swarm API", resource.Driver)
+ }
+
+ var data []byte
+ if resource.Driver == "" {
+ resolvedData, err := resolveFileObjectContentInternal(resource, workingDir, environment)
+ if err != nil {
+ return nil, errors.WrapIff(err, "failed to load %s %s", resourceType, baseName)
+ }
+ data = resolvedData
+ }
+ plan.Data = data
+ plan.Hash = hashManagedFileResourceInternal(resource, data)
+ plan.Meta.Name = managedResourceNameInternal(baseName, plan.Hash)
+ result[key] = plan
+ }
+ return result, nil
+}
+
+func ensureSwarmNetworksInternal(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, ns namespace, stackLabels map[string]string) (map[string]string, error) {
+ result := planNetworksInternal(project, ns)
+ for _, key := range slices.Sorted(maps.Keys(project.Networks)) {
+ cfg := project.Networks[key]
+ networkName := result[key]
+
+ if bool(cfg.External) {
+ if networkName == "bridge" || networkName == "host" || networkName == "none" {
+ continue
+ }
+ inspected, err := dockerClient.NetworkInspect(ctx, networkName, dockerclient.NetworkInspectOptions{Scope: "swarm"})
+ if err != nil {
+ return nil, invalidStackErrorInternal(errors.WrapIff(err, "external network %s is unavailable", networkName))
+ }
+ if inspected.Network.Scope != "swarm" {
+ return nil, invalidStackErrorInternal(errors.Errorf("external network %q has scope %q, expected swarm", networkName, inspected.Network.Scope))
+ }
+ continue
+ }
+
+ _, err := dockerClient.NetworkInspect(ctx, networkName, dockerclient.NetworkInspectOptions{Scope: "swarm"})
+ if err == nil {
+ continue
+ }
+ if !cerrdefs.IsNotFound(err) {
+ return nil, errors.WrapIff(err, "failed to inspect network %s", networkName)
+ }
+
+ driver := strings.TrimSpace(cfg.Driver)
+ if driver == "" {
+ driver = "overlay"
+ }
+
+ labels := mergeLabelsInternal(cfg.Labels, stackLabels)
+ createOpts := dockerclient.NetworkCreateOptions{
+ Driver: driver,
+ Scope: "swarm",
+ EnableIPv4: cfg.EnableIPv4,
+ EnableIPv6: cfg.EnableIPv6,
+ Internal: cfg.Internal,
+ Attachable: cfg.Attachable,
+ Options: cfg.DriverOpts,
+ Labels: labels,
+ IPAM: convertIPAMInternal(cfg.Ipam),
+ }
+
+ if _, err := dockerClient.NetworkCreate(ctx, networkName, createOpts); err != nil {
+ return nil, errors.WrapIff(err, "failed to create network %s", networkName)
+ }
+ }
+
+ return result, nil
+}
+
+// ensureSwarmVolumesInternal pre-creates named volumes that carry a driver or
+// driver_opts so that Swarm services pick up the correct volume configuration.
+// Without this step Docker creates a plain local volume on first use and the
+// driver options are silently ignored — the root cause of issue #2376.
+func ensureSwarmVolumesInternal(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, ns namespace, stackLabels map[string]string) error {
+ volumeNameByKey := planVolumesInternal(project, ns)
+ for _, key := range slices.Sorted(maps.Keys(project.Volumes)) {
+ cfg := project.Volumes[key]
+ // External volumes must already exist; nothing to create.
+ if cfg.External {
+ continue
+ }
+ // Only act when driver or driver_opts are explicitly set.
+ if cfg.Driver == "" && len(cfg.DriverOpts) == 0 {
+ continue
+ }
+
+ name := volumeNameByKey[key]
+
+ // If the volume already exists, leave it as-is to avoid disrupting
+ // running services that may be attached to it.
+ if _, err := dockerClient.VolumeInspect(ctx, name, dockerclient.VolumeInspectOptions{}); err == nil {
+ continue
+ } else if !cerrdefs.IsNotFound(err) {
+ return errors.WrapIff(err, "failed to inspect volume %s", name)
+ }
+
+ driver := cfg.Driver
+ if driver == "" {
+ driver = "local"
+ }
+ labels := mergeLabelsInternal(cfg.Labels, stackLabels)
+ if _, err := dockerClient.VolumeCreate(ctx, dockerclient.VolumeCreateOptions{
+ Name: name,
+ Driver: driver,
+ DriverOpts: cfg.DriverOpts,
+ Labels: labels,
+ }); err != nil {
+ return errors.WrapIff(err, "failed to create volume %s", name)
+ }
+ }
+ return nil
+}
+
+func configFileResourceAdapterInternal(dockerClient *dockerclient.Client) fileResourceAdapterInternal {
+ return fileResourceAdapterInternal{
+ ResourceType: "config",
+ Inspect: func(ctx context.Context, name string) (resourceMeta, error) {
+ configResult, err := dockerClient.ConfigInspect(ctx, name, dockerclient.ConfigInspectOptions{})
+ if err != nil {
+ return resourceMeta{}, err
+ }
+ config := configResult.Config
+ return resourceMeta{ID: config.ID, Name: config.Spec.Name}, nil
+ },
+ Create: func(ctx context.Context, resource managedFileResourceSpecInternal) (resourceMeta, error) {
+ spec := swarm.ConfigSpec{
+ Annotations: swarm.Annotations{Name: resource.Name, Labels: resource.Labels},
+ Data: resource.Data,
+ }
+ if resource.TemplateDriver != "" {
+ spec.Templating = &swarm.Driver{Name: resource.TemplateDriver}
+ }
+ response, err := dockerClient.ConfigCreate(ctx, dockerclient.ConfigCreateOptions{Spec: spec})
+ if err != nil {
+ return resourceMeta{}, errors.WrapIff(err, "failed to create config %s", resource.Name)
+ }
+ return resourceMeta{ID: response.ID, Name: resource.Name}, nil
+ },
+ List: func(ctx context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
+ configsResult, err := dockerClient.ConfigList(ctx, dockerclient.ConfigListOptions{Filters: filters})
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to list stack configs")
+ }
+ return collectStaleManagedResourcesInternal(configsResult.Items, func(cfg swarm.Config) staleManagedResourceInternal {
+ return staleManagedResourceInternal{ID: cfg.ID, Name: cfg.Spec.Name}
+ }), nil
+ },
+ Remove: func(ctx context.Context, id string) error {
+ _, err := dockerClient.ConfigRemove(ctx, id, dockerclient.ConfigRemoveOptions{})
+ return err
+ },
+ }
+}
+
+func secretFileResourceAdapterInternal(dockerClient *dockerclient.Client) fileResourceAdapterInternal {
+ return fileResourceAdapterInternal{
+ ResourceType: "secret",
+ Inspect: func(ctx context.Context, name string) (resourceMeta, error) {
+ secretResult, err := dockerClient.SecretInspect(ctx, name, dockerclient.SecretInspectOptions{})
+ if err != nil {
+ return resourceMeta{}, err
+ }
+ secret := secretResult.Secret
+ return resourceMeta{ID: secret.ID, Name: secret.Spec.Name}, nil
+ },
+ Create: func(ctx context.Context, resource managedFileResourceSpecInternal) (resourceMeta, error) {
+ spec := swarm.SecretSpec{
+ Annotations: swarm.Annotations{Name: resource.Name, Labels: resource.Labels},
+ Data: resource.Data,
+ }
+ if resource.Driver != "" {
+ spec.Driver = &swarm.Driver{Name: resource.Driver, Options: resource.DriverOpts}
+ }
+ if resource.TemplateDriver != "" {
+ spec.Templating = &swarm.Driver{Name: resource.TemplateDriver}
+ }
+ response, err := dockerClient.SecretCreate(ctx, dockerclient.SecretCreateOptions{Spec: spec})
+ if err != nil {
+ return resourceMeta{}, errors.WrapIff(err, "failed to create secret %s", resource.Name)
+ }
+ return resourceMeta{ID: response.ID, Name: resource.Name}, nil
+ },
+ List: func(ctx context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
+ secretsResult, err := dockerClient.SecretList(ctx, dockerclient.SecretListOptions{Filters: filters})
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to list stack secrets")
+ }
+ return collectStaleManagedResourcesInternal(secretsResult.Items, func(secret swarm.Secret) staleManagedResourceInternal {
+ return staleManagedResourceInternal{ID: secret.ID, Name: secret.Spec.Name}
+ }), nil
+ },
+ Remove: func(ctx context.Context, id string) error {
+ _, err := dockerClient.SecretRemove(ctx, id, dockerclient.SecretRemoveOptions{})
+ return err
+ },
+ }
+}
+
+func ensurePlannedFileResourcesInternal(
+ ctx context.Context,
+ plans map[string]plannedFileResourceInternal,
+ stackLabels map[string]string,
+ adapter fileResourceAdapterInternal,
+) (map[string]resourceMeta, error) {
+ result := make(map[string]resourceMeta, len(plans))
+ for _, key := range slices.Sorted(maps.Keys(plans)) {
+ plan := plans[key]
+ if plan.IsExternal {
+ meta, err := adapter.Inspect(ctx, plan.Meta.Name)
+ if err != nil {
+ return nil, invalidStackErrorInternal(errors.WrapIff(
+ err,
+ "external %s %s is unavailable",
+ adapter.ResourceType,
+ plan.Meta.Name,
+ ))
+ }
+ result[key] = meta
+ continue
+ }
+
+ meta, err := ensureManagedFileResourceInternal(ctx, plan, stackLabels, adapter)
+ if err != nil {
+ return nil, err
+ }
+ result[key] = meta
+ }
+ return result, nil
+}
+
+func ensureManagedFileResourceInternal(
+ ctx context.Context,
+ plan plannedFileResourceInternal,
+ stackLabels map[string]string,
+ adapter fileResourceAdapterInternal,
+) (resourceMeta, error) {
+ if meta, err := adapter.Inspect(ctx, plan.Meta.Name); err == nil {
+ return meta, nil
+ } else if !cerrdefs.IsNotFound(err) {
+ return resourceMeta{}, errors.WrapIff(err, "failed to inspect %s %s", adapter.ResourceType, plan.Meta.Name)
+ }
+
+ resourceLabels := mergeLabelsInternal(plan.Labels, stackLabels)
+ resourceLabels[resourceTypeLabel] = adapter.ResourceType
+ resourceLabels[resourceNameLabel] = plan.BaseName
+ resourceLabels[resourceHashLabel] = plan.Hash
+ return adapter.Create(ctx, managedFileResourceSpecInternal{
+ Name: plan.Meta.Name,
+ Labels: resourceLabels,
+ Data: plan.Data,
+ Driver: plan.Config.Driver,
+ DriverOpts: plan.Config.DriverOpts,
+ TemplateDriver: plan.Config.TemplateDriver,
+ })
+}
diff --git a/backend/pkg/libarcane/swarm/stack_deploy_engine.go b/backend/pkg/libarcane/swarm/stack_deploy_engine.go
deleted file mode 100644
index 41c130f40..000000000
--- a/backend/pkg/libarcane/swarm/stack_deploy_engine.go
+++ /dev/null
@@ -1,1480 +0,0 @@
-package swarm
-
-import (
- "context"
- "crypto/sha256"
- "encoding/hex"
- "fmt"
- "maps"
- "net/netip"
- "os"
- "path/filepath"
- "strconv"
- "strings"
- "time"
-
- "emperror.dev/errors"
-
- composegoloader "github.com/compose-spec/compose-go/v2/loader"
- composegotypes "github.com/compose-spec/compose-go/v2/types"
- cerrdefs "github.com/containerd/errdefs"
- "github.com/docker/compose/v5/pkg/api"
- "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
- swarmtypes "github.com/getarcaneapp/arcane/types/v2/swarm"
- "github.com/moby/moby/api/types/mount"
- "github.com/moby/moby/api/types/network"
- "github.com/moby/moby/api/types/swarm"
- dockerclient "github.com/moby/moby/client"
- "github.com/samber/mo"
-)
-
-type resourceMeta struct {
- ID string
- Name string
-}
-
-const (
- resolveImageAlways = "always"
- resolveImageChanged = "changed"
- resolveImageNever = "never"
- stackImageLabel = "com.docker.stack.image"
- resourceTypeLabel = "io.getarcane.swarm.resource.type"
- resourceNameLabel = "io.getarcane.swarm.resource.name"
- resourceHashLabel = "io.getarcane.swarm.resource.hash"
- resourceNameMaxHash = 12
-)
-
-// StackDeployOptions controls how a swarm stack is deployed.
-type StackDeployOptions struct {
- RegistryAuthForImage func(context.Context, string) (string, error)
- PathMapper *projects.PathMapper
- Name string
- ComposeContent string
- OverrideContent string
- EnvContent string
- ResolveImage string
- WorkingDir string
- WithRegistryAuth bool
- Prune bool
-}
-
-type StackRenderOptions struct {
- Name string
- ComposeContent string
- OverrideContent string
- EnvContent string
- WorkingDir string
- PathMapper *projects.PathMapper
-}
-
-type StackRenderResult struct {
- Name string
- RenderedCompose string
- Services []string
- Networks []string
- Volumes []string
- Configs []string
- Secrets []string
-}
-
-// DeployStack deploys a Compose-defined stack to Docker Swarm using the Engine API.
-//
-// It validates the stack name, loads the Compose project with environment
-// interpolation, ensures required swarm-scoped networks, configs, and secrets
-// exist, creates or updates services to match the desired state, optionally
-// prunes services no longer declared by the stack, and removes stale managed
-// configs and secrets after reconciliation.
-//
-// ctx controls cancellation for Compose loading and Docker API calls.
-// dockerClient must target a swarm manager capable of creating and updating stack resources.
-// opts provides the stack name, compose content, optional env content, registry-auth behavior, pruning, and image-resolution mode.
-//
-// Returns nil when the stack has been reconciled successfully.
-// Returns an error if the stack name is empty, the compose or env content is
-// invalid, a referenced resource cannot be inspected or created, or any Docker
-// API call required to reconcile the stack fails.
-func DeployStack(ctx context.Context, dockerClient *dockerclient.Client, opts StackDeployOptions) error {
- stackName := strings.TrimSpace(opts.Name)
- if stackName == "" {
- return errors.New("stack name is required")
- }
- resolveMode, err := normalizeResolveImageMode(opts.ResolveImage)
- if err != nil {
- return err
- }
-
- project, err := loadComposeProject(ctx, stackName, opts.ComposeContent, opts.OverrideContent, opts.EnvContent, opts.WorkingDir, opts.PathMapper)
- if err != nil {
- return err
- }
- if project.Name == "" {
- project.Name = stackName
- }
-
- stackLabels := map[string]string{swarmtypes.StackNamespaceLabel: stackName}
-
- networkNameByKey, err := ensureSwarmNetworks(ctx, dockerClient, project, stackName, stackLabels)
- if err != nil {
- return err
- }
-
- if err := ensureSwarmVolumesInternal(ctx, dockerClient, project, stackName, stackLabels); err != nil {
- return err
- }
-
- configMetaByKey, err := ensureSwarmConfigs(ctx, dockerClient, project, stackName, stackLabels)
- if err != nil {
- return err
- }
-
- secretMetaByKey, err := ensureSwarmSecrets(ctx, dockerClient, project, stackName, stackLabels)
- if err != nil {
- return err
- }
-
- existingServices, err := listStackServices(ctx, dockerClient, stackName)
- if err != nil {
- return err
- }
-
- desiredServices, err := reconcileStackServices(
- ctx,
- dockerClient,
- project,
- stackName,
- stackLabels,
- networkNameByKey,
- configMetaByKey,
- secretMetaByKey,
- existingServices,
- opts,
- resolveMode,
- )
- if err != nil {
- return err
- }
-
- if opts.Prune {
- for name, svc := range existingServices {
- if _, ok := desiredServices[name]; ok {
- continue
- }
- if _, err := dockerClient.ServiceRemove(ctx, svc.ID, dockerclient.ServiceRemoveOptions{}); err != nil {
- return errors.WrapIff(err, "failed to remove swarm service %s", name)
- }
- }
- }
-
- if err := cleanupStackResources(ctx, dockerClient, stackName, configMetaByKey, secretMetaByKey); err != nil {
- return err
- }
-
- return nil
-}
-
-func reconcileStackServices(
- ctx context.Context,
- dockerClient *dockerclient.Client,
- project *composegotypes.Project,
- stackName string,
- stackLabels map[string]string,
- networkNameByKey map[string]string,
- configMetaByKey map[string]resourceMeta,
- secretMetaByKey map[string]resourceMeta,
- existingServices map[string]swarm.Service,
- opts StackDeployOptions,
- resolveMode string,
-) (map[string]struct{}, error) {
- desiredServices := map[string]struct{}{}
-
- for key, service := range project.Services {
- if service.Name == "" {
- service.Name = key
- }
- spec := buildServiceSpec(service, stackName, stackLabels, networkNameByKey, configMetaByKey, secretMetaByKey, project.Volumes)
- desiredServices[spec.Name] = struct{}{}
-
- if existing, ok := existingServices[spec.Name]; ok {
- if err := updateSwarmService(ctx, dockerClient, existing, spec, opts.WithRegistryAuth, opts.RegistryAuthForImage, resolveMode); err != nil {
- return nil, err
- }
- continue
- }
-
- if err := createSwarmService(ctx, dockerClient, spec, opts.WithRegistryAuth, opts.RegistryAuthForImage, resolveMode); err != nil {
- return nil, err
- }
- }
-
- return desiredServices, nil
-}
-
-func cleanupStackResources(
- ctx context.Context,
- dockerClient *dockerclient.Client,
- stackName string,
- configMetaByKey map[string]resourceMeta,
- secretMetaByKey map[string]resourceMeta,
-) error {
- desiredConfigNames := make(map[string]struct{}, len(configMetaByKey))
- for _, meta := range configMetaByKey {
- desiredConfigNames[meta.Name] = struct{}{}
- }
- if err := cleanupStaleConfigs(ctx, dockerClient, stackName, desiredConfigNames); err != nil {
- return err
- }
-
- desiredSecretNames := make(map[string]struct{}, len(secretMetaByKey))
- for _, meta := range secretMetaByKey {
- desiredSecretNames[meta.Name] = struct{}{}
- }
- if err := cleanupStaleSecrets(ctx, dockerClient, stackName, desiredSecretNames); err != nil {
- return err
- }
-
- return nil
-}
-
-// RenderStackConfig renders a Compose-defined stack without deploying it.
-//
-// It validates the stack name, loads and interpolates the Compose project using
-// the provided environment content, marshals the normalized project back to
-// YAML, and reports the discovered service, network, volume, config, and secret
-// names that would participate in deployment.
-//
-// ctx controls cancellation for Compose loading.
-// opts provides the stack name, compose content, and optional env content to render.
-//
-// Returns the rendered compose YAML and related resource names.
-// Returns an error if the stack name is empty, the compose or env content is
-// invalid, or the normalized Compose project cannot be marshaled.
-func RenderStackConfig(ctx context.Context, opts StackRenderOptions) (*StackRenderResult, error) {
- stackName := strings.TrimSpace(opts.Name)
- if stackName == "" {
- return nil, errors.New("stack name is required")
- }
-
- project, err := loadComposeProject(ctx, stackName, opts.ComposeContent, opts.OverrideContent, opts.EnvContent, opts.WorkingDir, opts.PathMapper)
- if err != nil {
- return nil, err
- }
- if project.Name == "" {
- project.Name = stackName
- }
-
- rendered, err := project.MarshalYAML()
- if err != nil {
- return nil, errors.WrapIf(err, "failed to render compose project")
- }
-
- return &StackRenderResult{
- Name: stackName,
- RenderedCompose: string(rendered),
- Services: project.ServiceNames(),
- Networks: project.NetworkNames(),
- Volumes: project.VolumeNames(),
- Configs: project.ConfigNames(),
- Secrets: project.SecretNames(),
- }, nil
-}
-
-func loadComposeProject(ctx context.Context, projectName, composeContent, overrideContent, envContent, providedWorkingDir string, pathMapper *projects.PathMapper) (*composegotypes.Project, error) {
- composeContent = strings.TrimSpace(composeContent)
- if composeContent == "" {
- return nil, errors.New("compose content is required")
- }
-
- envMap, err := parseEnvContent(envContent)
- if err != nil {
- return nil, errors.WrapIf(err, "failed to parse env content")
- }
-
- workingDir := strings.TrimSpace(providedWorkingDir)
- if workingDir == "" {
- cwd, err := os.Getwd()
- if err != nil {
- workingDir = "/tmp"
- } else {
- workingDir = cwd
- }
- }
- envMap["PWD"] = workingDir
-
- configFiles := []composegotypes.ConfigFile{
- {Content: []byte(composeContent)},
- }
- // Merge an optional Docker Compose override on top of the base content, as
- // `docker compose` does. Listing it last makes the override take precedence.
- if trimmedOverride := strings.TrimSpace(overrideContent); trimmedOverride != "" {
- configFiles = append(configFiles, composegotypes.ConfigFile{Content: []byte(trimmedOverride)})
- }
-
- configDetails := composegotypes.ConfigDetails{
- Version: api.ComposeVersion,
- WorkingDir: workingDir,
- ConfigFiles: configFiles,
- Environment: composegotypes.Mapping(envMap),
- }
-
- project, err := composegoloader.LoadWithContext(ctx, configDetails, func(opts *composegoloader.Options) {
- if strings.TrimSpace(projectName) != "" {
- opts.SetProjectName(strings.TrimSpace(projectName), true)
- }
- })
- if err != nil {
- return nil, errors.WrapIf(err, "failed to load compose project")
- }
-
- project = project.WithoutUnnecessaryResources()
-
- // Resolve relative paths for bind mounts, secrets, and configs
- projects.ResolveRelativeProjectPaths(project, workingDir)
-
- // Translate container paths to host paths for Docker execution
- if pathMapper != nil {
- if err := pathMapper.TranslateVolumeSources(project); err != nil {
- return nil, errors.WrapIf(err, "failed to translate paths for docker host")
- }
- }
-
- return project, nil
-}
-
-func listStackServices(ctx context.Context, dockerClient *dockerclient.Client, stackName string) (map[string]swarm.Service, error) {
- filter := make(dockerclient.Filters).Add("label", fmt.Sprintf("%s=%s", swarmtypes.StackNamespaceLabel, stackName))
- servicesResult, err := dockerClient.ServiceList(ctx, dockerclient.ServiceListOptions{Filters: filter})
- if err != nil {
- return nil, errors.WrapIf(err, "failed to list swarm services")
- }
- services := servicesResult.Items
-
- byName := make(map[string]swarm.Service, len(services))
- for _, service := range services {
- byName[service.Spec.Name] = service
- }
- return byName, nil
-}
-
-func ensureSwarmNetworks(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, stackName string, stackLabels map[string]string) (map[string]string, error) {
- result := make(map[string]string, len(project.Networks))
- for key, cfg := range project.Networks {
- networkName := strings.TrimSpace(cfg.Name)
- if networkName == "" {
- networkName = key
- }
-
- if bool(cfg.External) {
- result[key] = networkName
- continue
- }
-
- stackedName := stackScopedName(stackName, networkName)
- result[key] = stackedName
-
- _, err := dockerClient.NetworkInspect(ctx, stackedName, dockerclient.NetworkInspectOptions{Scope: "swarm"})
- if err == nil {
- continue
- }
- if !cerrdefs.IsNotFound(err) {
- return nil, errors.WrapIff(err, "failed to inspect network %s", stackedName)
- }
-
- driver := strings.TrimSpace(cfg.Driver)
- if driver == "" {
- driver = "overlay"
- }
-
- labels := mergeLabels(cfg.Labels, stackLabels)
- createOpts := dockerclient.NetworkCreateOptions{
- Driver: driver,
- Scope: "swarm",
- EnableIPv4: cfg.EnableIPv4,
- EnableIPv6: cfg.EnableIPv6,
- Internal: cfg.Internal,
- Attachable: cfg.Attachable,
- Options: cfg.DriverOpts,
- Labels: labels,
- IPAM: convertIPAM(cfg.Ipam),
- }
-
- if _, err := dockerClient.NetworkCreate(ctx, stackedName, createOpts); err != nil {
- return nil, errors.WrapIff(err, "failed to create network %s", stackedName)
- }
- }
-
- return result, nil
-}
-
-func ensureSwarmConfigs(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, stackName string, stackLabels map[string]string) (map[string]resourceMeta, error) {
- result := make(map[string]resourceMeta, len(project.Configs))
- for key, cfg := range project.Configs {
- name := resolveResourceName(stackName, key, cfg.Name, cfg.External)
- if cfg.External {
- meta, err := inspectConfig(ctx, dockerClient, name)
- if err != nil {
- return nil, err
- }
- result[key] = meta
- continue
- }
-
- meta, err := ensureConfig(ctx, dockerClient, name, cfg, stackLabels, project.WorkingDir)
- if err != nil {
- return nil, err
- }
- result[key] = meta
- }
- return result, nil
-}
-
-// ensureSwarmVolumesInternal pre-creates named volumes that carry a driver or
-// driver_opts so that Swarm services pick up the correct volume configuration.
-// Without this step Docker creates a plain local volume on first use and the
-// driver options are silently ignored — the root cause of issue #2376.
-func ensureSwarmVolumesInternal(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, stackName string, stackLabels map[string]string) error {
- for key, cfg := range project.Volumes {
- // External volumes must already exist; nothing to create.
- if cfg.External {
- continue
- }
- // Only act when driver or driver_opts are explicitly set.
- if cfg.Driver == "" && len(cfg.DriverOpts) == 0 {
- continue
- }
-
- name := resolveResourceName(stackName, key, cfg.Name, cfg.External)
-
- // If the volume already exists, leave it as-is to avoid disrupting
- // running services that may be attached to it.
- if _, err := dockerClient.VolumeInspect(ctx, name, dockerclient.VolumeInspectOptions{}); err == nil {
- continue
- } else if !cerrdefs.IsNotFound(err) {
- return errors.WrapIff(err, "failed to inspect volume %s", name)
- }
-
- driver := cfg.Driver
- if driver == "" {
- driver = "local"
- }
- labels := mergeLabels(cfg.Labels, stackLabels)
- if _, err := dockerClient.VolumeCreate(ctx, dockerclient.VolumeCreateOptions{
- Name: name,
- Driver: driver,
- DriverOpts: cfg.DriverOpts,
- Labels: labels,
- }); err != nil {
- return errors.WrapIff(err, "failed to create volume %s", name)
- }
- }
- return nil
-}
-
-func ensureSwarmSecrets(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, stackName string, stackLabels map[string]string) (map[string]resourceMeta, error) {
- result := make(map[string]resourceMeta, len(project.Secrets))
- for key, cfg := range project.Secrets {
- name := resolveResourceName(stackName, key, cfg.Name, cfg.External)
- if cfg.External {
- meta, err := inspectSecret(ctx, dockerClient, name)
- if err != nil {
- return nil, err
- }
- result[key] = meta
- continue
- }
-
- meta, err := ensureSecret(ctx, dockerClient, name, cfg, stackLabels, project.WorkingDir)
- if err != nil {
- return nil, err
- }
- result[key] = meta
- }
- return result, nil
-}
-
-func ensureConfig(ctx context.Context, dockerClient *dockerclient.Client, name string, cfg composegotypes.ConfigObjConfig, stackLabels map[string]string, workingDir string) (resourceMeta, error) {
- return ensureManagedFileResourceInternal(ctx, name, composegotypes.FileObjectConfig(cfg), cfg.Labels, stackLabels, workingDir, managedFileResourceOptionsInternal{
- ResourceType: "config",
- Inspect: func(ctx context.Context, managedName string) (resourceMeta, error) {
- return inspectConfig(ctx, dockerClient, managedName)
- },
- Create: createConfigResourceInternal(dockerClient),
- })
-}
-
-func ensureSecret(ctx context.Context, dockerClient *dockerclient.Client, name string, cfg composegotypes.SecretConfig, stackLabels map[string]string, workingDir string) (resourceMeta, error) {
- return ensureManagedFileResourceInternal(ctx, name, composegotypes.FileObjectConfig(cfg), cfg.Labels, stackLabels, workingDir, managedFileResourceOptionsInternal{
- ResourceType: "secret",
- Inspect: func(ctx context.Context, managedName string) (resourceMeta, error) {
- return inspectSecret(ctx, dockerClient, managedName)
- },
- Create: createSecretResourceInternal(dockerClient),
- })
-}
-
-func createConfigResourceInternal(dockerClient *dockerclient.Client) func(context.Context, string, map[string]string, []byte) (resourceMeta, error) {
- return func(ctx context.Context, managedName string, labels map[string]string, data []byte) (resourceMeta, error) {
- spec := swarm.ConfigSpec{
- Annotations: managedResourceAnnotationsInternal(managedName, labels),
- Data: data,
- }
-
- resp, err := dockerClient.ConfigCreate(ctx, dockerclient.ConfigCreateOptions{Spec: spec})
- if err != nil {
- return resourceMeta{}, errors.WrapIff(err, "failed to create config %s", managedName)
- }
- return resourceMeta{ID: resp.ID, Name: managedName}, nil
- }
-}
-
-func createSecretResourceInternal(dockerClient *dockerclient.Client) func(context.Context, string, map[string]string, []byte) (resourceMeta, error) {
- return func(ctx context.Context, managedName string, labels map[string]string, data []byte) (resourceMeta, error) {
- spec := swarm.SecretSpec{
- Annotations: managedResourceAnnotationsInternal(managedName, labels),
- Data: data,
- }
-
- resp, err := dockerClient.SecretCreate(ctx, dockerclient.SecretCreateOptions{Spec: spec})
- if err != nil {
- return resourceMeta{}, errors.WrapIff(err, "failed to create secret %s", managedName)
- }
- return resourceMeta{ID: resp.ID, Name: managedName}, nil
- }
-}
-
-func managedResourceAnnotationsInternal(name string, labels map[string]string) swarm.Annotations {
- return swarm.Annotations{
- Name: name,
- Labels: labels,
- }
-}
-
-type managedFileResourceOptionsInternal struct {
- ResourceType string
- Inspect func(context.Context, string) (resourceMeta, error)
- Create func(context.Context, string, map[string]string, []byte) (resourceMeta, error)
-}
-
-func ensureManagedFileResourceInternal(
- ctx context.Context,
- name string,
- fileObject composegotypes.FileObjectConfig,
- labels map[string]string,
- stackLabels map[string]string,
- workingDir string,
- opts managedFileResourceOptionsInternal,
-) (resourceMeta, error) {
- data, err := resolveFileObjectContent(fileObject, workingDir)
- if err != nil {
- return resourceMeta{}, errors.WrapIff(err, "failed to load %s %s", opts.ResourceType, name)
- }
-
- hash := hashManagedResource(data)
- managedName := managedResourceName(name, hash)
- if meta, err := opts.Inspect(ctx, managedName); err == nil {
- return meta, nil
- } else if !cerrdefs.IsNotFound(err) {
- return resourceMeta{}, errors.WrapIff(err, "failed to inspect %s %s", opts.ResourceType, managedName)
- }
-
- resourceLabels := mergeLabels(labels, stackLabels)
- resourceLabels[resourceTypeLabel] = opts.ResourceType
- resourceLabels[resourceNameLabel] = name
- resourceLabels[resourceHashLabel] = hash
- return opts.Create(ctx, managedName, resourceLabels, data)
-}
-
-func inspectConfig(ctx context.Context, dockerClient *dockerclient.Client, name string) (resourceMeta, error) {
- configResult, err := dockerClient.ConfigInspect(ctx, name, dockerclient.ConfigInspectOptions{})
- if err != nil {
- return resourceMeta{}, err
- }
- config := configResult.Config
- return resourceMeta{ID: config.ID, Name: config.Spec.Name}, nil
-}
-
-func inspectSecret(ctx context.Context, dockerClient *dockerclient.Client, name string) (resourceMeta, error) {
- secretResult, err := dockerClient.SecretInspect(ctx, name, dockerclient.SecretInspectOptions{})
- if err != nil {
- return resourceMeta{}, err
- }
- secret := secretResult.Secret
- return resourceMeta{ID: secret.ID, Name: secret.Spec.Name}, nil
-}
-
-func resolveResourceName(stackName, key, resourceName string, external composegotypes.External) string {
- name := strings.TrimSpace(resourceName)
- if name == "" {
- name = key
- }
- if bool(external) {
- return name
- }
- return stackScopedName(stackName, name)
-}
-
-func buildServiceSpec(
- service composegotypes.ServiceConfig,
- stackName string,
- stackLabels map[string]string,
- networkNameByKey map[string]string,
- configMetaByKey map[string]resourceMeta,
- secretMetaByKey map[string]resourceMeta,
- projectVolumes composegotypes.Volumes,
-) swarm.ServiceSpec {
- serviceName := stackScopedName(stackName, service.Name)
- serviceLabels := mergeLabels(nil, stackLabels)
- if service.Deploy != nil {
- serviceLabels = mergeLabels(service.Deploy.Labels, serviceLabels)
- }
- if service.Image != "" {
- serviceLabels[stackImageLabel] = service.Image
- }
-
- spec := swarm.ServiceSpec{
- Annotations: swarm.Annotations{
- Name: serviceName,
- Labels: serviceLabels,
- },
- TaskTemplate: swarm.TaskSpec{
- ContainerSpec: &swarm.ContainerSpec{
- Image: service.Image,
- Command: toStringSlice(service.Entrypoint),
- Args: toStringSlice(service.Command),
- Env: convertEnv(service.Environment),
- Dir: service.WorkingDir,
- User: service.User,
- Groups: service.GroupAdd,
- Hostname: service.Hostname,
- Init: service.Init,
- StopSignal: service.StopSignal,
- StopGracePeriod: convertDurationPtr(service.StopGracePeriod),
- ReadOnly: service.ReadOnly,
- TTY: service.Tty,
- OpenStdin: service.StdinOpen,
- Labels: mergeLabels(service.Labels, stackLabels),
- Mounts: convertServiceMounts(service.Volumes, stackName, projectVolumes),
- Secrets: convertServiceSecretRefs(service.Secrets, secretMetaByKey),
- Configs: convertServiceConfigRefs(service.Configs, configMetaByKey),
- },
- Networks: buildServiceNetworks(service, networkNameByKey),
- },
- }
-
- if len(service.ExtraHosts) > 0 {
- spec.TaskTemplate.ContainerSpec.Hosts = service.ExtraHosts.AsList(":")
- }
-
- if len(service.DNS) > 0 || len(service.DNSSearch) > 0 || len(service.DNSOpts) > 0 {
- spec.TaskTemplate.ContainerSpec.DNSConfig = &swarm.DNSConfig{
- Nameservers: parseIPList(service.DNS),
- Search: []string(service.DNSSearch),
- Options: service.DNSOpts,
- }
- }
-
- applyDeployConfig(&spec, service.Deploy, service.Scale)
- applyServicePorts(&spec, service.Ports)
-
- return spec
-}
-
-func createSwarmService(
- ctx context.Context,
- dockerClient *dockerclient.Client,
- spec swarm.ServiceSpec,
- withRegistryAuth bool,
- registryAuthForImage func(context.Context, string) (string, error),
- resolveMode string,
-) error {
- encodedRegistryAuth, err := resolveRegistryAuthForSpec(ctx, spec, withRegistryAuth, registryAuthForImage)
- if err != nil {
- return err
- }
- queryRegistry := encodedRegistryAuth != "" || shouldQueryRegistryOnCreate(resolveMode)
- opts := dockerclient.ServiceCreateOptions{
- Spec: spec,
- QueryRegistry: queryRegistry,
- }
- if encodedRegistryAuth != "" {
- opts.EncodedRegistryAuth = encodedRegistryAuth
- }
- if _, err := dockerClient.ServiceCreate(ctx, opts); err != nil {
- return errors.WrapIff(err, "failed to create swarm service %s", spec.Name)
- }
- return nil
-}
-
-func updateSwarmService(
- ctx context.Context,
- dockerClient *dockerclient.Client,
- existing swarm.Service,
- spec swarm.ServiceSpec,
- withRegistryAuth bool,
- registryAuthForImage func(context.Context, string) (string, error),
- resolveMode string,
-) error {
- encodedRegistryAuth, err := resolveRegistryAuthForSpec(ctx, spec, withRegistryAuth, registryAuthForImage)
- if err != nil {
- return err
- }
- queryRegistry := encodedRegistryAuth != "" || shouldQueryRegistryOnUpdate(resolveMode, existing, spec)
- if !queryRegistry {
- preserveExistingResolvedImage(&spec, existing)
- }
- // Do not force task rescheduling on no-op updates.
- spec.TaskTemplate.ForceUpdate = existing.Spec.TaskTemplate.ForceUpdate
-
- opts := dockerclient.ServiceUpdateOptions{
- Version: existing.Version,
- Spec: spec,
- QueryRegistry: queryRegistry,
- }
- if encodedRegistryAuth != "" {
- opts.EncodedRegistryAuth = encodedRegistryAuth
- opts.RegistryAuthFrom = swarm.RegistryAuthFromSpec
- } else {
- opts.RegistryAuthFrom = swarm.RegistryAuthFromPreviousSpec
- }
-
- if _, err := dockerClient.ServiceUpdate(ctx, existing.ID, opts); err != nil {
- if strings.Contains(err.Error(), "service does not have a previous spec") {
- opts.RegistryAuthFrom = ""
- if _, retryErr := dockerClient.ServiceUpdate(ctx, existing.ID, opts); retryErr != nil {
- return errors.WrapIff(retryErr, "failed to update swarm service %s", spec.Name)
- }
- return nil
- }
- return errors.WrapIff(err, "failed to update swarm service %s", spec.Name)
- }
- return nil
-}
-
-func applyDeployConfig(spec *swarm.ServiceSpec, deploy *composegotypes.DeployConfig, scale *int) {
- if deploy == nil {
- applyServiceMode(spec, "", scale)
- return
- }
-
- applyServiceMode(spec, deploy.Mode, scale)
- if deploy.Replicas != nil && spec.Mode.Replicated != nil {
- spec.Mode.Replicated.Replicas = toUint64Pointer(*deploy.Replicas)
- }
-
- if deploy.EndpointMode != "" {
- if spec.EndpointSpec == nil {
- spec.EndpointSpec = &swarm.EndpointSpec{}
- }
- spec.EndpointSpec.Mode = swarm.ResolutionMode(deploy.EndpointMode)
- }
-
- if deploy.UpdateConfig != nil {
- spec.UpdateConfig = &swarm.UpdateConfig{
- Parallelism: valueOrZero(deploy.UpdateConfig.Parallelism),
- Delay: time.Duration(deploy.UpdateConfig.Delay),
- FailureAction: swarm.FailureAction(deploy.UpdateConfig.FailureAction),
- Monitor: time.Duration(deploy.UpdateConfig.Monitor),
- MaxFailureRatio: deploy.UpdateConfig.MaxFailureRatio,
- Order: swarm.UpdateOrder(deploy.UpdateConfig.Order),
- }
- }
- if deploy.RollbackConfig != nil {
- spec.RollbackConfig = &swarm.UpdateConfig{
- Parallelism: valueOrZero(deploy.RollbackConfig.Parallelism),
- Delay: time.Duration(deploy.RollbackConfig.Delay),
- FailureAction: swarm.FailureAction(deploy.RollbackConfig.FailureAction),
- Monitor: time.Duration(deploy.RollbackConfig.Monitor),
- MaxFailureRatio: deploy.RollbackConfig.MaxFailureRatio,
- Order: swarm.UpdateOrder(deploy.RollbackConfig.Order),
- }
- }
-
- if deploy.RestartPolicy != nil {
- spec.TaskTemplate.RestartPolicy = &swarm.RestartPolicy{
- Condition: swarm.RestartPolicyCondition(deploy.RestartPolicy.Condition),
- Delay: convertDurationPtr(deploy.RestartPolicy.Delay),
- Window: convertDurationPtr(deploy.RestartPolicy.Window),
- }
- if deploy.RestartPolicy.MaxAttempts != nil {
- spec.TaskTemplate.RestartPolicy.MaxAttempts = deploy.RestartPolicy.MaxAttempts
- }
- }
-
- if deploy.Resources.Limits != nil || deploy.Resources.Reservations != nil {
- spec.TaskTemplate.Resources = &swarm.ResourceRequirements{}
- }
- if deploy.Resources.Limits != nil {
- spec.TaskTemplate.Resources.Limits = &swarm.Limit{
- NanoCPUs: int64(deploy.Resources.Limits.NanoCPUs * 1e9),
- MemoryBytes: int64(deploy.Resources.Limits.MemoryBytes),
- Pids: deploy.Resources.Limits.Pids,
- }
- }
- if deploy.Resources.Reservations != nil {
- spec.TaskTemplate.Resources.Reservations = &swarm.Resources{
- NanoCPUs: int64(deploy.Resources.Reservations.NanoCPUs * 1e9),
- MemoryBytes: int64(deploy.Resources.Reservations.MemoryBytes),
- }
- }
-
- if len(deploy.Placement.Constraints) > 0 || len(deploy.Placement.Preferences) > 0 || deploy.Placement.MaxReplicas > 0 {
- spec.TaskTemplate.Placement = &swarm.Placement{
- Constraints: deploy.Placement.Constraints,
- MaxReplicas: deploy.Placement.MaxReplicas,
- }
- if len(deploy.Placement.Preferences) > 0 {
- preferences := make([]swarm.PlacementPreference, 0, len(deploy.Placement.Preferences))
- for _, preference := range deploy.Placement.Preferences {
- if spread := strings.TrimSpace(preference.Spread); spread != "" {
- preferences = append(preferences, swarm.PlacementPreference{
- Spread: &swarm.SpreadOver{SpreadDescriptor: spread},
- })
- }
- }
- spec.TaskTemplate.Placement.Preferences = preferences
- }
- }
-}
-
-func applyServiceMode(spec *swarm.ServiceSpec, mode string, scale *int) {
- mode = strings.ToLower(strings.TrimSpace(mode))
- switch mode {
- case "global":
- spec.Mode = swarm.ServiceMode{Global: &swarm.GlobalService{}}
- default:
- replicas := uint64(1)
- if scale != nil {
- if *scale <= 0 {
- replicas = 0
- } else {
- replicas = uint64(*scale)
- }
- }
- spec.Mode = swarm.ServiceMode{Replicated: &swarm.ReplicatedService{Replicas: &replicas}}
- }
-}
-
-func applyServicePorts(spec *swarm.ServiceSpec, ports []composegotypes.ServicePortConfig) {
- if len(ports) == 0 {
- return
- }
-
- endpoint := spec.EndpointSpec
- if endpoint == nil {
- endpoint = &swarm.EndpointSpec{}
- }
-
- converted := make([]swarm.PortConfig, 0, len(ports))
- for _, port := range ports {
- entry := swarm.PortConfig{
- Name: port.Name,
- Protocol: network.IPProtocol(strings.ToLower(port.Protocol)),
- TargetPort: port.Target,
- }
- if port.Mode != "" {
- entry.PublishMode = swarm.PortConfigPublishMode(strings.ToLower(port.Mode))
- }
- if port.Published != "" {
- if published, err := strconv.ParseUint(port.Published, 10, 32); err == nil {
- entry.PublishedPort = uint32(published)
- }
- }
- converted = append(converted, entry)
- }
-
- endpoint.Ports = converted
- spec.EndpointSpec = endpoint
-}
-
-func buildServiceNetworks(service composegotypes.ServiceConfig, networkNameByKey map[string]string) []swarm.NetworkAttachmentConfig {
- var attachments []swarm.NetworkAttachmentConfig
- if len(service.Networks) == 0 {
- if defaultNetwork, ok := networkNameByKey["default"]; ok {
- attachments = append(attachments, swarm.NetworkAttachmentConfig{Target: defaultNetwork})
- }
- return attachments
- }
-
- for name, cfg := range service.Networks {
- networkName := networkNameByKey[name]
- if networkName == "" {
- networkName = name
- }
- if cfg == nil {
- attachments = append(attachments, swarm.NetworkAttachmentConfig{Target: networkName})
- continue
- }
- attachments = append(attachments, swarm.NetworkAttachmentConfig{
- Target: networkName,
- Aliases: cfg.Aliases,
- DriverOpts: cfg.DriverOpts,
- })
- }
- return attachments
-}
-
-func convertServiceMounts(volumes []composegotypes.ServiceVolumeConfig, stackName string, projectVolumes composegotypes.Volumes) []mount.Mount {
- if len(volumes) == 0 {
- return nil
- }
- result := make([]mount.Mount, 0, len(volumes))
- for _, vol := range volumes {
- mountType := mapVolumeType(vol.Type)
- source := vol.Source
- // Driver-configured named volumes must use the stack-scoped name so
- // services reference the volume pre-created by ensureSwarmVolumesInternal.
- // Without this, Docker creates a plain local volume and silently ignores
- // driver/driver_opts — the root cause of issue #2376.
- if mountType == mount.TypeVolume && source != "" {
- if volCfg, ok := projectVolumes[source]; ok && !bool(volCfg.External) && (volCfg.Driver != "" || len(volCfg.DriverOpts) > 0) {
- source = resolveResourceName(stackName, source, volCfg.Name, volCfg.External)
- }
- }
- entry := mount.Mount{
- Type: mountType,
- Source: source,
- Target: vol.Target,
- ReadOnly: vol.ReadOnly,
- Consistency: mount.Consistency(vol.Consistency),
- }
- if vol.Bind != nil {
- entry.BindOptions = &mount.BindOptions{
- Propagation: mount.Propagation(vol.Bind.Propagation),
- CreateMountpoint: bool(vol.Bind.CreateHostPath),
- }
- }
- if vol.Volume != nil {
- entry.VolumeOptions = &mount.VolumeOptions{
- NoCopy: vol.Volume.NoCopy,
- Labels: vol.Volume.Labels,
- Subpath: vol.Volume.Subpath,
- }
- }
- if vol.Tmpfs != nil {
- entry.TmpfsOptions = &mount.TmpfsOptions{
- SizeBytes: int64(vol.Tmpfs.Size),
- Mode: os.FileMode(vol.Tmpfs.Mode),
- }
- }
- if vol.Image != nil {
- entry.ImageOptions = &mount.ImageOptions{Subpath: vol.Image.SubPath}
- }
- result = append(result, entry)
- }
- return result
-}
-
-func convertServiceSecretRefs(secrets []composegotypes.ServiceSecretConfig, secretMetaByKey map[string]resourceMeta) []*swarm.SecretReference {
- if len(secrets) == 0 {
- return nil
- }
- result := make([]*swarm.SecretReference, 0, len(secrets))
- for _, secret := range secrets {
- meta, ok := secretMetaByKey[secret.Source]
- if !ok {
- continue
- }
- ref := &swarm.SecretReference{
- SecretID: meta.ID,
- SecretName: meta.Name,
- }
- target := secret.Target
- if target == "" {
- target = meta.Name
- }
- ref.File = &swarm.SecretReferenceFileTarget{
- Name: target,
- UID: utils.StringOrDefault(secret.UID, "0"),
- GID: utils.StringOrDefault(secret.GID, "0"),
- Mode: fileModeOrDefault(secret.Mode),
- }
- result = append(result, ref)
- }
- return result
-}
-
-func convertServiceConfigRefs(configs []composegotypes.ServiceConfigObjConfig, configMetaByKey map[string]resourceMeta) []*swarm.ConfigReference {
- if len(configs) == 0 {
- return nil
- }
- result := make([]*swarm.ConfigReference, 0, len(configs))
- for _, cfg := range configs {
- meta, ok := configMetaByKey[cfg.Source]
- if !ok {
- continue
- }
- ref := &swarm.ConfigReference{
- ConfigID: meta.ID,
- ConfigName: meta.Name,
- }
- target := cfg.Target
- if target == "" {
- target = meta.Name
- }
- ref.File = &swarm.ConfigReferenceFileTarget{
- Name: target,
- UID: utils.StringOrDefault(cfg.UID, "0"),
- GID: utils.StringOrDefault(cfg.GID, "0"),
- Mode: fileModeOrDefault(cfg.Mode),
- }
- result = append(result, ref)
- }
- return result
-}
-
-func resolveFileObjectContent(fileConfig composegotypes.FileObjectConfig, workingDir string) ([]byte, error) {
- if fileConfig.Content != "" {
- return []byte(fileConfig.Content), nil
- }
- if fileConfig.Environment != "" {
- value, ok := os.LookupEnv(fileConfig.Environment)
- if !ok {
- return nil, errors.Errorf("environment variable %s not set", fileConfig.Environment)
- }
- return []byte(value), nil
- }
- if fileConfig.File != "" {
- path, err := resolvePathWithinWorkingDirInternal(workingDir, fileConfig.File)
- if err != nil {
- return nil, err
- }
- return os.ReadFile(path)
- }
- return nil, errors.New("config or secret content is required")
-}
-
-func resolvePathWithinWorkingDirInternal(workingDir, path string) (string, error) {
- baseDir := filepath.Clean(workingDir)
- if !filepath.IsAbs(baseDir) {
- absBaseDir, err := filepath.Abs(baseDir)
- if err != nil {
- return "", errors.WrapIff(err, "failed to resolve working directory %q", workingDir)
- }
- baseDir = absBaseDir
- }
-
- resolvedPath := path
- if !filepath.IsAbs(resolvedPath) {
- resolvedPath = filepath.Join(baseDir, resolvedPath)
- }
- resolvedPath = filepath.Clean(resolvedPath)
- if !filepath.IsAbs(resolvedPath) {
- absResolvedPath, err := filepath.Abs(resolvedPath)
- if err != nil {
- return "", errors.WrapIff(err, "failed to resolve config file path %q", path)
- }
- resolvedPath = absResolvedPath
- }
-
- relativePath, err := filepath.Rel(baseDir, resolvedPath)
- if err != nil {
- return "", errors.WrapIff(err, "failed to validate config file path %q", path)
- }
- if relativePath == ".." || strings.HasPrefix(relativePath, ".."+string(filepath.Separator)) {
- return "", errors.Errorf("config file path %q escapes the working directory", path)
- }
-
- return resolvedPath, nil
-}
-
-func convertIPAM(cfg composegotypes.IPAMConfig) *network.IPAM {
- if cfg.Driver == "" && len(cfg.Config) == 0 {
- return nil
- }
- result := &network.IPAM{
- Driver: cfg.Driver,
- }
- if len(cfg.Config) > 0 {
- pools := make([]network.IPAMConfig, 0, len(cfg.Config))
- for _, pool := range cfg.Config {
- if pool == nil {
- continue
- }
- subnet := parsePrefix(pool.Subnet)
- ipRange := parsePrefix(pool.IPRange)
- gateway := parseAddr(pool.Gateway).OrEmpty()
- pools = append(pools, network.IPAMConfig{
- Subnet: subnet,
- Gateway: gateway,
- IPRange: ipRange,
- AuxAddress: parseAuxAddresses(pool.AuxiliaryAddresses),
- })
- }
- result.Config = pools
- }
- return result
-}
-
-func parseIPList(values []string) []netip.Addr {
- if len(values) == 0 {
- return nil
- }
- out := make([]netip.Addr, 0, len(values))
- for _, value := range values {
- addr, ok := parseAddr(value).Get()
- if ok {
- out = append(out, addr)
- }
- }
- return out
-}
-
-func parseAddr(value string) mo.Option[netip.Addr] {
- value = strings.TrimSpace(value)
- if value == "" {
- return mo.None[netip.Addr]()
- }
- addr, err := netip.ParseAddr(value)
- if err != nil {
- return mo.None[netip.Addr]()
- }
- return mo.Some(addr)
-}
-
-func parsePrefix(value string) netip.Prefix {
- value = strings.TrimSpace(value)
- if value == "" {
- return netip.Prefix{}
- }
- prefix, err := netip.ParsePrefix(value)
- if err != nil {
- return netip.Prefix{}
- }
- return prefix
-}
-
-func parseAuxAddresses(values map[string]string) map[string]netip.Addr {
- if len(values) == 0 {
- return nil
- }
- out := make(map[string]netip.Addr, len(values))
- for key, value := range values {
- if addr, ok := parseAddr(value).Get(); ok {
- out[key] = addr
- }
- }
- return out
-}
-
-func convertEnv(env composegotypes.MappingWithEquals) []string {
- if env == nil {
- return nil
- }
- result := make([]string, 0, len(env))
- for key, value := range env {
- if value == nil {
- result = append(result, key)
- continue
- }
- result = append(result, fmt.Sprintf("%s=%s", key, *value))
- }
- return result
-}
-
-func toStringSlice(command composegotypes.ShellCommand) []string {
- if len(command) == 0 {
- return nil
- }
- return []string(command)
-}
-
-func convertDurationPtr(duration *composegotypes.Duration) *time.Duration {
- if duration == nil {
- return nil
- }
- return new(time.Duration(*duration))
-}
-
-func toUint64Pointer(value int) *uint64 {
- if value < 0 {
- return nil
- }
- return new(uint64(value))
-}
-
-func fileModeOrDefault(mode *composegotypes.FileMode) os.FileMode {
- if mode == nil {
- return 0444
- }
- converted := fileModeToUint32(mode)
- if converted == nil {
- return 0444
- }
- return os.FileMode(*converted)
-}
-
-func fileModeToUint32(mode *composegotypes.FileMode) *uint32 {
- return convertFileMode(mode)
-}
-
-func valueOrZero(value *uint64) uint64 {
- if value == nil {
- return 0
- }
- return *value
-}
-
-func mergeLabels(primary map[string]string, secondary map[string]string) map[string]string {
- out := map[string]string{}
- maps.Copy(out, primary)
- maps.Copy(out, secondary)
- return out
-}
-
-func stackScopedName(stackName, resourceName string) string {
- resourceName = strings.TrimSpace(resourceName)
- if resourceName == "" {
- return stackName
- }
- return fmt.Sprintf("%s_%s", stackName, resourceName)
-}
-
-func mapVolumeType(value string) mount.Type {
- switch strings.ToLower(value) {
- case "bind":
- return mount.TypeBind
- case "tmpfs":
- return mount.TypeTmpfs
- case "npipe":
- return mount.TypeNamedPipe
- case "cluster":
- return mount.TypeCluster
- case "image":
- return mount.TypeImage
- case "volume", "":
- return mount.TypeVolume
- default:
- return mount.TypeVolume
- }
-}
-
-func convertFileMode(mode *composegotypes.FileMode) *uint32 {
- if mode == nil {
- return nil
- }
- return toUint32FromInt64(int64(*mode)).ToPointer()
-}
-
-func toUint32FromInt64(value int64) mo.Option[uint32] {
- if value < 0 || value > int64(^uint32(0)) {
- return mo.None[uint32]()
- }
- return mo.Some(uint32(value))
-}
-
-func normalizeResolveImageMode(value string) (string, error) {
- mode := strings.ToLower(strings.TrimSpace(value))
- if mode == "" {
- return resolveImageAlways, nil
- }
- switch mode {
- case resolveImageAlways, resolveImageChanged, resolveImageNever:
- return mode, nil
- default:
- return "", errors.Errorf("invalid resolve image mode %q: expected always, changed, or never", value)
- }
-}
-
-func shouldQueryRegistryOnCreate(resolveMode string) bool {
- return resolveMode == resolveImageAlways || resolveMode == resolveImageChanged
-}
-
-func shouldQueryRegistryOnUpdate(resolveMode string, existing swarm.Service, desired swarm.ServiceSpec) bool {
- switch resolveMode {
- case resolveImageAlways:
- return true
- case resolveImageChanged:
- desiredImage := resolveServiceImage(desired)
- existingImage := existing.Spec.Labels[stackImageLabel]
- return desiredImage != "" && desiredImage != existingImage
- default:
- return false
- }
-}
-
-func resolveServiceImage(spec swarm.ServiceSpec) string {
- if spec.TaskTemplate.ContainerSpec == nil {
- return ""
- }
- return spec.TaskTemplate.ContainerSpec.Image
-}
-
-func preserveExistingResolvedImage(spec *swarm.ServiceSpec, existing swarm.Service) {
- if spec.TaskTemplate.ContainerSpec == nil || existing.Spec.TaskTemplate.ContainerSpec == nil {
- return
- }
- if resolveServiceImage(*spec) == existing.Spec.Labels[stackImageLabel] {
- spec.TaskTemplate.ContainerSpec.Image = existing.Spec.TaskTemplate.ContainerSpec.Image
- }
-}
-
-func parseEnvContent(envContent string) (map[string]string, error) {
- env := make(projects.EnvMap)
- for _, entry := range os.Environ() {
- key, value, ok := strings.Cut(entry, "=")
- if !ok || key == "" {
- continue
- }
- env[key] = value
- }
-
- if strings.TrimSpace(envContent) == "" {
- return env, nil
- }
-
- parsedEnv, err := projects.ParseProjectEnvContent(envContent, env)
- if err != nil {
- return nil, err
- }
-
- maps.Copy(env, parsedEnv)
- return env, nil
-}
-
-func hashManagedResource(data []byte) string {
- sum := sha256.Sum256(data)
- return hex.EncodeToString(sum[:])
-}
-
-func managedResourceName(logicalName, hash string) string {
- hash = strings.TrimSpace(hash)
- if len(hash) > resourceNameMaxHash {
- hash = hash[:resourceNameMaxHash]
- }
- if hash == "" {
- return logicalName
- }
- return fmt.Sprintf("%s_%s", logicalName, hash)
-}
-
-func resolveRegistryAuthForSpec(
- ctx context.Context,
- spec swarm.ServiceSpec,
- withRegistryAuth bool,
- registryAuthForImage func(context.Context, string) (string, error),
-) (string, error) {
- if !withRegistryAuth || registryAuthForImage == nil {
- return "", nil
- }
-
- image := resolveServiceImage(spec)
- if strings.TrimSpace(image) == "" {
- return "", nil
- }
-
- encodedRegistryAuth, err := registryAuthForImage(ctx, image)
- if err != nil {
- return "", errors.WrapIff(err, "failed to resolve registry auth for image %s", image)
- }
-
- return encodedRegistryAuth, nil
-}
-
-func cleanupStaleConfigs(ctx context.Context, dockerClient *dockerclient.Client, stackName string, desiredNames map[string]struct{}) error {
- return cleanupStaleManagedResourcesInternal(ctx, stackName, desiredNames, staleManagedResourceOptionsInternal{
- ResourceType: "config",
- List: listStaleConfigResourcesInternal(dockerClient),
- Remove: removeConfigResourceInternal(dockerClient),
- })
-}
-
-func cleanupStaleSecrets(ctx context.Context, dockerClient *dockerclient.Client, stackName string, desiredNames map[string]struct{}) error {
- return cleanupStaleManagedResourcesInternal(ctx, stackName, desiredNames, staleManagedResourceOptionsInternal{
- ResourceType: "secret",
- List: listStaleSecretResourcesInternal(dockerClient),
- Remove: removeSecretResourceInternal(dockerClient),
- })
-}
-
-func listStaleConfigResourcesInternal(dockerClient *dockerclient.Client) func(context.Context, dockerclient.Filters) ([]staleManagedResourceInternal, error) {
- return func(ctx context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
- configsResult, err := dockerClient.ConfigList(ctx, dockerclient.ConfigListOptions{Filters: filters})
- if err != nil {
- return nil, errors.WrapIf(err, "failed to list stack configs")
- }
-
- return collectStaleManagedResourcesInternal(configsResult.Items, func(cfg swarm.Config) staleManagedResourceInternal {
- return staleManagedResourceInternal{ID: cfg.ID, Name: cfg.Spec.Name}
- }), nil
- }
-}
-
-func listStaleSecretResourcesInternal(dockerClient *dockerclient.Client) func(context.Context, dockerclient.Filters) ([]staleManagedResourceInternal, error) {
- return func(ctx context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
- secretsResult, err := dockerClient.SecretList(ctx, dockerclient.SecretListOptions{Filters: filters})
- if err != nil {
- return nil, errors.WrapIf(err, "failed to list stack secrets")
- }
-
- return collectStaleManagedResourcesInternal(secretsResult.Items, func(secret swarm.Secret) staleManagedResourceInternal {
- return staleManagedResourceInternal{ID: secret.ID, Name: secret.Spec.Name}
- }), nil
- }
-}
-
-func collectStaleManagedResourcesInternal[T any](items []T, convert func(T) staleManagedResourceInternal) []staleManagedResourceInternal {
- resources := make([]staleManagedResourceInternal, 0, len(items))
- for _, item := range items {
- resources = append(resources, convert(item))
- }
- return resources
-}
-
-func removeConfigResourceInternal(dockerClient *dockerclient.Client) func(context.Context, string) error {
- return func(ctx context.Context, id string) error {
- _, err := dockerClient.ConfigRemove(ctx, id, dockerclient.ConfigRemoveOptions{})
- return err
- }
-}
-
-func removeSecretResourceInternal(dockerClient *dockerclient.Client) func(context.Context, string) error {
- return func(ctx context.Context, id string) error {
- _, err := dockerClient.SecretRemove(ctx, id, dockerclient.SecretRemoveOptions{})
- return err
- }
-}
-
-type staleManagedResourceInternal struct {
- ID string
- Name string
-}
-
-type staleManagedResourceOptionsInternal struct {
- ResourceType string
- List func(context.Context, dockerclient.Filters) ([]staleManagedResourceInternal, error)
- Remove func(context.Context, string) error
-}
-
-func cleanupStaleManagedResourcesInternal(ctx context.Context, stackName string, desiredNames map[string]struct{}, opts staleManagedResourceOptionsInternal) error {
- filters := make(dockerclient.Filters)
- filters.Add("label", fmt.Sprintf("%s=%s", swarmtypes.StackNamespaceLabel, stackName))
- filters.Add("label", resourceTypeLabel+"="+opts.ResourceType)
-
- resources, err := opts.List(ctx, filters)
- if err != nil {
- return err
- }
-
- for _, resource := range resources {
- if _, ok := desiredNames[resource.Name]; ok {
- continue
- }
- if err := opts.Remove(ctx, resource.ID); err != nil && !cerrdefs.IsNotFound(err) {
- if isStaleSwarmResourceStillInUse(err) {
- continue
- }
- return errors.WrapIff(err, "failed to remove stale stack %s %s", opts.ResourceType, resource.Name)
- }
- }
-
- return nil
-}
-
-func isStaleSwarmResourceStillInUse(err error) bool {
- if cerrdefs.IsConflict(err) {
- return true
- }
-
- message := strings.ToLower(err.Error())
- return strings.Contains(message, "in use")
-}
diff --git a/backend/pkg/libarcane/swarm/stack_deploy_engine_test.go b/backend/pkg/libarcane/swarm/stack_deploy_engine_test.go
deleted file mode 100644
index f51123c83..000000000
--- a/backend/pkg/libarcane/swarm/stack_deploy_engine_test.go
+++ /dev/null
@@ -1,102 +0,0 @@
-package swarm
-
-import (
- "context"
- "path/filepath"
- "testing"
-
- composegotypes "github.com/compose-spec/compose-go/v2/types"
- "github.com/moby/moby/api/types/mount"
- "github.com/moby/moby/api/types/swarm"
- "github.com/stretchr/testify/require"
-)
-
-func TestResolvePathWithinWorkingDirInternal_AllowsPathsWithinWorkingDir(t *testing.T) {
- workingDir := filepath.Join(string(filepath.Separator), "tmp", "stack")
-
- path, err := resolvePathWithinWorkingDirInternal(workingDir, filepath.Join("configs", "app.env"))
- require.NoError(t, err)
- require.Equal(t, filepath.Join(workingDir, "configs", "app.env"), path)
-}
-
-func TestLoadComposeProject_MergesOverrideContent(t *testing.T) {
- base := "services:\n app:\n image: nginx:alpine\n environment:\n FROM_BASE: \"1\"\n"
- override := "services:\n app:\n image: busybox:latest\n environment:\n FROM_OVERRIDE: \"1\"\n"
-
- project, err := loadComposeProject(context.Background(), "stack", base, override, "", "", nil)
- require.NoError(t, err)
- require.NotNil(t, project)
-
- app := project.Services["app"]
- require.Equal(t, "busybox:latest", app.Image)
- require.Contains(t, app.Environment, "FROM_BASE")
- require.Contains(t, app.Environment, "FROM_OVERRIDE")
-}
-
-func TestLoadComposeProject_WithoutOverrideContent(t *testing.T) {
- base := "services:\n app:\n image: nginx:alpine\n"
-
- project, err := loadComposeProject(context.Background(), "stack", base, "", "", "", nil)
- require.NoError(t, err)
- require.NotNil(t, project)
- require.Equal(t, "nginx:alpine", project.Services["app"].Image)
-}
-
-func TestResolvePathWithinWorkingDirInternal_RejectsEscapingPaths(t *testing.T) {
- workingDir := filepath.Join(string(filepath.Separator), "tmp", "stack")
-
- _, err := resolvePathWithinWorkingDirInternal(workingDir, filepath.Join("..", "..", "etc", "shadow"))
- require.Error(t, err)
- require.Contains(t, err.Error(), "escapes the working directory")
-}
-
-func TestConvertServiceMountsScopesOnlyConfiguredNamedVolumes(t *testing.T) {
- mounts := convertServiceMounts(
- []composegotypes.ServiceVolumeConfig{
- {Type: "volume", Source: "plain", Target: "/plain"},
- {Type: "volume", Source: "driver", Target: "/driver"},
- {Type: "volume", Source: "opts", Target: "/opts"},
- {Type: "volume", Source: "external", Target: "/external"},
- },
- "stack",
- composegotypes.Volumes{
- "plain": {},
- "driver": {Driver: "local"},
- "opts": {Name: "custom", DriverOpts: map[string]string{"type": "nfs"}},
- "external": {External: true},
- },
- )
-
- require.Len(t, mounts, 4)
- require.Equal(t, mount.TypeVolume, mounts[0].Type)
- require.Equal(t, "plain", mounts[0].Source)
- require.Equal(t, "stack_driver", mounts[1].Source)
- require.Equal(t, "stack_custom", mounts[2].Source)
- require.Equal(t, "external", mounts[3].Source)
-}
-
-func TestApplyDeployConfigConvertsCPUFractionToNanoCPUs(t *testing.T) {
- spec := &swarm.ServiceSpec{}
- deploy := &composegotypes.DeployConfig{
- Resources: composegotypes.Resources{
- Limits: &composegotypes.Resource{
- NanoCPUs: 0.5,
- MemoryBytes: 536870912,
- },
- Reservations: &composegotypes.Resource{
- NanoCPUs: 0.25,
- MemoryBytes: 268435456,
- },
- },
- }
-
- applyDeployConfig(spec, deploy, nil)
-
- require.NotNil(t, spec.TaskTemplate.Resources)
- require.NotNil(t, spec.TaskTemplate.Resources.Limits)
- require.Equal(t, int64(500_000_000), spec.TaskTemplate.Resources.Limits.NanoCPUs)
- require.Equal(t, int64(536870912), spec.TaskTemplate.Resources.Limits.MemoryBytes)
- require.NotNil(t, spec.TaskTemplate.Resources.Reservations)
- require.Equal(t, int64(250_000_000), spec.TaskTemplate.Resources.Reservations.NanoCPUs)
- require.Equal(t, int64(268435456), spec.TaskTemplate.Resources.Reservations.MemoryBytes)
-}
diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.go
index 45d930292..92bdaacbb 100644
--- a/backend/pkg/projects/fs_util.go
+++ b/backend/pkg/projects/fs_util.go
@@ -728,6 +728,28 @@ func IsSafeSubdirectory(baseDir, subdir string) bool {
return !strings.HasPrefix(rel, "..") && !filepath.IsAbs(rel)
}
+// ResolvePathWithinDir resolves path and rejects paths that escape baseDir.
+func ResolvePathWithinDir(baseDir, path string) (string, error) {
+ resolvedBase, err := filepath.Abs(filepath.Clean(baseDir))
+ if err != nil {
+ return "", errors.WrapIff(err, "failed to resolve base directory %q", baseDir)
+ }
+
+ resolvedPath := path
+ if !filepath.IsAbs(resolvedPath) {
+ resolvedPath = filepath.Join(resolvedBase, resolvedPath)
+ }
+ resolvedPath, err = filepath.Abs(filepath.Clean(resolvedPath))
+ if err != nil {
+ return "", errors.WrapIff(err, "failed to resolve path %q", path)
+ }
+ if !IsSafeSubdirectory(resolvedBase, resolvedPath) {
+ return "", errors.Errorf("path %q escapes directory %q", path, baseDir)
+ }
+
+ return resolvedPath, nil
+}
+
func SaveOrUpdateProjectFiles(projectsRoot, projectPath, composeContent string, envContent *string) error {
return WriteProjectFiles(projectsRoot, projectPath, composeContent, envContent)
}
diff --git a/backend/pkg/projects/fs_util_test.go b/backend/pkg/projects/fs_util_test.go
index 715d39963..34cd736a3 100644
--- a/backend/pkg/projects/fs_util_test.go
+++ b/backend/pkg/projects/fs_util_test.go
@@ -65,6 +65,22 @@ func TestResolveConfiguredContainerDirectory(t *testing.T) {
})
}
+func TestResolvePathWithinDir(t *testing.T) {
+ workingDir := filepath.Join(string(filepath.Separator), "tmp", "stack")
+
+ t.Run("allows paths within the directory", func(t *testing.T) {
+ resolved, err := ResolvePathWithinDir(workingDir, filepath.Join("configs", "app.env"))
+ require.NoError(t, err)
+ require.Equal(t, filepath.Join(workingDir, "configs", "app.env"), resolved)
+ })
+
+ t.Run("rejects escaping paths", func(t *testing.T) {
+ _, err := ResolvePathWithinDir(workingDir, filepath.Join("..", "..", "etc", "shadow"))
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "escapes directory")
+ })
+}
+
func TestReadProjectFiles(t *testing.T) {
t.Run("detects compose path when not provided", func(t *testing.T) {
projectPath := t.TempDir()
diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.go
index e31628896..6be05bd32 100644
--- a/backend/pkg/projects/load.go
+++ b/backend/pkg/projects/load.go
@@ -7,6 +7,7 @@ import (
"math"
"os"
"path/filepath"
+ "reflect"
"slices"
"strconv"
"strings"
@@ -22,6 +23,7 @@ import (
"github.com/docker/compose/v5/pkg/api"
"github.com/docker/go-units"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ projecttypes "github.com/getarcaneapp/arcane/backend/v2/pkg/projects/types"
"github.com/samber/mo"
)
@@ -156,6 +158,61 @@ func LoadComposeProjectLenient(ctx context.Context, composeFile, projectName, pr
return loadComposeProjectInternal(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, true)
}
+// LoadComposeProjectFromContent loads a Compose project from in-memory source content.
+func LoadComposeProjectFromContent(ctx context.Context, opts projecttypes.ComposeContentOptions) (project *composetypes.Project, err error) {
+ defer recoverComposeLoadPanicInternal(ctx, "in-memory compose content", &project, &err)
+
+ if strings.TrimSpace(opts.ComposeContent) == "" {
+ return nil, errors.New("compose content is required")
+ }
+ composeContent := opts.ComposeContent
+
+ workingDir := strings.TrimSpace(opts.WorkingDir)
+ if workingDir == "" {
+ workingDir, err = os.Getwd()
+ if err != nil {
+ workingDir = os.TempDir()
+ }
+ }
+
+ envMap := maps.Clone(loadProcessEnvSnapshotInternal())
+ if envMap == nil {
+ envMap = make(EnvMap)
+ }
+ if strings.TrimSpace(opts.EnvContent) != "" {
+ parsedEnv, parseErr := ParseProjectEnvContent(opts.EnvContent, envMap)
+ if parseErr != nil {
+ return nil, errors.WrapIf(parseErr, "failed to parse env content")
+ }
+ maps.Copy(envMap, parsedEnv)
+ }
+ envMap["PWD"] = workingDir
+
+ configFiles := []composetypes.ConfigFile{{Content: []byte(composeContent)}}
+ if strings.TrimSpace(opts.OverrideContent) != "" {
+ configFiles = append(configFiles, composetypes.ConfigFile{Content: []byte(opts.OverrideContent)})
+ }
+
+ configDetails := composetypes.ConfigDetails{
+ Version: api.ComposeVersion,
+ WorkingDir: workingDir,
+ ConfigFiles: configFiles,
+ Environment: composetypes.Mapping(envMap),
+ }
+
+ project, err = loader.LoadWithContext(ctx, configDetails, func(loaderOpts *loader.Options) {
+ if projectName := strings.TrimSpace(opts.ProjectName); projectName != "" {
+ loaderOpts.SetProjectName(projectName, true)
+ }
+ loader.WithDiscardEnvFiles(loaderOpts)
+ })
+ if err != nil {
+ return nil, errors.WrapIf(err, "failed to load compose project")
+ }
+
+ return finishLoadedProjectInternal(project, workingDir, opts.PathMapper, false)
+}
+
// wrapTypeCastMappingLenientInternal prepares the interp type-cast mapping for lenient
// loading: every existing cast falls back to "0" when it fails (so the lenient
// placeholder for an undefined variable doesn't abort interpolation), and casts
@@ -273,17 +330,7 @@ func loadComposeProjectInternal(
configureLoader func(*loader.Options),
lenient bool,
) (project *composetypes.Project, err error) {
- defer func() {
- if panicErr := emperror.Recover(recover()); panicErr != nil {
- slog.WarnContext(ctx,
- "panic while loading compose project; compose file may contain invalid syntax",
- "path", composeFile,
- "error", panicErr,
- )
- err = errors.WrapIff(panicErr, "load compose project panic for %s", composeFile)
- project = nil
- }
- }()
+ defer recoverComposeLoadPanicInternal(ctx, composeFile, &project, &err)
workdir := filepath.Dir(composeFile)
@@ -351,22 +398,49 @@ func loadComposeProjectInternal(
project.ComposeFiles = append(project.ComposeFiles, configFile.Filename)
}
- project = project.WithoutUnnecessaryResources()
+ project, err = finishLoadedProjectInternal(project, workdir, pathMapper, true)
+ if err != nil {
+ return nil, err
+ }
- // Resolve relative paths for bind mounts, secrets, and configs
- ResolveRelativeProjectPaths(project, workdir)
+ injectServiceConfiguration(project, injectionVars)
+ return project, nil
+}
- // Translate container paths to host paths for Docker execution
- if pathMapper != nil {
- if err := pathMapper.TranslateVolumeSources(project); err != nil {
+func finishLoadedProjectInternal(project *composetypes.Project, workingDir string, pathMapper projecttypes.VolumeSourcePathMapper, translateFileResources bool) (*composetypes.Project, error) {
+ project = project.WithoutUnnecessaryResources()
+ ResolveRelativeProjectPaths(project, workingDir)
+
+ if !isNilVolumeSourcePathMapperInternal(pathMapper) {
+ if err := pathMapper.TranslateVolumeSources(project, translateFileResources); err != nil {
return nil, errors.WrapIf(err, "failed to translate paths for docker host")
}
}
- injectServiceConfiguration(project, injectionVars)
return project, nil
}
+func isNilVolumeSourcePathMapperInternal(pathMapper projecttypes.VolumeSourcePathMapper) bool {
+ if pathMapper == nil {
+ return true
+ }
+
+ value := reflect.ValueOf(pathMapper)
+ return value.Kind() == reflect.Pointer && value.IsNil()
+}
+
+func recoverComposeLoadPanicInternal(ctx context.Context, source string, project **composetypes.Project, err *error) {
+ if panicErr := emperror.Recover(recover()); panicErr != nil {
+ slog.WarnContext(ctx,
+ "panic while loading compose project; compose file may contain invalid syntax",
+ "path", source,
+ "error", panicErr,
+ )
+ *err = errors.WrapIff(panicErr, "load compose project panic for %s", source)
+ *project = nil
+ }
+}
+
func applyCustomLabelsInternal(projectName string, serviceName string, workingDirectory string, composeFiles []string) composetypes.Labels {
return composetypes.Labels{
api.ProjectLabel: projectName,
diff --git a/backend/pkg/projects/path_mapper.go b/backend/pkg/projects/path_mapper.go
index da65d89d0..c7afe4de4 100644
--- a/backend/pkg/projects/path_mapper.go
+++ b/backend/pkg/projects/path_mapper.go
@@ -1,11 +1,14 @@
package projects
import (
+ "context"
+ "log/slog"
"path/filepath"
"strings"
"emperror.dev/errors"
composetypes "github.com/compose-spec/compose-go/v2/types"
+ "github.com/moby/moby/client"
"github.com/samber/mo"
)
@@ -61,6 +64,50 @@ func NewPathMapperFromMounts(mounts []HostMount) *PathMapper {
}
}
+// NewPathMapperForConfiguredDirectory resolves an optional container-to-host
+// directory mapping and falls back to Docker mount discovery when no explicit
+// host path is configured.
+func NewPathMapperForConfiguredDirectory(ctx context.Context, configuredPath, defaultDir string, dockerClient *client.Client) *PathMapper {
+ configuredPath = strings.TrimSpace(configuredPath)
+ if configuredPath == "" {
+ configuredPath = defaultDir
+ }
+
+ containerDir := configuredPath
+ hostDir := ""
+ if parts := strings.SplitN(configuredPath, ":", 2); len(parts) == 2 &&
+ !IsWindowsDrivePath(configuredPath) &&
+ strings.HasPrefix(parts[0], "/") {
+ containerDir = parts[0]
+ hostDir = parts[1]
+ }
+
+ containerDir, err := GetProjectsDirectory(ctx, strings.TrimSpace(containerDir))
+ if err != nil {
+ slog.WarnContext(ctx, "unable to resolve configured source directory, using default", "path", configuredPath, "error", err)
+ containerDir = filepath.Clean(defaultDir)
+ }
+
+ if strings.TrimSpace(hostDir) != "" {
+ pathMapper := NewPathMapper(containerDir, filepath.Clean(strings.TrimSpace(hostDir)))
+ if pathMapper.IsNonMatchingMount() {
+ return pathMapper
+ }
+ return nil
+ }
+
+ mounts, err := GetCurrentContainerMounts(ctx, dockerClient)
+ if err != nil || len(mounts) == 0 {
+ return nil
+ }
+
+ pathMapper := NewPathMapperFromMounts(mounts)
+ if pathMapper.IsNonMatchingMount() {
+ return pathMapper
+ }
+ return nil
+}
+
// ResolveHostPath returns the host-side path for containerPath by selecting the
// longest-prefix mount whose Destination contains it and appending the trailing relative
// segment to that mount's Source. It returns None when no mount contains the path.
@@ -145,8 +192,10 @@ func (pm *PathMapper) ContainerToHost(containerPath string) (string, error) {
return hostPath, nil
}
-// TranslateVolumeSources translates all bind mount sources in a compose project
-func (pm *PathMapper) TranslateVolumeSources(project *composetypes.Project) error {
+// TranslateVolumeSources translates bind mount sources in a Compose project.
+// File-backed configs and secrets are translated only when the Docker host,
+// rather than Arcane itself, will read those files.
+func (pm *PathMapper) TranslateVolumeSources(project *composetypes.Project, translateFileResources bool) error {
if !pm.IsNonMatchingMount() {
return nil // No translation needed
}
@@ -173,6 +222,10 @@ func (pm *PathMapper) TranslateVolumeSources(project *composetypes.Project) erro
project.Services[si] = service
}
+ if !translateFileResources {
+ return nil
+ }
+
// Translate secrets
for name, secret := range project.Secrets {
if secret.File != "" {
diff --git a/backend/pkg/projects/path_mapper_test.go b/backend/pkg/projects/path_mapper_test.go
index b826d6df8..c48963f3d 100644
--- a/backend/pkg/projects/path_mapper_test.go
+++ b/backend/pkg/projects/path_mapper_test.go
@@ -1,6 +1,8 @@
package projects
import (
+ "context"
+ "path/filepath"
"testing"
composetypes "github.com/compose-spec/compose-go/v2/types"
@@ -8,6 +10,29 @@ import (
"github.com/stretchr/testify/require"
)
+func TestNewPathMapperForConfiguredDirectory(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("matching paths do not need a mapper", func(t *testing.T) {
+ containerDir := t.TempDir()
+ pathMapper := NewPathMapperForConfiguredDirectory(ctx, containerDir, containerDir, nil)
+ require.Nil(t, pathMapper)
+ })
+
+ t.Run("explicit mapping is translated", func(t *testing.T) {
+ containerDir := filepath.Join(t.TempDir(), "container")
+ hostDir := "/host/path"
+ pathMapper := NewPathMapperForConfiguredDirectory(ctx, containerDir+":"+hostDir, containerDir, nil)
+ require.NotNil(t, pathMapper)
+
+ source := filepath.Join(containerDir, "0/stack/compose.yaml")
+ expected := filepath.Join(hostDir, "0/stack/compose.yaml")
+ translated, err := pathMapper.ContainerToHost(source)
+ require.NoError(t, err)
+ require.Equal(t, filepath.ToSlash(expected), filepath.ToSlash(translated))
+ })
+}
+
func TestPathMapper_MatchingMount_NoTranslation(t *testing.T) {
pm := NewPathMapper("/app/data/projects", "")
result, err := pm.ContainerToHost("/app/data/projects/test/data")
@@ -106,7 +131,7 @@ func TestPathMapper_TranslateVolumeSources(t *testing.T) {
},
}
- err := pm.TranslateVolumeSources(project)
+ err := pm.TranslateVolumeSources(project, true)
require.NoError(t, err)
assert.Equal(t, "C:/User/arcane/projects/myproj/data", project.Services["app"].Volumes[0].Source)
@@ -114,3 +139,30 @@ func TestPathMapper_TranslateVolumeSources(t *testing.T) {
assert.Equal(t, "C:/User/arcane/projects/myproj/secret.txt", project.Secrets["my-secret"].File)
assert.Equal(t, "C:/User/arcane/projects/myproj/config.yaml", project.Configs["my-config"].File)
}
+
+func TestPathMapper_TranslateVolumeSourcesKeepsArcaneReadFiles(t *testing.T) {
+ pm := NewPathMapper("/app/data/swarm/sources", "/host/swarm/sources")
+ project := &composetypes.Project{
+ Services: composetypes.Services{
+ "app": {
+ Name: "app",
+ Volumes: []composetypes.ServiceVolumeConfig{{
+ Type: composetypes.VolumeTypeBind,
+ Source: "/app/data/swarm/sources/0/stack/data",
+ Target: "/data",
+ }},
+ },
+ },
+ Secrets: composetypes.Secrets{
+ "secret": {File: "/app/data/swarm/sources/0/stack/secret.txt"},
+ },
+ Configs: composetypes.Configs{
+ "config": {File: "/app/data/swarm/sources/0/stack/config.yaml"},
+ },
+ }
+
+ require.NoError(t, pm.TranslateVolumeSources(project, false))
+ assert.Equal(t, "/host/swarm/sources/0/stack/data", project.Services["app"].Volumes[0].Source)
+ assert.Equal(t, "/app/data/swarm/sources/0/stack/secret.txt", project.Secrets["secret"].File)
+ assert.Equal(t, "/app/data/swarm/sources/0/stack/config.yaml", project.Configs["config"].File)
+}
diff --git a/backend/pkg/projects/types/compose_content.go b/backend/pkg/projects/types/compose_content.go
new file mode 100644
index 000000000..969929916
--- /dev/null
+++ b/backend/pkg/projects/types/compose_content.go
@@ -0,0 +1,20 @@
+package types
+
+import (
+ composetypes "github.com/compose-spec/compose-go/v2/types"
+)
+
+// VolumeSourcePathMapper translates Compose volume sources for the Docker host.
+type VolumeSourcePathMapper interface {
+ TranslateVolumeSources(project *composetypes.Project, translateFileResources bool) error
+}
+
+// ComposeContentOptions configures loading a Compose project from in-memory content.
+type ComposeContentOptions struct {
+ ProjectName string
+ ComposeContent string
+ OverrideContent string
+ EnvContent string
+ WorkingDir string
+ PathMapper VolumeSourcePathMapper
+}
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index dbf773d9e..7891bacb1 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -2845,6 +2845,10 @@
"project_logs_realtime_desc": "Real-time project logs",
"swarm_stack_source_loading": "Loading saved source...",
"swarm_stack_source_load_error": "Arcane couldn’t load the saved source files for this stack.",
+ "swarm_stack_deploy_prune": "Prune removed services",
+ "swarm_stack_registry_auth": "Send registry authentication",
+ "swarm_stack_resolve_image": "Resolve images",
+ "swarm_stack_resolve_image_changed": "When changed",
"volume_backup_no_files": "No files found in this backup.",
"swarm_stack_saved_source": "Saved source for {stackName}",
"editor_validating": "Validating...",
diff --git a/frontend/src/lib/services/swarm-service.ts b/frontend/src/lib/services/swarm-service.ts
index ddb9b969a..366029096 100644
--- a/frontend/src/lib/services/swarm-service.ts
+++ b/frontend/src/lib/services/swarm-service.ts
@@ -38,9 +38,7 @@ import type {
SwarmConfigSummary,
SwarmSecretSummary,
SwarmConfigCreateRequest,
- SwarmConfigUpdateRequest,
SwarmSecretCreateRequest,
- SwarmSecretUpdateRequest,
SwarmJoinCandidate,
SwarmJoinEnvironmentsRequest,
SwarmJoinEnvironmentsResponse
@@ -103,11 +101,6 @@ class SwarmService extends BaseAPIService {
return res.data;
}
- async getNode(nodeId: string): Promise<SwarmNodeSummary> {
- const envId = await environmentStore.getCurrentEnvironmentId();
- return this.handleResponse(this.api.get(`/environments/${envId}/swarm/nodes/${nodeId}`));
- }
-
async getNodeAgentDeployment(nodeId: string, rotate = false): Promise<SwarmNodeAgentDeployment> {
const envId = await environmentStore.getCurrentEnvironmentId();
return this.handleResponse(this.api.post(`/environments/${envId}/swarm/nodes/${nodeId}/agent/deployment`, { rotate }));
@@ -283,21 +276,11 @@ class SwarmService extends BaseAPIService {
return this.handleResponse(this.api.get(`/environments/${envId}/swarm/configs`));
}
- async getConfig(configId: string): Promise<SwarmConfigSummary> {
- const envId = await environmentStore.getCurrentEnvironmentId();
- return this.handleResponse(this.api.get(`/environments/${envId}/swarm/configs/${configId}`));
- }
-
async createConfig(request: SwarmConfigCreateRequest): Promise<SwarmConfigSummary> {
const envId = await environmentStore.getCurrentEnvironmentId();
return this.handleResponse(this.api.post(`/environments/${envId}/swarm/configs`, request));
}
- async updateConfig(configId: string, request: SwarmConfigUpdateRequest): Promise<SwarmConfigSummary> {
- const envId = await environmentStore.getCurrentEnvironmentId();
- return this.handleResponse(this.api.put(`/environments/${envId}/swarm/configs/${configId}`, request));
- }
-
async removeConfig(configId: string): Promise<void> {
const envId = await environmentStore.getCurrentEnvironmentId();
await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/configs/${configId}`));
@@ -308,21 +291,11 @@ class SwarmService extends BaseAPIService {
return this.handleResponse(this.api.get(`/environments/${envId}/swarm/secrets`));
}
- async getSecret(secretId: string): Promise<SwarmSecretSummary> {
- const envId = await environmentStore.getCurrentEnvironmentId();
- return this.handleResponse(this.api.get(`/environments/${envId}/swarm/secrets/${secretId}`));
- }
-
async createSecret(request: SwarmSecretCreateRequest): Promise<SwarmSecretSummary> {
const envId = await environmentStore.getCurrentEnvironmentId();
return this.handleResponse(this.api.post(`/environments/${envId}/swarm/secrets`, request));
}
- async updateSecret(secretId: string, request: SwarmSecretUpdateRequest): Promise<SwarmSecretSummary> {
- const envId = await environmentStore.getCurrentEnvironmentId();
- return this.handleResponse(this.api.put(`/environments/${envId}/swarm/secrets/${secretId}`, request));
- }
-
async removeSecret(secretId: string): Promise<void> {
const envId = await environmentStore.getCurrentEnvironmentId();
await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/secrets/${secretId}`));
diff --git a/frontend/src/lib/types/swarm.ts b/frontend/src/lib/types/swarm.ts
index c7cddabdd..3f579afb5 100644
--- a/frontend/src/lib/types/swarm.ts
+++ b/frontend/src/lib/types/swarm.ts
@@ -336,10 +336,17 @@ export interface SwarmStackInspect {
updatedAt: string;
}
+export interface SwarmSyncFile {
+ relativePath: string;
+ content: string;
+}
+
export interface SwarmStackDeployRequest {
name: string;
composeContent: string;
+ overrideContent?: string;
envContent?: string;
+ files?: SwarmSyncFile[];
withRegistryAuth?: boolean;
prune?: boolean;
resolveImage?: string;
@@ -352,6 +359,7 @@ export interface SwarmStackDeployResponse {
export interface SwarmStackRenderConfigRequest {
name: string;
composeContent: string;
+ overrideContent?: string;
envContent?: string;
}
@@ -369,12 +377,16 @@ export interface SwarmStackRenderConfigResponse {
export interface SwarmStackSource {
name: string;
composeContent: string;
+ overrideContent?: string;
envContent?: string;
+ files?: SwarmSyncFile[];
}
export interface SwarmStackSourceUpdateRequest {
composeContent: string;
+ overrideContent?: string;
envContent?: string;
+ files?: SwarmSyncFile[];
}
export interface SwarmInfo {
@@ -496,20 +508,10 @@ export interface SwarmConfigCreateRequest {
spec: Record<string, unknown>;
}
-export interface SwarmConfigUpdateRequest {
- version?: number;
- spec: Record<string, unknown>;
-}
-
export interface SwarmSecretCreateRequest {
spec: Record<string, unknown>;
}
-export interface SwarmSecretUpdateRequest {
- version?: number;
- spec: Record<string, unknown>;
-}
-
// --- Compose projects ---
export interface ServicePort {
diff --git a/frontend/src/routes/(app)/swarm/stacks/new/+page.svelte b/frontend/src/routes/(app)/swarm/stacks/new/+page.svelte
index 02b324ca4..b8f9970db 100644
--- a/frontend/src/routes/(app)/swarm/stacks/new/+page.svelte
+++ b/frontend/src/routes/(app)/swarm/stacks/new/+page.svelte
@@ -1,6 +1,7 @@
<script lang="ts">
import { ArcaneButton } from '#lib/components/arcane-button/index.js';
import { goto, refreshAll } from '$app/navigation';
+ import { untrack } from 'svelte';
import { toast } from 'svelte-sonner';
import { preventDefault, createForm } from '#lib/utils/settings';
import TemplateSelectionDialog from '#lib/components/dialogs/template-selection-dialog.svelte';
@@ -8,15 +9,34 @@
import { swarmService } from '#lib/services/swarm-service.js';
import ComposeCreateMenu from '#lib/components/compose-create-menu.svelte';
import ComposeFileEditorPanel from '#lib/components/compose-file-editor-panel.svelte';
- import { ArrowLeftIcon } from '#lib/icons';
+ import { ArrowLeftIcon, TrashIcon } from '#lib/icons';
import CodePanel from '../../../projects/components/CodePanel.svelte';
import EditableName from '../../../projects/components/EditableName.svelte';
import EditorTabStrip from '../../../projects/components/EditorTabStrip.svelte';
import ProjectFileTreePanel from '../../../projects/components/ProjectFileTreePanel.svelte';
import ResizableSplit from '#lib/components/resizable-split.svelte';
+ import { Checkbox } from '#lib/components/ui/checkbox';
+ import { Label } from '#lib/components/ui/label';
+ import * as Select from '#lib/components/ui/select';
import { environmentStore } from '#lib/stores/environment.store.svelte';
import DockerRunConverterDialog from '#lib/components/compose/docker-run-converter-dialog.svelte';
import { globalVariablesToMap } from '#lib/utils/template-load';
+ import type { ProjectFileDraft } from '#lib/types/project-files';
+ import type { SwarmSyncFile } from '#lib/types/swarm';
+ import {
+ isProjectFileSelectionUnder,
+ planProjectFileCreate,
+ planProjectFileMove,
+ planProjectFileRename,
+ projectFileBasename,
+ projectFileLanguage,
+ projectFilePathMatches,
+ remapProjectFilePath,
+ remapProjectFileRecord,
+ remapSelectedProjectFileKey,
+ removeProjectFileRecord,
+ type ManagedProjectFileEntry
+ } from '../../../projects/components/project-file-tree-utils';
import {
createComposeEditorSchema,
createComposeTemplateDialogFlow,
@@ -66,28 +86,103 @@
let composeOpen = $state(true);
let envOpen = $state(true);
let nameInputRef = $state<HTMLInputElement | null>(null);
+ let overrideContent = $state(untrack(() => data.overrideTemplate || ''));
+ let overrideActive = $state(untrack(() => (data.overrideTemplate || '').trim().length > 0));
+ let deployOptions = $state({
+ prune: false,
+ withRegistryAuth: false,
+ resolveImage: 'always'
+ });
+
+ function decodeStackFileContent(content: string): string {
+ try {
+ const bytes = Uint8Array.from(atob(content), (character) => character.charCodeAt(0));
+ return new TextDecoder().decode(bytes);
+ } catch {
+ return content;
+ }
+ }
+
+ function encodeStackFileContent(content: string): string {
+ const bytes = new TextEncoder().encode(content);
+ let encoded = '';
+ for (const byte of bytes) {
+ encoded += String.fromCharCode(byte);
+ }
+ return btoa(encoded);
+ }
+
+ let stackFiles = $state<ProjectFileDraft[]>(
+ untrack(() => (data.sourceFiles ?? []).map((file) => ({ relativePath: file.relativePath, isDirectory: false })))
+ );
+ let stackFileContents = $state<Record<string, string>>(
+ untrack(() =>
+ Object.fromEntries((data.sourceFiles ?? []).map((file) => [file.relativePath, decodeStackFileContent(file.content)]))
+ )
+ );
+ const stackFileEntries = $derived.by<ManagedProjectFileEntry[]>(() =>
+ stackFiles.map((file) => ({
+ path: file.relativePath,
+ relativePath: file.relativePath,
+ name: projectFileBasename(file.relativePath),
+ isDirectory: !!file.isDirectory,
+ size: file.isDirectory ? 0 : (stackFileContents[file.relativePath]?.length ?? 0),
+ content: file.isDirectory ? undefined : (stackFileContents[file.relativePath] ?? ''),
+ pending: false
+ }))
+ );
+ const stackFilePaths = $derived.by(() => new Set(stackFileEntries.map((file) => file.relativePath)));
let selectedStackFile = $state('compose');
let openStackTabs = $state<string[]>(['compose']);
let stackTreeWidth = $state<number | null>(null);
let treeOutlineOpen = $state(false);
let treeCommandPaletteOpen = $state(false);
- const stackOpenTabs = $derived(openStackTabs.length > 0 ? openStackTabs : ['compose']);
+ const stackOpenTabs = $derived.by(() => {
+ const valid = openStackTabs.filter((key) => {
+ if (key === 'compose' || key === 'env') return true;
+ if (key === 'override') return overrideActive;
+ if (!key.startsWith('file:')) return false;
+ const entry = stackFileEntries.find((file) => file.relativePath === key.slice(5));
+ return !!entry && !entry.isDirectory;
+ });
+ return valid.length > 0 ? valid : ['compose'];
+ });
const activeStackTab = $derived(
stackOpenTabs.includes(selectedStackFile) ? selectedStackFile : (stackOpenTabs[0] ?? 'compose')
);
const stackTabs = $derived(
stackOpenTabs.map((key) => ({
key,
- label: key === 'compose' ? 'compose.yaml' : '.env',
- title: key === 'compose' ? 'compose.yaml' : '.env',
- iconClass: key === 'compose' ? 'text-blue-500' : 'text-green-500',
+ label:
+ key === 'compose'
+ ? 'compose.yaml'
+ : key === 'override'
+ ? 'compose.override.yaml'
+ : key === 'env'
+ ? '.env'
+ : projectFileBasename(key.slice(5)),
+ title:
+ key === 'compose' ? 'compose.yaml' : key === 'override' ? 'compose.override.yaml' : key === 'env' ? '.env' : key.slice(5),
+ iconClass:
+ key === 'compose'
+ ? 'text-blue-500'
+ : key === 'override'
+ ? 'text-purple-500'
+ : key === 'env'
+ ? 'text-green-500'
+ : 'text-muted-foreground',
pending: false
}))
);
+ function isStackDirectoryKey(key: string): boolean {
+ if (!key.startsWith('file:')) return false;
+ return stackFileEntries.find((file) => file.relativePath === key.slice(5))?.isDirectory === true;
+ }
+
function openStackTab(key: string) {
- if (!openStackTabs.includes(key)) {
+ if (!isStackDirectoryKey(key) && !openStackTabs.includes(key)) {
openStackTabs = [...openStackTabs, key];
}
selectedStackFile = key;
@@ -102,7 +197,82 @@
}
}
+ function addOverride() {
+ overrideActive = true;
+ openStackTab('override');
+ }
+
+ function removeOverride() {
+ overrideContent = '';
+ overrideActive = false;
+ closeStackTab('override');
+ }
+
+ function createStackFile(parentPath: string, name: string, content = '') {
+ const relativePath = planProjectFileCreate(stackFilePaths, parentPath, name);
+ if (!relativePath) return;
+ stackFiles = [...stackFiles, { relativePath, isDirectory: false }];
+ stackFileContents = { ...stackFileContents, [relativePath]: content };
+ openStackTab(`file:${relativePath}`);
+ }
+
+ function createStackFolder(parentPath: string, name: string) {
+ const relativePath = planProjectFileCreate(stackFilePaths, parentPath, name);
+ if (!relativePath) return;
+ stackFiles = [...stackFiles, { relativePath, isDirectory: true }];
+ selectedStackFile = `file:${relativePath}`;
+ }
+
+ function applyStackFilePathChange(oldPath: string, newPath: string) {
+ stackFiles = stackFiles.map((file) => ({
+ ...file,
+ relativePath: remapProjectFilePath(file.relativePath, oldPath, newPath)
+ }));
+ stackFileContents = remapProjectFileRecord(stackFileContents, oldPath, newPath);
+ openStackTabs = openStackTabs.map((tab) => remapSelectedProjectFileKey(tab, oldPath, newPath) ?? tab);
+ const remappedSelection = remapSelectedProjectFileKey(selectedStackFile, oldPath, newPath);
+ if (remappedSelection) {
+ selectedStackFile = remappedSelection;
+ }
+ }
+
+ function renameStackFile(relativePath: string, newName: string) {
+ const plan = planProjectFileRename(stackFilePaths, relativePath, newName);
+ if (!plan) return;
+ applyStackFilePathChange(relativePath, plan.newPath);
+ }
+
+ function moveStackFile(relativePath: string, newParentPath: string) {
+ const entry = stackFileEntries.find((file) => file.relativePath === relativePath);
+ const newPath = planProjectFileMove(entry, stackFilePaths, relativePath, newParentPath);
+ if (!newPath) return;
+ applyStackFilePathChange(relativePath, newPath);
+ }
+
+ function deleteStackFile(relativePath: string) {
+ stackFiles = stackFiles.filter((file) => !projectFilePathMatches(file.relativePath, relativePath));
+ stackFileContents = removeProjectFileRecord(stackFileContents, relativePath);
+ openStackTabs = openStackTabs.filter((tab) => !isProjectFileSelectionUnder(tab, relativePath));
+ if (isProjectFileSelectionUnder(selectedStackFile, relativePath)) {
+ selectedStackFile = stackOpenTabs[0] ?? 'compose';
+ }
+ }
+
+ function buildStackFilePayload(): SwarmSyncFile[] {
+ return stackFiles
+ .filter((file) => !file.isDirectory)
+ .map((file) => ({
+ relativePath: file.relativePath,
+ content: encodeStackFileContent(stackFileContents[file.relativePath] ?? '')
+ }));
+ }
+
const globalVariableMap = $derived(globalVariablesToMap(data.globalVariables));
+ const stackEditorContext = $derived({
+ envContent: $inputs.envContent.value,
+ composeContents: [$inputs.composeContent.value, overrideContent].filter((content) => content.length > 0),
+ globalVariables: globalVariableMap
+ });
async function handleSubmit() {
if (isEditMode) {
@@ -116,7 +286,17 @@
await submitComposeResourceForm({
validate: form.validate,
setLoading: (value) => (ui.saving = value),
- submit: ({ name, composeContent, envContent }) => swarmService.deployStack({ name, composeContent, envContent }),
+ submit: ({ name, composeContent, envContent }) =>
+ swarmService.deployStack({
+ name,
+ composeContent,
+ overrideContent,
+ envContent,
+ files: buildStackFilePayload(),
+ prune: deployOptions.prune,
+ withRegistryAuth: deployOptions.withRegistryAuth,
+ resolveImage: deployOptions.resolveImage
+ }),
failureMessage: (name) => m.common_create_failed({ resource: `${m.swarm_stack()} "${name}"` }),
onSuccess: async (_result, { name }) => {
toast.success(m.common_create_success({ resource: `${m.swarm_stack()} "${name}"` }));
@@ -129,7 +309,13 @@
await submitComposeResourceForm({
validate: form.validate,
setLoading: (value) => (ui.saving = value),
- submit: ({ name, composeContent, envContent }) => swarmService.deployStack({ name, composeContent, envContent }),
+ submit: ({ name, composeContent, envContent }) =>
+ swarmService.updateStackSource(name, {
+ composeContent,
+ overrideContent,
+ envContent,
+ files: buildStackFilePayload()
+ }),
failureMessage: (name) => m.common_update_failed({ resource: `${m.swarm_stack()} "${name}"` }),
onSuccess: async (_result, { name }) => {
toast.success(m.common_update_success({ resource: `${m.swarm_stack()} "${name}"` }));
@@ -223,7 +409,46 @@
/>
</div>
- <form class="flex h-full min-h-0 flex-1 flex-col px-2 pb-4 sm:px-6" onsubmit={preventDefault(handleSubmit)}>
+ <form class="flex h-full min-h-0 flex-1 flex-col gap-3 px-2 pb-4 sm:px-6" onsubmit={preventDefault(handleSubmit)}>
+ {#if !isEditMode}
+ <div class="flex shrink-0 flex-wrap items-center gap-x-6 gap-y-3 rounded-lg border border-border bg-card px-4 py-3">
+ <div class="flex items-center gap-2">
+ <Checkbox
+ id="swarm-stack-prune"
+ checked={deployOptions.prune}
+ onCheckedChange={(checked) => (deployOptions.prune = checked === true)}
+ />
+ <Label for="swarm-stack-prune" class="font-normal">{m.swarm_stack_deploy_prune()}</Label>
+ </div>
+ <div class="flex items-center gap-2">
+ <Checkbox
+ id="swarm-stack-registry-auth"
+ checked={deployOptions.withRegistryAuth}
+ onCheckedChange={(checked) => (deployOptions.withRegistryAuth = checked === true)}
+ />
+ <Label for="swarm-stack-registry-auth" class="font-normal">{m.swarm_stack_registry_auth()}</Label>
+ </div>
+ <div class="flex min-w-56 items-center gap-2">
+ <Label for="swarm-stack-resolve-image" class="shrink-0 font-normal">{m.swarm_stack_resolve_image()}</Label>
+ <Select.Root type="single" bind:value={deployOptions.resolveImage}>
+ <Select.Trigger id="swarm-stack-resolve-image" class="h-8 min-w-32">
+ <span class="truncate">
+ {deployOptions.resolveImage === 'changed'
+ ? m.swarm_stack_resolve_image_changed()
+ : deployOptions.resolveImage === 'never'
+ ? m.common_never()
+ : m.common_always()}
+ </span>
+ </Select.Trigger>
+ <Select.Content>
+ <Select.Item value="always">{m.common_always()}</Select.Item>
+ <Select.Item value="changed">{m.swarm_stack_resolve_image_changed()}</Select.Item>
+ <Select.Item value="never">{m.common_never()}</Select.Item>
+ </Select.Content>
+ </Select.Root>
+ </div>
+ </div>
+ {/if}
<div class="flex min-h-0 flex-1 flex-col overflow-hidden rounded-lg border border-border bg-card">
<ResizableSplit
class="min-h-0 flex-1"
@@ -242,10 +467,18 @@
{#snippet first()}
<ProjectFileTreePanel
composeFileName="compose.yaml"
- entries={[]}
+ overrideFileName="compose.override.yaml"
+ showOverride={overrideActive}
+ onAddOverride={addOverride}
+ entries={stackFileEntries}
selectedFile={selectedStackFile}
disabled={ui.saving || ui.isLoadingTemplateContent}
onSelect={openStackTab}
+ onCreateFile={createStackFile}
+ onCreateFolder={createStackFolder}
+ onRename={renameStackFile}
+ onMove={moveStackFile}
+ onDelete={deleteStackFile}
/>
{/snippet}
@@ -274,14 +507,35 @@
bind:value={$inputs.composeContent.value}
error={$inputs.composeContent.error ?? undefined}
fileId={isEditMode ? `swarm:stacks:${initialName}:compose` : 'swarm:stacks:new:compose'}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: [$inputs.composeContent.value],
- globalVariables: globalVariableMap
- }}
+ editorContext={stackEditorContext}
bind:outlineOpen={treeOutlineOpen}
bind:commandPaletteOpen={treeCommandPaletteOpen}
/>
+ {:else if activeStackTab === 'override'}
+ <div class="flex min-h-0 flex-1 flex-col">
+ <div class="flex shrink-0 items-center justify-between gap-2 border-b border-border px-3 py-2">
+ <p class="text-xs text-muted-foreground">{m.compose_override_hint()}</p>
+ <button
+ type="button"
+ class="flex shrink-0 items-center gap-1 text-xs font-medium text-muted-foreground hover:text-destructive"
+ onclick={removeOverride}
+ >
+ <TrashIcon class="size-3.5 shrink-0" />
+ <span>{m.compose_override_remove()}</span>
+ </button>
+ </div>
+ <CodePanel
+ variant="plain"
+ open={true}
+ title="compose.override.yaml"
+ language="yaml"
+ bind:value={overrideContent}
+ fileId={isEditMode ? `swarm:stacks:${initialName}:override` : 'swarm:stacks:new:override'}
+ editorContext={stackEditorContext}
+ bind:outlineOpen={treeOutlineOpen}
+ bind:commandPaletteOpen={treeCommandPaletteOpen}
+ />
+ </div>
{:else if activeStackTab === 'env'}
<CodePanel
variant="plain"
@@ -291,11 +545,21 @@
bind:value={$inputs.envContent.value}
error={$inputs.envContent.error ?? undefined}
fileId={isEditMode ? `swarm:stacks:${initialName}:env` : 'swarm:stacks:new:env'}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: [$inputs.composeContent.value],
- globalVariables: globalVariableMap
- }}
+ editorContext={stackEditorContext}
+ bind:outlineOpen={treeOutlineOpen}
+ bind:commandPaletteOpen={treeCommandPaletteOpen}
+ />
+ {:else if activeStackTab.startsWith('file:')}
+ {@const relativePath = activeStackTab.slice(5)}
+ <CodePanel
+ variant="plain"
+ open={true}
+ title={relativePath}
+ language={projectFileLanguage(relativePath)}
+ validationMode="none"
+ bind:value={stackFileContents[relativePath]}
+ fileId={`swarm:stacks:${isEditMode ? initialName : 'new'}:file:${relativePath}`}
+ editorContext={stackEditorContext}
bind:outlineOpen={treeOutlineOpen}
bind:commandPaletteOpen={treeCommandPaletteOpen}
/>
diff --git a/frontend/src/routes/(app)/swarm/stacks/new/+page.ts b/frontend/src/routes/(app)/swarm/stacks/new/+page.ts
index d82b126c2..40998716a 100644
--- a/frontend/src/routes/(app)/swarm/stacks/new/+page.ts
+++ b/frontend/src/routes/(app)/swarm/stacks/new/+page.ts
@@ -50,6 +50,8 @@ export const load: PageLoad = async ({ url }) => {
defaultTemplate: isEditMode
? (sourceStack?.composeContent ?? '')
: (selectedTemplate?.content ?? defaultTemplates.swarmStackTemplate),
+ overrideTemplate: sourceStack?.overrideContent ?? '',
+ sourceFiles: sourceStack?.files ?? [],
isEditMode,
selectedTemplate: selectedTemplate?.template || null,
sourceStackName: sourceStack?.name || sourceStackName || null,
diff --git a/types/swarm/config_secret.go b/types/swarm/config_secret.go
index d6855aea9..4222c0324 100644
--- a/types/swarm/config_secret.go
+++ b/types/swarm/config_secret.go
@@ -27,20 +27,10 @@ type ConfigCreateRequest struct {
Spec json.RawMessage `json:"spec" doc:"Config specification"`
}
-type ConfigUpdateRequest struct {
- Version uint64 `json:"version,omitempty"`
- Spec json.RawMessage `json:"spec" doc:"Updated config specification"`
-}
-
type SecretCreateRequest struct {
Spec json.RawMessage `json:"spec" doc:"Secret specification"`
}
-type SecretUpdateRequest struct {
- Version uint64 `json:"version,omitempty"`
- Spec json.RawMessage `json:"spec" doc:"Updated secret specification"`
-}
-
// NewConfigSummary converts a Docker swarm config into the API-facing ConfigSummary shape.
//
// It copies the config identity, version, timestamps, and spec from the Docker
diff --git a/types/swarm/stack.go b/types/swarm/stack.go
index f952bb09c..749a06d78 100644
--- a/types/swarm/stack.go
+++ b/types/swarm/stack.go
@@ -95,27 +95,29 @@ type StackRenderConfigResponse struct {
// Required: true
RenderedCompose string `json:"renderedCompose"`
- // Services contains service names discovered in the compose file.
+ // Services contains the final stack-scoped service names.
//
// Required: true
Services []string `json:"services"`
- // Networks contains network names discovered in the compose file.
+ // Networks contains the final resolved network names, including stack
+ // namespacing for non-external resources.
//
// Required: true
Networks []string `json:"networks"`
- // Volumes contains volume names discovered in the compose file.
+ // Volumes contains the final resolved volume names, including stack
+ // namespacing for non-external resources.
//
// Required: true
Volumes []string `json:"volumes"`
- // Configs contains config names discovered in the compose file.
+ // Configs contains the final content-addressed or external config names.
//
// Required: true
Configs []string `json:"configs"`
- // Secrets contains secret names discovered in the compose file.
+ // Secrets contains the final content-addressed or external secret names.
//
// Required: true
Secrets []string `json:"secrets"`
diff --git a/types/swarm/stack_deploy.go b/types/swarm/stack_deploy.go
index 55ea9a2f2..0db82dd36 100644
--- a/types/swarm/stack_deploy.go
+++ b/types/swarm/stack_deploy.go
@@ -43,10 +43,11 @@ type StackDeployRequest struct {
// Required: false
ResolveImage string `json:"resolveImage,omitempty"`
- // WorkingDir defines the working directory context for evaluating compose files.
+ // WorkingDir is the trusted internal working directory used by GitOps.
+ // It is never decoded from public API requests.
//
// Required: false
- WorkingDir string `json:"workingDir,omitempty"`
+ WorkingDir string `json:"-"`
}
// SyncFile represents a file to be synced to the target environment.