Skip to content

Modern Docker Management, Designed for Everyone

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.go
deleted file mode 100644
index 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.go
index 3059bc54b..0dd307eee 100644
--- a/backend/internal/api/routes.go
+++ b/backend/internal/api/routes.go
@@ -24,7 +24,7 @@ type Services struct {
Template *services.TemplateService
ContainerRegistry *services.ContainerRegistryService
System *services.SystemService
- AutoUpdate *services.AutoUpdateService
+ Updater *services.UpdaterService
Event *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.DockerClien
system.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.go
new file mode 100644
index 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.go
index 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.go
index 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, *se
templateService := 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, *se
Template: 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.go
similarity index 60%
rename from backend/internal/dto/auto_update_dto.go
rename to backend/internal/dto/updater_dto.go
index 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.go
index 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, autoUpdate
log.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, auto
interval := time.Duration(autoUpdateInterval) * time.Second
log.Printf("Auto-update settings changed - new interval: %v", interval)
-
return nil
}
diff --git a/backend/internal/models/updater.go b/backend/internal/models/updater.go
new file mode 100644
index 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.go
deleted file mode 100644
index 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 &registry.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.go
index 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, profil
return 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 event
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
new file mode 100644
index 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.ts
index 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, AutoUpdateSta
export 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.ts
index 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.svelte
index 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.svelte
index 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.svelte
index 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 page
let 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.svelte
index 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,