Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: move auto updater to just updater confirm working with projects
Kyle Mendell1382213820ce
diff --git a/backend/internal/api/auto_update_handler.go b/backend/internal/api/auto_update_handler.godeleted file mode 100644index 0dbd0b9dc..000000000--- a/backend/internal/api/auto_update_handler.go+++ /dev/null@@ -1,115 +0,0 @@-package api--import (- "net/http"- "strconv"-- "github.com/gin-gonic/gin"- "github.com/ofkm/arcane-backend/internal/dto"- "github.com/ofkm/arcane-backend/internal/services"-)--type AutoUpdateHandler struct {- autoUpdateService *services.AutoUpdateService-}--func NewAutoUpdateHandler(autoUpdateService *services.AutoUpdateService) *AutoUpdateHandler {- return &AutoUpdateHandler{- autoUpdateService: autoUpdateService,- }-}--func (h *AutoUpdateHandler) CheckForUpdates(c *gin.Context) {- var req dto.AutoUpdateCheckDto- if err := c.ShouldBindJSON(&req); err != nil {- req = dto.AutoUpdateCheckDto{Type: "all"}- }-- result, err := h.autoUpdateService.CheckForUpdates(c.Request.Context(), req)- if err != nil {- c.JSON(http.StatusInternalServerError, gin.H{- "success": false,- "error": err.Error(),- })- return- }-- c.JSON(http.StatusOK, gin.H{- "success": true,- "data": result,- })-}--func (h *AutoUpdateHandler) CheckContainers(c *gin.Context) {- req := dto.AutoUpdateCheckDto{- Type: "containers",- }-- result, err := h.autoUpdateService.CheckForUpdates(c.Request.Context(), req)- if err != nil {- c.JSON(http.StatusInternalServerError, gin.H{- "success": false,- "error": err.Error(),- })- return- }-- c.JSON(http.StatusOK, gin.H{- "success": true,- "data": result,- })-}--func (h *AutoUpdateHandler) CheckStacks(c *gin.Context) {- req := dto.AutoUpdateCheckDto{- Type: "stacks",- }-- result, err := h.autoUpdateService.CheckForUpdates(c.Request.Context(), req)- if err != nil {- c.JSON(http.StatusInternalServerError, gin.H{- "success": false,- "error": err.Error(),- })- return- }-- c.JSON(http.StatusOK, gin.H{- "success": true,- "data": result,- })-}--func (h *AutoUpdateHandler) GetUpdateHistory(c *gin.Context) {- limit := 50- if limitStr := c.Query("limit"); limitStr != "" {- if parsedLimit, err := strconv.Atoi(limitStr); err == nil && parsedLimit > 0 {- limit = parsedLimit- if limit > 100 {- limit = 100- }- }- }-- history, err := h.autoUpdateService.GetAutoUpdateHistory(c.Request.Context(), limit)- if err != nil {- c.JSON(http.StatusInternalServerError, gin.H{- "success": false,- "error": err.Error(),- })- return- }-- c.JSON(http.StatusOK, gin.H{- "success": true,- "data": history,- })-}--func (h *AutoUpdateHandler) GetUpdateStatus(c *gin.Context) {- status := h.autoUpdateService.GetUpdateStatus()- c.JSON(http.StatusOK, gin.H{- "success": true,- "data": status,- })-}diff --git a/backend/internal/api/routes.go b/backend/internal/api/routes.goindex 3059bc54b..0dd307eee 100644--- a/backend/internal/api/routes.go+++ b/backend/internal/api/routes.go@@ -24,7 +24,7 @@ type Services struct {Template *services.TemplateServiceContainerRegistry *services.ContainerRegistryServiceSystem *services.SystemService- AutoUpdate *services.AutoUpdateService+ Updater *services.UpdaterServiceEvent *services.EventService}@@ -44,10 +44,10 @@ func SetupRoutes(r *gin.Engine, services *Services, appConfig *config.Config) {setupNetworkRoutes(api, services)setupTemplateRoutes(api, services)setupContainerRegistryRoutes(api, services)- setupAutoUpdateRoutes(api, services)setupConverterRoutes(api, services)setupImageUpdateRoutes(api, services)setupEventRoutes(api, services)+ setupUpdaterRoutes(api, services)}func setupContainerRegistryRoutes(api *gin.RouterGroup, services *Services) {@@ -253,17 +253,15 @@ func setupSystemRoutes(api *gin.RouterGroup, dockerService *services.DockerCliensystem.POST("/containers/stop-all", systemHandler.StopAllContainers)}-func setupAutoUpdateRoutes(api *gin.RouterGroup, services *Services) {- autoUpdate := api.Group("/updates")+func setupUpdaterRoutes(api *gin.RouterGroup, services *Services) {+ autoUpdate := api.Group("/updater")autoUpdate.Use(middleware.AuthMiddleware(services.Auth))- autoUpdateHandler := NewAutoUpdateHandler(services.AutoUpdate)+ updaterHandler := NewUpdaterHandler(services.Updater)- autoUpdate.POST("/check", autoUpdateHandler.CheckForUpdates)- autoUpdate.POST("/check/containers", autoUpdateHandler.CheckContainers)- autoUpdate.POST("/check/compose", autoUpdateHandler.CheckStacks)- autoUpdate.GET("/history", autoUpdateHandler.GetUpdateHistory)- autoUpdate.GET("/status", autoUpdateHandler.GetUpdateStatus)+ autoUpdate.POST("/run", updaterHandler.Run)+ autoUpdate.GET("/history", updaterHandler.History)+ autoUpdate.GET("/status", updaterHandler.Status)}func setupContainerRoutes(api *gin.RouterGroup, services *Services) {diff --git a/backend/internal/api/updater_handler.go b/backend/internal/api/updater_handler.gonew file mode 100644index 000000000..cf54c4dff--- /dev/null+++ b/backend/internal/api/updater_handler.go@@ -0,0 +1,52 @@+package api++import (+ "net/http"+ "strconv"++ "github.com/gin-gonic/gin"+ "github.com/ofkm/arcane-backend/internal/dto"+ "github.com/ofkm/arcane-backend/internal/services"+)++type UpdaterHandler struct {+ updaterService *services.UpdaterService+}++func NewUpdaterHandler(updaterService *services.UpdaterService) *UpdaterHandler {+ return &UpdaterHandler{updaterService: updaterService}+}++func (h *UpdaterHandler) Run(c *gin.Context) {+ var req dto.UpdaterRunRequest+ _ = c.ShouldBindJSON(&req)++ out, err := h.updaterService.ApplyPending(c.Request.Context(), req.DryRun)+ if err != nil {+ c.JSON(http.StatusInternalServerError, gin.H{"success": false, "error": err.Error()})+ return+ }++ c.JSON(http.StatusOK, gin.H{"success": true, "data": out})+}++func (h *UpdaterHandler) Status(c *gin.Context) {+ status := h.updaterService.GetStatus()+ c.JSON(http.StatusOK, gin.H{"success": true, "data": status})+}++func (h *UpdaterHandler) History(c *gin.Context) {+ limit := 50+ if ls := c.Query("limit"); ls != "" {+ if v, err := strconv.Atoi(ls); err == nil && v > 0 {+ limit = v+ }+ }++ history, err := h.updaterService.GetHistory(c.Request.Context(), limit)+ if err != nil {+ c.JSON(http.StatusInternalServerError, gin.H{"success": false, "error": err.Error()})+ return+ }+ c.JSON(http.StatusOK, gin.H{"success": true, "data": history})+}diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.goindex f0921f7cb..bf2c138d4 100644--- a/backend/internal/bootstrap/jobs_bootstrap.go+++ b/backend/internal/bootstrap/jobs_bootstrap.go@@ -18,7 +18,7 @@ func initializeScheduler() (*job.Scheduler, error) {}func registerJobs(appCtx context.Context, scheduler *job.Scheduler, appServices *api.Services) {- if err := job.RegisterAutoUpdateJob(appCtx, scheduler, appServices.AutoUpdate, appServices.Settings); err != nil {+ if err := job.RegisterAutoUpdateJob(appCtx, scheduler, appServices.Updater, appServices.Settings); err != nil {slog.ErrorContext(appCtx, "Failed to register auto-update job", slog.Any("error", err))}diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.goindex 4c3e3d279..85ae11e12 100644--- a/backend/internal/bootstrap/services_bootstrap.go+++ b/backend/internal/bootstrap/services_bootstrap.go@@ -27,7 +27,7 @@ func initializeServices(db *database.DB, cfg *config.Config) (*api.Services, *setemplateService := services.NewTemplateService(db)authService := services.NewAuthService(userService, settingsService, eventService, cfg.JWTSecret, cfg)oidcService := services.NewOidcService(authService, cfg)- autoUpdate := services.NewAutoUpdateService(db, dockerClientService, settingsService, containerService, stackService, imageService, imageUpdate, containerRegistry, eventService)+ updaterService := services.NewUpdaterService(db, settingsService, dockerClientService, stackService, imageUpdate, containerRegistry, eventService, imageService)systemService := services.NewSystemService(db, dockerClientService, containerService, imageService, volumeService, networkService, settingsService)appServices := &api.Services{@@ -46,7 +46,7 @@ func initializeServices(db *database.DB, cfg *config.Config) (*api.Services, *seTemplate: templateService,ContainerRegistry: containerRegistry,System: systemService,- AutoUpdate: autoUpdate,+ Updater: updaterService,ImageUpdate: imageUpdate,Event: eventService,}diff --git a/backend/internal/dto/auto_update_dto.go b/backend/internal/dto/updater_dto.gosimilarity index 60%rename from backend/internal/dto/auto_update_dto.gorename to backend/internal/dto/updater_dto.goindex dfdb12742..9b7df7918 100644--- a/backend/internal/dto/auto_update_dto.go+++ b/backend/internal/dto/updater_dto.go@@ -1,5 +1,29 @@package dto+type UpdaterRunRequest struct {+ DryRun bool `json:"dryRun"`+}++type UpdaterItem struct {+ ResourceID string `json:"resourceId"`+ ResourceType string `json:"resourceType"` // "image" | "container" | "stack"+ ResourceName string `json:"resourceName,omitempty"`+ Status string `json:"status"` // "checked" | "updated" | "skipped" | "failed" | "up_to_date" | "update_available"+ Error string `json:"error,omitempty"`+ OldImages map[string]string `json:"oldImages,omitempty"`+ NewImages map[string]string `json:"newImages,omitempty"`+ UpdateApplied bool `json:"updateApplied,omitempty"`+}++type UpdaterRunResult struct {+ Checked int `json:"checked"`+ Updated int `json:"updated"`+ Skipped int `json:"skipped"`+ Failed int `json:"failed"`+ Items []UpdaterItem `json:"items"`+ Duration string `json:"duration"`+}+type AutoUpdateCheckDto struct {Type string `json:"type,omitempty"`ResourceIds []string `json:"resourceIds,omitempty"`@@ -31,14 +55,3 @@ type AutoUpdateResourceResult struct {Error string `json:"error,omitempty"`Details map[string]interface{} `json:"details,omitempty"`}--type AutoUpdateConfigDto struct {- Enabled bool `json:"enabled"`- CheckInterval int `json:"checkInterval"` // minutes- IncludeContainers bool `json:"includeContainers"`- IncludeStacks bool `json:"includeStacks"`- AutoApplyUpdates bool `json:"autoApplyUpdates"`- ExcludedImages []string `json:"excludedImages,omitempty"`- ExcludedContainers []string `json:"excludedContainers,omitempty"`- ExcludedStacks []string `json:"excludedStacks,omitempty"`-}diff --git a/backend/internal/job/auto_update_job.go b/backend/internal/job/auto_update_job.goindex 0cd828ea5..4b6c830b5 100644--- a/backend/internal/job/auto_update_job.go+++ b/backend/internal/job/auto_update_job.go@@ -6,24 +6,23 @@ import ("time""github.com/go-co-op/gocron/v2"- "github.com/ofkm/arcane-backend/internal/dto""github.com/ofkm/arcane-backend/internal/services")type AutoUpdateJob struct {- autoUpdateService *services.AutoUpdateService- settingsService *services.SettingsService+ updaterService *services.UpdaterService+ settingsService *services.SettingsService}-func NewAutoUpdateJob(autoUpdateService *services.AutoUpdateService, settingsService *services.SettingsService) *AutoUpdateJob {+func NewAutoUpdateJob(updaterService *services.UpdaterService, settingsService *services.SettingsService) *AutoUpdateJob {return &AutoUpdateJob{- autoUpdateService: autoUpdateService,- settingsService: settingsService,+ updaterService: updaterService,+ settingsService: settingsService,}}-func RegisterAutoUpdateJob(ctx context.Context, scheduler *Scheduler, autoUpdateService *services.AutoUpdateService, settingsService *services.SettingsService) error {- autoUpdateEnabled := settingsService.GetBoolSetting(ctx, "autoUpdateEnabled", false)+func RegisterAutoUpdateJob(ctx context.Context, scheduler *Scheduler, updaterService *services.UpdaterService, settingsService *services.SettingsService) error {+ autoUpdateEnabled := settingsService.GetBoolSetting(ctx, "autoUpdate", false)autoUpdateInterval := settingsService.GetIntSetting(ctx, "autoUpdateInterval", 300)if !autoUpdateEnabled {@@ -39,7 +38,7 @@ func RegisterAutoUpdateJob(ctx context.Context, scheduler *Scheduler, autoUpdatelog.Printf("Registering auto-update job with %v interval", interval)- job := NewAutoUpdateJob(autoUpdateService, settingsService)+ job := NewAutoUpdateJob(updaterService, settingsService)jobDefinition := gocron.DurationJob(interval)@@ -53,36 +52,27 @@ func RegisterAutoUpdateJob(ctx context.Context, scheduler *Scheduler, autoUpdate}func (j *AutoUpdateJob) Execute(ctx context.Context) error {- log.Println("=== Starting scheduled auto-update check ===")+ log.Println("=== Starting scheduled updater run ===")- // Get individual settings- autoUpdateEnabled := j.settingsService.GetBoolSetting(ctx, "autoUpdateEnabled", false)-- if !autoUpdateEnabled {- log.Println("Auto-update disabled, skipping scheduled check")+ enabled := j.settingsService.GetBoolSetting(ctx, "autoUpdate", false)+ if !enabled {+ log.Println("Auto-update disabled, skipping")return nil}- req := dto.AutoUpdateCheckDto{- Type: "all",- ForceUpdate: false,- DryRun: false,- }-- result, err := j.autoUpdateService.CheckForUpdates(ctx, req)+ result, err := j.updaterService.ApplyPending(ctx, false)if err != nil {- log.Printf("Error during auto-update: %v", err)+ log.Printf("Updater error: %v", err)return err}- log.Printf("Auto-update completed: %d checked, %d updated, %d skipped, %d failed",+ log.Printf("Updater completed: checked=%d updated=%d skipped=%d failed=%d",result.Checked, result.Updated, result.Skipped, result.Failed)-return nil}-func UpdateAutoUpdateJobSchedule(ctx context.Context, scheduler *Scheduler, autoUpdateService *services.AutoUpdateService, settingsService *services.SettingsService) error {- autoUpdateEnabled := settingsService.GetBoolSetting(ctx, "autoUpdateEnabled", false)+func UpdateAutoUpdateJobSchedule(ctx context.Context, scheduler *Scheduler, updaterService *services.UpdaterService, settingsService *services.SettingsService) error {+ autoUpdateEnabled := settingsService.GetBoolSetting(ctx, "autoUpdate", false)autoUpdateInterval := settingsService.GetIntSetting(ctx, "autoUpdateInterval", 300)if !autoUpdateEnabled {@@ -92,6 +82,5 @@ func UpdateAutoUpdateJobSchedule(ctx context.Context, scheduler *Scheduler, autointerval := time.Duration(autoUpdateInterval) * time.Secondlog.Printf("Auto-update settings changed - new interval: %v", interval)-return nil}diff --git a/backend/internal/models/updater.go b/backend/internal/models/updater.gonew file mode 100644index 000000000..c517e1096--- /dev/null+++ b/backend/internal/models/updater.go@@ -0,0 +1,3 @@+package models++// Reserved for future persisted updater state or config overrides specific to the updater module.diff --git a/backend/internal/services/auto_update_service.go b/backend/internal/services/auto_update_service.godeleted file mode 100644index 37ba13a2b..000000000--- a/backend/internal/services/auto_update_service.go+++ /dev/null@@ -1,1310 +0,0 @@-package services--import (- "context"- "encoding/base64"- "encoding/json"- "fmt"- "io"- "log"- "slices"- "strings"- "sync"- "time"-- "github.com/docker/docker/api/types/container"- "github.com/docker/docker/api/types/image"- "github.com/docker/docker/api/types/network"- "github.com/docker/docker/api/types/registry"- "gopkg.in/yaml.v3"-- "github.com/ofkm/arcane-backend/internal/database"- "github.com/ofkm/arcane-backend/internal/dto"- "github.com/ofkm/arcane-backend/internal/models"- "github.com/ofkm/arcane-backend/internal/utils"-)--type AutoUpdateService struct {- db *database.DB- dockerService *DockerClientService- settingsService *SettingsService- containerService *ContainerService- stackService *StackService- imageService *ImageService- imageUpdateService *ImageUpdateService- registryService *ContainerRegistryService- eventService *EventService- updatingContainers map[string]bool- updatingStacks map[string]bool- mutex sync.RWMutex-}--func NewAutoUpdateService(- db *database.DB,- dockerService *DockerClientService,- settingsService *SettingsService,- containerService *ContainerService,- stackService *StackService,- imageService *ImageService,- imageUpdateService *ImageUpdateService,- registryService *ContainerRegistryService,- eventService *EventService,-) *AutoUpdateService {- return &AutoUpdateService{- db: db,- dockerService: dockerService,- settingsService: settingsService,- containerService: containerService,- stackService: stackService,- imageService: imageService,- imageUpdateService: imageUpdateService,- registryService: registryService,- eventService: eventService,- updatingContainers: make(map[string]bool),- updatingStacks: make(map[string]bool),- }-}--func (s *AutoUpdateService) CheckForUpdates(ctx context.Context, req dto.AutoUpdateCheckDto) (*dto.AutoUpdateResultDto, error) {- startTime := time.Now()- result := &dto.AutoUpdateResultDto{- Success: true,- StartTime: startTime.Format(time.RFC3339),- Results: []dto.AutoUpdateResourceResult{},- }-- metadata := models.JSON{- "action": "check_start",- "type": req.Type,- "dryRun": req.DryRun,- "forceUpdate": req.ForceUpdate,- "resourceCount": len(req.ResourceIds),- }- if _, logErr := s.eventService.CreateEvent(ctx, CreateEventRequest{- Type: models.EventTypeSystemAutoUpdate,- Severity: models.EventSeverityInfo,- Title: "Auto-update check started",- Description: fmt.Sprintf("Auto-update check initiated for type: %s", req.Type),- UserID: &systemUser.ID,- Username: &systemUser.Username,- EnvironmentID: utils.Ptr("0"),- Metadata: metadata,- }); logErr != nil {- log.Printf("Failed to log auto-update start event: %v", logErr)- }-- // Get individual setting instead of full settings struct- autoUpdateEnabled := s.settingsService.GetBoolSetting(ctx, "autoUpdateEnabled", false)-- if !autoUpdateEnabled && !req.ForceUpdate {- result.Skipped = 1- result.EndTime = time.Now().Format(time.RFC3339)- result.Duration = time.Since(startTime).String()-- // Log skipped event- skipMetadata := models.JSON{- "action": "check_skipped",- "reason": "auto_update_disabled",- }- if _, logErr := s.eventService.CreateEvent(ctx, CreateEventRequest{- Type: models.EventTypeSystemAutoUpdate,- Severity: models.EventSeverityInfo,- Title: "Auto-update check skipped",- Description: "Auto-update is disabled and force update was not requested",- UserID: &systemUser.ID,- Username: &systemUser.Username,- EnvironmentID: utils.Ptr("0"),- Metadata: skipMetadata,- }); logErr != nil {- log.Printf("Failed to log auto-update skip event: %v", logErr)- }-- return result, nil- }-- // Use image-based update approach- if req.Type == "" || req.Type == "all" || req.Type == "images" {- if err := s.processImageUpdates(ctx, req, result); err != nil {- log.Printf("Image update process failed, falling back to container-based approach: %v", err)- return s.processContainerBasedUpdates(ctx, req, result, startTime)- }- } else {- return s.processContainerBasedUpdates(ctx, req, result, startTime)- }-- result.EndTime = time.Now().Format(time.RFC3339)- result.Duration = time.Since(startTime).String()-- // Log auto-update check completion event- completionMetadata := models.JSON{- "action": "check_completed",- "duration": result.Duration,- "checked": result.Checked,- "updated": result.Updated,- "failed": result.Failed,- "skipped": result.Skipped,- "success": result.Success,- }- severity := models.EventSeveritySuccess- if result.Failed > 0 {- severity = models.EventSeverityWarning- }-- if _, logErr := s.eventService.CreateEvent(ctx, CreateEventRequest{- Type: models.EventTypeSystemAutoUpdate,- Severity: severity,- Title: "Auto-update check completed",- Description: fmt.Sprintf("Auto-update completed: %d checked, %d updated, %d failed", result.Checked, result.Updated, result.Failed),- UserID: &systemUser.ID,- Username: &systemUser.Username,- EnvironmentID: utils.Ptr("0"),- Metadata: completionMetadata,- }); logErr != nil {- log.Printf("Failed to log auto-update completion event: %v", logErr)- }-- return result, nil-}--//nolint:gocognit-func (s *AutoUpdateService) processImageUpdates(ctx context.Context, req dto.AutoUpdateCheckDto, result *dto.AutoUpdateResultDto) error {- imageUpdates, err := s.imageUpdateService.CheckAllImages(ctx, 0)- if err != nil {- return fmt.Errorf("failed to check image updates: %w", err)- }-- imagesToUpdate := make(map[string]string)- for imageRef, updateResult := range imageUpdates {- if updateResult.HasUpdate && updateResult.Error == "" {- newImageRef := imageRef- if updateResult.UpdateType == "tag" && updateResult.LatestVersion != "" {- newImageRef = s.constructImageRefWithTag(imageRef, updateResult.LatestVersion)- }- imagesToUpdate[imageRef] = newImageRef- }- }-- if len(imagesToUpdate) == 0 {- return nil- }-- pulledImages := make(map[string]string)- for oldImageRef, newImageRef := range imagesToUpdate {- imageResult := dto.AutoUpdateResourceResult{- ResourceID: oldImageRef,- ResourceName: oldImageRef,- ResourceType: "image",- Status: "checked",- UpdateAvailable: true,- UpdateApplied: false,- OldImages: map[string]string{"main": oldImageRef},- NewImages: map[string]string{"main": newImageRef},- }-- if !req.DryRun {- if err := s.pullImageWithAuth(ctx, newImageRef); err != nil {- log.Printf("Failed to pull image %s: %v", newImageRef, err)- imageResult.Status = "failed"- imageResult.Error = fmt.Sprintf("Failed to pull image: %v", err)- result.Failed++- } else {- pulledImages[oldImageRef] = newImageRef- imageResult.Status = "updated"- imageResult.UpdateApplied = true- result.Updated++- }- } else {- imageResult.Status = "skipped"- result.Skipped++- }-- result.Results = append(result.Results, imageResult)- result.Checked++-- // Record the image update result (success or failure)- if err := s.recordAutoUpdate(ctx, imageResult); err != nil {- log.Printf("Failed to record auto-update result for image %s: %v", oldImageRef, err)- }- }-- // Only restart containers if we successfully pulled some images- if !req.DryRun && len(pulledImages) > 0 {- containerResults, err := s.restartContainersUsingImages(ctx, pulledImages)- if err != nil {- log.Printf("Error restarting containers: %v", err)- }-- for _, containerResult := range containerResults {- result.Results = append(result.Results, containerResult)- result.Checked++- if containerResult.UpdateApplied {- result.Updated++- } else if containerResult.Error != "" {- result.Failed++- }-- if err := s.recordAutoUpdate(ctx, containerResult); err != nil {- log.Printf("Failed to record auto-update result for container %s: %v", containerResult.ResourceName, err)- }- }- }-- return nil-}--func (s *AutoUpdateService) processContainerBasedUpdates(ctx context.Context, req dto.AutoUpdateCheckDto, result *dto.AutoUpdateResultDto, startTime time.Time) (*dto.AutoUpdateResultDto, error) {- var wg sync.WaitGroup- resultsChan := make(chan dto.AutoUpdateResourceResult, 1000)- errorsChan := make(chan error, 100)-- checkType := strings.ToLower(req.Type)- if checkType == "" || checkType == "all" {- checkType = "all"- }-- if checkType == "all" || checkType == "containers" {- wg.Add(1)- go func() {- defer wg.Done()- s.checkContainers(ctx, req, resultsChan, errorsChan)- }()- }-- if checkType == "all" || checkType == "stacks" {- wg.Add(1)- go func() {- defer wg.Done()- s.checkStacks(ctx, req, resultsChan, errorsChan)- }()- }-- go func() {- wg.Wait()- close(resultsChan)- close(errorsChan)- }()-- for res := range resultsChan {- result.Results = append(result.Results, res)- result.Checked++-- if res.UpdateAvailable {- if res.UpdateApplied {- result.Updated++- } else if req.DryRun {- result.Skipped++- }- }-- if res.Error != "" {- result.Failed++- }-- if err := s.recordAutoUpdate(ctx, res); err != nil {- log.Printf("Failed to record auto-update result: %v", err)- }- }-- for err := range errorsChan {- log.Printf("Auto-update error: %v", err)- }-- result.EndTime = time.Now().Format(time.RFC3339)- result.Duration = time.Since(startTime).String()- return result, nil-}--// Refactored from pullImage and restartContainersUsingUpdatedImages-func (s *AutoUpdateService) pullImageWithAuth(ctx context.Context, imageRef string) error {- dockerClient, err := s.dockerService.CreateConnection(ctx)- if err != nil {- return fmt.Errorf("failed to connect to Docker: %w", err)- }- defer dockerClient.Close()-- pullOptions := image.PullOptions{}- authConfig, err := s.getAuthConfigForImage(ctx, imageRef)- if err != nil {- log.Printf("Warning: Failed to get auth config for image %s: %v", imageRef, err)- } else if authConfig != nil {- authJSON, err := json.Marshal(authConfig)- if err != nil {- return fmt.Errorf("failed to marshal auth config: %w", err)- }- pullOptions.RegistryAuth = base64.URLEncoding.EncodeToString(authJSON)- }-- reader, err := dockerClient.ImagePull(ctx, imageRef, pullOptions)- if err != nil {- // Log image pull failure event- metadata := models.JSON{- "action": "auto_pull_failed",- "imageRef": imageRef,- "error": err.Error(),- }- if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImagePull, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {- log.Printf("Failed to log image pull failure event: %v", logErr)- }- return fmt.Errorf("failed to pull image %s: %w", imageRef, err)- }- defer reader.Close()-- if _, err := io.Copy(io.Discard, reader); err != nil {- return fmt.Errorf("failed to complete image pull: %w", err)- }-- // Log successful image pull event- metadata := models.JSON{- "action": "auto_pull_success",- "imageRef": imageRef,- }- if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImagePull, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {- log.Printf("Failed to log image pull success event: %v", logErr)- }-- log.Printf("Successfully pulled image: %s", imageRef)- return nil-}--func (s *AutoUpdateService) restartContainersUsingImages(ctx context.Context, updatedImages map[string]string) ([]dto.AutoUpdateResourceResult, error) {- dockerClient, err := s.dockerService.CreateConnection(ctx)- if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)- }- defer dockerClient.Close()-- containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: false})- if err != nil {- return nil, fmt.Errorf("failed to list containers: %w", err)- }-- var results []dto.AutoUpdateResourceResult-- for _, cnt := range containers {- containerJSON, err := dockerClient.ContainerInspect(ctx, cnt.ID)- if err != nil {- continue- }-- containerImageRef := containerJSON.Config.Image- var newImageRef string- var found bool-- for oldImageRef, updatedImageRef := range updatedImages {- if s.imageMatches(containerImageRef, oldImageRef) {- newImageRef = updatedImageRef- found = true- break- }- }-- if !found {- continue- }-- containerName := s.getContainerName(cnt)- result := dto.AutoUpdateResourceResult{- ResourceID: cnt.ID,- ResourceName: containerName,- ResourceType: "container",- Status: "checked",- OldImages: map[string]string{"main": containerImageRef},- NewImages: map[string]string{"main": newImageRef},- }-- s.mutex.Lock()- if s.updatingContainers[cnt.ID] {- s.mutex.Unlock()- result.Status = "skipped"- result.Error = "Already updating"- results = append(results, result)- continue- }- s.updatingContainers[cnt.ID] = true- s.mutex.Unlock()-- if err := s.updateContainerWithLatestImage(ctx, cnt, containerJSON, newImageRef); err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to restart container: %v", err)- } else {- result.Status = "updated"- result.UpdateAvailable = true- result.UpdateApplied = true- log.Printf("Successfully restarted container %s with updated image %s", containerName, newImageRef)- }-- s.mutex.Lock()- delete(s.updatingContainers, cnt.ID)- s.mutex.Unlock()-- results = append(results, result)- }-- return results, nil-}--// Helper method to check if container image matches updated image-func (s *AutoUpdateService) imageMatches(containerImage, updatedImage string) bool {- containerBase := strings.Split(containerImage, "@")[0]- updatedBase := strings.Split(updatedImage, "@")[0]-- containerRepo := strings.Split(containerBase, ":")[0]- updatedRepo := strings.Split(updatedBase, ":")[0]-- return containerRepo == updatedRepo-}--func (s *AutoUpdateService) checkContainers(- ctx context.Context,- req dto.AutoUpdateCheckDto,- results chan<- dto.AutoUpdateResourceResult,- errors chan<- error,-) {- dockerClient, err := s.dockerService.CreateConnection(ctx)- if err != nil {- errors <- fmt.Errorf("failed to connect to Docker: %w", err)- return- }- defer dockerClient.Close()-- containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: false})- if err != nil {- errors <- fmt.Errorf("failed to list containers: %w", err)- return- }-- for _, cnt := range containers {- if len(req.ResourceIds) > 0 && !slices.Contains(req.ResourceIds, cnt.ID) {- continue- }-- if !s.isContainerEligibleForUpdate(cnt) {- continue- }-- result := s.checkSingleContainer(ctx, cnt, req.DryRun)- results <- result- }-}--func (s *AutoUpdateService) checkSingleContainer(- ctx context.Context,- cnt container.Summary,- dryRun bool,-) dto.AutoUpdateResourceResult {- containerName := s.getContainerName(cnt)-- result := dto.AutoUpdateResourceResult{- ResourceID: cnt.ID,- ResourceName: containerName,- ResourceType: "container",- Status: "checked",- OldImages: make(map[string]string),- NewImages: make(map[string]string),- }-- s.mutex.Lock()- if s.updatingContainers[cnt.ID] {- s.mutex.Unlock()- result.Status = "skipped"- result.Error = "Already updating"- return result- }- s.updatingContainers[cnt.ID] = true- s.mutex.Unlock()-- defer func() {- s.mutex.Lock()- delete(s.updatingContainers, cnt.ID)- s.mutex.Unlock()- }()-- dockerClient, err := s.dockerService.CreateConnection(ctx)- if err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to connect to Docker: %v", err)- return result- }- defer dockerClient.Close()-- containerJSON, err := dockerClient.ContainerInspect(ctx, cnt.ID)- if err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to inspect container: %v", err)- return result- }-- imageRef := containerJSON.Config.Image- result.OldImages["main"] = fmt.Sprintf("%s@%s", imageRef, cnt.ImageID)-- updateResult, err := s.imageUpdateService.CheckImageUpdate(ctx, imageRef)- if err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to check for updates: %v", err)- return result- }-- if updateResult.Error != "" {- result.Status = "failed"- result.Error = updateResult.Error- return result- }-- result.UpdateAvailable = updateResult.HasUpdate- if updateResult.HasUpdate {- newImageRef := imageRef- if updateResult.UpdateType == "tag" && updateResult.LatestVersion != "" {- newImageRef = s.constructImageRefWithTag(imageRef, updateResult.LatestVersion)- }- result.NewImages["main"] = newImageRef-- // Get auto update setting when needed- autoUpdateEnabled := s.settingsService.GetBoolSetting(ctx, "autoUpdateEnabled", false)-- if !dryRun && autoUpdateEnabled {- if err := s.updateContainerWithLatestImage(ctx, cnt, containerJSON, newImageRef); err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to update container: %v", err)- return result- }- result.UpdateApplied = true- result.Status = "updated"- } else {- result.Status = "update_available"- }- } else {- result.Status = "up_to_date"- }-- return result-}--func (s *AutoUpdateService) updateContainerWithLatestImage(- ctx context.Context,- cnt container.Summary,- containerJSON container.InspectResponse,- newImageRef string,-) error {- dockerClient, err := s.dockerService.CreateConnection(ctx)- if err != nil {- return fmt.Errorf("failed to connect to Docker: %w", err)- }- defer dockerClient.Close()-- containerName := s.getContainerName(cnt)- log.Printf("Pulling latest image %s for container %s", newImageRef, containerName)-- pullOptions := image.PullOptions{}-- authConfig, err := s.getAuthConfigForImage(ctx, newImageRef)- if err != nil {- log.Printf("Warning: Failed to get auth config for image %s: %v", newImageRef, err)- } else if authConfig != nil {- authJSON, err := json.Marshal(authConfig)- if err != nil {- return fmt.Errorf("failed to marshal auth config: %w", err)- }- pullOptions.RegistryAuth = base64.URLEncoding.EncodeToString(authJSON)- }-- reader, err := dockerClient.ImagePull(ctx, newImageRef, pullOptions)- if err != nil {- // Log container update failure event- metadata := models.JSON{- "action": "auto_update_failed",- "oldImage": containerJSON.Config.Image,- "newImage": newImageRef,- "error": err.Error(),- "step": "image_pull",- }- if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerUpdate, cnt.ID, containerName, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {- log.Printf("Failed to log container update failure event: %v", logErr)- }- return fmt.Errorf("failed to pull image %s: %w", newImageRef, err)- }- defer reader.Close()-- if _, err := io.Copy(io.Discard, reader); err != nil {- return fmt.Errorf("failed to complete image pull: %w", err)- }-- // Log container stop event- stopMetadata := models.JSON{- "action": "auto_update_stop",- "reason": "updating_image",- }- if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStop, cnt.ID, containerName, systemUser.ID, systemUser.Username, "0", stopMetadata); logErr != nil {- log.Printf("Failed to log container stop event: %v", logErr)- }-- if err := dockerClient.ContainerStop(ctx, cnt.ID, container.StopOptions{}); err != nil {- return fmt.Errorf("failed to stop container: %w", err)- }-- if err := dockerClient.ContainerRemove(ctx, cnt.ID, container.RemoveOptions{}); err != nil {- return fmt.Errorf("failed to remove old container: %w", err)- }-- // Log container delete event- deleteMetadata := models.JSON{- "action": "auto_update_delete",- "reason": "replacing_with_updated_image",- }- if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerDelete, cnt.ID, containerName, systemUser.ID, systemUser.Username, "0", deleteMetadata); logErr != nil {- log.Printf("Failed to log container delete event: %v", logErr)- }-- containerJSON.Config.Image = newImageRef-- resp, err := dockerClient.ContainerCreate(- ctx,- containerJSON.Config,- containerJSON.HostConfig,- &network.NetworkingConfig{- EndpointsConfig: containerJSON.NetworkSettings.Networks,- },- nil,- containerJSON.Name,- )- if err != nil {- return fmt.Errorf("failed to create new container: %w", err)- }-- // Log container create event- createMetadata := models.JSON{- "action": "auto_update_create",- "oldImage": containerJSON.Config.Image,- "newImage": newImageRef,- "newImageId": resp.ID,- }- if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerCreate, resp.ID, containerName, systemUser.ID, systemUser.Username, "0", createMetadata); logErr != nil {- log.Printf("Failed to log container create event: %v", logErr)- }-- if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {- return fmt.Errorf("failed to start new container: %w", err)- }-- // Log container start event- startMetadata := models.JSON{- "action": "auto_update_start",- "oldImage": containerJSON.Config.Image,- "newImage": newImageRef,- "newImageId": resp.ID,- }- if logErr := s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStart, resp.ID, containerName, systemUser.ID, systemUser.Username, "0", startMetadata); logErr != nil {- log.Printf("Failed to log container start event: %v", logErr)- }-- log.Printf("Successfully updated container %s with image %s", containerName, newImageRef)- return nil-}--// Helper method to construct image reference with new tag - KEEPING THIS FUNCTION-func (s *AutoUpdateService) constructImageRefWithTag(imageRef, newTag string) string {- parts := strings.Split(imageRef, ":")- if len(parts) > 1 {- // Replace the tag part- parts[len(parts)-1] = newTag- return strings.Join(parts, ":")- }- // If no tag, append the new tag- return imageRef + ":" + newTag-}--func (s *AutoUpdateService) checkStacks(- ctx context.Context,- req dto.AutoUpdateCheckDto,- results chan<- dto.AutoUpdateResourceResult,- errors chan<- error,-) {- stacks, err := s.stackService.ListStacks(ctx)- if err != nil {- errors <- fmt.Errorf("failed to list stacks: %w", err)- return- }-- for _, stack := range stacks {- if len(req.ResourceIds) > 0 && !slices.Contains(req.ResourceIds, stack.ID) {- continue- }-- if !s.isStackEligibleForUpdate(ctx, stack) {- continue- }-- result := s.checkSingleStack(ctx, stack, req.DryRun)- results <- result- }-}--// Update checkSingleStack to remove settings parameter-func (s *AutoUpdateService) checkSingleStack(- ctx context.Context,- stack models.Stack,- dryRun bool,-) dto.AutoUpdateResourceResult {- result := dto.AutoUpdateResourceResult{- ResourceID: stack.ID,- ResourceName: stack.Name,- ResourceType: "stack",- Status: "checked",- OldImages: make(map[string]string),- NewImages: make(map[string]string),- Details: make(map[string]interface{}),- }-- s.mutex.Lock()- if s.updatingStacks[stack.ID] {- s.mutex.Unlock()- result.Status = "skipped"- result.Error = "Already updating"- return result- }- s.updatingStacks[stack.ID] = true- s.mutex.Unlock()-- defer func() {- s.mutex.Lock()- delete(s.updatingStacks, stack.ID)- s.mutex.Unlock()- }()-- services, err := s.stackService.GetStackServices(ctx, stack.ID)- if err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to get stack services: %v", err)- return result- }-- for _, svc := range services {- if svc.Image != "" {- result.OldImages[svc.Name] = svc.Image- }- }-- hasUpdates, imageUpdates, err := s.checkStackImagesForUpdates(ctx, stack)- if err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to check for updates: %v", err)- return result- }-- result.UpdateAvailable = hasUpdates- if hasUpdates {- for svcName, newImage := range imageUpdates {- result.NewImages[svcName] = newImage- }-- if !dryRun {- if err := s.updateStack(ctx, stack); err != nil {- result.Status = "failed"- result.Error = fmt.Sprintf("Failed to update stack: %v", err)- return result- }- result.UpdateApplied = true- result.Status = "updated"- } else {- result.Status = "update_available"- }- } else {- result.Status = "up_to_date"- }-- return result-}--func (s *AutoUpdateService) updateStack(- ctx context.Context,- stack models.Stack,-) error {- log.Printf("Updating stack: %s", stack.Name)-- updateMetadata := models.JSON{- "action": "auto_update_start",- "reason": "image_updates_available",- }- if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", updateMetadata); logErr != nil {- log.Printf("Failed to log stack update start event: %v", logErr)- }-- log.Printf("Pulling latest images for stack: %s", stack.Name)- if err := s.stackService.PullStackImages(ctx, stack.ID, io.Discard); err != nil {- log.Printf("Warning: Failed to pull some images: %v", err)- // Log image pull warning- pullWarningMetadata := models.JSON{- "action": "auto_update_pull_warning",- "error": err.Error(),- }- if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", pullWarningMetadata); logErr != nil {- log.Printf("Failed to log stack pull warning event: %v", logErr)- }- }-- log.Printf("Redeploying stack: %s", stack.Name)- if err := s.stackService.RedeployStack(ctx, stack.ID, nil, nil, systemUser); err != nil {- // Log stack update failure event- failureMetadata := models.JSON{- "action": "auto_update_failed",- "error": err.Error(),- }- if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", failureMetadata); logErr != nil {- log.Printf("Failed to log stack update failure event: %v", logErr)- }- return fmt.Errorf("failed to redeploy stack: %w", err)- }-- // Log stack update success event- successMetadata := models.JSON{- "action": "auto_update_success",- }- if logErr := s.eventService.LogStackEvent(ctx, models.EventTypeStackUpdate, stack.ID, stack.Name, systemUser.ID, systemUser.Username, "0", successMetadata); logErr != nil {- log.Printf("Failed to log stack update success event: %v", logErr)- }-- log.Printf("Successfully updated stack: %s", stack.Name)- return nil-}--func (s *AutoUpdateService) checkImageForUpdate(- ctx context.Context,- imageRef string,-) (bool, string, error) {- if s.isDigestBasedImage(imageRef) {- return false, "", nil- }-- registryUtils := utils.NewRegistryUtils()- registry, repository, tag, err := registryUtils.SplitImageReference(imageRef)- if err != nil {- return false, "", fmt.Errorf("failed to parse image reference: %w", err)- }-- authURL, err := registryUtils.CheckAuth(ctx, registry)- if err != nil {- return false, "", fmt.Errorf("failed to check registry auth: %w", err)- }-- var token string- if authURL != "" {- authConfig, err := s.getAuthConfigForImage(ctx, imageRef)- if err != nil {- log.Printf("Warning: Failed to get auth config for image %s: %v", imageRef, err)- }-- var creds *utils.RegistryCredentials- if authConfig != nil {- creds = &utils.RegistryCredentials{- Username: authConfig.Username,- Token: authConfig.Password,- }- }-- token, err = registryUtils.GetToken(ctx, authURL, repository, creds)- if err != nil {- return false, "", fmt.Errorf("failed to get registry token: %w", err)- }- }-- remoteDigest, err := registryUtils.GetLatestDigest(ctx, registry, repository, tag, token)- if err != nil {- return false, "", fmt.Errorf("failed to get remote digest: %w", err)- }-- localDigest, err := s.getImageDigest(ctx, imageRef)- if err != nil {- return false, "", fmt.Errorf("failed to get local digest: %w", err)- }-- hasUpdate := localDigest != remoteDigest- if hasUpdate {- log.Printf("Update available for %s: %s -> %s", imageRef, localDigest[:12], remoteDigest[:12])- }-- return hasUpdate, remoteDigest, nil-}--func (s *AutoUpdateService) getImageDigest(ctx context.Context, imageRef string) (string, error) {- dockerClient, err := s.dockerService.CreateConnection(ctx)- if err != nil {- return "", fmt.Errorf("failed to connect to Docker: %w", err)- }- defer dockerClient.Close()-- imageInfo, err := dockerClient.ImageInspect(ctx, imageRef)- if err != nil {- return "", fmt.Errorf("failed to inspect image: %w", err)- }-- for _, digest := range imageInfo.RepoDigests {- if strings.Contains(digest, "@sha256:") {- parts := strings.Split(digest, "@")- if len(parts) == 2 {- return parts[1], nil- }- }- }-- return imageInfo.ID, nil-}--func (s *AutoUpdateService) isContainerEligibleForUpdate(cnt container.Summary) bool {- if cnt.State != "running" {- return false- }-- if s.isPartOfStack(cnt.Labels) {- return false- }-- return s.hasAutoUpdateLabel(cnt.Labels)-}--func (s *AutoUpdateService) isStackEligibleForUpdate(ctx context.Context, stack models.Stack) bool {- if stack.Status != models.StackStatusRunning && stack.Status != models.StackStatusPartiallyRunning {- return false- }-- eligible, err := s.stackHasAutoUpdateLabel(ctx, stack)- if err != nil {- log.Printf("Error checking stack eligibility: %v", err)- return false- }-- return eligible-}--func (s *AutoUpdateService) stackHasAutoUpdateLabel(ctx context.Context, stack models.Stack) (bool, error) {- composeContent, _, err := s.stackService.GetStackContent(ctx, stack.ID)- if err != nil {- return false, err- }-- var composeData map[string]interface{}- if err := yaml.Unmarshal([]byte(composeContent), &composeData); err != nil {- return false, err- }-- services, ok := composeData["services"].(map[string]interface{})- if !ok {- return false, nil- }-- for _, service := range services {- if s.serviceHasAutoUpdateLabel(service) {- return true, nil- }- }-- return false, nil-}--func (s *AutoUpdateService) serviceHasAutoUpdateLabel(service interface{}) bool {- serviceMap, ok := service.(map[string]interface{})- if !ok {- return false- }-- labels, ok := serviceMap["labels"].(map[string]interface{})- if !ok {- if labelsList, ok := serviceMap["labels"].([]interface{}); ok {- for _, label := range labelsList {- if labelStr, ok := label.(string); ok {- if strings.HasPrefix(labelStr, "arcane.auto-update=") && strings.Contains(labelStr, "true") {- return true- }- }- }- }- return false- }-- if autoUpdate, exists := labels["arcane.auto-update"]; exists {- if autoUpdateStr, ok := autoUpdate.(string); ok {- return strings.ToLower(autoUpdateStr) == "true"- }- }-- return false-}--func (s *AutoUpdateService) recordAutoUpdate(ctx context.Context, result dto.AutoUpdateResourceResult) error {- record := &models.AutoUpdateRecord{- ResourceID: result.ResourceID,- ResourceType: result.ResourceType,- ResourceName: result.ResourceName,- Status: models.AutoUpdateStatus(result.Status),- StartTime: time.Now(),- UpdateAvailable: result.UpdateAvailable,- UpdateApplied: result.UpdateApplied,- }-- if result.Error != "" {- record.Error = &result.Error- if result.Details == nil {- result.Details = make(map[string]interface{})- }- result.Details["errorType"] = s.categorizeError(result.Error)- result.Details["timestamp"] = time.Now().Format(time.RFC3339)- }-- if len(result.OldImages) > 0 {- oldImagesJSON := make(models.JSON)- for k, v := range result.OldImages {- oldImagesJSON[k] = v- }- record.OldImageVersions = oldImagesJSON- }-- if len(result.NewImages) > 0 {- newImagesJSON := make(models.JSON)- for k, v := range result.NewImages {- newImagesJSON[k] = v- }- record.NewImageVersions = newImagesJSON- }-- if len(result.Details) > 0 {- detailsJSON := make(models.JSON)- for k, v := range result.Details {- detailsJSON[k] = v- }- record.Details = detailsJSON- }-- endTime := time.Now()- record.EndTime = &endTime-- if err := s.db.WithContext(ctx).Create(record).Error; err != nil {- return fmt.Errorf("failed to record auto-update: %w", err)- }-- return nil-}--// Helper method to categorize errors for better notification handling-func (s *AutoUpdateService) categorizeError(errorMsg string) string {- errorMsg = strings.ToLower(errorMsg)-- switch {- case strings.Contains(errorMsg, "no matching manifest"):- return "platform_incompatible"- case strings.Contains(errorMsg, "manifest unknown"):- return "image_not_found"- case strings.Contains(errorMsg, "unauthorized"):- return "authentication_failed"- case strings.Contains(errorMsg, "forbidden"):- return "permission_denied"- case strings.Contains(errorMsg, "timeout"):- return "network_timeout"- case strings.Contains(errorMsg, "connection refused"):- return "registry_unavailable"- case strings.Contains(errorMsg, "failed to pull"):- return "pull_failed"- case strings.Contains(errorMsg, "failed to restart"):- return "restart_failed"- default:- return "unknown"- }-}--func (s *AutoUpdateService) GetAutoUpdateHistory(ctx context.Context, limit int) ([]models.AutoUpdateRecord, error) {- var records []models.AutoUpdateRecord-- query := s.db.WithContext(ctx).Order("start_time DESC")- if limit > 0 {- query = query.Limit(limit)- }-- if err := query.Find(&records).Error; err != nil {- return nil, fmt.Errorf("failed to get auto-update history: %w", err)- }-- return records, nil-}--func (s *AutoUpdateService) GetUpdateStatus() map[string]interface{} {- s.mutex.RLock()- defer s.mutex.RUnlock()-- containerIds := make([]string, 0, len(s.updatingContainers))- for id := range s.updatingContainers {- containerIds = append(containerIds, id)- }-- stackIds := make([]string, 0, len(s.updatingStacks))- for id := range s.updatingStacks {- stackIds = append(stackIds, id)- }-- return map[string]interface{}{- "updatingContainers": len(s.updatingContainers),- "updatingStacks": len(s.updatingStacks),- "containerIds": containerIds,- "stackIds": stackIds,- }-}--func (s *AutoUpdateService) extractImageReferences(composeContent string) map[string]string {- images := make(map[string]string)-- var composeData map[string]interface{}- if err := yaml.Unmarshal([]byte(composeContent), &composeData); err != nil {- return images- }-- services, ok := composeData["services"].(map[string]interface{})- if !ok {- return images- }-- for serviceName, service := range services {- serviceMap, ok := service.(map[string]interface{})- if !ok {- continue- }-- if imageVal, exists := serviceMap["image"]; exists {- if imageStr, ok := imageVal.(string); ok {- images[serviceName] = strings.TrimSpace(imageStr)- }- }- }-- return images-}--func (s *AutoUpdateService) isDigestBasedImage(imageRef string) bool {- return strings.Contains(imageRef, "@sha256:")-}--func (s *AutoUpdateService) isPartOfStack(labels map[string]string) bool {- if labels == nil {- return false- }-- if projectName, exists := labels["com.docker.compose.project"]; exists && projectName != "" {- return true- }-- if stackName, exists := labels["arcane.stack"]; exists && stackName != "" {- return true- }-- return false-}--func (s *AutoUpdateService) hasAutoUpdateLabel(labels map[string]string) bool {- if labels == nil {- return false- }-- if autoUpdate, exists := labels["arcane.auto-update"]; exists {- return strings.ToLower(autoUpdate) == "true"- }-- return false-}--func (s *AutoUpdateService) getContainerName(cnt container.Summary) string {- if len(cnt.Names) > 0 {- name := cnt.Names[0]- if strings.HasPrefix(name, "/") {- return name[1:]- }- return name- }- return cnt.ID[:12]-}--func (s *AutoUpdateService) getAuthConfigForImage(ctx context.Context, imageRef string) (*registry.AuthConfig, error) {- registryDomain, err := utils.ExtractRegistryDomain(imageRef)- if err != nil {- return nil, fmt.Errorf("failed to extract domain: %w", err)- }- normalizedImageDomain := s.normalizeRegistryURL(registryDomain)-- registries, err := s.registryService.GetAllRegistries(ctx)- if err != nil {- return nil, fmt.Errorf("failed to list registries: %w", err)- }-- for _, reg := range registries {- normalizedRegURL := s.normalizeRegistryURL(reg.URL)- if normalizedRegURL == normalizedImageDomain {- decryptedToken, err := utils.Decrypt(reg.Token)- if err != nil {- log.Printf("Failed to decrypt token for registry %s: %v", reg.URL, err)- continue- }-- return ®istry.AuthConfig{- Username: reg.Username,- Password: decryptedToken,- }, nil- }- }-- return nil, nil-}--func (s *AutoUpdateService) normalizeRegistryURL(url string) string {- url = strings.TrimSpace(url)- url = strings.ToLower(url)- url = strings.TrimPrefix(url, "https://")- url = strings.TrimPrefix(url, "http://")- url = strings.TrimSuffix(url, "/")-- if url == "docker.io" || url == "registry-1.docker.io" || url == "index.docker.io" {- return "docker.io"- }-- return url-}--func (s *AutoUpdateService) checkStackImagesForUpdates(ctx context.Context, stack models.Stack) (bool, map[string]string, error) {- composeContent, _, err := s.stackService.GetStackContent(ctx, stack.ID)- if err != nil {- return false, nil, err- }-- images := s.extractImageReferences(composeContent)- hasUpdates := false- imageUpdates := make(map[string]string)-- services, err := s.stackService.GetStackServices(ctx, stack.ID)- if err != nil {- return false, nil, fmt.Errorf("failed to get stack services: %w", err)- }-- serviceImageIDs := make(map[string]string)- for _, svc := range services {- if svc.Image != "" {- currentImageID, err := s.getImageDigest(ctx, svc.Image)- if err != nil {- log.Printf("Warning: Failed to get current image digest for service %s: %v", svc.Name, err)- continue- }- serviceImageIDs[svc.Name] = currentImageID- }- }-- for serviceName, imageRef := range images {- if s.isDigestBasedImage(imageRef) {- continue- }-- hasUpdate, newDigest, err := s.checkImageForUpdate(ctx, imageRef)- if err != nil {- log.Printf("Error checking updates for %s in stack %s: %v", imageRef, stack.Name, err)- continue- }-- if hasUpdate {- hasUpdates = true- imageUpdates[serviceName] = fmt.Sprintf("%s@%s", imageRef, newDigest)- }- }-- return hasUpdates, imageUpdates, nil-}diff --git a/backend/internal/services/stack_service.go b/backend/internal/services/stack_service.goindex a8e09d351..38251d8ad 100644--- a/backend/internal/services/stack_service.go+++ b/backend/internal/services/stack_service.go@@ -865,12 +865,14 @@ func (s *StackService) RedeployStack(ctx context.Context, stackID string, profilreturn err}+ // Pull first (wait for completion and auth via ImageService)if err := s.PullStackImages(ctx, stackID, io.Discard); err != nil {fmt.Printf("Warning: failed to pull images: %v\n", err)}- if err := s.StopStack(ctx, stackID, systemUser); err != nil {- return fmt.Errorf("failed to stop stack for redeploy: %w", err)+ // Use down (not stop) to avoid port/name conflicts and ensure a clean restart+ if err := s.DownStack(ctx, stackID, systemUser); err != nil {+ return fmt.Errorf("failed to down stack for redeploy: %w", err)}// Log stack redeploy eventdiff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.gonew file mode 100644index 000000000..0ead8f956--- /dev/null+++ b/backend/internal/services/updater_service.go@@ -0,0 +1,669 @@+package services++import (+ "context"+ "fmt"+ "io"+ "log"+ "strings"+ "time"++ "github.com/docker/docker/api/types/container"+ "github.com/docker/docker/api/types/filters"+ "github.com/docker/docker/api/types/network"+ "github.com/docker/docker/client"++ "github.com/ofkm/arcane-backend/internal/database"+ "github.com/ofkm/arcane-backend/internal/dto"+ "github.com/ofkm/arcane-backend/internal/models"+)++type UpdaterService struct {+ db *database.DB+ settingsService *SettingsService+ dockerService *DockerClientService+ stackService *StackService+ imageUpdateService *ImageUpdateService+ registryService *ContainerRegistryService+ eventService *EventService+ imageService *ImageService++ updatingContainers map[string]bool+ updatingStacks map[string]bool+}++func NewUpdaterService(+ db *database.DB,+ settings *SettingsService,+ docker *DockerClientService,+ stacks *StackService,+ imageUpdates *ImageUpdateService,+ registries *ContainerRegistryService,+ events *EventService,+ imageSvc *ImageService,+) *UpdaterService {+ return &UpdaterService{+ db: db,+ settingsService: settings,+ dockerService: docker,+ stackService: stacks,+ imageUpdateService: imageUpdates,+ registryService: registries,+ eventService: events,+ imageService: imageSvc,+ updatingContainers: map[string]bool{},+ updatingStacks: map[string]bool{},+ }+}++// ApplyPending pulls images and restarts impacted containers/stacks for all image_updates with has_update = true.+// - For tag updates: repo:latestVersion+// - For digest updates: keep tag ref (repo:tag), pulling refreshes digest; recreate with same ref.+func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*dto.UpdaterRunResult, error) {+ start := time.Now()+ out := &dto.UpdaterRunResult{Items: []dto.UpdaterItem{}}++ // enabled := s.settingsService.GetBoolSetting(ctx, "autoUpdate", false)+ // if !enabled {+ // out.Duration = time.Since(start).String()+ // return out, nil+ // }++ var records []models.ImageUpdateRecord+ if err := s.db.WithContext(ctx).Where("has_update = ?", true).Find(&records).Error; err != nil {+ return nil, fmt.Errorf("query pending image updates: %w", err)+ }+ if len(records) == 0 {+ out.Duration = time.Since(start).String()+ return out, nil+ }++ // Only update images that are actually used by running resources+ usedImages, err := s.collectUsedImages(ctx)+ if err != nil {+ // Non-fatal: continue without the filter+ usedImages = map[string]struct{}{}+ }++ // Plan updates and capture OLD image digests before pull+ type updatePlan struct {+ oldRef string+ newRef string+ oldIDs []string // sha256:... image IDs that currently back oldRef+ }+ var plans []updatePlan++ for _, r := range records {+ if r.Repository == "" || r.Tag == "" {+ continue+ }+ oldRef := fmt.Sprintf("%s:%s", r.Repository, r.Tag)+ oldNorm := s.normalizeRef(oldRef)++ if len(usedImages) > 0 {+ if _, ok := usedImages[oldNorm]; !ok {+ continue+ }+ }++ newRef := oldRef+ if r.IsTagUpdate() && r.LatestVersion != nil && *r.LatestVersion != "" {+ newRef = fmt.Sprintf("%s:%s", r.Repository, *r.LatestVersion)+ }++ oldIDs, _ := s.resolveLocalImageIDsForRef(ctx, oldRef)+ plans = append(plans, updatePlan{oldRef: oldRef, newRef: newRef, oldIDs: oldIDs})+ }++ if len(plans) == 0 {+ out.Duration = time.Since(start).String()+ return out, nil+ }++ // Build maps for fast matching later+ oldRefToNewRef := map[string]string{}+ oldIDToNewRef := map[string]string{} // sha256 -> newRef+ for _, p := range plans {+ oldRefToNewRef[p.oldRef] = p.newRef+ for _, id := range p.oldIDs {+ oldIDToNewRef[id] = p.newRef+ }+ }++ // Pull images with ImageService (waits for completion)+ for _, p := range plans {+ item := dto.UpdaterItem{+ ResourceID: p.oldRef,+ ResourceType: "image",+ ResourceName: p.oldRef,+ Status: "checked",+ OldImages: map[string]string{"main": p.oldRef},+ NewImages: map[string]string{"main": p.newRef},+ }+ out.Checked++++ if dryRun {+ item.Status = "skipped"+ out.Skipped+++ out.Items = append(out.Items, item)+ _ = s.recordRun(ctx, item)+ continue+ }++ if err := s.imageService.PullImage(ctx, p.newRef, io.Discard, systemUser); err != nil {+ item.Status = "failed"+ item.Error = err.Error()+ out.Failed+++ } else {+ item.Status = "updated"+ item.UpdateApplied = true+ out.Updated+++ }+ out.Items = append(out.Items, item)+ _ = s.recordRun(ctx, item)+ }++ // Restart containers using old image IDs (skip stack-managed)+ if !dryRun && len(oldIDToNewRef) > 0 {+ results, err := s.restartContainersUsingOldIDs(ctx, oldIDToNewRef, oldRefToNewRef)+ if err != nil {+ log.Printf("container restarts had errors: %v", err)+ }+ for _, r := range results {+ item := dto.UpdaterItem{+ ResourceID: r.ResourceID,+ ResourceType: "container",+ ResourceName: r.ResourceName,+ Status: r.Status,+ Error: r.Error,+ OldImages: r.OldImages,+ NewImages: r.NewImages,+ UpdateApplied: r.UpdateApplied,+ }+ out.Items = append(out.Items, item)+ out.Checked+++ switch {+ case r.UpdateApplied:+ out.Updated+++ case r.Error != "":+ out.Failed+++ default:+ out.Skipped+++ }+ _ = s.recordRun(ctx, item)+ }++ // Redeploy impacted stacks (only running ones)+ if err := s.redeployStacksUsingOldIDs(ctx, oldIDToNewRef, out); err != nil {+ log.Printf("stack redeploys had errors: %v", err)+ }+ }++ // Refresh image_updates by re-checking+ for oldRef := range oldRefToNewRef {+ if _, err := s.imageUpdateService.CheckImageUpdate(ctx, oldRef); err != nil {+ log.Printf("refresh update record failed for %s: %v", oldRef, err)+ }+ }++ out.Duration = time.Since(start).String()+ return out, nil+}++func (s *UpdaterService) GetStatus() map[string]any {+ containerIDs := make([]string, 0, len(s.updatingContainers))+ for id := range s.updatingContainers {+ containerIDs = append(containerIDs, id)+ }+ stackIDs := make([]string, 0, len(s.updatingStacks))+ for id := range s.updatingStacks {+ stackIDs = append(stackIDs, id)+ }++ return map[string]any{+ "updatingContainers": len(s.updatingContainers),+ "updatingStacks": len(s.updatingStacks),+ "containerIds": containerIDs,+ "stackIds": stackIDs,+ }+}++func (s *UpdaterService) GetHistory(ctx context.Context, limit int) ([]models.AutoUpdateRecord, error) {+ var rec []models.AutoUpdateRecord+ q := s.db.WithContext(ctx).Order("start_time DESC")+ if limit > 0 {+ q = q.Limit(limit)+ }+ if err := q.Find(&rec).Error; err != nil {+ return nil, fmt.Errorf("get history: %w", err)+ }+ return rec, nil+}++// --- internals ---++func (s *UpdaterService) updateContainer(ctx context.Context, cnt container.Summary, inspect container.InspectResponse, newRef string) error {+ dcli, err := s.dockerService.CreateConnection(ctx)+ if err != nil {+ return fmt.Errorf("docker connect: %w", err)+ }+ defer dcli.Close()++ name := s.getContainerName(cnt)++ // stop+ if err := dcli.ContainerStop(ctx, cnt.ID, container.StopOptions{}); err != nil {+ return fmt.Errorf("stop: %w", err)+ }+ _ = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStop, cnt.ID, name, systemUser.ID, systemUser.Username, "0", models.JSON{"action": "updater_stop"})++ // remove+ if err := dcli.ContainerRemove(ctx, cnt.ID, container.RemoveOptions{}); err != nil {+ return fmt.Errorf("remove: %w", err)+ }+ _ = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerDelete, cnt.ID, name, systemUser.ID, systemUser.Username, "0", models.JSON{"action": "updater_delete"})++ // recreate with new image ref+ cfg := inspect.Config+ cfg.Image = newRef+ resp, err := dcli.ContainerCreate(ctx, cfg, inspect.HostConfig, &network.NetworkingConfig{EndpointsConfig: inspect.NetworkSettings.Networks}, nil, inspect.Name)+ if err != nil {+ return fmt.Errorf("create: %w", err)+ }+ _ = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerCreate, resp.ID, name, systemUser.ID, systemUser.Username, "0", models.JSON{"action": "updater_create", "newImageId": resp.ID})++ if err := dcli.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {+ return fmt.Errorf("start: %w", err)+ }+ _ = s.eventService.LogContainerEvent(ctx, models.EventTypeContainerStart, resp.ID, name, systemUser.ID, systemUser.Username, "0", models.JSON{"action": "updater_start"})++ return nil+}++// normalizeRef returns a canonical "registry/repository:tag" without digest.+// Examples:+// - "redis:latest" -> "docker.io/library/redis:latest"+// - "nginx@sha256:..." -> "docker.io/library/nginx:latest" (if no tag was present, defaults to latest)+func (s *UpdaterService) normalizeRef(ref string) string {+ ref = s.stripDigest(ref)++ // Split tag+ tag := "latest"+ if i := strings.LastIndex(ref, ":"); i != -1 && strings.LastIndex(ref, "/") < i {+ tag = ref[i+1:]+ ref = ref[:i]+ }++ parts := strings.Split(ref, "/")+ domain := ""+ switch {+ case len(parts) > 0 && (strings.Contains(parts[0], ".") || strings.Contains(parts[0], ":") || parts[0] == "localhost"):+ domain = strings.ToLower(parts[0])+ parts = parts[1:]+ default:+ domain = "docker.io"+ }+ repo := strings.Join(parts, "/")+ if domain == "docker.io" && !strings.Contains(repo, "/") {+ repo = "library/" + repo+ }++ // Canonical docker.io domain+ switch domain {+ case "index.docker.io", "registry-1.docker.io":+ domain = "docker.io"+ }+ return strings.ToLower(domain + "/" + repo + ":" + tag)+}++func (s *UpdaterService) stripDigest(ref string) string {+ if i := strings.Index(ref, "@"); i != -1 {+ return ref[:i]+ }+ return ref+}++// collectUsedImages builds a set of normalized image refs used by running containers and running stacks.+func (s *UpdaterService) collectUsedImages(ctx context.Context) (map[string]struct{}, error) {+ out := map[string]struct{}{}++ // Running containers+ dcli, err := s.dockerService.CreateConnection(ctx)+ if err == nil {+ defer dcli.Close()+ list, err := dcli.ContainerList(ctx, container.ListOptions{All: false})+ if err == nil {+ for _, c := range list {+ inspect, err := dcli.ContainerInspect(ctx, c.ID)+ if err != nil {+ continue+ }+ for _, t := range s.getNormalizedTagsForContainer(ctx, dcli, inspect) {+ out[t] = struct{}{}+ }+ }+ }+ }++ // Running stacks (service definitions)+ stacks, err2 := s.stackService.ListStacks(ctx)+ if err2 == nil {+ for _, st := range stacks {+ if st.Status != models.StackStatusRunning {+ continue+ }+ srvs, err := s.stackService.GetStackServices(ctx, st.ID)+ if err != nil {+ continue+ }+ for _, svc := range srvs {+ if svc.Image == "" {+ continue+ }+ out[s.normalizeRef(svc.Image)] = struct{}{}+ }+ }+ }++ return out, nil+}++// Resolve a container's image to all normalized repo:tags that reference it.+// Falls back to the config image reference as a tag if present.+func (s *UpdaterService) getNormalizedTagsForContainer(ctx context.Context, dcli *client.Client, inspect container.InspectResponse) []string {+ seen := map[string]struct{}{}++ // Prefer tags from the image object (handles sha256 IDs)+ if dcli != nil {+ if ii, err := dcli.ImageInspect(ctx, inspect.Image); err == nil {+ for _, tag := range ii.RepoTags {+ if tag == "<none>:<none>" || tag == "" {+ continue+ }+ seen[s.normalizeRef(tag)] = struct{}{}+ }+ }+ }++ // Fallback to the configured image ref (may already be a tag)+ if inspect.Config != nil && inspect.Config.Image != "" {+ seen[s.normalizeRef(inspect.Config.Image)] = struct{}{}+ }++ out := make([]string, 0, len(seen))+ for k := range seen {+ out = append(out, k)+ }+ return out+}++func (s *UpdaterService) getContainerName(cnt container.Summary) string {+ if len(cnt.Names) > 0 {+ n := cnt.Names[0]+ if strings.HasPrefix(n, "/") {+ return n[1:]+ }+ return n+ }+ return cnt.ID[:12]+}++func (s *UpdaterService) recordRun(ctx context.Context, item dto.UpdaterItem) error {+ rec := &models.AutoUpdateRecord{+ ResourceID: item.ResourceID,+ ResourceType: item.ResourceType,+ ResourceName: item.ResourceName,+ Status: models.AutoUpdateStatus(item.Status),+ StartTime: time.Now(),+ UpdateAvailable: item.Status == "updated" || item.Status == "update_available",+ UpdateApplied: item.UpdateApplied,+ }++ if item.Error != "" {+ rec.Error = &item.Error+ }++ if len(item.OldImages) > 0 {+ old := make(models.JSON)+ for k, v := range item.OldImages {+ old[k] = v+ }+ rec.OldImageVersions = old+ }+ if len(item.NewImages) > 0 {+ newv := make(models.JSON)+ for k, v := range item.NewImages {+ newv[k] = v+ }+ rec.NewImageVersions = newv+ }++ end := time.Now()+ rec.EndTime = &end++ return s.db.WithContext(ctx).Create(rec).Error+}++func (s *UpdaterService) isPartOfStack(labels map[string]string) bool {+ if labels == nil {+ return false+ }+ // Swarm stack label+ if _, ok := labels["com.docker.stack.namespace"]; ok {+ return true+ }+ // Compose project label+ if _, ok := labels["com.docker.compose.project"]; ok {+ return true+ }+ return false+}++// Resolve the local image ID(s) currently referenced by ref (repo:tag) before we pull.+// Returns IDs like "sha256:...".+func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref string) ([]string, error) {+ dcli, err := s.dockerService.CreateConnection(ctx)+ if err != nil {+ return nil, err+ }+ defer dcli.Close()++ ids := []string{}+ if ii, err := dcli.ImageInspect(ctx, ref); err == nil && ii.ID != "" {+ ids = append(ids, ii.ID)+ }+ return ids, nil+}++// Containers: match by old image ID. Fallback to tag match if needed.+func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDToNewRef map[string]string, oldRefToNewRef map[string]string) ([]dto.AutoUpdateResourceResult, error) {+ dcli, err := s.dockerService.CreateConnection(ctx)+ if err != nil {+ return nil, fmt.Errorf("docker connect: %w", err)+ }+ defer dcli.Close()++ list, err := dcli.ContainerList(ctx, container.ListOptions{All: false})+ if err != nil {+ return nil, fmt.Errorf("list containers: %w", err)+ }++ var results []dto.AutoUpdateResourceResult+ for _, c := range list {+ if s.isPartOfStack(c.Labels) {+ continue+ }+ inspect, err := dcli.ContainerInspect(ctx, c.ID)+ if err != nil {+ continue+ }++ var (+ newRef string+ match string+ )++ // Primary: match by digest (image ID)+ if nr, ok := oldIDToNewRef[inspect.Image]; ok {+ newRef = nr+ match = inspect.Image+ } else {+ // Fallback: resolve tags and match by tag+ updatedNorm := map[string]string{}+ for oldRef, nr := range oldRefToNewRef {+ updatedNorm[s.normalizeRef(oldRef)] = nr+ }+ for _, t := range s.getNormalizedTagsForContainer(ctx, dcli, inspect) {+ if nr, ok := updatedNorm[t]; ok {+ newRef = nr+ match = t+ break+ }+ }+ if newRef == "" {+ continue+ }+ }++ name := s.getContainerName(c)+ res := dto.AutoUpdateResourceResult{+ ResourceID: c.ID,+ ResourceName: name,+ ResourceType: "container",+ Status: "checked",+ OldImages: map[string]string{"main": match},+ NewImages: map[string]string{"main": s.normalizeRef(newRef)},+ }++ if err := s.updateContainer(ctx, c, inspect, newRef); err != nil {+ res.Status = "failed"+ res.Error = err.Error()+ } else {+ res.Status = "updated"+ res.UpdateAvailable = true+ res.UpdateApplied = true+ }+ results = append(results, res)+ }+ return results, nil+}++// Stacks: impacted if any container in the stack runs an image ID in oldIDToNewRef.+func (s *UpdaterService) redeployStacksUsingOldIDs(ctx context.Context, oldIDToNewRef map[string]string, out *dto.UpdaterRunResult) error {+ stacks, err := s.stackService.ListStacks(ctx)+ if err != nil {+ return fmt.Errorf("list stacks: %w", err)+ }++ dcli, derr := s.dockerService.CreateConnection(ctx)+ if derr != nil {+ return fmt.Errorf("docker connect: %w", derr)+ }+ defer dcli.Close()++ for _, st := range stacks {+ // Only redeploy stacks that are currently running+ if st.Status != models.StackStatusRunning {+ out.Items = append(out.Items, dto.UpdaterItem{+ ResourceID: st.ID,+ ResourceType: "stack",+ ResourceName: st.Name,+ Status: "skipped",+ })+ out.Skipped+++ out.Checked+++ continue+ }++ containers, lerr := s.getStackContainers(ctx, dcli, st.Name)+ if lerr != nil {+ log.Printf("list stack containers %s: %v", st.Name, lerr)+ continue+ }++ impacted := false+ for _, c := range containers {+ inspect, ierr := dcli.ContainerInspect(ctx, c.ID)+ if ierr != nil {+ continue+ }+ if _, ok := oldIDToNewRef[inspect.Image]; ok {+ impacted = true+ break+ }+ }++ if !impacted {+ out.Items = append(out.Items, dto.UpdaterItem{+ ResourceID: st.ID,+ ResourceType: "stack",+ ResourceName: st.Name,+ Status: "skipped",+ })+ out.Skipped+++ out.Checked+++ continue+ }++ item := dto.UpdaterItem{+ ResourceID: st.ID,+ ResourceType: "stack",+ ResourceName: st.Name,+ Status: "checked",+ }+ out.Checked++++ // Pull, down, deploy to avoid conflicts and ensure fresh images+ if err := s.stackService.PullStackImages(ctx, st.ID, io.Discard); err != nil {+ log.Printf("stack pull warning: %v", err)+ }+ if err := s.stackService.RedeployStack(ctx, st.ID, nil, nil, systemUser); err != nil {+ item.Status = "failed"+ item.Error = err.Error()+ out.Failed+++ } else {+ item.Status = "updated"+ item.UpdateApplied = true+ out.Updated+++ }+ out.Items = append(out.Items, item)+ _ = s.recordRun(ctx, item)+ }+ return nil+}++// getStackContainers returns the union of containers matching compose or swarm stack labels (OR semantics).+func (s *UpdaterService) getStackContainers(ctx context.Context, dcli *client.Client, stackName string) ([]container.Summary, error) {+ byID := map[string]container.Summary{}++ // Compose label+ f1 := filters.NewArgs()+ f1.Add("label", "com.docker.compose.project="+stackName)+ cs1, err1 := dcli.ContainerList(ctx, container.ListOptions{All: true, Filters: f1})+ if err1 == nil {+ for _, c := range cs1 {+ byID[c.ID] = c+ }+ }++ // Swarm namespace label+ f2 := filters.NewArgs()+ f2.Add("label", "com.docker.stack.namespace="+stackName)+ cs2, err2 := dcli.ContainerList(ctx, container.ListOptions{All: true, Filters: f2})+ if err2 == nil {+ for _, c := range cs2 {+ byID[c.ID] = c+ }+ }++ // If both failed, return the last error+ if err1 != nil && err2 != nil {+ return nil, err2+ }++ out := make([]container.Summary, 0, len(byID))+ for _, c := range byID {+ out = append(out, c)+ }+ return out, nil+}diff --git a/frontend/src/lib/services/api/autoupdate-api-service.ts b/frontend/src/lib/services/api/autoupdate-api-service.tsindex 15b00d26c..01eea6003 100644--- a/frontend/src/lib/services/api/autoupdate-api-service.ts+++ b/frontend/src/lib/services/api/autoupdate-api-service.ts@@ -3,36 +3,18 @@ import type { AutoUpdateCheck, AutoUpdateResult, AutoUpdateRecord, AutoUpdateStaexport default class AutoUpdateAPIService extends BaseAPIService {async checkForUpdates(options?: AutoUpdateCheck): Promise<AutoUpdateResult> {- const response = await this.api.post('/updates/check', options || {});- return response.data;- }-- async checkContainers(): Promise<AutoUpdateResult> {- const response = await this.api.post('/updates/check/containers');- return response.data;+ const response = await this.api.post('/updater/run', options || {});+ return response.data.data;}- async checkStacks(): Promise<AutoUpdateResult> {- const response = await this.api.post('/updates/check/compose');- return response.data;+ async getStatus(): Promise<AutoUpdateStatus> {+ const response = await this.api.get('/updater/status');+ return response.data.data;}async getUpdateHistory(limit?: number): Promise<AutoUpdateRecord[]> {const params = limit ? { limit } : {};- const response = await this.api.get('/updates/history', { params });+ const response = await this.api.get('/updater/history', { params });return response.data.data;}-- async getUpdateStatus(): Promise<AutoUpdateStatus> {- const response = await this.api.get('/updates/status');- return response.data.data;- }-- async dryRun(type: 'containers' | 'stacks' | 'all' = 'all'): Promise<AutoUpdateResult> {- const response = await this.api.post('/updates/check', {- type,- dryRun: true- });- return response.data;- }}diff --git a/frontend/src/lib/types/auto-update.type.ts b/frontend/src/lib/types/auto-update.type.tsindex b596a25d3..b1eb5abf6 100644--- a/frontend/src/lib/types/auto-update.type.ts+++ b/frontend/src/lib/types/auto-update.type.ts@@ -6,21 +6,18 @@ export interface AutoUpdateCheck {}export interface AutoUpdateResult {- success: boolean;checked: number;updated: number;skipped: number;failed: number;- startTime: string;- endTime: string;+ items: AutoUpdateResourceResult[];duration: string;- results: AutoUpdateResourceResult[];}export interface AutoUpdateResourceResult {resourceId: string;resourceName: string;- resourceType: 'container' | 'stack';+ resourceType: 'image' | 'container' | 'stack';status: 'checked' | 'up_to_date' | 'update_available' | 'updated' | 'failed' | 'skipped';updateAvailable: boolean;updateApplied: boolean;@@ -52,3 +49,58 @@ export interface AutoUpdateStatus {containerIds: string[];stackIds: string[];}++// export interface AutoUpdateCheck {+// type?: 'containers' | 'stacks' | 'all';+// resourceIds?: string[];+// forceUpdate?: boolean;+// dryRun?: boolean;+// }++// export interface AutoUpdateResult {+// success: boolean;+// checked: number;+// updated: number;+// skipped: number;+// failed: number;+// startTime: string;+// endTime: string;+// duration: string;+// results: AutoUpdateResourceResult[];+// }++// export interface AutoUpdateResourceResult {+// resourceId: string;+// resourceName: string;+// resourceType: 'container' | 'stack';+// status: 'checked' | 'up_to_date' | 'update_available' | 'updated' | 'failed' | 'skipped';+// updateAvailable: boolean;+// updateApplied: boolean;+// oldImages?: Record<string, string>;+// newImages?: Record<string, string>;+// error?: string;+// details?: Record<string, any>;+// }++// export interface AutoUpdateRecord {+// id: string;+// resourceId: string;+// resourceType: string;+// resourceName: string;+// status: string;+// startTime: string;+// endTime?: string;+// updateAvailable: boolean;+// updateApplied: boolean;+// oldImageVersions?: Record<string, string>;+// newImageVersions?: Record<string, string>;+// error?: string;+// details?: Record<string, any>;+// }++// export interface AutoUpdateStatus {+// updatingContainers: number;+// updatingStacks: number;+// containerIds: string[];+// stackIds: string[];+// }diff --git a/frontend/src/routes/compose/+page.svelte b/frontend/src/routes/compose/+page.svelteindex df239e028..3217ea6a1 100644--- a/frontend/src/routes/compose/+page.svelte+++ b/frontend/src/routes/compose/+page.svelte@@ -29,7 +29,7 @@async function handleCheckForUpdates() {isLoading.updating = true;handleApiResultWithCallbacks({- result: await tryCatch(autoUpdateAPI.checkStacks()),+ result: await tryCatch(autoUpdateAPI.checkForUpdates()),message: 'Failed to Check Compose Projects for Updates',setLoadingState: (value) => (isLoading.updating = value),async onSuccess() {diff --git a/frontend/src/routes/containers/+page.svelte b/frontend/src/routes/containers/+page.svelteindex 0c377fb32..20e892004 100644--- a/frontend/src/routes/containers/+page.svelte+++ b/frontend/src/routes/containers/+page.svelte@@ -25,7 +25,7 @@async function handleCheckForUpdates() {isLoading.checking = true;handleApiResultWithCallbacks({- result: await tryCatch(autoUpdateAPI.checkContainers()),+ result: await tryCatch(autoUpdateAPI.checkForUpdates()),message: 'Failed to Check Containers for Updates',setLoadingState: (value) => (isLoading.checking = value),async onSuccess() {diff --git a/frontend/src/routes/onboarding/security/+page.svelte b/frontend/src/routes/onboarding/security/+page.svelteindex 68973dfa8..ce5f49b99 100644--- a/frontend/src/routes/onboarding/security/+page.svelte+++ b/frontend/src/routes/onboarding/security/+page.svelte@@ -31,11 +31,10 @@scopes: 'openid email profile'});- // Page state mirrors the main Security Settings pagelet localAuthEnabled = $state(true);let oidcEnabled = $state(false);- let sessionTimeout = $state(60); // minutes, to match settings page- let passwordPolicy = $state('strong');+ let sessionTimeout = $state(60);+ let passwordPolicy = $state<'strong' | 'standard' | 'basic'>('strong');let isLoading = $state({ saving: false });@@ -47,7 +46,6 @@sessionTimeout = currentSettings.authSessionTimeout ?? 60;passwordPolicy = currentSettings.authPasswordPolicy ?? 'strong';- // Parse OIDC config if present (do not persist clientSecret in state)if (currentSettings.authOidcConfig) {try {const cfg = JSON.parse(currentSettings.authOidcConfig);diff --git a/frontend/src/routes/onboarding/settings/+page.svelte b/frontend/src/routes/onboarding/settings/+page.svelteindex b9b47403d..6ce71bd17 100644--- a/frontend/src/routes/onboarding/settings/+page.svelte+++ b/frontend/src/routes/onboarding/settings/+page.svelte@@ -35,7 +35,7 @@try {await settingsAPI.updateSettings({...currentSettings,- autoUpdateEnabled: appSettings.autoUpdate,+ autoUpdate: appSettings.autoUpdate,autoUpdateInterval: parseInt(appSettings.autoUpdateInterval),dockerPruneMode: appSettings.pruneMode,baseServerUrl: appSettings.baseServerUrl,