Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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, environmentSvchumamw.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, environmentSvchumamw.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 *CreateSwarmConfireturn &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 *CreateSwarmSecrereturn &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.goindex 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.goindex 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.Contereturn 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.goindex 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, scfg := 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.goindex 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, reworkingDir = 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, reWorkingDir: 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, stackNamereturn 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, stackNamereturn 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, dockerClreturn 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 streturn 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.ConfigCrreturn 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.SecretCrreturn 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, environmenreturn 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, environmenreturn 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 contextreturn 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.goindex 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_UsesStoredFilesWithoutSwarmManagersource, 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.godeleted file mode 100644index 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.godeleted file mode 100644index 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.goindex 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.goindex 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.goindex 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, prreturn 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.goindex da65d89d0..c7afe4de4 100644--- a/backend/pkg/projects/path_mapper.go+++ b/backend/pkg/projects/path_mapper.go@@ -1,11 +1,14 @@package projectsimport (+ "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) erroproject.Services[si] = service}+ if !translateFileResources {+ return nil+ }+// Translate secretsfor 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.goindex b826d6df8..c48963f3d 100644--- a/backend/pkg/projects/path_mapper_test.go+++ b/backend/pkg/projects/path_mapper_test.go@@ -1,6 +1,8 @@package projectsimport (+ "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.gonew file mode 100644index 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.jsonindex 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.tsindex 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.tsindex 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.svelteindex 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"><ResizableSplitclass="min-h-0 flex-1"@@ -242,10 +467,18 @@{#snippet first()}<ProjectFileTreePanelcomposeFileName="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'}<CodePanelvariant="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.tsindex 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.goindex 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 Dockerdiff --git a/types/swarm/stack.go b/types/swarm/stack.goindex f952bb09c..749a06d78 100644--- a/types/swarm/stack.go+++ b/types/swarm/stack.go@@ -95,27 +95,29 @@ type StackRenderConfigResponse struct {// Required: trueRenderedCompose string `json:"renderedCompose"`- // Services contains service names discovered in the compose file.+ // Services contains the final stack-scoped service names.//// Required: trueServices []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: trueNetworks []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: trueVolumes []string `json:"volumes"`- // Configs contains config names discovered in the compose file.+ // Configs contains the final content-addressed or external config names.//// Required: trueConfigs []string `json:"configs"`- // Secrets contains secret names discovered in the compose file.+ // Secrets contains the final content-addressed or external secret names.//// Required: trueSecrets []string `json:"secrets"`diff --git a/types/swarm/stack_deploy.go b/types/swarm/stack_deploy.goindex 55ea9a2f2..0db82dd36 100644--- a/types/swarm/stack_deploy.go+++ b/types/swarm/stack_deploy.go@@ -43,10 +43,11 @@ type StackDeployRequest struct {// Required: falseResolveImage 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.