Skip to content

Modern Docker Management, Designed for Everyone

perf: overall performance improvements and db transactions (#951)

Kyle Mendell40d12a4c15eb
diff --git a/backend/internal/api/system_handler.go b/backend/internal/api/system_handler.go
index f027a2ed5..4826f8830 100644
--- a/backend/internal/api/system_handler.go
+++ b/backend/internal/api/system_handler.go
@@ -117,12 +117,11 @@ type SystemStats struct {
func (h *SystemHandler) Health(c *gin.Context) {
ctx := c.Request.Context()
- dockerClient, err := h.dockerService.CreateConnection(ctx)
+ dockerClient, err := h.dockerService.GetClient()
if err != nil {
c.Status(http.StatusServiceUnavailable)
return
}
- defer dockerClient.Close()
// Try to ping Docker to ensure it's responsive
_, err = dockerClient.Ping(ctx)
@@ -137,7 +136,7 @@ func (h *SystemHandler) Health(c *gin.Context) {
func (h *SystemHandler) GetDockerInfo(c *gin.Context) {
ctx := c.Request.Context()
- dockerClient, err := h.dockerService.CreateConnection(ctx)
+ dockerClient, err := h.dockerService.GetClient()
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
@@ -145,7 +144,6 @@ func (h *SystemHandler) GetDockerInfo(c *gin.Context) {
})
return
}
- defer dockerClient.Close()
version, err := dockerClient.ServerVersion(ctx)
if err != nil {
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index 77044b9dc..2080c29b1 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -59,12 +59,12 @@ func Bootstrap(ctx context.Context) error {
}
utils.TestDockerConnection(appCtx, func(ctx context.Context) error {
- dockerClient, err := dockerClientService.CreateConnection(ctx)
+ dockerClient, err := dockerClientService.GetClient()
if err != nil {
return err
}
- dockerClient.Close()
- return nil
+ _, err = dockerClient.Ping(ctx)
+ return err
})
utils.InitializeNonAgentFeatures(appCtx, cfg,
diff --git a/backend/internal/models/settings.go b/backend/internal/models/settings.go
index 316dbfac4..1fbbb8fec 100644
--- a/backend/internal/models/settings.go
+++ b/backend/internal/models/settings.go
@@ -88,7 +88,8 @@ type Settings struct {
// Notifications category (placeholder for category metadata only - actual settings managed via notification service)
NotificationsCategoryPlaceholder SettingVariable `key:"notificationsCategory,internal" meta:"label=Notifications;type=internal;keywords=notifications,alerts,email,discord,webhooks,events,messages;category=notifications;description=Configure notification providers and alerts" catmeta:"id=notifications;title=Notifications;icon=bell;url=/settings/notifications;description=Configure email and Discord notifications for container and image updates"`
- InstanceID SettingVariable `key:"instanceId,internal" meta:"label=Instance ID;type=text;keywords=instance,id,uuid,identifier;category=internal;description=Unique instance identifier"`
+ AgentToken SettingVariable `key:"agentToken,internal,sensitive"`
+ InstanceID SettingVariable `key:"instanceId,internal"`
}
func (SettingVariable) TableName() string {
diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.go
index 012f15cb0..a282a79c8 100644
--- a/backend/internal/services/auth_service.go
+++ b/backend/internal/services/auth_service.go
@@ -190,18 +190,27 @@ func (s *AuthService) Login(ctx context.Context, username, password string) (*mo
}
if s.userService.NeedsPasswordUpgrade(user.PasswordHash) {
- if err := s.userService.UpgradePasswordHash(ctx, user.ID, password); err != nil {
- fmt.Printf("Warning: Failed to upgrade password hash for user %s: %v\n", user.ID, err)
- } else {
- fmt.Printf("Successfully upgraded password hash for user %s from bcrypt to Argon2\n", user.Username)
- }
+ s.runInBackground(ctx, "upgrade_password_hash", func(ctx context.Context) error {
+ if err := s.userService.UpgradePasswordHash(ctx, user.ID, password); err != nil {
+ return fmt.Errorf("failed to upgrade password hash for user %s: %w", user.ID, err)
+ }
+ slog.InfoContext(ctx, "Successfully upgraded password hash from bcrypt to Argon2", "user", user.Username)
+ return nil
+ })
}
now := time.Now()
user.LastLogin = &now
- if _, err := s.userService.UpdateUser(ctx, user); err != nil {
- fmt.Printf("Failed to update user's last login time: %v\n", err)
- }
+
+ // Run last login update in background
+ // Use utils.Ptr to create a safe copy of the user struct to avoid data race
+ userCopy := utils.Ptr(*user)
+ s.runInBackground(ctx, "update_last_login", func(ctx context.Context) error {
+ if _, err := s.userService.UpdateUser(ctx, userCopy); err != nil {
+ return fmt.Errorf("failed to update user's last login time: %w", err)
+ }
+ return nil
+ })
tokenPair, err := s.generateTokenPair(ctx, user)
if err != nil {
@@ -212,9 +221,13 @@ func (s *AuthService) Login(ctx context.Context, username, password string) (*mo
"action": "login",
"method": "local",
}
- if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, user.ID, user.Username, metadata); logErr != nil {
- fmt.Printf("Could not log user login action: %s\n", logErr)
- }
+
+ // Run event logging in background
+ logUserID := user.ID
+ logUsername := user.Username
+ s.runInBackground(ctx, "log_user_login", func(ctx context.Context) error {
+ return s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, logUserID, logUsername, metadata)
+ })
return user, tokenPair, nil
}
@@ -240,9 +253,13 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo dto.OidcUserInfo,
"newUser": isNewUser,
"subject": userInfo.Subject,
}
- if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, user.ID, user.Username, metadata); logErr != nil {
- fmt.Printf("Could not log OIDC user login action: %s\n", logErr)
- }
+
+ // Run event logging in background
+ userID := user.ID
+ username := user.Username
+ s.runInBackground(ctx, "log_oidc_login", func(ctx context.Context) error {
+ return s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, userID, username, metadata)
+ })
return user, tokenPair, nil
}
@@ -659,3 +676,24 @@ func generateUsernameFromEmail(email, subject string) string {
}
return "user_" + subject
}
+
+func (s *AuthService) runInBackground(ctx context.Context, name string, fn func(ctx context.Context) error) {
+ // Detach context to prevent cancellation when the parent request finishes
+ bgCtx := context.WithoutCancel(ctx)
+
+ go func() {
+ defer func() {
+ if r := recover(); r != nil {
+ slog.ErrorContext(bgCtx, "Background task panicked", "task", name, "panic", r)
+ }
+ }()
+
+ // Set a reasonable timeout for background tasks
+ taskCtx, cancel := context.WithTimeout(bgCtx, 1*time.Minute)
+ defer cancel()
+
+ if err := fn(taskCtx); err != nil {
+ slog.ErrorContext(taskCtx, "Background task failed", "task", name, "error", err)
+ }
+ }()
+}
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index 0d123c419..1041a4958 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -32,12 +32,11 @@ func NewContainerService(db *database.DB, eventService *EventService, dockerServ
}
func (s *ContainerService) StartContainer(ctx context.Context, containerID string, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", containerID, "", user.ID, user.Username, "0", err, models.JSON{"action": "start"})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
metadata := models.JSON{
"action": "start",
@@ -58,12 +57,11 @@ func (s *ContainerService) StartContainer(ctx context.Context, containerID strin
}
func (s *ContainerService) StopContainer(ctx context.Context, containerID string, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", containerID, "", user.ID, user.Username, "0", err, models.JSON{"action": "stop"})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
metadata := models.JSON{
"action": "stop",
@@ -84,12 +82,11 @@ func (s *ContainerService) StopContainer(ctx context.Context, containerID string
}
func (s *ContainerService) RestartContainer(ctx context.Context, containerID string, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", containerID, "", user.ID, user.Username, "0", err, models.JSON{"action": "restart"})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
metadata := models.JSON{
"action": "restart",
@@ -109,11 +106,10 @@ func (s *ContainerService) RestartContainer(ctx context.Context, containerID str
}
func (s *ContainerService) GetContainerByID(ctx context.Context, id string) (*container.InspectResponse, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
container, err := dockerClient.ContainerInspect(ctx, id)
if err != nil {
@@ -124,12 +120,11 @@ func (s *ContainerService) GetContainerByID(ctx context.Context, id string) (*co
}
func (s *ContainerService) DeleteContainer(ctx context.Context, containerID string, force bool, removeVolumes bool, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", containerID, "", user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force, "removeVolumes": removeVolumes})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
// Get container mounts before deletion if we need to remove volumes
var volumesToRemove []string
@@ -179,12 +174,11 @@ func (s *ContainerService) DeleteContainer(ctx context.Context, containerID stri
}
func (s *ContainerService) CreateContainer(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string, user models.User, credentials []dto.ContainerRegistryCredential) (*container.InspectResponse, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", "", containerName, user.ID, user.Username, "0", err, models.JSON{"action": "create", "image": config.Image})
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
_, err = dockerClient.ImageInspect(ctx, config.Image)
if err != nil {
@@ -242,11 +236,10 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe
}
func (s *ContainerService) StreamStats(ctx context.Context, containerID string, statsChan chan<- interface{}) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
stats, err := dockerClient.ContainerStats(ctx, containerID, true)
if err != nil {
@@ -279,11 +272,10 @@ func (s *ContainerService) StreamStats(ctx context.Context, containerID string,
}
func (s *ContainerService) StreamLogs(ctx context.Context, containerID string, logsChan chan<- string, follow bool, tail, since string, timestamps bool) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
options := container.LogsOptions{
ShowStdout: true,
@@ -415,11 +407,10 @@ func (s *ContainerService) readAllLogs(logs io.ReadCloser, logsChan chan<- strin
}
func (s *ContainerService) ListContainersPaginated(ctx context.Context, params pagination.QueryParams, includeAll bool) ([]dto.ContainerSummaryDto, pagination.Response, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, pagination.Response{}, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
dockerContainers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: includeAll})
if err != nil {
@@ -516,11 +507,10 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params p
// CreateExec creates an exec instance in the container
func (s *ContainerService) CreateExec(ctx context.Context, containerID string, cmd []string) (string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return "", fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
execConfig := container.ExecOptions{
AttachStdin: true,
@@ -540,11 +530,10 @@ func (s *ContainerService) CreateExec(ctx context.Context, containerID string, c
// AttachExec attaches to an exec instance and returns stdin, stdout/stderr streams
func (s *ContainerService) AttachExec(ctx context.Context, execID string) (io.WriteCloser, io.Reader, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
execAttach, err := dockerClient.ContainerExecAttach(ctx, execID, container.ExecAttachOptions{
Tty: true,
diff --git a/backend/internal/services/docker_client_service.go b/backend/internal/services/docker_client_service.go
index d882e3e30..d89c2eb07 100644
--- a/backend/internal/services/docker_client_service.go
+++ b/backend/internal/services/docker_client_service.go
@@ -3,6 +3,7 @@ package services
import (
"context"
"fmt"
+ "sync"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/image"
@@ -18,6 +19,8 @@ import (
type DockerClientService struct {
db *database.DB
config *config.Config
+ client *client.Client
+ mu sync.Mutex
}
func NewDockerClientService(db *database.DB, cfg *config.Config) *DockerClientService {
@@ -27,25 +30,38 @@ func NewDockerClientService(db *database.DB, cfg *config.Config) *DockerClientSe
}
}
-func (s *DockerClientService) CreateConnection(ctx context.Context) (*client.Client, error) {
+// GetClient returns a singleton Docker client instance.
+// It initializes the client on the first call.
+func (s *DockerClientService) GetClient() (*client.Client, error) {
+ if s.client != nil {
+ return s.client, nil
+ }
+
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ // Double-check locking
+ if s.client != nil {
+ return s.client, nil
+ }
+
cli, err := client.NewClientWithOpts(
client.WithHost(s.config.DockerHost),
client.WithAPIVersionNegotiation(),
)
-
if err != nil {
return nil, fmt.Errorf("failed to create Docker client: %w", err)
}
- return cli, nil
+ s.client = cli
+ return s.client, nil
}
func (s *DockerClientService) GetAllContainers(ctx context.Context) ([]container.Summary, int, int, int, error) {
- dockerClient, err := s.CreateConnection(ctx)
+ dockerClient, err := s.GetClient()
if err != nil {
return nil, 0, 0, 0, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
@@ -66,11 +82,10 @@ func (s *DockerClientService) GetAllContainers(ctx context.Context) ([]container
}
func (s *DockerClientService) GetAllImages(ctx context.Context) ([]image.Summary, int, int, int, error) {
- dockerClient, err := s.CreateConnection(ctx)
+ dockerClient, err := s.GetClient()
if err != nil {
return nil, 0, 0, 0, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
images, err := dockerClient.ImageList(ctx, image.ListOptions{All: true})
if err != nil {
@@ -91,11 +106,10 @@ func (s *DockerClientService) GetAllImages(ctx context.Context) ([]image.Summary
}
func (s *DockerClientService) GetAllNetworks(ctx context.Context) (_ []network.Summary, totalNetworks int, inuseNetworks int, unusedNetworks int, error error) {
- dockerClient, err := s.CreateConnection(ctx)
+ dockerClient, err := s.GetClient()
if err != nil {
return nil, 0, 0, 0, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
@@ -140,11 +154,10 @@ func (s *DockerClientService) GetAllNetworks(ctx context.Context) (_ []network.S
}
func (s *DockerClientService) GetAllVolumes(ctx context.Context) ([]*volume.Volume, int, int, int, error) {
- dockerClient, err := s.CreateConnection(ctx)
+ dockerClient, err := s.GetClient()
if err != nil {
return nil, 0, 0, 0, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.go
index 1faca77b2..261e4919a 100644
--- a/backend/internal/services/environment_service.go
+++ b/backend/internal/services/environment_service.go
@@ -8,8 +8,6 @@ import (
"io"
"log/slog"
"net/http"
- "net/url"
- "path"
"strings"
"time"
@@ -205,12 +203,11 @@ func (s *EnvironmentService) testLocalDockerConnection(ctx context.Context, id s
reqCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
- dockerClient, err := s.dockerService.CreateConnection(reqCtx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
_ = s.updateEnvironmentStatusInternal(ctx, id, string(models.EnvironmentStatusOffline))
return "offline", fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
_, err = dockerClient.Ping(reqCtx)
if err != nil {
@@ -298,111 +295,6 @@ func (s *EnvironmentService) PairAndPersistAgentToken(ctx context.Context, envir
return token, nil
}
-func (s *EnvironmentService) BuildWSAuthHeadersFromRequest(req *http.Request, agentToken string) http.Header {
- h := http.Header{}
- if auth := req.Header.Get("Authorization"); auth != "" {
- h.Set("Authorization", auth)
- } else if c, err := req.Cookie("token"); err == nil && c != nil && c.Value != "" {
- h.Set("Authorization", "Bearer "+c.Value)
- }
-
- // If no Authorization header was set, forward original cookies (needed for external SSO like Authelia).
- if h.Get("Authorization") == "" {
- if cookieHeader := req.Header.Get("Cookie"); cookieHeader != "" {
- // Pass through all cookies so upstream auth (Authelia) still sees its session.
- h.Set("Cookie", cookieHeader)
- }
- }
-
- if agentToken != "" {
- h.Set("X-Arcane-Agent-Token", agentToken)
- }
- return h
-}
-
-func wsScheme(req *http.Request) string {
- // Prefer explicit headers set by reverse proxies.
- check := func(v string) string {
- v = strings.TrimSpace(strings.ToLower(v))
- if v == "" {
- return ""
- }
- if strings.HasPrefix(v, "https") {
- return "wss"
- }
- if strings.HasPrefix(v, "http") {
- return "ws"
- }
- return ""
- }
-
- if s := check(req.Header.Get("X-Forwarded-Proto")); s != "" {
- return s
- }
- if s := check(req.Header.Get("X-Forwarded-Scheme")); s != "" {
- return s
- }
-
- // Parse standardized Forwarded header: Forwarded: proto=https; host=...
- if fwd := req.Header.Get("Forwarded"); fwd != "" {
- // naive parse: split by ; and ,
- parts := strings.Split(fwd, ";")
- for _, p := range parts {
- p = strings.TrimSpace(p)
- if strings.HasPrefix(strings.ToLower(p), "proto=") {
- if s := check(strings.TrimPrefix(p, "proto=")); s != "" {
- return s
- }
- }
- }
- }
-
- // Fallback: infer from Origin
- if origin := req.Header.Get("Origin"); strings.HasPrefix(strings.ToLower(origin), "https://") {
- return "wss"
- }
-
- // Direct TLS?
- if req.TLS != nil {
- return "wss"
- }
- return "ws"
-}
-
-func (s *EnvironmentService) BuildLocalWSTarget(req *http.Request, absolutePath string, agentToken string) (string, http.Header) {
- u := &url.URL{
- Scheme: wsScheme(req),
- Host: req.Host,
- Path: absolutePath,
- RawQuery: req.URL.RawQuery,
- }
- h := s.BuildWSAuthHeadersFromRequest(req, agentToken)
- return u.String(), h
-}
-
-// BuildRemoteWSTarget returns ws URL and headers for a remote environment.
-// absolutePath should be the full API path (e.g. "/api/environments/0/stats/ws").
-func (s *EnvironmentService) BuildRemoteWSTarget(environment *models.Environment, absolutePath string, req *http.Request) (string, http.Header, error) {
- base, err := url.Parse(strings.TrimRight(environment.ApiUrl, "/"))
- if err != nil {
- return "", nil, fmt.Errorf("invalid environment url: %w", err)
- }
- if base.Scheme == "https" {
- base.Scheme = "wss"
- } else {
- base.Scheme = "ws"
- }
- base.Path = path.Join(base.Path, absolutePath)
- base.RawQuery = req.URL.RawQuery
-
- agentToken := ""
- if environment.AccessToken != nil {
- agentToken = *environment.AccessToken
- }
- h := s.BuildWSAuthHeadersFromRequest(req, agentToken)
- return base.String(), h, nil
-}
-
func (s *EnvironmentService) GetDB() *database.DB {
return s.db
}
diff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.go
index 7d547b7c9..cbf21957b 100644
--- a/backend/internal/services/event_service.go
+++ b/backend/internal/services/event_service.go
@@ -3,6 +3,7 @@ package services
import (
"context"
"fmt"
+ "log/slog"
"strings"
"time"
@@ -12,6 +13,7 @@ import (
"github.com/ofkm/arcane-backend/internal/utils/pagination"
"golang.org/x/text/cases"
"golang.org/x/text/language"
+ "gorm.io/gorm"
)
type EventService struct {
@@ -60,8 +62,15 @@ func (s *EventService) CreateEvent(ctx context.Context, req CreateEventRequest)
},
}
- if err := s.db.WithContext(ctx).Create(event).Error; err != nil {
- return nil, fmt.Errorf("failed to create event: %w", err)
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Create(event).Error; err != nil {
+ return fmt.Errorf("failed to create event: %w", err)
+ }
+ return nil
+ })
+
+ if err != nil {
+ return nil, err
}
return event, nil
@@ -180,23 +189,27 @@ func (s *EventService) GetEventsByEnvironmentPaginated(ctx context.Context, envi
}
func (s *EventService) DeleteEvent(ctx context.Context, eventID string) error {
- result := s.db.WithContext(ctx).Delete(&models.Event{}, "id = ?", eventID)
- if result.Error != nil {
- return fmt.Errorf("failed to delete event: %w", result.Error)
- }
- if result.RowsAffected == 0 {
- return fmt.Errorf("event not found")
- }
- return nil
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ result := tx.Delete(&models.Event{}, "id = ?", eventID)
+ if result.Error != nil {
+ return fmt.Errorf("failed to delete event: %w", result.Error)
+ }
+ if result.RowsAffected == 0 {
+ return fmt.Errorf("event not found")
+ }
+ return nil
+ })
}
func (s *EventService) DeleteOldEvents(ctx context.Context, olderThan time.Duration) error {
cutoff := time.Now().Add(-olderThan)
- result := s.db.WithContext(ctx).Where("timestamp < ?", cutoff).Delete(&models.Event{})
- if result.Error != nil {
- return fmt.Errorf("failed to delete old events: %w", result.Error)
- }
- return nil
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ result := tx.Where("timestamp < ?", cutoff).Delete(&models.Event{})
+ if result.Error != nil {
+ return fmt.Errorf("failed to delete old events: %w", result.Error)
+ }
+ return nil
+ })
}
func (s *EventService) LogContainerEvent(ctx context.Context, eventType models.EventType, containerID, containerName, userID, username, environmentID string, metadata models.JSON) error {
@@ -331,35 +344,88 @@ func (s *EventService) LogErrorEvent(ctx context.Context, eventType models.Event
return
}
- if metadata == nil {
- metadata = models.JSON{}
- }
- metadata["error"] = err.Error()
-
- titleCaser := cases.Title(language.English)
- title := fmt.Sprintf("%s error", titleCaser.String(resourceType))
- if resourceName != "" {
- title = fmt.Sprintf("%s error: %s", titleCaser.String(resourceType), resourceName)
- }
-
- description := fmt.Sprintf("Failed to perform operation on %s: %s", resourceType, err.Error())
+ // Run error logging in background to prevent blocking the main flow
+ // Detach context to ensure logging completes even if request is canceled
+ bgCtx := context.WithoutCancel(ctx)
+ go func() {
+ // Set a timeout for the background logging
+ logCtx, cancel := context.WithTimeout(bgCtx, 30*time.Second)
+ defer cancel()
+
+ if metadata == nil {
+ metadata = models.JSON{}
+ }
+ metadata["error"] = err.Error()
+
+ titleCaser := cases.Title(language.English)
+ title := fmt.Sprintf("%s error", titleCaser.String(resourceType))
+ if resourceName != "" {
+ title = fmt.Sprintf("%s error: %s", titleCaser.String(resourceType), resourceName)
+ }
+
+ description := fmt.Sprintf("Failed to perform operation on %s: %s", resourceType, err.Error())
+
+ _, logErr := s.CreateEvent(logCtx, CreateEventRequest{
+ Type: eventType,
+ Severity: models.EventSeverityError,
+ Title: title,
+ Description: description,
+ ResourceType: &resourceType,
+ ResourceID: &resourceID,
+ ResourceName: &resourceName,
+ UserID: &userID,
+ Username: &username,
+ EnvironmentID: &environmentID,
+ Metadata: metadata,
+ })
+ if logErr != nil {
+ slog.ErrorContext(logCtx, "Failed to log error event", "error", logErr)
+ }
+ }()
+}
- _, logErr := s.CreateEvent(ctx, CreateEventRequest{
- Type: eventType,
- Severity: models.EventSeverityError,
- Title: title,
- Description: description,
- ResourceType: &resourceType,
- ResourceID: &resourceID,
- ResourceName: &resourceName,
- UserID: &userID,
- Username: &username,
- EnvironmentID: &environmentID,
- Metadata: metadata,
- })
- if logErr != nil {
- fmt.Printf("Failed to log error event: %v\n", logErr)
- }
+var eventDefinitions = map[models.EventType]struct {
+ TitleFormat string
+ DescriptionFormat string
+ Severity models.EventSeverity
+}{
+ models.EventTypeContainerStart: {"Container started: %s", "Container '%s' has been started", models.EventSeveritySuccess},
+ models.EventTypeContainerStop: {"Container stopped: %s", "Container '%s' has been stopped", models.EventSeverityInfo},
+ models.EventTypeContainerRestart: {"Container restarted: %s", "Container '%s' has been restarted", models.EventSeverityInfo},
+ models.EventTypeContainerDelete: {"Container deleted: %s", "Container '%s' has been deleted", models.EventSeverityWarning},
+ models.EventTypeContainerCreate: {"Container created: %s", "Container '%s' has been created", models.EventSeveritySuccess},
+ models.EventTypeContainerScan: {"Container scanned: %s", "Security scan completed for container '%s'", models.EventSeverityInfo},
+ models.EventTypeContainerUpdate: {"Container updated: %s", "Container '%s' has been updated", models.EventSeverityInfo},
+ models.EventTypeContainerError: {"Container error: %s", "An error occurred with container '%s'", models.EventSeverityError},
+
+ models.EventTypeImagePull: {"Image pulled: %s", "Image '%s' has been pulled", models.EventSeveritySuccess},
+ models.EventTypeImageLoad: {"Image loaded: %s", "Image '%s' has been loaded from archive", models.EventSeveritySuccess},
+ models.EventTypeImageDelete: {"Image deleted: %s", "Image '%s' has been deleted", models.EventSeverityWarning},
+ models.EventTypeImageScan: {"Image scanned: %s", "Security scan completed for image '%s'", models.EventSeverityInfo},
+ models.EventTypeImageError: {"Image error: %s", "An error occurred with image '%s'", models.EventSeverityError},
+
+ models.EventTypeProjectDeploy: {"Project deployed: %s", "Project '%s' has been deployed", models.EventSeveritySuccess},
+ models.EventTypeProjectDelete: {"Project deleted: %s", "Project '%s' has been deleted", models.EventSeverityWarning},
+ models.EventTypeProjectStart: {"Project started: %s", "Project '%s' has been started", models.EventSeveritySuccess},
+ models.EventTypeProjectStop: {"Project stopped: %s", "Project '%s' has been stopped", models.EventSeverityInfo},
+ models.EventTypeProjectCreate: {"Project created: %s", "Project '%s' has been created", models.EventSeveritySuccess},
+ models.EventTypeProjectUpdate: {"Project updated: %s", "Project '%s' has been updated", models.EventSeverityInfo},
+ models.EventTypeProjectError: {"Project error: %s", "An error occurred with project '%s'", models.EventSeverityError},
+
+ models.EventTypeVolumeCreate: {"Volume created: %s", "Volume '%s' has been created", models.EventSeveritySuccess},
+ models.EventTypeVolumeDelete: {"Volume deleted: %s", "Volume '%s' has been deleted", models.EventSeverityWarning},
+ models.EventTypeVolumeError: {"Volume error: %s", "An error occurred with volume '%s'", models.EventSeverityError},
+
+ models.EventTypeNetworkCreate: {"Network created: %s", "Network '%s' has been created", models.EventSeveritySuccess},
+ models.EventTypeNetworkDelete: {"Network deleted: %s", "Network '%s' has been deleted", models.EventSeverityWarning},
+ models.EventTypeNetworkError: {"Network error: %s", "An error occurred with network '%s'", models.EventSeverityError},
+
+ models.EventTypeSystemPrune: {"System prune completed", "System resources have been pruned", models.EventSeverityInfo},
+ models.EventTypeSystemAutoUpdate: {"System auto-update completed", "System auto-update process has completed", models.EventSeverityInfo},
+ models.EventTypeSystemUpgrade: {"System upgrade completed", "System upgrade process has completed", models.EventSeverityInfo},
+
+ models.EventTypeUserLogin: {"User logged in: %s", "User '%s' has logged in", models.EventSeverityInfo},
+ models.EventTypeUserLogout: {"User logged out: %s", "User '%s' has logged out", models.EventSeverityInfo},
}
func (s *EventService) toEventDto(event *models.Event) *dto.EventDto {
@@ -388,152 +454,22 @@ func (s *EventService) toEventDto(event *models.Event) *dto.EventDto {
}
func (s *EventService) generateEventTitle(eventType models.EventType, resourceName string) string {
- switch eventType {
- case models.EventTypeContainerStart:
- return fmt.Sprintf("Container started: %s", resourceName)
- case models.EventTypeContainerStop:
- return fmt.Sprintf("Container stopped: %s", resourceName)
- case models.EventTypeContainerRestart:
- return fmt.Sprintf("Container restarted: %s", resourceName)
- case models.EventTypeContainerDelete:
- return fmt.Sprintf("Container deleted: %s", resourceName)
- case models.EventTypeContainerCreate:
- return fmt.Sprintf("Container created: %s", resourceName)
- case models.EventTypeContainerScan:
- return fmt.Sprintf("Container scanned: %s", resourceName)
- case models.EventTypeContainerUpdate:
- return fmt.Sprintf("Container updated: %s", resourceName)
- case models.EventTypeContainerError:
- return fmt.Sprintf("Container error: %s", resourceName)
- case models.EventTypeImagePull:
- return fmt.Sprintf("Image pulled: %s", resourceName)
- case models.EventTypeImageLoad:
- return fmt.Sprintf("Image loaded: %s", resourceName)
- case models.EventTypeImageDelete:
- return fmt.Sprintf("Image deleted: %s", resourceName)
- case models.EventTypeImageScan:
- return fmt.Sprintf("Image scanned: %s", resourceName)
- case models.EventTypeImageError:
- return fmt.Sprintf("Image error: %s", resourceName)
- case models.EventTypeProjectDeploy:
- return fmt.Sprintf("Project deployed: %s", resourceName)
- case models.EventTypeProjectDelete:
- return fmt.Sprintf("Project deleted: %s", resourceName)
- case models.EventTypeProjectStart:
- return fmt.Sprintf("Project started: %s", resourceName)
- case models.EventTypeProjectStop:
- return fmt.Sprintf("Project stopped: %s", resourceName)
- case models.EventTypeProjectCreate:
- return fmt.Sprintf("Project created: %s", resourceName)
- case models.EventTypeProjectUpdate:
- return fmt.Sprintf("Project updated: %s", resourceName)
- case models.EventTypeProjectError:
- return fmt.Sprintf("Project error: %s", resourceName)
- case models.EventTypeVolumeCreate:
- return fmt.Sprintf("Volume created: %s", resourceName)
- case models.EventTypeVolumeDelete:
- return fmt.Sprintf("Volume deleted: %s", resourceName)
- case models.EventTypeVolumeError:
- return fmt.Sprintf("Volume error: %s", resourceName)
- case models.EventTypeNetworkCreate:
- return fmt.Sprintf("Network created: %s", resourceName)
- case models.EventTypeNetworkDelete:
- return fmt.Sprintf("Network deleted: %s", resourceName)
- case models.EventTypeNetworkError:
- return fmt.Sprintf("Network error: %s", resourceName)
- case models.EventTypeSystemPrune:
- return "System prune completed"
- case models.EventTypeSystemAutoUpdate:
- return "System auto-update completed"
- case models.EventTypeSystemUpgrade:
- return "System upgrade completed"
- case models.EventTypeUserLogin:
- return fmt.Sprintf("User logged in: %s", resourceName)
- case models.EventTypeUserLogout:
- return fmt.Sprintf("User logged out: %s", resourceName)
- default:
- return fmt.Sprintf("Event: %s", string(eventType))
+ if def, ok := eventDefinitions[eventType]; ok {
+ return fmt.Sprintf(def.TitleFormat, resourceName)
}
+ return fmt.Sprintf("Event: %s", string(eventType))
}
func (s *EventService) generateEventDescription(eventType models.EventType, resourceType, resourceName string) string {
- switch eventType {
- case models.EventTypeContainerScan, models.EventTypeImageScan:
- return fmt.Sprintf("Security scan completed for %s '%s'", resourceType, resourceName)
- case models.EventTypeContainerStart:
- return fmt.Sprintf("Container '%s' has been started", resourceName)
- case models.EventTypeContainerStop:
- return fmt.Sprintf("Container '%s' has been stopped", resourceName)
- case models.EventTypeContainerRestart:
- return fmt.Sprintf("Container '%s' has been restarted", resourceName)
- case models.EventTypeContainerDelete:
- return fmt.Sprintf("Container '%s' has been deleted", resourceName)
- case models.EventTypeContainerCreate:
- return fmt.Sprintf("Container '%s' has been created", resourceName)
- case models.EventTypeContainerUpdate:
- return fmt.Sprintf("Container '%s' has been updated", resourceName)
- case models.EventTypeContainerError:
- return fmt.Sprintf("An error occurred with container '%s'", resourceName)
- case models.EventTypeImagePull:
- return fmt.Sprintf("Image '%s' has been pulled", resourceName)
- case models.EventTypeImageLoad:
- return fmt.Sprintf("Image '%s' has been loaded from archive", resourceName)
- case models.EventTypeImageDelete:
- return fmt.Sprintf("Image '%s' has been deleted", resourceName)
- case models.EventTypeImageError:
- return fmt.Sprintf("An error occurred with image '%s'", resourceName)
- case models.EventTypeProjectDeploy:
- return fmt.Sprintf("Project '%s' has been deployed", resourceName)
- case models.EventTypeProjectDelete:
- return fmt.Sprintf("Project '%s' has been deleted", resourceName)
- case models.EventTypeProjectStart:
- return fmt.Sprintf("Project '%s' has been started", resourceName)
- case models.EventTypeProjectStop:
- return fmt.Sprintf("Project '%s' has been stopped", resourceName)
- case models.EventTypeProjectCreate:
- return fmt.Sprintf("Project '%s' has been created", resourceName)
- case models.EventTypeProjectUpdate:
- return fmt.Sprintf("Project '%s' has been updated", resourceName)
- case models.EventTypeProjectError:
- return fmt.Sprintf("An error occurred with project '%s'", resourceName)
- case models.EventTypeVolumeCreate:
- return fmt.Sprintf("Volume '%s' has been created", resourceName)
- case models.EventTypeVolumeDelete:
- return fmt.Sprintf("Volume '%s' has been deleted", resourceName)
- case models.EventTypeVolumeError:
- return fmt.Sprintf("An error occurred with volume '%s'", resourceName)
- case models.EventTypeNetworkCreate:
- return fmt.Sprintf("Network '%s' has been created", resourceName)
- case models.EventTypeNetworkDelete:
- return fmt.Sprintf("Network '%s' has been deleted", resourceName)
- case models.EventTypeNetworkError:
- return fmt.Sprintf("An error occurred with network '%s'", resourceName)
- case models.EventTypeSystemPrune:
- return "System resources have been pruned"
- case models.EventTypeSystemAutoUpdate:
- return "System auto-update process has completed"
- case models.EventTypeSystemUpgrade:
- return "System upgrade process has completed"
- case models.EventTypeUserLogin:
- return fmt.Sprintf("User '%s' has logged in", resourceName)
- case models.EventTypeUserLogout:
- return fmt.Sprintf("User '%s' has logged out", resourceName)
- default:
- return fmt.Sprintf("%s operation performed on %s '%s'", string(eventType), resourceType, resourceName)
+ if def, ok := eventDefinitions[eventType]; ok {
+ return fmt.Sprintf(def.DescriptionFormat, resourceName)
}
+ return fmt.Sprintf("%s operation performed on %s '%s'", string(eventType), resourceType, resourceName)
}
func (s *EventService) getEventSeverity(eventType models.EventType) models.EventSeverity {
- switch eventType {
- case models.EventTypeContainerDelete, models.EventTypeImageDelete, models.EventTypeProjectDelete, models.EventTypeVolumeDelete, models.EventTypeNetworkDelete:
- return models.EventSeverityWarning
- case models.EventTypeContainerStart, models.EventTypeContainerCreate, models.EventTypeImagePull, models.EventTypeImageLoad, models.EventTypeProjectDeploy, models.EventTypeProjectStart, models.EventTypeProjectCreate, models.EventTypeVolumeCreate, models.EventTypeNetworkCreate:
- return models.EventSeveritySuccess
- case models.EventTypeContainerStop, models.EventTypeContainerRestart, models.EventTypeContainerScan, models.EventTypeContainerUpdate, models.EventTypeImageScan, models.EventTypeProjectStop, models.EventTypeProjectUpdate, models.EventTypeSystemPrune, models.EventTypeSystemAutoUpdate, models.EventTypeSystemUpgrade, models.EventTypeUserLogin, models.EventTypeUserLogout:
- return models.EventSeverityInfo
- case models.EventTypeContainerError, models.EventTypeImageError, models.EventTypeProjectError, models.EventTypeVolumeError, models.EventTypeNetworkError:
- return models.EventSeverityError
- default:
- return models.EventSeverityInfo
+ if def, ok := eventDefinitions[eventType]; ok {
+ return def.Severity
}
+ return models.EventSeverityInfo
}
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index 3458d34c1..b9f13a6b4 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -22,6 +22,8 @@ import (
"github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/utils/pagination"
+ "golang.org/x/sync/errgroup"
+ "gorm.io/gorm"
)
type ImageService struct {
@@ -43,11 +45,10 @@ func NewImageService(db *database.DB, dockerService *DockerClientService, regist
}
func (s *ImageService) GetImageByID(ctx context.Context, id string) (*image.InspectResponse, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
inspect, err := dockerClient.ImageInspect(ctx, id)
if err != nil {
@@ -58,12 +59,11 @@ func (s *ImageService) GetImageByID(ctx context.Context, id string) (*image.Insp
}
func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeImageError, "image", id, "", user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
imageDetails, inspectErr := dockerClient.ImageInspect(ctx, id)
var imageName string
@@ -85,7 +85,11 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, u
}
if s.db != nil {
- s.db.WithContext(ctx).Delete(&models.ImageUpdateRecord{}, "id = ?", id)
+ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ return tx.Delete(&models.ImageUpdateRecord{}, "id = ?", id).Error
+ }); err != nil {
+ slog.WarnContext(ctx, "failed to delete image update record", "id", id, "error", err)
+ }
}
metadata := models.JSON{
@@ -94,38 +98,30 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, u
"force": force,
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageDelete, id, imageName, user.ID, user.Username, "0", metadata); logErr != nil {
- slog.Warn("could not log image deletion action", slog.Any("err", logErr), slog.String("image", imageName), slog.String("image_id", id))
+ slog.Warn("could not log image deletion action", "err", logErr, "image", imageName, "image_id", id)
}
return nil
}
func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user models.User, externalCreds []dto.ContainerRegistryCredential) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeImageError, "image", "", imageName, user.ID, user.Username, "0", err, models.JSON{"action": "pull"})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
- slog.DebugContext(ctx, "Attempting to pull image",
- slog.String("image", imageName),
- slog.Int("externalCredCount", len(externalCreds)))
+ slog.DebugContext(ctx, "Attempting to pull image", "image", imageName, "externalCredCount", len(externalCreds))
pullOptions, err := s.getPullOptionsWithAuth(ctx, imageName, externalCreds)
if err != nil {
- slog.WarnContext(ctx, "Failed to get registry authentication for image; proceeding without auth",
- slog.String("image", imageName),
- slog.String("error", err.Error()))
+ slog.WarnContext(ctx, "Failed to get registry authentication for image; proceeding without auth", "image", imageName, "error", err.Error())
pullOptions = image.PullOptions{}
}
reader, err := dockerClient.ImagePull(ctx, imageName, pullOptions)
if err != nil {
- slog.ErrorContext(ctx, "Docker ImagePull failed",
- slog.String("image", imageName),
- slog.Bool("hasAuth", pullOptions.RegistryAuth != ""),
- slog.String("error", err.Error()))
+ slog.ErrorContext(ctx, "Docker ImagePull failed", "image", imageName, "hasAuth", pullOptions.RegistryAuth != "", "error", err.Error())
s.eventService.LogErrorEvent(ctx, models.EventTypeImageError, "image", "", imageName, user.ID, user.Username, "0", err, models.JSON{"action": "pull"})
return fmt.Errorf("failed to initiate image pull for %s: %w", imageName, err)
}
@@ -151,7 +147,7 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progress
}
if scanErr := scanner.Err(); scanErr != nil {
if errors.Is(scanErr, context.Canceled) || strings.Contains(scanErr.Error(), "context canceled") {
- slog.Debug("image pull stream canceled", slog.String("image", imageName), slog.Any("err", scanErr))
+ slog.Debug("image pull stream canceled", "image", imageName, "err", scanErr)
s.eventService.LogErrorEvent(ctx, models.EventTypeImageError, "image", "", imageName, user.ID, user.Username, "0", scanErr, models.JSON{"action": "pull", "step": "canceled"})
return fmt.Errorf("image pull stream canceled for %s: %w", imageName, scanErr)
}
@@ -159,14 +155,14 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progress
return fmt.Errorf("error reading image pull stream for %s: %w", imageName, scanErr)
}
- slog.Debug("image pull stream completed", slog.String("image", imageName))
+ slog.Debug("image pull stream completed", "image", imageName)
metadata := models.JSON{
"action": "pull",
"imageName": imageName,
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImagePull, "", imageName, user.ID, user.Username, "0", metadata); logErr != nil {
- slog.Warn("could not log image pull action", slog.Any("err", logErr), slog.String("image", imageName))
+ slog.Warn("could not log image pull action", "err", logErr, "image", imageName)
}
return nil
@@ -176,12 +172,11 @@ func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader
// Wrap reader with size limit enforcement
limitedReader := io.LimitReader(reader, maxSizeBytes+1)
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeImageError, "image", "", fileName, user.ID, user.Username, "0", err, models.JSON{"action": "load"})
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
// ImageLoad accepts a tar archive reader and optional load options
loadResp, err := dockerClient.ImageLoad(ctx, limitedReader)
@@ -210,18 +205,17 @@ func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader
"fileName": fileName,
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageLoad, "", fileName, user.ID, user.Username, "0", metadata); logErr != nil {
- slog.Warn("could not log image load action", slog.Any("err", logErr), slog.String("file", fileName))
+ slog.Warn("could not log image load action", "err", logErr, "file", fileName)
}
return &result, nil
}
func (s *ImageService) ImageExistsLocally(ctx context.Context, imageName string) (bool, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return false, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
_, err = dockerClient.ImageInspect(ctx, imageName)
if err == nil {
@@ -240,31 +234,21 @@ func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef stri
registryHost := s.extractRegistryHost(imageRef)
- if len(externalCreds) > 0 {
- for _, cred := range externalCreds {
- if !cred.Enabled || cred.Username == "" || cred.Token == "" {
- continue
- }
-
- credHost := s.normalizeRegistryForComparison(cred.URL)
- if credHost == s.normalizeRegistryForComparison(registryHost) {
- authConfig := &registry.AuthConfig{
- Username: cred.Username,
- Password: cred.Token,
- ServerAddress: s.normalizeRegistryURL(cred.URL),
- }
-
- authBytes, err := json.Marshal(authConfig)
- if err != nil {
- return pullOptions, fmt.Errorf("failed to marshal auth config: %w", err)
- }
+ // Check external credentials first
+ for _, cred := range externalCreds {
+ if !cred.Enabled || cred.Username == "" || cred.Token == "" {
+ continue
+ }
- pullOptions.RegistryAuth = base64.StdEncoding.EncodeToString(authBytes)
- slog.DebugContext(ctx, "Using external credentials for image pull",
- slog.String("registry", credHost),
- slog.String("username", cred.Username))
- return pullOptions, nil
+ if s.isRegistryMatch(cred.URL, registryHost) {
+ authStr, err := s.createAuthHeader(cred.Username, cred.Token, s.normalizeRegistryURL(cred.URL))
+ if err != nil {
+ return pullOptions, fmt.Errorf("failed to create auth header: %w", err)
}
+ pullOptions.RegistryAuth = authStr
+
+ slog.DebugContext(ctx, "Using external credentials for image pull", "registry", registryHost, "username", cred.Username)
+ return pullOptions, nil
}
}
@@ -272,6 +256,7 @@ func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef stri
return pullOptions, nil
}
+ // Check database registries
registries, err := s.registryService.GetEnabledRegistries(ctx)
if err != nil {
return pullOptions, fmt.Errorf("failed to get registry credentials: %w", err)
@@ -284,21 +269,13 @@ func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef stri
return pullOptions, fmt.Errorf("failed to decrypt token for registry %s: %w", reg.URL, err)
}
- authConfig := &registry.AuthConfig{
- Username: reg.Username,
- Password: decryptedToken,
- ServerAddress: s.normalizeRegistryURL(reg.URL),
- }
-
- authBytes, err := json.Marshal(authConfig)
+ authStr, err := s.createAuthHeader(reg.Username, decryptedToken, s.normalizeRegistryURL(reg.URL))
if err != nil {
- return pullOptions, fmt.Errorf("failed to marshal auth config: %w", err)
+ return pullOptions, fmt.Errorf("failed to create auth header: %w", err)
}
+ pullOptions.RegistryAuth = authStr
- pullOptions.RegistryAuth = base64.StdEncoding.EncodeToString(authBytes)
- slog.DebugContext(ctx, "Using database credentials for image pull",
- slog.String("registry", registryHost),
- slog.String("username", reg.Username))
+ slog.DebugContext(ctx, "Using database credentials for image pull", "registry", registryHost, "username", reg.Username)
break
}
}
@@ -306,6 +283,21 @@ func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef stri
return pullOptions, nil
}
+func (s *ImageService) createAuthHeader(username, password, serverAddress string) (string, error) {
+ authConfig := &registry.AuthConfig{
+ Username: username,
+ Password: password,
+ ServerAddress: serverAddress,
+ }
+
+ authBytes, err := json.Marshal(authConfig)
+ if err != nil {
+ return "", err
+ }
+
+ return base64.StdEncoding.EncodeToString(authBytes), nil
+}
+
func (s *ImageService) extractRegistryHost(imageRef string) string {
if i := strings.IndexByte(imageRef, '@'); i != -1 {
imageRef = imageRef[:i]
@@ -358,11 +350,10 @@ func (s *ImageService) normalizeRegistryURL(url string) string {
}
func (s *ImageService) PruneImages(ctx context.Context, dangling bool) (*image.PruneReport, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
filterArgs := filters.NewArgs()
if dangling {
@@ -376,6 +367,26 @@ func (s *ImageService) PruneImages(ctx context.Context, dangling bool) (*image.P
return nil, fmt.Errorf("failed to prune images: %w", err)
}
+ // Clean up database records for deleted images
+ if s.db != nil && len(report.ImagesDeleted) > 0 {
+ var idsToDelete []string
+ for _, img := range report.ImagesDeleted {
+ if img.Deleted != "" {
+ idsToDelete = append(idsToDelete, img.Deleted)
+ } else if img.Untagged != "" {
+ idsToDelete = append(idsToDelete, img.Untagged)
+ }
+ }
+
+ if len(idsToDelete) > 0 {
+ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ return tx.Where("id IN ?", idsToDelete).Delete(&models.ImageUpdateRecord{}).Error
+ }); err != nil {
+ slog.WarnContext(ctx, "failed to clean up image update records after prune", "error", err)
+ }
+ }
+ }
+
metadata := models.JSON{
"action": "prune",
"dangling": dangling,
@@ -383,129 +394,64 @@ func (s *ImageService) PruneImages(ctx context.Context, dangling bool) (*image.P
"spaceReclaimed": report.SpaceReclaimed,
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.Warn("could not log image prune action", slog.Any("err", logErr))
+ slog.Warn("could not log image prune action", "err", logErr)
}
return &report, nil
}
func (s *ImageService) ListImagesPaginated(ctx context.Context, params pagination.QueryParams) ([]dto.ImageSummaryDto, pagination.Response, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, pagination.Response{}, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
- dockerImages, err := dockerClient.ImageList(ctx, image.ListOptions{})
- if err != nil {
- return nil, pagination.Response{}, fmt.Errorf("failed to list Docker images: %w", err)
- }
+ var (
+ dockerImages []image.Summary
+ containers []container.Summary
+ updateRecords []models.ImageUpdateRecord
+ )
- containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
- if err != nil {
- return nil, pagination.Response{}, fmt.Errorf("failed to list containers: %w", err)
- }
+ g, ctx := errgroup.WithContext(ctx)
- inUseMap := buildInUseMap(containers)
+ // Fetch Docker images
+ g.Go(func() error {
+ var err error
+ dockerImages, err = dockerClient.ImageList(ctx, image.ListOptions{})
+ if err != nil {
+ return fmt.Errorf("failed to list Docker images: %w", err)
+ }
+ return nil
+ })
+
+ // Fetch containers to determine usage
+ g.Go(func() error {
+ var err error
+ containers, err = dockerClient.ContainerList(ctx, container.ListOptions{All: true})
+ if err != nil {
+ return fmt.Errorf("failed to list containers: %w", err)
+ }
+ return nil
+ })
- var updateRecords []models.ImageUpdateRecord
- if s.db != nil {
- s.db.WithContext(ctx).Find(&updateRecords)
+ // Fetch update records from DB
+ g.Go(func() error {
+ if s.db != nil {
+ return s.db.WithContext(ctx).Find(&updateRecords).Error
+ }
+ return nil
+ })
+
+ if err := g.Wait(); err != nil {
+ return nil, pagination.Response{}, err
}
+
+ inUseMap := buildInUseMap(containers)
updateMap := buildUpdateMap(updateRecords)
items := mapDockerImagesToDTOs(dockerImages, inUseMap, updateMap)
- config := pagination.Config[dto.ImageSummaryDto]{
- SearchAccessors: []pagination.SearchAccessor[dto.ImageSummaryDto]{
- func(i dto.ImageSummaryDto) (string, error) { return i.Repo, nil },
- func(i dto.ImageSummaryDto) (string, error) { return i.Tag, nil },
- func(i dto.ImageSummaryDto) (string, error) { return i.ID, nil },
- func(i dto.ImageSummaryDto) (string, error) {
- if len(i.RepoTags) > 0 {
- return i.RepoTags[0], nil
- }
- return "", nil
- },
- },
- SortBindings: []pagination.SortBinding[dto.ImageSummaryDto]{
- {
- Key: "repo",
- Fn: func(a, b dto.ImageSummaryDto) int {
- return strings.Compare(a.Repo, b.Repo)
- },
- },
- {
- Key: "tag",
- Fn: func(a, b dto.ImageSummaryDto) int {
- return strings.Compare(a.Tag, b.Tag)
- },
- },
- {
- Key: "size",
- Fn: func(a, b dto.ImageSummaryDto) int {
- if a.Size < b.Size {
- return -1
- }
- if a.Size > b.Size {
- return 1
- }
- return 0
- },
- },
- {
- Key: "created",
- Fn: func(a, b dto.ImageSummaryDto) int {
- if a.Created < b.Created {
- return -1
- }
- if a.Created > b.Created {
- return 1
- }
- return 0
- },
- },
- {
- Key: "inUse",
- Fn: func(a, b dto.ImageSummaryDto) int {
- if a.InUse == b.InUse {
- return 0
- }
- if a.InUse {
- return -1
- }
- return 1
- },
- },
- },
- FilterAccessors: []pagination.FilterAccessor[dto.ImageSummaryDto]{
- {
- Key: "inUse",
- Fn: func(i dto.ImageSummaryDto, filterValue string) bool {
- if filterValue == "true" {
- return i.InUse
- }
- if filterValue == "false" {
- return !i.InUse
- }
- return true
- },
- },
- {
- Key: "updates",
- Fn: func(i dto.ImageSummaryDto, filterValue string) bool {
- hasUpdate := i.UpdateInfo != nil && i.UpdateInfo.HasUpdate
- if filterValue == "true" {
- return hasUpdate
- }
- if filterValue == "false" {
- return !hasUpdate
- }
- return true
- },
- },
- },
- }
+ config := s.getImagePaginationConfig()
result := pagination.SearchOrderAndPaginate(items, params, config)
@@ -542,11 +488,10 @@ func convertLabels(labels map[string]string) map[string]interface{} {
}
func (s *ImageService) GetTotalImageSize(ctx context.Context) (int64, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return 0, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
images, err := dockerClient.ImageList(ctx, image.ListOptions{})
if err != nil {
@@ -674,3 +619,96 @@ func mapDockerImagesToDTOs(dockerImages []image.Summary, inUseMap map[string]boo
}
return items
}
+
+func (s *ImageService) getImagePaginationConfig() pagination.Config[dto.ImageSummaryDto] {
+ return pagination.Config[dto.ImageSummaryDto]{
+ SearchAccessors: []pagination.SearchAccessor[dto.ImageSummaryDto]{
+ func(i dto.ImageSummaryDto) (string, error) { return i.Repo, nil },
+ func(i dto.ImageSummaryDto) (string, error) { return i.Tag, nil },
+ func(i dto.ImageSummaryDto) (string, error) { return i.ID, nil },
+ func(i dto.ImageSummaryDto) (string, error) {
+ if len(i.RepoTags) > 0 {
+ return i.RepoTags[0], nil
+ }
+ return "", nil
+ },
+ },
+ SortBindings: []pagination.SortBinding[dto.ImageSummaryDto]{
+ {
+ Key: "repo",
+ Fn: func(a, b dto.ImageSummaryDto) int {
+ return strings.Compare(a.Repo, b.Repo)
+ },
+ },
+ {
+ Key: "tag",
+ Fn: func(a, b dto.ImageSummaryDto) int {
+ return strings.Compare(a.Tag, b.Tag)
+ },
+ },
+ {
+ Key: "size",
+ Fn: func(a, b dto.ImageSummaryDto) int {
+ if a.Size < b.Size {
+ return -1
+ }
+ if a.Size > b.Size {
+ return 1
+ }
+ return 0
+ },
+ },
+ {
+ Key: "created",
+ Fn: func(a, b dto.ImageSummaryDto) int {
+ if a.Created < b.Created {
+ return -1
+ }
+ if a.Created > b.Created {
+ return 1
+ }
+ return 0
+ },
+ },
+ {
+ Key: "inUse",
+ Fn: func(a, b dto.ImageSummaryDto) int {
+ if a.InUse == b.InUse {
+ return 0
+ }
+ if a.InUse {
+ return -1
+ }
+ return 1
+ },
+ },
+ },
+ FilterAccessors: []pagination.FilterAccessor[dto.ImageSummaryDto]{
+ {
+ Key: "inUse",
+ Fn: func(i dto.ImageSummaryDto, filterValue string) bool {
+ if filterValue == "true" {
+ return i.InUse
+ }
+ if filterValue == "false" {
+ return !i.InUse
+ }
+ return true
+ },
+ },
+ {
+ Key: "updates",
+ Fn: func(i dto.ImageSummaryDto, filterValue string) bool {
+ hasUpdate := i.UpdateInfo != nil && i.UpdateInfo.HasUpdate
+ if filterValue == "true" {
+ return hasUpdate
+ }
+ if filterValue == "false" {
+ return !hasUpdate
+ }
+ return true
+ },
+ },
+ },
+ }
+}
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 55ed5c391..6324bc17a 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -3,11 +3,10 @@ package services
import (
"context"
"fmt"
- "strings"
- "time"
-
"log/slog"
+ "strings"
"sync"
+ "time"
ref "github.com/distribution/reference"
"github.com/docker/docker/api/types/image"
@@ -16,6 +15,8 @@ import (
"github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/utils"
registry "github.com/ofkm/arcane-backend/internal/utils/registry"
+ "golang.org/x/sync/errgroup"
+ "gorm.io/gorm"
)
type ImageUpdateService struct {
@@ -72,14 +73,10 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
"checkType": "digest",
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "Failed to log image update check error event",
- slog.String("imageRef", imageRef),
- slog.String("error", logErr.Error()))
+ slog.WarnContext(ctx, "Failed to log image update check error event", "imageRef", imageRef, "error", logErr.Error())
}
if saveErr := s.saveUpdateResult(ctx, imageRef, result); saveErr != nil {
- slog.WarnContext(ctx, "Failed to save update result",
- slog.String("imageRef", imageRef),
- slog.String("error", saveErr.Error()))
+ slog.WarnContext(ctx, "Failed to save update result", "imageRef", imageRef, "error", saveErr.Error())
}
return result, err
}
@@ -95,22 +92,16 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
"responseTimeMs": digestResult.ResponseTimeMs,
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "Failed to log image update check event",
- slog.String("imageRef", imageRef),
- slog.String("error", logErr.Error()))
+ slog.WarnContext(ctx, "Failed to log image update check event", "imageRef", imageRef, "error", logErr.Error())
}
if saveErr := s.saveUpdateResult(ctx, imageRef, digestResult); saveErr != nil {
- slog.WarnContext(ctx, "Failed to save update result",
- slog.String("imageRef", imageRef),
- slog.String("error", saveErr.Error()))
+ slog.WarnContext(ctx, "Failed to save update result", "imageRef", imageRef, "error", saveErr.Error())
}
// Send notification if update is available
if digestResult.HasUpdate && s.notificationService != nil {
if notifErr := s.notificationService.SendImageUpdateNotification(ctx, imageRef, digestResult, models.NotificationEventImageUpdate); notifErr != nil {
- slog.WarnContext(ctx, "Failed to send update notification",
- slog.String("imageRef", imageRef),
- slog.String("error", notifErr.Error()))
+ slog.WarnContext(ctx, "Failed to send update notification", "imageRef", imageRef, "error", notifErr.Error())
}
}
@@ -128,15 +119,11 @@ type authDetails struct {
func (s *ImageUpdateService) getRegistryToken(ctx context.Context, regHost, repository string, regs []models.ContainerRegistry) (string, *authDetails, error) {
rc := registry.NewClient()
- slog.DebugContext(ctx, "Checking registry auth",
- slog.String("registry", regHost),
- slog.String("repository", repository))
+ slog.DebugContext(ctx, "Checking registry auth", "registry", regHost, "repository", repository)
authURL, err := rc.CheckAuth(ctx, regHost)
if err != nil {
- slog.DebugContext(ctx, "Registry auth check failed",
- slog.String("registry", regHost),
- slog.String("error", err.Error()))
+ slog.DebugContext(ctx, "Registry auth check failed", "registry", regHost, "error", err.Error())
return "", nil, fmt.Errorf("failed to check auth: %w", err)
}
@@ -221,11 +208,11 @@ func (s *ImageUpdateService) checkDigestUpdate(ctx context.Context, parts *Image
}
slog.DebugContext(ctx, "digest comparison",
- slog.String("imageRef", fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag)),
- slog.String("primaryLocalDigest", localDigest),
- slog.Any("allLocalDigests", allLocalDigests),
- slog.String("remoteDigest", remoteDigest),
- slog.Bool("hasUpdate", hasUpdate))
+ "imageRef", fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag),
+ "primaryLocalDigest", localDigest,
+ "allLocalDigests", allLocalDigests,
+ "remoteDigest", remoteDigest,
+ "hasUpdate", hasUpdate)
return &dto.ImageUpdateResponse{
HasUpdate: hasUpdate,
@@ -332,11 +319,10 @@ func (s *ImageUpdateService) parseImageReferenceFallback(imageRef string) *Image
}
func (s *ImageUpdateService) getImageRefByID(ctx context.Context, imageID string) (string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return "", fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
imageID = strings.TrimPrefix(imageID, "sha256:")
inspectResponse, err := dockerClient.ImageInspect(ctx, imageID)
@@ -364,11 +350,10 @@ func (s *ImageUpdateService) getImageRefByID(ctx context.Context, imageID string
}
func (s *ImageUpdateService) getAllImageRefs(ctx context.Context, limit int) ([]string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
images, err := dockerClient.ImageList(ctx, image.ListOptions{})
if err != nil {
@@ -393,11 +378,10 @@ func (s *ImageUpdateService) getAllImageRefs(ctx context.Context, limit int) ([]
}
func (s *ImageUpdateService) getLocalImageDigestWithAll(ctx context.Context, imageRef string) (string, []string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return "", nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
inspectResponse, err := dockerClient.ImageInspect(ctx, imageRef)
if err != nil {
@@ -439,9 +423,7 @@ func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, regHost
registries, err := s.registryService.GetAllRegistries(ctx)
if err != nil {
- slog.DebugContext(ctx, "Failed to load registries for image",
- slog.String("registry", regHost),
- slog.String("error", err.Error()))
+ slog.DebugContext(ctx, "Failed to load registries for image", "registry", regHost, "error", err.Error())
return nil
}
@@ -457,15 +439,15 @@ func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, regHost
}
slog.DebugContext(ctx, "Matched registry credentials for image",
- slog.String("registry", regHost),
- slog.String("normalizedDomain", normalizedDomain),
- slog.Int("matchCount", len(matches)))
+ "registry", regHost,
+ "normalizedDomain", normalizedDomain,
+ "matchCount", len(matches))
for i, reg := range matches {
slog.DebugContext(ctx, "Matched credential",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL),
- slog.String("username", reg.Username))
+ "index", i,
+ "registryURL", reg.URL,
+ "username", reg.Username)
}
return matches
@@ -500,9 +482,7 @@ func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID s
"error": err.Error(),
}
if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, imageID, "", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "Failed to log image update check by ID error event",
- slog.String("imageID", imageID),
- slog.String("error", logErr.Error()))
+ slog.WarnContext(ctx, "Failed to log image update check by ID error event", "imageID", imageID, "error", logErr.Error())
}
return nil, fmt.Errorf("failed to get image reference: %w", err)
}
@@ -511,9 +491,7 @@ func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID s
return nil, err
}
if saveErr := s.saveUpdateResultByID(ctx, imageID, result); saveErr != nil {
- slog.WarnContext(ctx, "Failed to save update result by ID",
- slog.String("imageID", imageID),
- slog.String("error", saveErr.Error()))
+ slog.WarnContext(ctx, "Failed to save update result by ID", "imageID", imageID, "error", saveErr.Error())
}
return result, nil
}
@@ -603,29 +581,29 @@ func buildImageUpdateRecord(imageID, repo, tag string, result *dto.ImageUpdateRe
}
func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID string, result *dto.ImageUpdateResponse) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
- if err != nil {
- return fmt.Errorf("failed to connect to Docker: %w", err)
- }
- defer dockerClient.Close()
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return fmt.Errorf("failed to connect to Docker: %w", err)
+ }
- dockerImage, err := dockerClient.ImageInspect(ctx, imageID)
- if err != nil {
- return fmt.Errorf("failed to inspect image: %w", err)
- }
+ dockerImage, err := dockerClient.ImageInspect(ctx, imageID)
+ if err != nil {
+ return fmt.Errorf("failed to inspect image: %w", err)
+ }
- repo, tag := extractRepoAndTagFromImage(dockerImage)
- updateRecord := buildImageUpdateRecord(imageID, repo, tag, result)
+ repo, tag := extractRepoAndTagFromImage(dockerImage)
+ updateRecord := buildImageUpdateRecord(imageID, repo, tag, result)
- return s.db.WithContext(ctx).Save(updateRecord).Error
+ return tx.Save(updateRecord).Error
+ })
}
func (s *ImageUpdateService) getImageIDByRef(ctx context.Context, imageRef string) (string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return "", fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
inspectResponse, err := dockerClient.ImageInspect(ctx, imageRef)
if err != nil {
@@ -698,9 +676,7 @@ func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCre
}
encToken, encErr := utils.Encrypt(c.Token)
if encErr != nil {
- slog.WarnContext(ctx, "Failed to encrypt external registry token",
- slog.String("registryURL", c.URL),
- slog.String("error", encErr.Error()))
+ slog.WarnContext(ctx, "Failed to encrypt external registry token", "registryURL", c.URL, "error", encErr.Error())
continue
}
enabledRegs = append(enabledRegs, models.ContainerRegistry{
@@ -710,14 +686,13 @@ func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCre
Enabled: c.Enabled,
})
}
- slog.DebugContext(ctx, "Using external credentials for batch check",
- slog.Int("credentialCount", len(credMap)))
+ slog.DebugContext(ctx, "Using external credentials for batch check", "credentialCount", len(credMap))
return credMap, enabledRegs
}
dbRegs, err := s.registryService.GetEnabledRegistries(ctx)
if err != nil {
- slog.DebugContext(ctx, "Failed to load enabled registries", slog.String("error", err.Error()))
+ slog.DebugContext(ctx, "Failed to load enabled registries", "error", err.Error())
return credMap, nil
}
enabledRegs = dbRegs
@@ -732,9 +707,7 @@ func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCre
}
dec, decErr := utils.Decrypt(r.Token)
if decErr != nil {
- slog.DebugContext(ctx, "Decrypt registry token failed",
- slog.String("registryURL", r.URL),
- slog.String("error", decErr.Error()))
+ slog.DebugContext(ctx, "Decrypt registry token failed", "registryURL", r.URL, "error", decErr.Error())
continue
}
if _, exists := credMap[host]; !exists {
@@ -754,21 +727,21 @@ func (s *ImageUpdateService) buildRegistryAuthMap(ctx context.Context, rc *regis
}
slog.DebugContext(ctx, "Building registry auth map",
- slog.Int("registryCount", len(regRepos)),
- slog.Any("registries", func() []string {
+ "registryCount", len(regRepos),
+ "registries", func() []string {
regs := make([]string, 0, len(regRepos))
for r := range regRepos {
regs = append(regs, r)
}
return regs
- }()),
- slog.Any("credMapKeys", func() []string {
+ }(),
+ "credMapKeys", func() []string {
keys := make([]string, 0, len(credMap))
for k := range credMap {
keys = append(keys, k)
}
return keys
- }()))
+ }())
for regHost, set := range regRepos {
repos := make([]string, 0, len(set))
@@ -778,9 +751,7 @@ func (s *ImageUpdateService) buildRegistryAuthMap(ctx context.Context, rc *regis
authURL, err := rc.CheckAuth(ctx, regHost)
if err != nil {
- slog.DebugContext(ctx, "Auth probe failed",
- slog.String("registry", regHost),
- slog.String("error", err.Error()))
+ slog.DebugContext(ctx, "Auth probe failed", "registry", regHost, "error", err.Error())
regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}
continue
}
@@ -793,15 +764,13 @@ func (s *ImageUpdateService) buildRegistryAuthMap(ctx context.Context, rc *regis
// Credential attempt first (if available)
host := normalizeHost(regHost)
slog.DebugContext(ctx, "Looking up credentials for registry",
- slog.String("registry", regHost),
- slog.String("normalizedHost", host),
- slog.Bool("hasCredentials", credMap[host].username != ""))
+ "registry", regHost,
+ "normalizedHost", host,
+ "hasCredentials", credMap[host].username != "")
if c, ok := credMap[host]; ok && c.username != "" && c.token != "" {
creds := &registry.Credentials{Username: c.username, Token: c.token}
if tok, tokErr := rc.GetTokenMulti(ctx, authURL, repos, creds); tokErr == nil && tok != "" {
- slog.InfoContext(ctx, "Using credential auth for registry",
- slog.String("registry", regHost),
- slog.String("username", c.username))
+ slog.InfoContext(ctx, "Using credential auth for registry", "registry", regHost, "username", c.username)
regAuthMap[regHost] = regAuth{
token: tok,
auth: &authDetails{Method: "credential", Username: c.username, Registry: regHost},
@@ -809,27 +778,25 @@ func (s *ImageUpdateService) buildRegistryAuthMap(ctx context.Context, rc *regis
continue
} else {
slog.WarnContext(ctx, "Failed to get token with credentials, falling back to anonymous",
- slog.String("registry", regHost),
- slog.String("username", c.username),
- slog.String("error", func() string {
+ "registry", regHost,
+ "username", c.username,
+ "error", func() string {
if tokErr != nil {
return tokErr.Error()
}
return "empty token"
- }()))
+ }())
}
}
// Anonymous multi-scope fallback
if anonToken, anonErr := rc.GetTokenMulti(ctx, authURL, repos, nil); anonErr == nil && anonToken != "" {
- slog.DebugContext(ctx, "Using anonymous auth for registry",
- slog.String("registry", regHost))
+ slog.DebugContext(ctx, "Using anonymous auth for registry", "registry", regHost)
regAuthMap[regHost] = regAuth{token: anonToken, auth: &authDetails{Method: "anonymous", Registry: regHost}}
continue
}
// Fallback unknown
- slog.DebugContext(ctx, "No valid credentials found for registry, using unknown auth",
- slog.String("registry", regHost))
+ slog.DebugContext(ctx, "No valid credentials found for registry, using unknown auth", "registry", regHost)
regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}
}
return regAuthMap
@@ -914,9 +881,7 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
return results, nil
}
- slog.DebugContext(ctx, "Starting batch image update check",
- slog.Int("imageCount", len(imageRefs)),
- slog.Int("externalCredCount", len(externalCreds)))
+ slog.DebugContext(ctx, "Starting batch image update check", "imageCount", len(imageRefs), "externalCredCount", len(externalCreds))
rc := registry.NewClient()
@@ -927,50 +892,41 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
credMap, enabledRegs := s.buildCredentialMap(ctx, externalCreds)
- slog.DebugContext(ctx, "Built credential map",
- slog.Int("credMapSize", len(credMap)),
- slog.Int("enabledRegsCount", len(enabledRegs)))
+ slog.DebugContext(ctx, "Built credential map", "credMapSize", len(credMap), "enabledRegsCount", len(enabledRegs))
regAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)
- outCh := make(chan struct {
- ref string
- res *dto.ImageUpdateResponse
- }, len(images))
+ var mu sync.Mutex
+ g, ctx := errgroup.WithContext(ctx)
+ g.SetLimit(10) // Limit concurrency
- wg := sync.WaitGroup{}
- wg.Add(len(images))
for _, img := range images {
- go func(bi batchImage) {
- defer wg.Done()
- res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, bi.parts)
- outCh <- struct {
- ref string
- res *dto.ImageUpdateResponse
- }{bi.ref, res}
- }(img)
- }
- wg.Wait()
- close(outCh)
-
- for item := range outCh {
- results[item.ref] = item.res
- if err := s.saveUpdateResult(ctx, item.ref, item.res); err != nil {
- slog.WarnContext(ctx, "Failed to save update result",
- slog.String("imageRef", item.ref),
- slog.String("error", err.Error()))
- }
+ g.Go(func() error {
+ res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, img.parts)
+
+ mu.Lock()
+ results[img.ref] = res
+ mu.Unlock()
+
+ if err := s.saveUpdateResult(ctx, img.ref, res); err != nil {
+ slog.WarnContext(ctx, "Failed to save update result", "imageRef", img.ref, "error", err.Error())
+ }
+ return nil
+ })
+ }
+
+ if err := g.Wait(); err != nil {
+ slog.ErrorContext(ctx, "Batch check error", "error", err)
}
slog.InfoContext(ctx, "Batch image update check completed",
- slog.Int("totalImages", len(imageRefs)),
- slog.Int("successCount", len(results)),
- slog.Duration("duration", time.Since(startBatch)))
+ "totalImages", len(imageRefs),
+ "successCount", len(results),
+ "duration", time.Since(startBatch))
if s.notificationService != nil {
if notifErr := s.notificationService.SendBatchImageUpdateNotification(ctx, results); notifErr != nil {
- slog.WarnContext(ctx, "Failed to send batch update notification",
- slog.String("error", notifErr.Error()))
+ slog.WarnContext(ctx, "Failed to send batch update notification", "error", notifErr.Error())
}
}
@@ -991,11 +947,10 @@ func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int, exte
}
func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
// Get all image IDs from Docker
dockerImages, err := dockerClient.ImageList(ctx, image.ListOptions{})
@@ -1008,39 +963,61 @@ func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {
dockerImageIDs[img.ID] = true
}
- // Get all update records from database
- var updateRecords []models.ImageUpdateRecord
- if err := s.db.WithContext(ctx).Find(&updateRecords).Error; err != nil {
- return fmt.Errorf("failed to query update records: %w", err)
- }
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var updateRecords []models.ImageUpdateRecord
+ if err := tx.Find(&updateRecords).Error; err != nil {
+ return fmt.Errorf("failed to query update records: %w", err)
+ }
- // Delete records for images that no longer exist in Docker
- orphanedCount := 0
- for _, record := range updateRecords {
- if !dockerImageIDs[record.ID] {
- if err := s.db.WithContext(ctx).Delete(&models.ImageUpdateRecord{}, "id = ?", record.ID).Error; err != nil {
- slog.WarnContext(ctx, "Failed to delete orphaned update record",
- slog.String("imageId", record.ID),
- slog.String("error", err.Error()))
- } else {
- orphanedCount++
+ var idsToDelete []string
+ for _, record := range updateRecords {
+ if !dockerImageIDs[record.ID] {
+ idsToDelete = append(idsToDelete, record.ID)
}
}
- }
-
- slog.InfoContext(ctx, "Cleaned up orphaned image update records",
- slog.Int("deletedCount", orphanedCount))
- return nil
+ if len(idsToDelete) > 0 {
+ if err := tx.Delete(&models.ImageUpdateRecord{}, "id IN ?", idsToDelete).Error; err != nil {
+ return fmt.Errorf("failed to delete orphaned records: %w", err)
+ }
+ slog.InfoContext(ctx, "Cleaned up orphaned image update records", "deletedCount", len(idsToDelete))
+ } else {
+ slog.InfoContext(ctx, "No orphaned image update records found")
+ }
+ return nil
+ })
}
func (s *ImageUpdateService) GetUpdateSummary(ctx context.Context) (*dto.ImageUpdateSummaryResponse, error) {
- var totalImages, imagesWithUpdates, digestUpdates, tagUpdates, errorsCount int64
- s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Count(&totalImages)
- s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ?", true).Count(&imagesWithUpdates)
- s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "digest").Count(&digestUpdates)
- s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "tag").Count(&tagUpdates)
- s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("last_error IS NOT NULL").Count(&errorsCount)
+ var (
+ totalImages int64
+ imagesWithUpdates int64
+ digestUpdates int64
+ tagUpdates int64
+ errorsCount int64
+ )
+
+ g, ctx := errgroup.WithContext(ctx)
+
+ g.Go(func() error {
+ return s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Count(&totalImages).Error
+ })
+ g.Go(func() error {
+ return s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ?", true).Count(&imagesWithUpdates).Error
+ })
+ g.Go(func() error {
+ return s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "digest").Count(&digestUpdates).Error
+ })
+ g.Go(func() error {
+ return s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "tag").Count(&tagUpdates).Error
+ })
+ g.Go(func() error {
+ return s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("last_error IS NOT NULL").Count(&errorsCount).Error
+ })
+
+ if err := g.Wait(); err != nil {
+ return nil, err
+ }
return &dto.ImageUpdateSummaryResponse{
TotalImages: int(totalImages),
diff --git a/backend/internal/services/network_service.go b/backend/internal/services/network_service.go
index ff509cefd..3c15391a5 100644
--- a/backend/internal/services/network_service.go
+++ b/backend/internal/services/network_service.go
@@ -30,11 +30,10 @@ func NewNetworkService(db *database.DB, dockerService *DockerClientService, even
}
func (s *NetworkService) GetNetworkByID(ctx context.Context, id string) (*network.Inspect, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
networkInspect, err := dockerClient.NetworkInspect(ctx, id, network.InspectOptions{})
if err != nil {
@@ -45,12 +44,11 @@ func (s *NetworkService) GetNetworkByID(ctx context.Context, id string) (*networ
}
func (s *NetworkService) CreateNetwork(ctx context.Context, name string, options network.CreateOptions, user models.User) (*network.CreateResponse, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeNetworkError, "network", "", name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
response, err := dockerClient.NetworkCreate(ctx, name, options)
if err != nil {
@@ -71,12 +69,11 @@ func (s *NetworkService) CreateNetwork(ctx context.Context, name string, options
}
func (s *NetworkService) RemoveNetwork(ctx context.Context, id string, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeNetworkError, "network", id, "", user.ID, user.Username, "0", err, models.JSON{"action": "delete"})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
networkInfo, err := dockerClient.NetworkInspect(ctx, id, network.InspectOptions{})
var networkName string
@@ -103,11 +100,10 @@ func (s *NetworkService) RemoveNetwork(ctx context.Context, id string, user mode
}
func (s *NetworkService) PruneNetworks(ctx context.Context) (*network.PruneReport, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
filterArgs := filters.NewArgs()
@@ -128,11 +124,10 @@ func (s *NetworkService) PruneNetworks(ctx context.Context) (*network.PruneRepor
}
func (s *NetworkService) ListNetworksPaginated(ctx context.Context, params pagination.QueryParams) ([]dto.NetworkSummaryDto, pagination.Response, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, pagination.Response{}, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.go
index b6dc126d7..3e3a63f83 100644
--- a/backend/internal/services/oidc_service.go
+++ b/backend/internal/services/oidc_service.go
@@ -15,6 +15,7 @@ import (
"github.com/coreos/go-oidc/v3/oidc"
"golang.org/x/oauth2"
+ "golang.org/x/sync/singleflight"
"github.com/ofkm/arcane-backend/internal/config"
"github.com/ofkm/arcane-backend/internal/dto"
@@ -29,6 +30,7 @@ type OidcService struct {
providerCache *oidc.Provider
providerMutex sync.RWMutex
cachedIssuer string
+ sfGroup singleflight.Group
}
type OidcState struct {
@@ -43,10 +45,16 @@ func NewOidcService(authService *AuthService, cfg *config.Config, httpClient *ht
if httpClient == nil {
httpClient = http.DefaultClient
}
+
+ // Create a copy of the client to avoid modifying the shared one
+ // and remove the timeout so we can control it via context
+ oidcClient := *httpClient
+ oidcClient.Timeout = 0
+
return &OidcService{
authService: authService,
config: cfg,
- httpClient: httpClient,
+ httpClient: &oidcClient,
}
}
@@ -75,6 +83,22 @@ func (s *OidcService) ensureOpenIDScope(scopes []string) []string {
return scopes
}
+func (s *OidcService) getOauth2Config(cfg *models.OidcConfig, provider *oidc.Provider) oauth2.Config {
+ scopes := strings.Fields(cfg.Scopes)
+ if len(scopes) == 0 {
+ scopes = []string{"email", "profile"}
+ }
+ scopes = s.ensureOpenIDScope(scopes)
+
+ return oauth2.Config{
+ ClientID: cfg.ClientID,
+ ClientSecret: cfg.ClientSecret,
+ Endpoint: provider.Endpoint(),
+ RedirectURL: s.GetOidcRedirectURL(),
+ Scopes: scopes,
+ }
+}
+
func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (string, string, error) {
config, err := s.getEffectiveConfig(ctx)
if err != nil {
@@ -92,19 +116,7 @@ func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (s
nonce := utils.GenerateRandomString(32)
codeVerifier := utils.GenerateRandomString(128)
- scopes := strings.Fields(config.Scopes)
- if len(scopes) == 0 {
- scopes = []string{"email", "profile"}
- }
- scopes = s.ensureOpenIDScope(scopes)
-
- oauth2Config := oauth2.Config{
- ClientID: config.ClientID,
- ClientSecret: config.ClientSecret,
- Endpoint: provider.Endpoint(),
- RedirectURL: s.GetOidcRedirectURL(),
- Scopes: scopes,
- }
+ oauth2Config := s.getOauth2Config(config, provider)
authURL := oauth2Config.AuthCodeURL(state,
oauth2.SetAuthURLParam("nonce", nonce),
@@ -126,7 +138,7 @@ func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (s
}
encodedState := base64.URLEncoding.EncodeToString(stateJSON)
- slog.Debug("GenerateAuthURL: generated authorization URL", "issuer", config.IssuerURL, "scopes", scopes)
+ slog.Debug("GenerateAuthURL: generated authorization URL", "issuer", config.IssuerURL, "scopes", oauth2Config.Scopes)
return authURL, encodedState, nil
}
@@ -144,41 +156,50 @@ func (s *OidcService) getOrDiscoverProvider(ctx context.Context, issuer string)
}
s.providerMutex.RUnlock()
- s.providerMutex.Lock()
- defer s.providerMutex.Unlock()
+ // Use singleflight to prevent thundering herd
+ v, err, _ := s.sfGroup.Do(issuer, func() (interface{}, error) {
+ // Double check inside the lock/singleflight
+ s.providerMutex.RLock()
+ if s.providerCache != nil && s.cachedIssuer == issuer {
+ provider := s.providerCache
+ s.providerMutex.RUnlock()
+ return provider, nil
+ }
+ s.providerMutex.RUnlock()
- if s.providerCache != nil && s.cachedIssuer == issuer {
- return s.providerCache, nil
- }
+ // Create a context with a longer timeout for discovery
+ // We use context.WithoutCancel(ctx) as the parent because we don't want the discovery
+ // to be cancelled if the incoming request context is cancelled (e.g. client disconnect).
+ // This ensures the provider is cached for subsequent requests.
+ discoveryCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
+ defer cancel()
+
+ // Use the custom HTTP client with the new context
+ providerCtx := oidc.ClientContext(discoveryCtx, s.httpClient)
+ provider, err := oidc.NewProvider(providerCtx, issuer)
+ if err != nil {
+ slog.ErrorContext(ctx, "getOrDiscoverProvider: discovery failed", "issuer", issuer, "error", err)
+ return nil, fmt.Errorf("failed to discover provider at %s: %w", issuer, err)
+ }
+
+ s.providerMutex.Lock()
+ s.providerCache = provider
+ s.cachedIssuer = issuer
+ s.providerMutex.Unlock()
+
+ slog.DebugContext(ctx, "getOrDiscoverProvider: provider cached", "issuer", issuer)
+ return provider, nil
+ })
- providerCtx := oidc.ClientContext(ctx, s.httpClient)
- provider, err := oidc.NewProvider(providerCtx, issuer)
if err != nil {
- slog.Error("getOrDiscoverProvider: discovery failed", "issuer", issuer, "error", err)
- return nil, fmt.Errorf("failed to discover provider at %s: %w", issuer, err)
+ return nil, err
}
- s.providerCache = provider
- s.cachedIssuer = issuer
- slog.Debug("getOrDiscoverProvider: provider cached", "issuer", issuer)
-
- return provider, nil
+ return v.(*oidc.Provider), nil
}
func (s *OidcService) exchangeToken(ctx context.Context, cfg *models.OidcConfig, provider *oidc.Provider, code string, verifier string) (*oauth2.Token, error) {
- scopes := strings.Fields(cfg.Scopes)
- if len(scopes) == 0 {
- scopes = []string{"email", "profile"}
- }
- scopes = s.ensureOpenIDScope(scopes)
-
- oauth2Config := oauth2.Config{
- ClientID: cfg.ClientID,
- ClientSecret: cfg.ClientSecret,
- Endpoint: provider.Endpoint(),
- RedirectURL: s.GetOidcRedirectURL(),
- Scopes: scopes,
- }
+ oauth2Config := s.getOauth2Config(cfg, provider)
providerCtx := oidc.ClientContext(ctx, s.httpClient)
token, err := oauth2Config.Exchange(providerCtx, code, oauth2.VerifierOption(verifier))
@@ -238,20 +259,9 @@ func (s *OidcService) fetchClaims(ctx context.Context, provider *oidc.Provider,
func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedState string) (*dto.OidcUserInfo, *dto.OidcTokenResponse, error) {
slog.Debug("HandleCallback: processing callback", "code_present", code != "", "state_present", state != "")
- stateData, err := s.decodeState(storedState)
+ stateData, err := s.validateState(state, storedState)
if err != nil {
- slog.Error("HandleCallback: failed to decode stored state", "error", err)
- return nil, nil, fmt.Errorf("invalid state parameter: %w", err)
- }
-
- if state != stateData.State {
- slog.Error("HandleCallback: state mismatch", "received_len", len(state), "expected_len", len(stateData.State))
- return nil, nil, errors.New("state parameter mismatch")
- }
-
- if time.Since(stateData.CreatedAt) > 10*time.Minute {
- slog.Error("HandleCallback: state expired", "age", time.Since(stateData.CreatedAt))
- return nil, nil, errors.New("authentication state has expired")
+ return nil, nil, err
}
cfg, err := s.getEffectiveConfig(ctx)
@@ -270,6 +280,34 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta
return nil, nil, err
}
+ idToken, rawIDToken, err := s.verifyIDToken(ctx, provider, cfg, token, stateData.Nonce)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return s.buildUserInfo(ctx, provider, token, idToken, rawIDToken)
+}
+
+func (s *OidcService) validateState(state, storedState string) (*OidcState, error) {
+ stateData, err := s.decodeState(storedState)
+ if err != nil {
+ slog.Error("HandleCallback: failed to decode stored state", "error", err)
+ return nil, fmt.Errorf("invalid state parameter: %w", err)
+ }
+
+ if state != stateData.State {
+ slog.Error("HandleCallback: state mismatch", "received_len", len(state), "expected_len", len(stateData.State))
+ return nil, errors.New("state parameter mismatch")
+ }
+
+ if time.Since(stateData.CreatedAt) > 10*time.Minute {
+ slog.Error("HandleCallback: state expired", "age", time.Since(stateData.CreatedAt))
+ return nil, errors.New("authentication state has expired")
+ }
+ return stateData, nil
+}
+
+func (s *OidcService) verifyIDToken(ctx context.Context, provider *oidc.Provider, cfg *models.OidcConfig, token *oauth2.Token, nonce string) (*oidc.IDToken, string, error) {
var rawIDToken string
if idTokenValue := token.Extra("id_token"); idTokenValue != nil {
if idTokenStr, ok := idTokenValue.(string); ok {
@@ -277,44 +315,47 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta
}
}
- var idToken *oidc.IDToken
if rawIDToken == "" {
slog.Warn("HandleCallback: no ID token in response (non-compliant OIDC response)")
- } else {
- verifierConfig := &oidc.Config{
- ClientID: cfg.ClientID,
- }
+ return nil, "", nil
+ }
- if stateData.Nonce != "" {
- verifierConfig.Now = time.Now
- }
+ verifierConfig := &oidc.Config{
+ ClientID: cfg.ClientID,
+ }
- verifier := provider.Verifier(verifierConfig)
- providerCtx := oidc.ClientContext(ctx, s.httpClient)
+ if nonce != "" {
+ verifierConfig.Now = time.Now
+ }
- idToken, err = verifier.Verify(providerCtx, rawIDToken)
- if err != nil {
- slog.Error("HandleCallback: ID token verification failed", "error", err)
- return nil, nil, fmt.Errorf("failed to verify ID token: %w", err)
- }
+ verifier := provider.Verifier(verifierConfig)
+ providerCtx := oidc.ClientContext(ctx, s.httpClient)
- if stateData.Nonce != "" {
- var claims struct {
- Nonce string `json:"nonce"`
- }
- if err := idToken.Claims(&claims); err != nil {
- slog.Error("HandleCallback: failed to extract nonce from ID token", "error", err)
- return nil, nil, fmt.Errorf("failed to verify nonce: %w", err)
- }
- if claims.Nonce != stateData.Nonce {
- slog.Error("HandleCallback: nonce mismatch", "expected", stateData.Nonce, "got", claims.Nonce)
- return nil, nil, errors.New("nonce verification failed")
- }
- }
+ idToken, err := verifier.Verify(providerCtx, rawIDToken)
+ if err != nil {
+ slog.Error("HandleCallback: ID token verification failed", "error", err)
+ return nil, "", fmt.Errorf("failed to verify ID token: %w", err)
+ }
- slog.Debug("HandleCallback: ID token verified successfully", "subject", idToken.Subject, "issuer", idToken.Issuer)
+ if nonce != "" {
+ var claims struct {
+ Nonce string `json:"nonce"`
+ }
+ if err := idToken.Claims(&claims); err != nil {
+ slog.Error("HandleCallback: failed to extract nonce from ID token", "error", err)
+ return nil, "", fmt.Errorf("failed to verify nonce: %w", err)
+ }
+ if claims.Nonce != nonce {
+ slog.Error("HandleCallback: nonce mismatch", "expected", nonce, "got", claims.Nonce)
+ return nil, "", errors.New("nonce verification failed")
+ }
}
+ slog.Debug("HandleCallback: ID token verified successfully", "subject", idToken.Subject, "issuer", idToken.Issuer)
+ return idToken, rawIDToken, nil
+}
+
+func (s *OidcService) buildUserInfo(ctx context.Context, provider *oidc.Provider, token *oauth2.Token, idToken *oidc.IDToken, rawIDToken string) (*dto.OidcUserInfo, *dto.OidcTokenResponse, error) {
claims, err := s.fetchClaims(ctx, provider, token, idToken)
if err != nil {
slog.Error("HandleCallback: failed to fetch claims", "error", err)
@@ -364,85 +405,6 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta
return &userInfoDto, tokenResp, nil
}
-func (s *OidcService) RefreshToken(ctx context.Context, refreshToken string) (*dto.OidcTokenResponse, error) {
- if refreshToken == "" {
- return nil, errors.New("refresh token is required")
- }
-
- cfg, err := s.getEffectiveConfig(ctx)
- if err != nil {
- slog.Error("RefreshToken: failed to get OIDC config", "error", err)
- return nil, err
- }
-
- provider, err := s.getOrDiscoverProvider(ctx, cfg.IssuerURL)
- if err != nil {
- return nil, err
- }
-
- scopes := strings.Fields(cfg.Scopes)
- if len(scopes) == 0 {
- scopes = []string{"email", "profile"}
- }
- scopes = s.ensureOpenIDScope(scopes)
-
- oauth2Config := oauth2.Config{
- ClientID: cfg.ClientID,
- ClientSecret: cfg.ClientSecret,
- Endpoint: provider.Endpoint(),
- RedirectURL: s.GetOidcRedirectURL(),
- Scopes: scopes,
- }
-
- oldToken := &oauth2.Token{
- RefreshToken: refreshToken,
- }
-
- providerCtx := oidc.ClientContext(ctx, s.httpClient)
- tokenSource := oauth2Config.TokenSource(providerCtx, oldToken)
-
- newToken, err := tokenSource.Token()
- if err != nil {
- slog.Error("RefreshToken: token refresh failed", "error", err)
- return nil, fmt.Errorf("failed to refresh access token: %w", err)
- }
-
- tokenType := newToken.TokenType
- if tokenType == "" {
- tokenType = "Bearer"
- }
-
- var rawIDToken string
- if idTokenValue := newToken.Extra("id_token"); idTokenValue != nil {
- if idTokenStr, ok := idTokenValue.(string); ok {
- rawIDToken = idTokenStr
- }
- }
-
- tokenResp := &dto.OidcTokenResponse{
- AccessToken: newToken.AccessToken,
- TokenType: tokenType,
- RefreshToken: newToken.RefreshToken,
- IDToken: rawIDToken,
- }
-
- if !newToken.Expiry.IsZero() {
- expiresIn := int(time.Until(newToken.Expiry).Seconds())
- if expiresIn < 0 {
- expiresIn = 0
- }
- tokenResp.ExpiresIn = expiresIn
- }
-
- if tokenResp.RefreshToken == "" {
- tokenResp.RefreshToken = refreshToken
- slog.Debug("RefreshToken: no new refresh token issued, reusing existing")
- }
-
- slog.Info("RefreshToken: token refresh successful", "has_new_refresh_token", newToken.RefreshToken != "")
- return tokenResp, nil
-}
-
func (s *OidcService) decodeState(encodedState string) (*OidcState, error) {
stateJSON, err := base64.URLEncoding.DecodeString(encodedState)
if err != nil {
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 62b0a4022..772bbfa6f 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -14,6 +14,7 @@ import (
"github.com/compose-spec/compose-go/v2/loader"
"github.com/docker/compose/v2/pkg/api"
+ "github.com/docker/docker/api/types/container"
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/models"
@@ -405,11 +406,25 @@ func formatPorts(publishers []api.PortPublisher) []string {
for _, pub := range publishers {
if pub.PublishedPort > 0 {
ports = append(ports, fmt.Sprintf("%d:%d/%s", pub.PublishedPort, pub.TargetPort, pub.Protocol))
+ } else {
+ ports = append(ports, fmt.Sprintf("%d/%s", pub.TargetPort, pub.Protocol))
}
}
return ports
}
+func formatDockerPorts(ports []container.Port) []string {
+ var res []string
+ for _, p := range ports {
+ if p.PublicPort == 0 {
+ res = append(res, fmt.Sprintf("%d/%s", p.PrivatePort, p.Type))
+ } else {
+ res = append(res, fmt.Sprintf("%d:%d/%s", p.PublicPort, p.PrivatePort, p.Type))
+ }
+ }
+ return res
+}
+
func (s *ProjectService) countProjectFolders(ctx context.Context) (int, error) {
projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "data/projects")
projectsDir, err := fs.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
@@ -468,47 +483,73 @@ func (s *ProjectService) GetProjectStatusCounts(ctx context.Context) (folderCoun
}
totalProjects = len(projectsList)
+ runningProjects = 0
+ stoppedProjects = 0
- type statusResult struct {
- status models.ProjectStatus
+ // 1. Fetch all compose containers
+ containers, err := projects.ListGlobalComposeContainers(ctx)
+ if err != nil {
+ slog.ErrorContext(ctx, "Failed to list global compose containers for counts", "error", err)
+ // Fallback to DB status
+ for _, p := range projectsList {
+ s.incrementStatusCounts(p.Status, &runningProjects, &stoppedProjects)
+ }
+ return folderCount, runningProjects, stoppedProjects, totalProjects, nil
}
- resultChan := make(chan statusResult, totalProjects)
- semaphore := make(chan struct{}, 10)
- queryCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
- defer cancel()
-
- for _, proj := range projectsList {
- go func(p models.Project) {
- semaphore <- struct{}{}
- defer func() { <-semaphore }()
-
- projectCtx, projectCancel := context.WithTimeout(queryCtx, 2*time.Second)
- defer projectCancel()
-
- services, serr := s.getProjectServicesWithTimeout(projectCtx, p.ID)
- if serr != nil {
- resultChan <- statusResult{status: p.Status}
- return
- }
-
- resultChan <- statusResult{status: s.calculateProjectStatus(services)}
- }(proj)
+ // 2. Group by project
+ containersByProject := make(map[string][]container.Summary)
+ for _, c := range containers {
+ projName := c.Labels["com.docker.compose.project"]
+ if projName != "" {
+ containersByProject[projName] = append(containersByProject[projName], c)
+ }
}
- runningProjects = 0
- stoppedProjects = 0
+ // 3. Calculate status for each project
+ for _, p := range projectsList {
+ normName := normalizeComposeProjectName(p.Name)
+ projectContainers := containersByProject[normName]
- for i := 0; i < totalProjects; i++ {
- select {
- case res := <-resultChan:
- s.incrementStatusCounts(res.status, &runningProjects, &stoppedProjects)
- case <-queryCtx.Done():
- for j := i; j < totalProjects; j++ {
- s.incrementStatusCounts(projectsList[j].Status, &runningProjects, &stoppedProjects)
+ // Convert to ProjectServiceInfo (minimal needed for calculateProjectStatus)
+ var services []ProjectServiceInfo
+ for _, c := range projectContainers {
+ services = append(services, ProjectServiceInfo{
+ Status: c.State,
+ })
+ }
+
+ var status models.ProjectStatus
+ if len(services) == 0 {
+ status = models.ProjectStatusStopped
+ } else {
+ // We have containers, calculate status based on their state
+ // Note: calculateProjectStatus doesn't know about "missing" services (ServiceCount)
+ // So we need to check if runningCount == p.ServiceCount here if we want strict "Running"
+
+ // Re-implement logic here to be safe or rely on calculateProjectStatus?
+ // calculateProjectStatus returns Running if ALL *present* containers are running.
+ // But if we have 2/3 containers running, it returns Running? No.
+ // calculateProjectStatus: if runningCount == len(services) -> Running.
+ // But len(services) is only the *running* containers (or present ones).
+ // If we have 3 services defined, but only 2 containers exist (both running),
+ // calculateProjectStatus will say "Running".
+ // But strictly it should be "Partial" or "Restarting" or something.
+
+ // However, for the dashboard count, "Running" usually means "Healthy".
+ // Let's stick to calculateProjectStatus for consistency with previous logic,
+ // but maybe check ServiceCount.
+
+ st := s.calculateProjectStatus(services)
+
+ // Refine: if all containers are running, but we have fewer containers than defined services
+ if st == models.ProjectStatusRunning && len(services) < p.ServiceCount {
+ st = models.ProjectStatusPartiallyRunning
}
- return folderCount, runningProjects, stoppedProjects, totalProjects, nil
+ status = st
}
+
+ s.incrementStatusCounts(status, &runningProjects, &stoppedProjects)
}
return folderCount, runningProjects, stoppedProjects, totalProjects, nil
@@ -981,143 +1022,148 @@ func (s *ProjectService) ListProjects(ctx context.Context, params pagination.Que
}
// fetchProjectStatusConcurrently fetches live Docker status for multiple projects in parallel
-func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, projects []models.Project) []dto.ProjectDetailsDto {
- type projectResult struct {
- index int
- dto dto.ProjectDetailsDto
- }
-
- resultChan := make(chan projectResult, len(projects))
-
- const (
- concurrency = 10
- perProjectTimeout = 3 * time.Second
- minGlobalTimeout = 30 * time.Second
- )
-
- // Calculate dynamic timeout: (projects / concurrency) * per-project-timeout * 1.5 buffer
- projectBatches := (len(projects) + concurrency - 1) / concurrency // Ceiling division
- calculatedTimeout := time.Duration(projectBatches) * perProjectTimeout * 3 / 2
- globalTimeout := minGlobalTimeout
- if calculatedTimeout > globalTimeout {
- globalTimeout = calculatedTimeout
- }
-
- semaphore := make(chan struct{}, concurrency)
-
- queryCtx, cancel := context.WithTimeout(ctx, globalTimeout)
- defer cancel()
-
- slog.DebugContext(ctx, "Starting concurrent project status queries",
- "project_count", len(projects),
- "concurrency", concurrency,
- "per_project_timeout_sec", perProjectTimeout.Seconds(),
- "global_timeout_sec", globalTimeout.Seconds())
-
- // Launch goroutine for each project
- for i, project := range projects {
- go func(idx int, proj models.Project) {
- semaphore <- struct{}{} // Acquire semaphore
- defer func() { <-semaphore }() // Release semaphore
-
- // Create per-project timeout
- projectCtx, projectCancel := context.WithTimeout(queryCtx, perProjectTimeout)
- defer projectCancel()
-
- displayServiceCount := proj.ServiceCount
- displayRunningCount := proj.RunningCount
- displayStatus := string(proj.Status)
- var statusReason *string
-
- // Try to get live status from Docker
- if services, serr := s.getProjectServicesWithTimeout(projectCtx, proj.ID); serr == nil {
- displayServiceCount = len(services)
- _, displayRunningCount = s.getServiceCounts(services)
- displayStatus = string(s.calculateProjectStatus(services))
-
- if displayStatus == string(models.ProjectStatusUnknown) && len(services) == 0 {
- reason := "No services found in project"
- statusReason = &reason
- }
- } else {
- // On timeout or error, use cached values
- if errors.Is(serr, context.DeadlineExceeded) {
- reason := "Status query timed out, showing cached status"
- statusReason = &reason
- displayStatus = string(proj.Status)
- } else if !errors.Is(serr, context.Canceled) {
- displayStatus = string(proj.Status)
- if proj.StatusReason != nil {
- statusReason = proj.StatusReason
- }
- slog.WarnContext(projectCtx, "Failed to get live project status, using cached",
- "project_id", proj.ID,
- "project_name", proj.Name,
- "error", serr)
- }
- }
+// Optimized to use a single Docker API call instead of N calls + N file reads
+func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, projectsList []models.Project) []dto.ProjectDetailsDto {
+ // 1. Fetch all compose containers in one go
+ containers, err := projects.ListGlobalComposeContainers(ctx)
+ if err != nil {
+ slog.ErrorContext(ctx, "Failed to list global compose containers", "error", err)
+ // Fallback: return basic info with unknown status
+ results := make([]dto.ProjectDetailsDto, len(projectsList))
+ for i, p := range projectsList {
+ _ = dto.MapStruct(p, &results[i])
+ results[i].Status = string(models.ProjectStatusUnknown)
+ }
+ return results
+ }
- resultChan <- projectResult{
- index: idx,
- dto: dto.ProjectDetailsDto{
- ID: proj.ID,
- Name: proj.Name,
- DirName: utils.DerefString(proj.DirName),
- Path: proj.Path,
- Status: displayStatus,
- StatusReason: statusReason,
- ServiceCount: displayServiceCount,
- RunningCount: displayRunningCount,
- CreatedAt: proj.CreatedAt.Format(time.RFC3339),
- UpdatedAt: proj.UpdatedAt.Format(time.RFC3339),
- },
- }
- }(i, project)
- }
-
- // Collect results
- results := make([]dto.ProjectDetailsDto, len(projects))
- for i := 0; i < len(projects); i++ {
- select {
- case res := <-resultChan:
- results[res.index] = res.dto
- case <-queryCtx.Done():
- // Timeout - fill remaining with cached data
- remainingCount := len(projects) - i
- slog.WarnContext(ctx, "Project list query timed out, using cached data for remaining projects",
- "completed_count", i,
- "remaining_count", remainingCount,
- "total_projects", len(projects))
-
- for j := i; j < len(projects); j++ {
- proj := projects[j]
- results[j] = dto.ProjectDetailsDto{
- ID: proj.ID,
- Name: proj.Name,
- DirName: utils.DerefString(proj.DirName),
- Path: proj.Path,
- Status: string(proj.Status),
- StatusReason: proj.StatusReason,
- ServiceCount: proj.ServiceCount,
- RunningCount: proj.RunningCount,
- CreatedAt: proj.CreatedAt.Format(time.RFC3339),
- UpdatedAt: proj.UpdatedAt.Format(time.RFC3339),
- }
- }
- return results
+ // 2. Group containers by project name
+ containersByProject := make(map[string][]container.Summary)
+ for _, c := range containers {
+ projName := c.Labels["com.docker.compose.project"]
+ if projName != "" {
+ containersByProject[projName] = append(containersByProject[projName], c)
}
}
+ // 3. Map to DTOs
+ results := make([]dto.ProjectDetailsDto, len(projectsList))
+ for i, p := range projectsList {
+ results[i] = s.mapProjectToDto(ctx, p, containersByProject)
+ }
+
return results
}
-// getProjectServicesWithTimeout is a wrapper that respects context timeout
-func (s *ProjectService) getProjectServicesWithTimeout(ctx context.Context, projectID string) ([]ProjectServiceInfo, error) {
- return s.GetProjectServices(ctx, projectID)
+func (s *ProjectService) mapProjectToDto(ctx context.Context, p models.Project, containersByProject map[string][]container.Summary) dto.ProjectDetailsDto {
+ var resp dto.ProjectDetailsDto
+ _ = dto.MapStruct(p, &resp)
+
+ resp.CreatedAt = p.CreatedAt.Format(time.RFC3339)
+ resp.UpdatedAt = p.UpdatedAt.Format(time.RFC3339)
+ resp.DirName = utils.DerefString(p.DirName)
+
+ // Find containers for this project
+ normName := normalizeComposeProjectName(p.Name)
+ projectContainers := containersByProject[normName]
+
+ var services []ProjectServiceInfo
+ runningCount := 0
+
+ for _, c := range projectContainers {
+ svcName := c.Labels["com.docker.compose.service"]
+ state := c.State // "running", "exited", etc.
+
+ // Parse health from Status string if possible
+ var health *string
+ statusLower := strings.ToLower(c.Status)
+ switch {
+ case strings.Contains(statusLower, "(healthy)"):
+ h := "healthy"
+ health = &h
+ case strings.Contains(statusLower, "(unhealthy)"):
+ h := "unhealthy"
+ health = &h
+ case strings.Contains(statusLower, "(starting)"):
+ h := "starting"
+ health = &h
+ }
+
+ containerName := ""
+ if len(c.Names) > 0 {
+ containerName = strings.TrimPrefix(c.Names[0], "/")
+ }
+
+ services = append(services, ProjectServiceInfo{
+ Name: svcName,
+ Image: c.Image,
+ Status: state,
+ ContainerID: c.ID,
+ ContainerName: containerName,
+ Ports: formatDockerPorts(c.Ports),
+ Health: health,
+ })
+
+ if state == "running" {
+ runningCount++
+ }
+ }
+
+ resp.Services = make([]any, len(services))
+ for k, s := range services {
+ resp.Services[k] = s
+ }
+
+ // Use DB service count as the source of truth for "Total Services"
+ // since we are not parsing the YAML here.
+ resp.ServiceCount = p.ServiceCount
+ resp.RunningCount = runningCount
+
+ // Fix for missing service count (e.g. newly discovered projects)
+ if resp.ServiceCount == 0 {
+ if count, err := s.countServicesFromCompose(ctx, p); err == nil && count > 0 {
+ resp.ServiceCount = count
+ // Update DB asynchronously
+ go func(ctx context.Context, pid string, c int) {
+ s.db.WithContext(ctx).Model(&models.Project{}).Where("id = ?", pid).Update("service_count", c)
+ }(context.WithoutCancel(ctx), p.ID, count)
+ }
+ }
+
+ // Calculate Status
+ if len(services) == 0 {
+ resp.Status = string(models.ProjectStatusStopped)
+ } else {
+ switch {
+ case runningCount >= resp.ServiceCount && resp.ServiceCount > 0:
+ resp.Status = string(models.ProjectStatusRunning)
+ case runningCount > 0:
+ resp.Status = string(models.ProjectStatusPartiallyRunning)
+ default:
+ resp.Status = string(models.ProjectStatusStopped)
+ }
+ }
+
+ return resp
}
// End Table Functions
+func (s *ProjectService) countServicesFromCompose(ctx context.Context, p models.Project) (int, error) {
+ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "data/projects")
+ projectsDirectory, err := fs.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
+ if err != nil {
+ return 0, err
+ }
+
+ proj, _, err := projects.LoadComposeProjectFromDir(ctx, p.Path, normalizeComposeProjectName(p.Name), projectsDirectory)
+ if err != nil {
+ return 0, err
+ }
+
+ return len(proj.Services), nil
+}
+
func (s *ProjectService) calculateProjectStatus(services []ProjectServiceInfo) models.ProjectStatus {
if len(services) == 0 {
return models.ProjectStatusUnknown
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
new file mode 100644
index 000000000..6b8534acf
--- /dev/null
+++ b/backend/internal/services/project_service_test.go
@@ -0,0 +1,254 @@
+package services
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/docker/docker/api/types/container"
+ glsqlite "github.com/glebarez/sqlite"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "gorm.io/gorm"
+
+ "github.com/ofkm/arcane-backend/internal/database"
+ "github.com/ofkm/arcane-backend/internal/models"
+)
+
+func setupProjectTestDB(t *testing.T) *database.DB {
+ t.Helper()
+ db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, db.AutoMigrate(&models.Project{}, &models.SettingVariable{}))
+ return &database.DB{DB: db}
+}
+
+func TestProjectService_GetProjectFromDatabaseByID(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ // Setup dependencies
+ settingsService, _ := NewSettingsService(ctx, db)
+ svc := NewProjectService(db, settingsService, nil, nil)
+
+ // Create test project
+ proj := &models.Project{
+ BaseModel: models.BaseModel{
+ ID: "p1",
+ },
+ Name: "test-project",
+ Path: "/tmp/test-project",
+ }
+ require.NoError(t, db.Create(proj).Error)
+
+ // Test success
+ found, err := svc.GetProjectFromDatabaseByID(ctx, "p1")
+ require.NoError(t, err)
+ assert.Equal(t, "test-project", found.Name)
+
+ // Test not found
+ _, err = svc.GetProjectFromDatabaseByID(ctx, "non-existent")
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "project not found")
+}
+
+func TestProjectService_GetServiceCounts(t *testing.T) {
+ svc := &ProjectService{}
+
+ tests := []struct {
+ name string
+ services []ProjectServiceInfo
+ wantTotal int
+ wantRunning int
+ }{
+ {
+ name: "mixed status",
+ services: []ProjectServiceInfo{
+ {Name: "s1", Status: "running"},
+ {Name: "s2", Status: "exited"},
+ {Name: "s3", Status: "up"},
+ },
+ wantTotal: 3,
+ wantRunning: 2,
+ },
+ {
+ name: "all stopped",
+ services: []ProjectServiceInfo{
+ {Name: "s1", Status: "exited"},
+ },
+ wantTotal: 1,
+ wantRunning: 0,
+ },
+ {
+ name: "empty",
+ services: []ProjectServiceInfo{},
+ wantTotal: 0,
+ wantRunning: 0,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ total, running := svc.getServiceCounts(tt.services)
+ assert.Equal(t, tt.wantTotal, total)
+ assert.Equal(t, tt.wantRunning, running)
+ })
+ }
+}
+
+func TestProjectService_CalculateProjectStatus(t *testing.T) {
+ svc := &ProjectService{}
+
+ tests := []struct {
+ name string
+ services []ProjectServiceInfo
+ want models.ProjectStatus
+ }{
+ {
+ name: "empty",
+ services: []ProjectServiceInfo{},
+ want: models.ProjectStatusUnknown,
+ },
+ {
+ name: "all running",
+ services: []ProjectServiceInfo{
+ {Status: "running"},
+ {Status: "up"},
+ },
+ want: models.ProjectStatusRunning,
+ },
+ {
+ name: "all stopped",
+ services: []ProjectServiceInfo{
+ {Status: "exited"},
+ {Status: "stopped"},
+ },
+ want: models.ProjectStatusStopped,
+ },
+ {
+ name: "partial",
+ services: []ProjectServiceInfo{
+ {Status: "running"},
+ {Status: "exited"},
+ },
+ want: models.ProjectStatusPartiallyRunning,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := svc.calculateProjectStatus(tt.services)
+ assert.Equal(t, tt.want, got)
+ })
+ }
+}
+
+func TestProjectService_UpdateProjectStatusInternal(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ svc := NewProjectService(db, nil, nil, nil)
+
+ proj := &models.Project{
+ BaseModel: models.BaseModel{
+ ID: "p1",
+ },
+ Status: models.ProjectStatusUnknown,
+ }
+ require.NoError(t, db.Create(proj).Error)
+
+ err := svc.updateProjectStatusInternal(ctx, "p1", models.ProjectStatusRunning)
+ require.NoError(t, err)
+
+ var updated models.Project
+ require.NoError(t, db.First(&updated, "id = ?", "p1").Error)
+ assert.Equal(t, models.ProjectStatusRunning, updated.Status)
+ if updated.UpdatedAt != nil {
+ assert.WithinDuration(t, time.Now(), *updated.UpdatedAt, time.Second)
+ } else {
+ t.Error("UpdatedAt should not be nil")
+ }
+}
+
+func TestProjectService_IncrementStatusCounts(t *testing.T) {
+ svc := &ProjectService{}
+ running := 0
+ stopped := 0
+
+ svc.incrementStatusCounts(models.ProjectStatusRunning, &running, &stopped)
+ assert.Equal(t, 1, running)
+ assert.Equal(t, 0, stopped)
+
+ svc.incrementStatusCounts(models.ProjectStatusStopped, &running, &stopped)
+ assert.Equal(t, 1, running)
+ assert.Equal(t, 1, stopped)
+
+ svc.incrementStatusCounts(models.ProjectStatusUnknown, &running, &stopped)
+ assert.Equal(t, 1, running)
+ assert.Equal(t, 1, stopped)
+}
+
+func TestProjectService_FormatDockerPorts(t *testing.T) {
+ tests := []struct {
+ name string
+ input []container.Port
+ expected []string
+ }{
+ {
+ name: "public port",
+ input: []container.Port{
+ {PublicPort: 8080, PrivatePort: 80, Type: "tcp"},
+ },
+ expected: []string{"8080:80/tcp"},
+ },
+ {
+ name: "private only",
+ input: []container.Port{
+ {PrivatePort: 80, Type: "tcp"},
+ },
+ expected: []string{"80/tcp"},
+ },
+ {
+ name: "empty",
+ input: []container.Port{},
+ expected: nil,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := formatDockerPorts(tt.input)
+ assert.Equal(t, tt.expected, got)
+ })
+ }
+}
+
+func TestProjectService_NormalizeComposeProjectName(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ expected string
+ }{
+ {
+ name: "simple",
+ input: "myproject",
+ expected: "myproject",
+ },
+ {
+ name: "with special chars",
+ input: "My Project!",
+ expected: "myproject",
+ },
+ {
+ name: "empty",
+ input: "",
+ expected: "",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := normalizeComposeProjectName(tt.input)
+ assert.Equal(t, tt.expected, got)
+ })
+ }
+}
diff --git a/backend/internal/services/settings_service.go b/backend/internal/services/settings_service.go
index 707e40c12..048d8fda7 100644
--- a/backend/internal/services/settings_service.go
+++ b/backend/internal/services/settings_service.go
@@ -10,6 +10,7 @@ import (
"log/slog"
"os"
"reflect"
+ "strconv"
"strings"
"sync/atomic"
"time"
@@ -108,7 +109,6 @@ func (s *SettingsService) getDefaultSettings() *models.Settings {
}
func (s *SettingsService) loadDatabaseSettingsInternal(ctx context.Context, db *database.DB) (*models.Settings, error) {
-
if config.Load().UIConfigurationDisabled || config.Load().AgentMode {
slog.DebugContext(ctx, "loadDatabaseSettingsInternal: using env path", "UIConfigurationDisabled", config.Load().UIConfigurationDisabled, "AgentMode", config.Load().AgentMode, "Environment", config.Load().Environment)
return s.loadDatabaseConfigFromEnv(ctx, db)
@@ -138,28 +138,39 @@ func (s *SettingsService) loadDatabaseSettingsInternal(ctx context.Context, db *
s.applyEnvOverrides(ctx, dest)
return dest, nil
-
}
func (s *SettingsService) loadDatabaseConfigFromEnv(ctx context.Context, db *database.DB) (*models.Settings, error) {
dest := s.getDefaultSettings()
+ // Fetch all settings once to avoid N+1 queries for internal keys
+ var allSettings []models.SettingVariable
+ if err := db.WithContext(ctx).Find(&allSettings).Error; err != nil {
+ return nil, fmt.Errorf("failed to load settings for env config: %w", err)
+ }
+ settingsMap := make(map[string]string, len(allSettings))
+ for _, s := range allSettings {
+ settingsMap[s.Key] = s.Value
+ }
+
rt := reflect.ValueOf(dest).Elem().Type()
rv := reflect.ValueOf(dest).Elem()
for i := range rt.NumField() {
field := rt.Field(i)
- key, attrs, _ := strings.Cut(field.Tag.Get("key"), ",")
-
- if attrs == "internal" {
- var value string
- err := db.WithContext(ctx).
- Model(&models.SettingVariable{}).
- Where("key = ?", key).
- Select("value").
- First(&value).Error
- if err == nil {
- rv.Field(i).FieldByName("Value").SetString(value)
+ tagParts := strings.Split(field.Tag.Get("key"), ",")
+ key := tagParts[0]
+ isInternal := false
+ for _, attr := range tagParts[1:] {
+ if attr == "internal" {
+ isInternal = true
+ break
+ }
+ }
+
+ if isInternal {
+ if val, ok := settingsMap[key]; ok {
+ rv.Field(i).FieldByName("Value").SetString(val)
}
continue
}
@@ -278,15 +289,15 @@ func (s *SettingsService) SyncOidcEnvToDatabase(ctx context.Context) ([]models.S
}
func (s *SettingsService) UpdateSetting(ctx context.Context, key, value string) error {
- settingVar := &models.SettingVariable{
- Key: key,
- Value: value,
- }
-
- return s.db.WithContext(ctx).Save(settingVar).Error
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ settingVar := &models.SettingVariable{
+ Key: key,
+ Value: value,
+ }
+ return tx.Save(settingVar).Error
+ })
}
-//nolint:gocognit
func (s *SettingsService) UpdateSettings(ctx context.Context, updates dto.UpdateSettingsDto) ([]models.SettingVariable, error) {
defaultCfg := s.getDefaultSettings()
cfg, err := s.GetSettings(ctx)
@@ -294,6 +305,37 @@ func (s *SettingsService) UpdateSettings(ctx context.Context, updates dto.Update
return nil, fmt.Errorf("failed to load current settings: %w", err)
}
+ valuesToUpdate, changedPolling, changedAutoUpdate, err := s.prepareUpdateValues(updates, cfg, defaultCfg)
+ if err != nil {
+ return nil, err
+ }
+
+ if err := s.persistSettings(ctx, valuesToUpdate); err != nil {
+ return nil, err
+ }
+
+ if err := s.handleOidcConfigUpdate(ctx, updates); err != nil {
+ return nil, err
+ }
+
+ if changedPolling && s.OnImagePollingSettingsChanged != nil {
+ s.OnImagePollingSettingsChanged(ctx)
+ }
+ if changedAutoUpdate && s.OnAutoUpdateSettingsChanged != nil {
+ s.OnAutoUpdateSettingsChanged(ctx)
+ }
+
+ settings, err := s.GetSettings(ctx)
+ if err != nil {
+ return nil, fmt.Errorf("failed to retrieve updated settings: %w", err)
+ }
+
+ s.config.Store(settings)
+
+ return settings.ToSettingVariableSlice(false, false), nil
+}
+
+func (s *SettingsService) prepareUpdateValues(updates dto.UpdateSettingsDto, cfg, defaultCfg *models.Settings) ([]models.SettingVariable, bool, bool, error) {
rt := reflect.TypeOf(updates)
rv := reflect.ValueOf(updates)
valuesToUpdate := make([]models.SettingVariable, 0)
@@ -301,46 +343,38 @@ func (s *SettingsService) UpdateSettings(ctx context.Context, updates dto.Update
changedPolling := false
changedAutoUpdate := false
- // Iterate through fields using reflection
for i := 0; i < rt.NumField(); i++ {
field := rt.Field(i)
fieldValue := rv.Field(i)
- // Skip if the field is nil (not provided in request)
if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
continue
}
- // Get the value and json key
key, _, _ := strings.Cut(field.Tag.Get("json"), ",")
var value string
if fieldValue.Kind() == reflect.Ptr {
value = fieldValue.Elem().String()
}
- // Determine the actual value to use and save
var valueToSave string
var err error
if value == "" {
- // Use default value for empty strings
defaultValue, _, _, _ := defaultCfg.FieldByKey(key)
valueToSave = defaultValue
err = cfg.UpdateField(key, defaultValue, true)
} else {
- // Use the provided value
valueToSave = value
err = cfg.UpdateField(key, value, true)
}
- // Handle internal field errors
if errors.Is(err, models.SettingSensitiveForbiddenError{}) {
continue
} else if err != nil {
- return nil, fmt.Errorf("failed to update in-memory config for key '%s': %w", key, err)
+ return nil, false, false, fmt.Errorf("failed to update in-memory config for key '%s': %w", key, err)
}
- // Save the correct value to database
valuesToUpdate = append(valuesToUpdate, models.SettingVariable{
Key: key,
Value: valueToSave,
@@ -354,67 +388,55 @@ func (s *SettingsService) UpdateSettings(ctx context.Context, updates dto.Update
}
}
- err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- for _, setting := range valuesToUpdate {
+ return valuesToUpdate, changedPolling, changedAutoUpdate, nil
+}
+
+func (s *SettingsService) persistSettings(ctx context.Context, values []models.SettingVariable) error {
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ for _, setting := range values {
if err := tx.Save(&setting).Error; err != nil {
return fmt.Errorf("failed to update setting %s: %w", setting.Key, err)
}
}
return nil
})
- if err != nil {
- return nil, err
- }
+}
- // Merge OIDC config to avoid clearing secret when not provided
- if updates.AuthOidcConfig != nil {
- newCfgStr := *updates.AuthOidcConfig
+func (s *SettingsService) handleOidcConfigUpdate(ctx context.Context, updates dto.UpdateSettingsDto) error {
+ if updates.AuthOidcConfig == nil {
+ return nil
+ }
- var incoming models.OidcConfig
- if err := json.Unmarshal([]byte(newCfgStr), &incoming); err != nil {
- return nil, fmt.Errorf("invalid authOidcConfig JSON: %w", err)
- }
+ newCfgStr := *updates.AuthOidcConfig
+ var incoming models.OidcConfig
+ if err := json.Unmarshal([]byte(newCfgStr), &incoming); err != nil {
+ return fmt.Errorf("invalid authOidcConfig JSON: %w", err)
+ }
- // Get current settings to preserve existing secret if empty
- current, err := s.GetSettings(ctx)
- if err != nil {
- return nil, fmt.Errorf("failed to load current settings: %w", err)
- }
+ current, err := s.GetSettings(ctx)
+ if err != nil {
+ return fmt.Errorf("failed to load current settings: %w", err)
+ }
- if current.AuthOidcConfig.Value != "" {
- var existing models.OidcConfig
- if err := json.Unmarshal([]byte(current.AuthOidcConfig.Value), &existing); err == nil {
- if incoming.ClientSecret == "" {
- incoming.ClientSecret = existing.ClientSecret
- }
+ if current.AuthOidcConfig.Value != "" {
+ var existing models.OidcConfig
+ if err := json.Unmarshal([]byte(current.AuthOidcConfig.Value), &existing); err == nil {
+ if incoming.ClientSecret == "" {
+ incoming.ClientSecret = existing.ClientSecret
}
}
-
- mergedBytes, err := json.Marshal(incoming)
- if err != nil {
- return nil, fmt.Errorf("failed to marshal merged OIDC config: %w", err)
- }
-
- if err := s.UpdateSetting(ctx, "authOidcConfig", string(mergedBytes)); err != nil {
- return nil, fmt.Errorf("failed to update authOidcConfig: %w", err)
- }
}
- if changedPolling && s.OnImagePollingSettingsChanged != nil {
- s.OnImagePollingSettingsChanged(ctx)
- }
- if changedAutoUpdate && s.OnAutoUpdateSettingsChanged != nil {
- s.OnAutoUpdateSettingsChanged(ctx)
- }
-
- settings, err := s.GetSettings(ctx)
+ mergedBytes, err := json.Marshal(incoming)
if err != nil {
- return nil, fmt.Errorf("failed to retrieve updated settings: %w", err)
+ return fmt.Errorf("failed to marshal merged OIDC config: %w", err)
}
- s.config.Store(settings)
+ if err := s.UpdateSetting(ctx, "authOidcConfig", string(mergedBytes)); err != nil {
+ return fmt.Errorf("failed to update authOidcConfig: %w", err)
+ }
- return settings.ToSettingVariableSlice(false, false), nil
+ return nil
}
func (s *SettingsService) EnsureDefaultSettings(ctx context.Context) error {
@@ -534,30 +556,38 @@ func (s *SettingsService) setupInstanceID(ctx context.Context) error {
}
func (s *SettingsService) GetBoolSetting(ctx context.Context, key string, defaultValue bool) bool {
- var sv models.SettingVariable
- err := s.db.WithContext(ctx).Where("key = ?", key).First(&sv).Error
+ cfg := s.GetSettingsConfig()
+ val, _, _, err := cfg.FieldByKey(key)
+ if err != nil || val == "" {
+ return defaultValue
+ }
+ b, err := strconv.ParseBool(val)
if err != nil {
return defaultValue
}
- return sv.IsTrue()
+ return b
}
func (s *SettingsService) GetIntSetting(ctx context.Context, key string, defaultValue int) int {
- var sv models.SettingVariable
- err := s.db.WithContext(ctx).Where("key = ?", key).First(&sv).Error
+ cfg := s.GetSettingsConfig()
+ val, _, _, err := cfg.FieldByKey(key)
+ if err != nil || val == "" {
+ return defaultValue
+ }
+ i, err := strconv.Atoi(val)
if err != nil {
return defaultValue
}
- return sv.AsInt()
+ return i
}
func (s *SettingsService) GetStringSetting(ctx context.Context, key, defaultValue string) string {
- var sv models.SettingVariable
- err := s.db.WithContext(ctx).Where("key = ?", key).First(&sv).Error
- if err != nil {
+ cfg := s.GetSettingsConfig()
+ val, _, _, err := cfg.FieldByKey(key)
+ if err != nil || val == "" {
return defaultValue
}
- return sv.Value
+ return val
}
func (s *SettingsService) SetBoolSetting(ctx context.Context, key string, value bool) error {
@@ -593,45 +623,51 @@ func (s *SettingsService) SetStringSetting(ctx context.Context, key, value strin
func (s *SettingsService) EnsureEncryptionKey(ctx context.Context) (string, error) {
const keyName = "encryptionKey"
+ var key string
- var sv models.SettingVariable
- err := s.db.WithContext(ctx).
- Where("key = ?", keyName).
- First(&sv).Error
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var sv models.SettingVariable
+ err := tx.Where("key = ?", keyName).First(&sv).Error
- if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
- return "", fmt.Errorf("failed to load encryption key: %w", err)
- }
+ if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("failed to load encryption key: %w", err)
+ }
- // If already present and non-empty, return it
- if sv.Value != "" {
- return sv.Value, nil
- }
+ // If already present and non-empty, return it
+ if sv.Value != "" {
+ key = sv.Value
+ return nil
+ }
- notFound := errors.Is(err, gorm.ErrRecordNotFound)
+ notFound := errors.Is(err, gorm.ErrRecordNotFound)
- // Generate uuid -> sha256 -> base64 key (32 bytes raw -> 44 chars base64)
- u, genErr := uuid.GenerateUUID()
- if genErr != nil {
- return "", fmt.Errorf("failed to generate encryption key: %w", genErr)
- }
- sum := sha256.Sum256([]byte(u))
- key := base64.StdEncoding.EncodeToString(sum[:])
+ // Generate uuid -> sha256 -> base64 key (32 bytes raw -> 44 chars base64)
+ u, genErr := uuid.GenerateUUID()
+ if genErr != nil {
+ return fmt.Errorf("failed to generate encryption key: %w", genErr)
+ }
+ sum := sha256.Sum256([]byte(u))
+ generatedKey := base64.StdEncoding.EncodeToString(sum[:])
+ key = generatedKey
- if notFound {
- if createErr := s.db.WithContext(ctx).
- Create(&models.SettingVariable{Key: keyName, Value: key}).Error; createErr != nil {
- return "", fmt.Errorf("failed to persist encryption key: %w", createErr)
+ if notFound {
+ if createErr := tx.Create(&models.SettingVariable{Key: keyName, Value: generatedKey}).Error; createErr != nil {
+ return fmt.Errorf("failed to persist encryption key: %w", createErr)
+ }
+ return nil
}
- return key, nil
- }
- // Record existed but empty value; update it
- if updErr := s.db.WithContext(ctx).
- Model(&models.SettingVariable{}).
- Where("key = ?", keyName).
- Update("value", key).Error; updErr != nil {
- return "", fmt.Errorf("failed to update encryption key: %w", updErr)
+ // Record existed but empty value; update it
+ if updErr := tx.Model(&models.SettingVariable{}).
+ Where("key = ?", keyName).
+ Update("value", generatedKey).Error; updErr != nil {
+ return fmt.Errorf("failed to update encryption key: %w", updErr)
+ }
+ return nil
+ })
+
+ if err != nil {
+ return "", err
}
return key, nil
diff --git a/backend/internal/services/settings_service_test.go b/backend/internal/services/settings_service_test.go
index df27e5321..f9594eb51 100644
--- a/backend/internal/services/settings_service_test.go
+++ b/backend/internal/services/settings_service_test.go
@@ -261,3 +261,26 @@ func TestSettingsService_UpdateSettings_RefreshesCache(t *testing.T) {
}
require.True(t, found, "projectsDirectory setting not found in cached list")
}
+
+func TestSettingsService_LoadDatabaseSettings_InternalKeys_EnvMode(t *testing.T) {
+ // Set env + disable flag
+ t.Setenv("UI_CONFIGURATION_DISABLED", "true")
+
+ ctx := context.Background()
+ db := setupSettingsTestDB(t)
+
+ // Pre-populate an internal setting in the DB
+ internalKey := "instanceId"
+ internalVal := "test-instance-id"
+ require.NoError(t, db.DB.Create(&models.SettingVariable{Key: internalKey, Value: internalVal}).Error)
+
+ svc, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ // Reload explicitly to trigger the env loading path
+ require.NoError(t, svc.LoadDatabaseSettings(ctx))
+
+ cfg := svc.GetSettingsConfig()
+ // Should have loaded the internal setting from DB even in env mode
+ require.Equal(t, internalVal, cfg.InstanceID.Value)
+}
diff --git a/backend/internal/services/system_service.go b/backend/internal/services/system_service.go
index bad8fd563..6e53e106f 100644
--- a/backend/internal/services/system_service.go
+++ b/backend/internal/services/system_service.go
@@ -6,14 +6,17 @@ import (
"log/slog"
"regexp"
"strings"
+ "sync"
"github.com/docker/docker/api/types/build"
+ "github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/filters"
"github.com/goccy/go-yaml"
"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/converter"
+ "golang.org/x/sync/errgroup"
)
type SystemService struct {
@@ -60,7 +63,9 @@ func (s *SystemService) PruneAll(ctx context.Context, req dto.PruneSystemDto) (*
slog.Bool("dangling", req.Dangling))
result := &dto.PruneAllResult{Success: true}
+ var mu sync.Mutex
+ // 1. Prune Containers first (sequential) as it may free up other resources
if req.Containers {
slog.InfoContext(ctx, "Pruning stopped containers...")
if err := s.pruneContainers(ctx, result); err != nil {
@@ -69,43 +74,90 @@ func (s *SystemService) PruneAll(ctx context.Context, req dto.PruneSystemDto) (*
}
}
- danglingOnly := req.Dangling
- if settingsDangling, _ := s.getDanglingModeFromSettings(ctx); settingsDangling != danglingOnly {
- slog.DebugContext(ctx, "Prune request overriding stored image prune mode",
- slog.Bool("settings_dangling_only", settingsDangling),
- slog.Bool("request_dangling_only", danglingOnly))
- }
- slog.DebugContext(ctx, "Resolved image prune mode", slog.Bool("dangling_only", danglingOnly))
+ // 2. Prune other resources in parallel
+ g, ctx := errgroup.WithContext(ctx)
if req.Images {
- slog.InfoContext(ctx, "Pruning images...", slog.Bool("dangling_only", danglingOnly))
- if err := s.pruneImages(ctx, danglingOnly, result); err != nil {
- result.Errors = append(result.Errors, fmt.Sprintf("Image pruning failed: %v", err))
- result.Success = false
- }
+ g.Go(func() error {
+ danglingOnly := req.Dangling
+ if settingsDangling, _ := s.getDanglingModeFromSettings(ctx); settingsDangling != danglingOnly {
+ slog.DebugContext(ctx, "Prune request overriding stored image prune mode",
+ slog.Bool("settings_dangling_only", settingsDangling),
+ slog.Bool("request_dangling_only", danglingOnly))
+ }
+
+ slog.InfoContext(ctx, "Pruning images...", slog.Bool("dangling_only", danglingOnly))
+ localResult := &dto.PruneAllResult{}
+ if err := s.pruneImages(ctx, danglingOnly, localResult); err != nil {
+ mu.Lock()
+ result.Errors = append(result.Errors, fmt.Sprintf("Image pruning failed: %v", err))
+ result.Success = false
+ mu.Unlock()
+ } else {
+ mu.Lock()
+ result.ImagesDeleted = append(result.ImagesDeleted, localResult.ImagesDeleted...)
+ result.SpaceReclaimed += localResult.SpaceReclaimed
+ mu.Unlock()
+ }
+ return nil
+ })
}
if req.BuildCache {
- slog.InfoContext(ctx, "Pruning build cache...")
- if buildCacheErr := s.pruneBuildCache(ctx, result, !danglingOnly); buildCacheErr != nil {
- slog.WarnContext(ctx, "Build cache pruning encountered an error", slog.String("error", buildCacheErr.Error()))
- }
+ g.Go(func() error {
+ slog.InfoContext(ctx, "Pruning build cache...")
+ localResult := &dto.PruneAllResult{}
+ if err := s.pruneBuildCache(ctx, localResult, !req.Dangling); err != nil {
+ slog.WarnContext(ctx, "Build cache pruning encountered an error", slog.String("error", err.Error()))
+ // Build cache errors are often non-critical, but we log them
+ } else {
+ mu.Lock()
+ result.SpaceReclaimed += localResult.SpaceReclaimed
+ mu.Unlock()
+ }
+ return nil
+ })
}
if req.Volumes {
- slog.InfoContext(ctx, "Pruning unused volumes (not referenced by any container)...")
- if err := s.pruneVolumes(ctx, result); err != nil {
- result.Errors = append(result.Errors, fmt.Sprintf("Volume pruning failed: %v", err))
- result.Success = false
- }
+ g.Go(func() error {
+ slog.InfoContext(ctx, "Pruning unused volumes...")
+ localResult := &dto.PruneAllResult{}
+ if err := s.pruneVolumes(ctx, localResult); err != nil {
+ mu.Lock()
+ result.Errors = append(result.Errors, fmt.Sprintf("Volume pruning failed: %v", err))
+ result.Success = false
+ mu.Unlock()
+ } else {
+ mu.Lock()
+ result.VolumesDeleted = append(result.VolumesDeleted, localResult.VolumesDeleted...)
+ result.SpaceReclaimed += localResult.SpaceReclaimed
+ mu.Unlock()
+ }
+ return nil
+ })
}
if req.Networks {
- slog.InfoContext(ctx, "Pruning unused networks (not connected to any container)...")
- if err := s.pruneNetworks(ctx, result); err != nil {
- result.Errors = append(result.Errors, fmt.Sprintf("Network pruning failed: %v", err))
- result.Success = false
- }
+ g.Go(func() error {
+ slog.InfoContext(ctx, "Pruning unused networks...")
+ localResult := &dto.PruneAllResult{}
+ if err := s.pruneNetworks(ctx, localResult); err != nil {
+ mu.Lock()
+ result.Errors = append(result.Errors, fmt.Sprintf("Network pruning failed: %v", err))
+ result.Success = false
+ mu.Unlock()
+ } else {
+ mu.Lock()
+ result.NetworksDeleted = append(result.NetworksDeleted, localResult.NetworksDeleted...)
+ mu.Unlock()
+ }
+ return nil
+ })
+ }
+
+ if err := g.Wait(); err != nil {
+ slog.ErrorContext(ctx, "Prune operations failed", "error", err)
}
slog.InfoContext(ctx, "Selective prune operation completed",
@@ -133,95 +185,101 @@ func (s *SystemService) getDanglingModeFromSettings(ctx context.Context) (bool,
}
}
-func (s *SystemService) StartAllContainers(ctx context.Context) (*dto.ContainerActionResult, error) {
- result := &dto.ContainerActionResult{
- Success: true,
- }
+func (s *SystemService) performBatchContainerAction(ctx context.Context, containers []container.Summary, actionName string, shouldProcess func(container.Summary) bool, action func(context.Context, string) error) *dto.ContainerActionResult {
+ result := &dto.ContainerActionResult{Success: true}
+ var mu sync.Mutex
- containers, _, _, _, err := s.dockerService.GetAllContainers(ctx)
- if err != nil {
- result.Success = false
- result.Errors = append(result.Errors, fmt.Sprintf("Failed to list containers: %v", err))
- return result, err
- }
+ g, ctx := errgroup.WithContext(ctx)
+ // Limit concurrency to avoid overwhelming Docker daemon
+ g.SetLimit(5)
for _, container := range containers {
- if container.State != "running" {
- if err := s.containerService.StartContainer(ctx, container.ID, systemUser); err != nil {
- result.Failed = append(result.Failed, container.ID)
- result.Errors = append(result.Errors, fmt.Sprintf("Failed to start container %s: %v", container.ID, err))
+ c := container // capture loop var
+ if !shouldProcess(c) {
+ continue
+ }
+
+ g.Go(func() error {
+ err := action(ctx, c.ID)
+
+ mu.Lock()
+ defer mu.Unlock()
+
+ if err != nil {
+ result.Failed = append(result.Failed, c.ID)
+ result.Errors = append(result.Errors, fmt.Sprintf("Failed to %s container %s: %v", actionName, c.ID, err))
result.Success = false
} else {
- result.Started = append(result.Started, container.ID)
+ if actionName == "start" {
+ result.Started = append(result.Started, c.ID)
+ } else {
+ result.Stopped = append(result.Stopped, c.ID)
+ }
}
- }
+ return nil
+ })
}
- return result, nil
+ _ = g.Wait()
+ return result
}
-func (s *SystemService) StartAllStoppedContainers(ctx context.Context) (*dto.ContainerActionResult, error) {
- result := &dto.ContainerActionResult{
- Success: true,
- }
-
+func (s *SystemService) StartAllContainers(ctx context.Context) (*dto.ContainerActionResult, error) {
containers, _, _, _, err := s.dockerService.GetAllContainers(ctx)
if err != nil {
- result.Success = false
- result.Errors = append(result.Errors, fmt.Sprintf("Failed to list containers: %v", err))
- return result, err
+ return &dto.ContainerActionResult{
+ Success: false,
+ Errors: []string{fmt.Sprintf("Failed to list containers: %v", err)},
+ }, err
}
- for _, container := range containers {
- if container.State == "exited" {
- if err := s.containerService.StartContainer(ctx, container.ID, systemUser); err != nil {
- result.Failed = append(result.Failed, container.ID)
- result.Errors = append(result.Errors, fmt.Sprintf("Failed to start container %s: %v", container.ID, err))
- result.Success = false
- } else {
- result.Started = append(result.Started, container.ID)
- }
- }
+ return s.performBatchContainerAction(ctx, containers, "start",
+ func(c container.Summary) bool { return c.State != "running" },
+ func(ctx context.Context, id string) error {
+ return s.containerService.StartContainer(ctx, id, systemUser)
+ }), nil
+}
+
+func (s *SystemService) StartAllStoppedContainers(ctx context.Context) (*dto.ContainerActionResult, error) {
+ containers, _, _, _, err := s.dockerService.GetAllContainers(ctx)
+ if err != nil {
+ return &dto.ContainerActionResult{
+ Success: false,
+ Errors: []string{fmt.Sprintf("Failed to list containers: %v", err)},
+ }, err
}
- return result, nil
+ return s.performBatchContainerAction(ctx, containers, "start",
+ func(c container.Summary) bool { return c.State == "exited" },
+ func(ctx context.Context, id string) error {
+ return s.containerService.StartContainer(ctx, id, systemUser)
+ }), nil
}
func (s *SystemService) StopAllContainers(ctx context.Context) (*dto.ContainerActionResult, error) {
- result := &dto.ContainerActionResult{
- Success: true,
- }
-
containers, _, _, _, err := s.dockerService.GetAllContainers(ctx)
if err != nil {
- result.Success = false
- result.Errors = append(result.Errors, fmt.Sprintf("Failed to list containers: %v", err))
- return result, err
- }
-
- for _, cont := range containers {
- // Skip Arcane server container
- if cont.Labels != nil && cont.Labels["com.ofkm.arcane.server"] == "true" {
- continue
- }
- if err := s.containerService.StopContainer(ctx, cont.ID, systemUser); err != nil {
- result.Failed = append(result.Failed, cont.ID)
- result.Errors = append(result.Errors, fmt.Sprintf("Failed to stop container %s: %v", cont.ID, err))
- result.Success = false
- } else {
- result.Stopped = append(result.Stopped, cont.ID)
- }
+ return &dto.ContainerActionResult{
+ Success: false,
+ Errors: []string{fmt.Sprintf("Failed to list containers: %v", err)},
+ }, err
}
- return result, nil
+ return s.performBatchContainerAction(ctx, containers, "stop",
+ func(c container.Summary) bool {
+ // Skip Arcane server container
+ return c.Labels == nil || c.Labels["com.ofkm.arcane.server"] != "true"
+ },
+ func(ctx context.Context, id string) error {
+ return s.containerService.StopContainer(ctx, id, systemUser)
+ }), nil
}
func (s *SystemService) pruneContainers(ctx context.Context, result *dto.PruneAllResult) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
filterArgs := filters.NewArgs()
@@ -238,11 +296,10 @@ func (s *SystemService) pruneContainers(ctx context.Context, result *dto.PruneAl
func (s *SystemService) pruneImages(ctx context.Context, danglingOnly bool, result *dto.PruneAllResult) error {
slog.DebugContext(ctx, "Starting image pruning", slog.Bool("dangling_only", danglingOnly))
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
var filterArgs filters.Args
@@ -263,45 +320,37 @@ func (s *SystemService) pruneImages(ctx context.Context, danglingOnly bool, resu
slog.Int("images_deleted", len(report.ImagesDeleted)),
slog.Uint64("bytes_reclaimed", report.SpaceReclaimed))
- // Clean up update records for pruned images
+ // Collect IDs to delete from DB
+ var idsToDelete []string
for _, imgReport := range report.ImagesDeleted {
- var prunedDockerID string
if imgReport.Deleted != "" {
- prunedDockerID = imgReport.Deleted
+ idsToDelete = append(idsToDelete, imgReport.Deleted)
} else if imgReport.Untagged != "" {
- prunedDockerID = imgReport.Untagged
- }
-
- if prunedDockerID != "" && s.db != nil {
- // Only delete the update record
- if err := s.db.WithContext(ctx).Delete(&models.ImageUpdateRecord{}, "id = ?", prunedDockerID).Error; err != nil {
- slog.WarnContext(ctx, "Failed to delete image update record",
- slog.String("imageId", prunedDockerID),
- slog.String("error", err.Error()))
- }
+ idsToDelete = append(idsToDelete, imgReport.Untagged)
}
}
- result.ImagesDeleted = make([]string, 0, len(report.ImagesDeleted))
- for _, img := range report.ImagesDeleted {
- if img.Deleted != "" {
- result.ImagesDeleted = append(result.ImagesDeleted, img.Deleted)
- } else if img.Untagged != "" {
- result.ImagesDeleted = append(result.ImagesDeleted, img.Untagged)
+ // Batch delete update records
+ if len(idsToDelete) > 0 && s.db != nil {
+ if err := s.db.WithContext(ctx).Where("id IN ?", idsToDelete).Delete(&models.ImageUpdateRecord{}).Error; err != nil {
+ slog.WarnContext(ctx, "Failed to delete image update records",
+ slog.Int("count", len(idsToDelete)),
+ slog.String("error", err.Error()))
}
}
+
+ result.ImagesDeleted = idsToDelete
result.SpaceReclaimed += report.SpaceReclaimed
return nil
}
func (s *SystemService) pruneBuildCache(ctx context.Context, result *dto.PruneAllResult, pruneAllCache bool) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
result.Errors = append(result.Errors, fmt.Errorf("build cache pruning failed (connection): %w", err).Error())
slog.ErrorContext(ctx, "Error connecting to Docker for build cache prune", slog.String("error", err.Error()))
return fmt.Errorf("failed to connect to Docker for build cache prune: %w", err)
}
- defer dockerClient.Close()
options := build.CachePruneOptions{
All: pruneAllCache,
diff --git a/backend/internal/services/system_upgrade_service.go b/backend/internal/services/system_upgrade_service.go
index dbe28e9d4..39d09aae2 100644
--- a/backend/internal/services/system_upgrade_service.go
+++ b/backend/internal/services/system_upgrade_service.go
@@ -50,7 +50,7 @@ func (s *SystemUpgradeService) CanUpgrade(ctx context.Context) (bool, error) {
}
// Verify we can access Docker
- _, err = s.dockerService.CreateConnection(ctx)
+ _, err = s.dockerService.GetClient()
if err != nil {
return false, ErrDockerSocketAccess
}
@@ -107,11 +107,10 @@ func (s *SystemUpgradeService) TriggerUpgradeViaCLI(ctx context.Context, user mo
// Spawn the upgrade command in a detached container
// This will run independently of the current container
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
// Create the upgrader container config
config := &containertypes.Config{
@@ -229,11 +228,10 @@ func (s *SystemUpgradeService) getContainerIDFromHostname() (string, error) {
// findArcaneContainer finds the container using the ID
func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containerId string) (containertypes.InspectResponse, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return containertypes.InspectResponse{}, err
}
- defer dockerClient.Close()
// Try to inspect the container directly
container, err := dockerClient.ContainerInspect(ctx, containerId)
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 8259cd53d..8d925909c 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -25,12 +25,14 @@ import (
appfs "github.com/ofkm/arcane-backend/internal/utils/fs"
"github.com/ofkm/arcane-backend/internal/utils/pagination"
"github.com/ofkm/arcane-backend/internal/utils/template"
+ "golang.org/x/sync/errgroup"
"gorm.io/gorm"
)
type remoteCache struct {
- templates []models.ComposeTemplate
- lastFetch time.Time
+ templates []models.ComposeTemplate
+ lastFetch time.Time
+ refreshing bool
}
type registryFetchMeta struct {
@@ -48,9 +50,15 @@ type TemplateService struct {
registryMu sync.RWMutex
registryFetchMeta map[string]*registryFetchMeta
+
+ fsSyncMu sync.Mutex
+ lastFsSync time.Time
}
-const remoteCacheDuration = 5 * time.Minute
+const (
+ remoteCacheDuration = 5 * time.Minute
+ fsSyncInterval = 1 * time.Minute
+)
const remoteIDPrefix = "remote"
@@ -78,84 +86,70 @@ func NewTemplateService(ctx context.Context, db *database.DB, httpClient *http.C
func (s *TemplateService) ensureRemoteTemplatesLoaded(ctx context.Context) error {
s.remoteMu.Lock()
- defer s.remoteMu.Unlock()
+ // If cache is valid, return
if s.remoteCache.templates != nil && time.Since(s.remoteCache.lastFetch) < remoteCacheDuration {
+ s.remoteMu.Unlock()
return nil
}
- templates, err := s.loadRemoteTemplates(ctx)
- if err != nil {
- if s.remoteCache.templates == nil {
- return fmt.Errorf("failed to load remote templates: %w", err)
- }
- slog.WarnContext(ctx, "remote template refresh failed; using stale cache", "error", err)
- return nil
- }
+ // If we have cache (even stale) and are not already refreshing, trigger background refresh
+ if s.remoteCache.templates != nil {
+ if !s.remoteCache.refreshing {
+ s.remoteCache.refreshing = true
+ s.remoteMu.Unlock()
- s.remoteCache = remoteCache{templates: templates, lastFetch: time.Now()}
- return nil
-}
+ // Use a closure that accepts context to satisfy linter, though we create a new one
+ go func(parentCtx context.Context) {
+ // Create a detached context with timeout for background fetch
+ // We use context.WithoutCancel(parentCtx) to ensure it outlives the request
+ bgCtx, cancel := context.WithTimeout(context.WithoutCancel(parentCtx), 2*time.Minute)
+ defer cancel()
-func (s *TemplateService) GetAllTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {
- if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {
- slog.WarnContext(ctx, "failed to sync filesystem templates", "error", err)
- }
+ defer func() {
+ s.remoteMu.Lock()
+ s.remoteCache.refreshing = false
+ s.remoteMu.Unlock()
+ }()
- var templates []models.ComposeTemplate
- if err := s.db.WithContext(ctx).Preload("Registry").Find(&templates).Error; err != nil {
- return nil, fmt.Errorf("failed to get local templates: %w", err)
+ if _, err := s.refreshRemoteTemplates(bgCtx); err != nil {
+ slog.WarnContext(bgCtx, "background remote template refresh failed", "error", err)
+ }
+ }(ctx)
+ return nil // Return stale cache
+ }
+ s.remoteMu.Unlock()
+ return nil // Return stale cache while someone else refreshes
}
- // Trim heavy fields in list responses
- for i := range templates {
- templates[i].Content = ""
- templates[i].EnvContent = nil
- }
+ s.remoteMu.Unlock()
- if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {
- slog.WarnContext(ctx, "failed to load remote templates for GetAllTemplates", "error", err)
- } else {
- s.remoteMu.RLock()
- copied := make([]models.ComposeTemplate, len(s.remoteCache.templates))
- copy(copied, s.remoteCache.templates)
- s.remoteMu.RUnlock()
+ // No cache at all, must block
+ _, err := s.refreshRemoteTemplates(ctx)
+ return err
+}
- if len(copied) > 0 {
- templates = append(templates, copied...)
- }
+func (s *TemplateService) refreshRemoteTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {
+ templates, err := s.loadRemoteTemplates(ctx)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load remote templates: %w", err)
}
+ s.remoteMu.Lock()
+ defer s.remoteMu.Unlock()
+ s.remoteCache.templates = templates
+ s.remoteCache.lastFetch = time.Now()
return templates, nil
}
-func (s *TemplateService) GetAllTemplatesPaginated(ctx context.Context, params pagination.QueryParams) ([]dto.ComposeTemplateDto, pagination.Response, error) {
- if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {
- slog.WarnContext(ctx, "failed to sync filesystem templates", "error", err)
- }
-
- var templates []models.ComposeTemplate
- if err := s.db.WithContext(ctx).Preload("Registry").Find(&templates).Error; err != nil {
- return nil, pagination.Response{}, fmt.Errorf("failed to get local templates: %w", err)
- }
-
- // Trim heavy fields in list responses
- for i := range templates {
- templates[i].Content = ""
- templates[i].EnvContent = nil
- }
-
- if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {
- slog.WarnContext(ctx, "failed to load remote templates for GetAllTemplatesPaginated", "error", err)
- } else {
- s.remoteMu.RLock()
- copied := make([]models.ComposeTemplate, len(s.remoteCache.templates))
- copy(copied, s.remoteCache.templates)
- s.remoteMu.RUnlock()
+func (s *TemplateService) GetAllTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {
+ return s.getMergedTemplates(ctx)
+}
- if len(copied) > 0 {
- templates = append(templates, copied...)
- }
+func (s *TemplateService) GetAllTemplatesPaginated(ctx context.Context, params pagination.QueryParams) ([]dto.ComposeTemplateDto, pagination.Response, error) {
+ templates, err := s.getMergedTemplates(ctx)
+ if err != nil {
+ return nil, pagination.Response{}, err
}
items := make([]dto.ComposeTemplateDto, 0, len(templates))
@@ -282,77 +276,76 @@ func (s *TemplateService) CreateTemplate(ctx context.Context, template *models.C
}
template.IsCustom = true
template.IsRemote = false
- if err := s.db.WithContext(ctx).Create(template).Error; err != nil {
- return fmt.Errorf("failed to create template: %w", err)
- }
- return nil
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Create(template).Error; err != nil {
+ return fmt.Errorf("failed to create template: %w", err)
+ }
+ return nil
+ })
}
func (s *TemplateService) UpdateTemplate(ctx context.Context, id string, updates *models.ComposeTemplate) error {
- var existing models.ComposeTemplate
- err := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Error
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return fmt.Errorf("template not found")
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.ComposeTemplate
+ if err := tx.Where("id = ?", id).First(&existing).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("template not found")
+ }
+ return fmt.Errorf("failed to find template: %w", err)
}
- return fmt.Errorf("failed to find template: %w", err)
- }
- if existing.IsRemote {
- return fmt.Errorf("cannot update remote template")
- }
+ if existing.IsRemote {
+ return fmt.Errorf("cannot update remote template")
+ }
- existing.Name = updates.Name
- existing.Description = updates.Description
- existing.Content = updates.Content
- existing.EnvContent = updates.EnvContent
+ existing.Name = updates.Name
+ existing.Description = updates.Description
+ existing.Content = updates.Content
+ existing.EnvContent = updates.EnvContent
- err = s.db.WithContext(ctx).Save(&existing).Error
- if err != nil {
- return fmt.Errorf("failed to update template: %w", err)
- }
+ if err := tx.Save(&existing).Error; err != nil {
+ return fmt.Errorf("failed to update template: %w", err)
+ }
- return nil
+ return nil
+ })
}
func (s *TemplateService) DeleteTemplate(ctx context.Context, id string) error {
- var existing models.ComposeTemplate
- err := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Error
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return fmt.Errorf("template not found")
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.ComposeTemplate
+ if err := tx.Where("id = ?", id).First(&existing).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("template not found")
+ }
+ return fmt.Errorf("failed to find template: %w", err)
}
- return fmt.Errorf("failed to find template: %w", err)
- }
- if existing.IsRemote {
- return fmt.Errorf("cannot delete remote template directly")
- }
-
- baseDir, err := appfs.GetTemplatesDirectory(ctx)
- if err != nil {
- return fmt.Errorf("failed to get templates directory: %w", err)
- } else {
- templatePath := filepath.Join(baseDir, existing.Name)
+ if existing.IsRemote {
+ return fmt.Errorf("cannot delete remote template directly")
+ }
- if stat, err := os.Stat(templatePath); err == nil && stat.IsDir() {
- composeFile := filepath.Join(templatePath, "compose.yaml")
- if _, err := os.Stat(composeFile); err == nil {
- if err := os.RemoveAll(templatePath); err != nil {
- return fmt.Errorf("failed to delete template directory: %w", err)
+ baseDir, err := appfs.GetTemplatesDirectory(ctx)
+ if err != nil {
+ return fmt.Errorf("failed to get templates directory: %w", err)
+ } else {
+ templatePath := filepath.Join(baseDir, existing.Name)
+
+ if stat, err := os.Stat(templatePath); err == nil && stat.IsDir() {
+ composeFile := filepath.Join(templatePath, "compose.yaml")
+ if _, err := os.Stat(composeFile); err == nil {
+ if err := os.RemoveAll(templatePath); err != nil {
+ return fmt.Errorf("failed to delete template directory: %w", err)
+ }
}
}
}
- }
- result := s.db.WithContext(ctx).Where("id = ?", id).Delete(&models.ComposeTemplate{})
- if result.Error != nil {
- return fmt.Errorf("failed to delete template: %w", result.Error)
- }
- if result.RowsAffected == 0 {
- return fmt.Errorf("template not found after finding it")
- }
- return nil
+ if err := tx.Delete(&existing).Error; err != nil {
+ return fmt.Errorf("failed to delete template: %w", err)
+ }
+ return nil
+ })
}
func (s *TemplateService) GetComposeTemplate() string {
@@ -418,8 +411,14 @@ func (s *TemplateService) CreateRegistry(ctx context.Context, registry *models.T
registry.ID = uuid.NewString()
}
- if err := s.db.WithContext(ctx).Create(registry).Error; err != nil {
- return fmt.Errorf("failed to create registry: %w", err)
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Create(registry).Error; err != nil {
+ return fmt.Errorf("failed to create registry: %w", err)
+ }
+ return nil
+ })
+ if err != nil {
+ return err
}
s.invalidateRemoteCache()
@@ -427,16 +426,38 @@ func (s *TemplateService) CreateRegistry(ctx context.Context, registry *models.T
}
func (s *TemplateService) UpdateRegistry(ctx context.Context, id string, updates *models.TemplateRegistry) error {
- var existing models.TemplateRegistry
- if err := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Error; err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return errors.New("registry not found")
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.TemplateRegistry
+ if err := tx.Where("id = ?", id).First(&existing).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return errors.New("registry not found")
+ }
+ return fmt.Errorf("failed to find registry: %w", err)
+ }
+
+ if err := s.hydrateRegistryUpdates(ctx, updates, &existing); err != nil {
+ return err
+ }
+
+ if err := tx.Model(&models.TemplateRegistry{}).Where("id = ?", id).
+ Select("Name", "URL", "Description", "Enabled").
+ Updates(updates).Error; err != nil {
+ return err
}
- return fmt.Errorf("failed to find registry: %w", err)
+ return nil
+ })
+ if err != nil {
+ return err
}
+ s.invalidateRemoteCache()
+ return nil
+}
+
+func (s *TemplateService) hydrateRegistryUpdates(ctx context.Context, updates, existing *models.TemplateRegistry) error {
urlChanged := updates.URL != "" && updates.URL != existing.URL
needsHydration := updates.Name == "" || updates.Description == ""
+
if (urlChanged || needsHydration) && (updates.URL != "" || existing.URL != "") {
manifestURL := updates.URL
if manifestURL == "" {
@@ -453,28 +474,22 @@ func (s *TemplateService) UpdateRegistry(ctx context.Context, id string, updates
return fmt.Errorf("failed to fetch registry manifest: %w", err)
}
}
-
- result := s.db.WithContext(ctx).Model(&models.TemplateRegistry{}).Where("id = ?", id).
- Select("Name", "URL", "Description", "Enabled").
- Updates(updates)
- if result.Error != nil {
- return result.Error
- }
- if result.RowsAffected == 0 {
- return errors.New("registry not found")
- }
-
- s.invalidateRemoteCache()
return nil
}
func (s *TemplateService) DeleteRegistry(ctx context.Context, id string) error {
- result := s.db.WithContext(ctx).Where("id = ?", id).Delete(&models.TemplateRegistry{})
- if result.Error != nil {
- return result.Error
- }
- if result.RowsAffected == 0 {
- return errors.New("registry not found")
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ result := tx.Where("id = ?", id).Delete(&models.TemplateRegistry{})
+ if result.Error != nil {
+ return result.Error
+ }
+ if result.RowsAffected == 0 {
+ return errors.New("registry not found")
+ }
+ return nil
+ })
+ if err != nil {
+ return err
}
s.invalidateRemoteCache()
@@ -482,29 +497,43 @@ func (s *TemplateService) DeleteRegistry(ctx context.Context, id string) error {
}
func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {
- var templates []models.ComposeTemplate
-
registries, err := s.GetRegistries(ctx)
if err != nil {
return nil, err
}
+ var (
+ mu sync.Mutex
+ templates []models.ComposeTemplate
+ )
+
+ g, ctx := errgroup.WithContext(ctx)
+
for i := range registries {
reg := registries[i]
if !reg.Enabled {
continue
}
- remoteTemplates, err := s.fetchRegistryTemplates(ctx, &reg)
- if err != nil {
- slog.WarnContext(ctx, "failed to fetch templates from registry", "registry", reg.Name, "url", reg.URL, "error", err)
- continue
- }
+ g.Go(func() error {
+ remoteTemplates, err := s.fetchRegistryTemplates(ctx, &reg)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to fetch templates from registry", "registry", reg.Name, "url", reg.URL, "error", err)
+ return nil // Don't fail the whole group if one registry fails
+ }
- for _, rt := range remoteTemplates {
- template := s.convertRemoteToLocal(rt, &reg)
- templates = append(templates, template)
- }
+ mu.Lock()
+ defer mu.Unlock()
+ for _, rt := range remoteTemplates {
+ template := s.convertRemoteToLocal(rt, &reg)
+ templates = append(templates, template)
+ }
+ return nil
+ })
+ }
+
+ if err := g.Wait(); err != nil {
+ return nil, err
}
return templates, nil
@@ -671,60 +700,76 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
}
srcDesc := appfs.ImportedComposeDescription(dir)
- var existing models.ComposeTemplate
- if err := s.db.WithContext(ctx).
- Where("is_remote = ? AND registry_id IS NULL AND (description = ? OR name = ?)", false, srcDesc, base).
- First(&existing).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, fmt.Errorf("failed to check existing template: %w", err)
- } else if err == nil {
+ return s.downloadTemplateTransaction(ctx, remoteTemplate, base, composePath, envPath, srcDesc)
+}
+
+func (s *TemplateService) downloadTemplateTransaction(ctx context.Context, remoteTemplate *models.ComposeTemplate, base, composePath, envPath, srcDesc string) (*models.ComposeTemplate, error) {
+ var resultTemplate *models.ComposeTemplate
+
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.ComposeTemplate
+ if err := tx.
+ Where("is_remote = ? AND registry_id IS NULL AND (description = ? OR name = ?)", false, srcDesc, base).
+ First(&existing).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("failed to check existing template: %w", err)
+ } else if err == nil {
+ // Existing template found
+ composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)
+ if err != nil {
+ return fmt.Errorf("failed to fetch template content for existing local template: %w", err)
+ }
+
+ envPtr, werr := appfs.WriteTemplateFiles(composePath, envPath, composeContent, envContent)
+ if werr != nil {
+ return werr
+ }
+
+ existing.Content = composeContent
+ existing.EnvContent = envPtr
+ existing.Metadata = cloneTemplateMetadata(remoteTemplate.Metadata)
+
+ if err := tx.Save(&existing).Error; err != nil {
+ return fmt.Errorf("failed to update existing local template: %w", err)
+ }
+ resultTemplate = &existing
+ return nil
+ }
+
+ // New template
composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)
if err != nil {
- return nil, fmt.Errorf("failed to fetch template content for existing local template: %w", err)
+ return fmt.Errorf("failed to fetch template content for download: %w", err)
}
envPtr, werr := appfs.WriteTemplateFiles(composePath, envPath, composeContent, envContent)
if werr != nil {
- return nil, werr
+ return werr
}
- existing.Content = composeContent
- existing.EnvContent = envPtr
- existing.Metadata = cloneTemplateMetadata(remoteTemplate.Metadata)
+ localTemplate := &models.ComposeTemplate{
+ BaseModel: models.BaseModel{ID: uuid.NewString()},
+ Name: base,
+ Description: srcDesc,
+ Content: composeContent,
+ EnvContent: envPtr,
+ IsCustom: true,
+ IsRemote: false,
+ RegistryID: nil,
+ Registry: nil,
+ Metadata: cloneTemplateMetadata(remoteTemplate.Metadata),
+ }
- if err := s.db.WithContext(ctx).Save(&existing).Error; err != nil {
- return nil, fmt.Errorf("failed to update existing local template: %w", err)
+ if err := tx.Create(localTemplate).Error; err != nil {
+ return fmt.Errorf("failed to save local template: %w", err)
}
- return &existing, nil
- }
+ resultTemplate = localTemplate
+ return nil
+ })
- composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)
if err != nil {
- return nil, fmt.Errorf("failed to fetch template content for download: %w", err)
- }
-
- envPtr, werr := appfs.WriteTemplateFiles(composePath, envPath, composeContent, envContent)
- if werr != nil {
- return nil, werr
- }
-
- localTemplate := &models.ComposeTemplate{
- BaseModel: models.BaseModel{ID: uuid.NewString()},
- Name: base,
- Description: srcDesc,
- Content: composeContent,
- EnvContent: envPtr,
- IsCustom: true,
- IsRemote: false,
- RegistryID: nil,
- Registry: nil,
- Metadata: cloneTemplateMetadata(remoteTemplate.Metadata),
- }
-
- if err := s.db.WithContext(ctx).Create(localTemplate).Error; err != nil {
- return nil, fmt.Errorf("failed to save local template: %w", err)
+ return nil, err
}
-
- return localTemplate, nil
+ return resultTemplate, nil
}
func (s *TemplateService) templateBaseFromRemote(remoteTemplate *models.ComposeTemplate) string {
@@ -771,42 +816,44 @@ func (s *TemplateService) SyncLocalTemplatesFromFilesystem(ctx context.Context)
}
func (s *TemplateService) upsertFilesystemTemplate(ctx context.Context, name, desc, compose string, envPtr *string) error {
- var existing models.ComposeTemplate
- q := s.db.WithContext(ctx).
- Where("is_remote = ? AND registry_id IS NULL AND description = ?", false, desc).
- First(&existing)
-
- if q.Error == nil {
- existing.Name = name
- existing.Content = compose
- existing.EnvContent = envPtr
- existing.IsCustom = true
- existing.IsRemote = false
- if err := s.db.WithContext(ctx).Save(&existing).Error; err != nil {
- return fmt.Errorf("update template %s: %w", existing.ID, err)
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.ComposeTemplate
+ q := tx.
+ Where("is_remote = ? AND registry_id IS NULL AND description = ?", false, desc).
+ First(&existing)
+
+ if q.Error == nil {
+ existing.Name = name
+ existing.Content = compose
+ existing.EnvContent = envPtr
+ existing.IsCustom = true
+ existing.IsRemote = false
+ if err := tx.Save(&existing).Error; err != nil {
+ return fmt.Errorf("update template %s: %w", existing.ID, err)
+ }
+ return nil
+ }
+ if !errors.Is(q.Error, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("query existing template: %w", q.Error)
}
- return nil
- }
- if !errors.Is(q.Error, gorm.ErrRecordNotFound) {
- return fmt.Errorf("query existing template: %w", q.Error)
- }
- tpl := &models.ComposeTemplate{
- BaseModel: models.BaseModel{ID: uuid.NewString()},
- Name: name,
- Description: desc,
- Content: compose,
- EnvContent: envPtr,
- IsCustom: true,
- IsRemote: false,
- RegistryID: nil,
- Registry: nil,
- Metadata: nil,
- }
- if err := s.db.WithContext(ctx).Create(tpl).Error; err != nil {
- return fmt.Errorf("insert template %s: %w", name, err)
- }
- return nil
+ tpl := &models.ComposeTemplate{
+ BaseModel: models.BaseModel{ID: uuid.NewString()},
+ Name: name,
+ Description: desc,
+ Content: compose,
+ EnvContent: envPtr,
+ IsCustom: true,
+ IsRemote: false,
+ RegistryID: nil,
+ Registry: nil,
+ Metadata: nil,
+ }
+ if err := tx.Create(tpl).Error; err != nil {
+ return fmt.Errorf("insert template %s: %w", name, err)
+ }
+ return nil
+ })
}
func (s *TemplateService) processFolderEntry(ctx context.Context, baseDir, folder string) error {
@@ -818,6 +865,13 @@ func (s *TemplateService) processFolderEntry(ctx context.Context, baseDir, folde
}
func (s *TemplateService) syncFilesystemTemplatesInternal(ctx context.Context) error {
+ s.fsSyncMu.Lock()
+ defer s.fsSyncMu.Unlock()
+
+ if !s.lastFsSync.IsZero() && time.Since(s.lastFsSync) < fsSyncInterval {
+ return nil
+ }
+
dir, err := appfs.GetTemplatesDirectory(ctx)
if err != nil {
return fmt.Errorf("ensure templates dir: %w", err)
@@ -840,6 +894,8 @@ func (s *TemplateService) syncFilesystemTemplatesInternal(ctx context.Context) e
slog.WarnContext(ctx, "failed to read folder template", "folder", ent.Name(), "error", err)
}
}
+
+ s.lastFsSync = time.Now()
return nil
}
@@ -1048,3 +1104,30 @@ func (s *TemplateService) GetTemplateContentWithParsedData(ctx context.Context,
EnvVariables: envVars,
}, nil
}
+
+func (s *TemplateService) getMergedTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {
+ if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {
+ slog.WarnContext(ctx, "failed to sync filesystem templates", "error", err)
+ }
+
+ var templates []models.ComposeTemplate
+ // Use Omit to avoid fetching heavy content fields which are not needed for listing
+ if err := s.db.WithContext(ctx).Omit("Content", "EnvContent").Preload("Registry").Find(&templates).Error; err != nil {
+ return nil, fmt.Errorf("failed to get local templates: %w", err)
+ }
+
+ if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {
+ slog.WarnContext(ctx, "failed to load remote templates", "error", err)
+ } else {
+ s.remoteMu.RLock()
+ copied := make([]models.ComposeTemplate, len(s.remoteCache.templates))
+ copy(copied, s.remoteCache.templates)
+ s.remoteMu.RUnlock()
+
+ if len(copied) > 0 {
+ templates = append(templates, copied...)
+ }
+ }
+
+ return templates, nil
+}
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index f5bc8c8af..882283c39 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -296,11 +296,10 @@ func (s *UpdaterService) pruneImageIDs(ctx context.Context, ids []string) error
slog.DebugContext(ctx, "pruneImageIDs: attempting to prune image ids", "count", len(ids))
- dcli, err := s.dockerService.CreateConnection(ctx)
+ dcli, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("docker connect: %w", err)
}
- defer dcli.Close()
for _, id := range ids {
if id == "" {
@@ -369,11 +368,10 @@ func (s *UpdaterService) GetHistory(ctx context.Context, limit int) ([]models.Au
// --- internals ---
func (s *UpdaterService) updateContainer(ctx context.Context, cnt container.Summary, inspect container.InspectResponse, newRef string) error {
- dcli, err := s.dockerService.CreateConnection(ctx)
+ dcli, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("docker connect: %w", err)
}
- defer dcli.Close()
name := s.getContainerName(cnt)
slog.DebugContext(ctx, "updateContainer: starting update", "containerId", cnt.ID, "containerName", name, "newRef", newRef)
@@ -527,9 +525,9 @@ func (s *UpdaterService) isProjectOptedOut(ctx context.Context, dcli *client.Cli
func (s *UpdaterService) collectUsedImages(ctx context.Context) (map[string]struct{}, error) {
out := map[string]struct{}{}
- dcli, err := s.dockerService.CreateConnection(ctx)
+ dcli, err := s.dockerService.GetClient()
if err == nil && dcli != nil {
- defer dcli.Close()
+
slog.DebugContext(ctx, "collectUsedImages: docker connection created")
} else {
slog.DebugContext(ctx, "collectUsedImages: docker connection not available, continuing without container list", "err", err)
@@ -659,11 +657,10 @@ func (s *UpdaterService) recordRun(ctx context.Context, item dto.UpdaterItem) er
func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref string) ([]string, error) {
slog.DebugContext(ctx, "resolveLocalImageIDsForRef: resolving local image ids for ref", "ref", ref)
- dcli, err := s.dockerService.CreateConnection(ctx)
+ dcli, err := s.dockerService.GetClient()
if err != nil {
return nil, err
}
- defer dcli.Close()
ids := []string{}
if ii, err := dcli.ImageInspect(ctx, ref); err == nil && ii.ID != "" {
@@ -674,11 +671,10 @@ func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref str
}
func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDToNewRef map[string]string, oldRefToNewRef map[string]string) ([]dto.AutoUpdateResourceResult, error) {
- dcli, err := s.dockerService.CreateConnection(ctx)
+ dcli, err := s.dockerService.GetClient()
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 {
@@ -879,11 +875,10 @@ func (s *UpdaterService) anyImageIDsStillInUse(ctx context.Context, ids []string
slog.DebugContext(ctx, "anyImageIDsStillInUse: checking ids", "ids", ids)
- dcli, err := s.dockerService.CreateConnection(ctx)
+ dcli, err := s.dockerService.GetClient()
if err != nil {
return false, fmt.Errorf("docker connect: %w", err)
}
- defer dcli.Close()
list, err := dcli.ContainerList(ctx, container.ListOptions{All: false})
if err != nil {
diff --git a/backend/internal/services/user_service.go b/backend/internal/services/user_service.go
index 8ddae946f..8c8f8eb6b 100644
--- a/backend/internal/services/user_service.go
+++ b/backend/internal/services/user_service.go
@@ -131,30 +131,15 @@ func (s *UserService) validateArgon2Password(encodedHash, password string) error
}
func (s *UserService) CreateUser(ctx context.Context, user *models.User) (*models.User, error) {
- if err := s.db.WithContext(ctx).Create(user).Error; err != nil {
- return nil, fmt.Errorf("failed to create user: %w", err)
- }
- return user, nil
-}
-
-func (s *UserService) CreateUserWithPassword(username, password, email, role string, displayName string) (*models.User, error) {
- hashedPassword, err := s.hashPassword(password)
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Create(user).Error; err != nil {
+ return fmt.Errorf("failed to create user: %w", err)
+ }
+ return nil
+ })
if err != nil {
- return nil, fmt.Errorf("failed to hash password: %w", err)
- }
-
- user := &models.User{
- Username: username,
- Email: &email,
- DisplayName: &displayName,
- PasswordHash: hashedPassword,
- Roles: models.StringSlice{role},
- }
-
- if err := s.db.Create(user).Error; err != nil {
- return nil, fmt.Errorf("failed to create user: %w", err)
+ return nil, err
}
-
return user, nil
}
@@ -203,8 +188,14 @@ func (s *UserService) GetUserByEmail(ctx context.Context, email string) (*models
}
func (s *UserService) UpdateUser(ctx context.Context, user *models.User) (*models.User, error) {
- if err := s.db.WithContext(ctx).Save(user).Error; err != nil {
- return nil, fmt.Errorf("failed to update user: %w", err)
+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Save(user).Error; err != nil {
+ return fmt.Errorf("failed to update user: %w", err)
+ }
+ return nil
+ })
+ if err != nil {
+ return nil, err
}
return user, nil
}
@@ -213,6 +204,9 @@ func (s *UserService) UpdateUser(ctx context.Context, user *models.User) (*model
// It uses a row lock (FOR UPDATE) to prevent concurrent merges from racing and validates that the
// user isn't already linked to a different subject. The provided updateFn can mutate the user (e.g.,
// roles, display name, tokens, last login) before persisting.
+//
+// Note: The clause.Locking{Strength: "UPDATE"} statement is used to acquire a row-level lock.
+// This MUST be done inside a transaction to ensure the lock is held until the update is committed.
func (s *UserService) AttachOidcSubjectTransactional(ctx context.Context, userID string, subject string, updateFn func(u *models.User)) (*models.User, error) {
var out *models.User
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
@@ -255,49 +249,55 @@ func (s *UserService) AttachOidcSubjectTransactional(ctx context.Context, userID
return out, nil
}
-func (s *UserService) CountUsers() (int64, error) {
- var count int64
- if err := s.db.Model(&models.User{}).Count(&count).Error; err != nil {
- return 0, err
- }
- return count, nil
-}
-
-func (s *UserService) CreateDefaultAdmin() error {
- count, err := s.CountUsers()
+func (s *UserService) CreateDefaultAdmin(ctx context.Context) error {
+ // Hash password outside transaction to minimize lock time
+ hashedPassword, err := s.hashPassword("arcane-admin")
if err != nil {
- return fmt.Errorf("failed to count users: %w", err)
+ return fmt.Errorf("failed to hash default admin password: %w", err)
}
- if count > 0 {
- slog.Warn("Users already exist, skipping default admin creation")
- return nil
- }
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var count int64
+ if err := tx.Model(&models.User{}).Count(&count).Error; err != nil {
+ return fmt.Errorf("failed to count users: %w", err)
+ }
- user, err := s.CreateUserWithPassword("arcane", "arcane-admin", "admin@localhost", "admin", "Arcane Admin")
- if err != nil {
- return fmt.Errorf("failed to create default admin user: %w", err)
- }
+ if count > 0 {
+ slog.WarnContext(ctx, "Users already exist, skipping default admin creation")
+ return nil
+ }
- // Mark this user as requiring password change on first login
- user.RequiresPasswordChange = true
- if err := s.db.Save(user).Error; err != nil {
- slog.Warn("Failed to mark default admin for password change", "error", err)
- }
+ email := "admin@localhost"
+ displayName := "Arcane Admin"
+ user := &models.User{
+ Username: "arcane",
+ Email: &email,
+ DisplayName: &displayName,
+ PasswordHash: hashedPassword,
+ Roles: models.StringSlice{"admin"},
+ RequiresPasswordChange: true,
+ }
+
+ if err := tx.Create(user).Error; err != nil {
+ return fmt.Errorf("failed to create default admin user: %w", err)
+ }
- slog.Info("πŸ‘‘ Default admin user created!")
- slog.Info("πŸ”‘ Username: arcane")
- slog.Info("πŸ”‘ Password: arcane-admin")
- slog.Info("⚠️ User will be prompted to change password on first login")
+ slog.InfoContext(ctx, "πŸ‘‘ Default admin user created!")
+ slog.InfoContext(ctx, "πŸ”‘ Username: arcane")
+ slog.InfoContext(ctx, "πŸ”‘ Password: arcane-admin")
+ slog.InfoContext(ctx, "⚠️ User will be prompted to change password on first login")
- return nil
+ return nil
+ })
}
func (s *UserService) DeleteUser(ctx context.Context, id string) error {
- if err := s.db.WithContext(ctx).Delete(&models.User{}, "id = ?", id).Error; err != nil {
- return fmt.Errorf("failed to delete user: %w", err)
- }
- return nil
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Delete(&models.User{}, "id = ?", id).Error; err != nil {
+ return fmt.Errorf("failed to delete user: %w", err)
+ }
+ return nil
+ })
}
func (s *UserService) HashPassword(password string) (string, error) {
@@ -314,9 +314,14 @@ func (s *UserService) UpgradePasswordHash(ctx context.Context, userID, password
return fmt.Errorf("failed to create new hash: %w", err)
}
- return s.db.WithContext(ctx).Model(&models.User{}).
- Where("id = ?", userID).
- Update("password_hash", newHash).Error
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Model(&models.User{}).
+ Where("id = ?", userID).
+ Update("password_hash", newHash).Error; err != nil {
+ return fmt.Errorf("failed to update password hash: %w", err)
+ }
+ return nil
+ })
}
func (s *UserService) ListUsersPaginated(ctx context.Context, params pagination.QueryParams) ([]dto.UserResponseDto, pagination.Response, error) {
diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.go
index 17fa04de4..dde8e1704 100644
--- a/backend/internal/services/volume_service.go
+++ b/backend/internal/services/volume_service.go
@@ -33,11 +33,10 @@ func NewVolumeService(db *database.DB, dockerService *DockerClientService, event
}
func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*dto.VolumeDto, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
vol, err := dockerClient.VolumeInspect(ctx, name)
if err != nil {
@@ -79,12 +78,11 @@ func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*dto.
}
func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions, user models.User) (*dto.VolumeDto, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
created, err := dockerClient.VolumeCreate(ctx, options)
if err != nil {
@@ -116,12 +114,11 @@ func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateO
}
func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool, user models.User) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
if err := dockerClient.VolumeRemove(ctx, name, force); err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
@@ -146,11 +143,10 @@ func (s *VolumeService) PruneVolumes(ctx context.Context) (*dto.VolumePruneRepor
}
func (s *VolumeService) PruneVolumesWithOptions(ctx context.Context, all bool) (*dto.VolumePruneReportDto, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
// Docker's VolumesPrune behavior (API v1.42+):
// - Without 'all' flag: Only removes anonymous (unnamed) volumes that are not in use
@@ -191,11 +187,10 @@ func (s *VolumeService) PruneVolumesWithOptions(ctx context.Context, all bool) (
}
func (s *VolumeService) GetVolumeUsage(ctx context.Context, name string) (bool, []string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return false, nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
vol, err := dockerClient.VolumeInspect(ctx, name)
if err != nil {
@@ -370,11 +365,10 @@ func (s *VolumeService) buildPaginationResponse(result pagination.FilterResult[d
}
func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params pagination.QueryParams) ([]dto.VolumeDto, pagination.Response, dto.VolumeUsageCounts, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
+ dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, pagination.Response{}, dto.VolumeUsageCounts{}, fmt.Errorf("failed to connect to Docker: %w", err)
}
- defer dockerClient.Close()
volListBody, err := dockerClient.VolumeList(ctx, volume.ListOptions{})
if err != nil {
diff --git a/backend/internal/utils/bootstrap_util.go b/backend/internal/utils/bootstrap_util.go
index 9e57ca505..b7dbec11a 100644
--- a/backend/internal/utils/bootstrap_util.go
+++ b/backend/internal/utils/bootstrap_util.go
@@ -66,12 +66,12 @@ func TestDockerConnection(ctx context.Context, testFunc func(context.Context) er
}
}
-func InitializeNonAgentFeatures(ctx context.Context, cfg *config.Config, createAdminFunc func() error, syncOidcFunc func(context.Context) error) {
+func InitializeNonAgentFeatures(ctx context.Context, cfg *config.Config, createAdminFunc func(context.Context) error, syncOidcFunc func(context.Context) error) {
if cfg.AgentMode {
return
}
- if err := createAdminFunc(); err != nil {
+ if err := createAdminFunc(ctx); err != nil {
slog.WarnContext(ctx, "Failed to create default admin user",
slog.String("error", err.Error()))
}
diff --git a/backend/internal/utils/docker/volume_utils.go b/backend/internal/utils/docker/volume_utils.go
index bd3e91895..20d126c7d 100644
--- a/backend/internal/utils/docker/volume_utils.go
+++ b/backend/internal/utils/docker/volume_utils.go
@@ -72,12 +72,6 @@ func InvalidateVolumeUsageCache() {
volumeUsageCacheTime = time.Time{}
}
-func SetVolumeUsageCacheTTL(ttl time.Duration) {
- volumeUsageCacheMutex.Lock()
- defer volumeUsageCacheMutex.Unlock()
- volumeUsageCacheTTL = ttl
-}
-
func GetContainersUsingVolume(ctx context.Context, dockerClient *client.Client, volumeName string) ([]string, error) {
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
diff --git a/backend/internal/utils/filter_utils.go b/backend/internal/utils/filter_utils.go
deleted file mode 100644
index 969f895f2..000000000
--- a/backend/internal/utils/filter_utils.go
+++ /dev/null
@@ -1,151 +0,0 @@
-package utils
-
-import (
- "fmt"
- "net/url"
- "strconv"
- "strings"
-
- "github.com/docker/docker/api/types/filters"
-)
-
-// NormalizeQueryToFilters converts raw URL query into a flat filters map.
-// Supports: filters[foo]=bar, filters.foo=bar, foo=bar.
-func NormalizeQueryToFilters(q url.Values) map[string]interface{} {
- if q == nil {
- return nil
- }
- out := map[string]interface{}{}
- for k, vals := range q {
- // skip reserved
- if strings.HasPrefix(k, "pagination[") || strings.HasPrefix(k, "sort[") || k == "search" {
- continue
- }
- key := k
- if strings.HasPrefix(key, "filters[") && strings.HasSuffix(key, "]") {
- key = key[len("filters[") : len(key)-1]
- } else if strings.HasPrefix(key, "filters.") {
- key = key[len("filters."):]
- }
- if len(vals) == 1 {
- out[key] = vals[0]
- } else if len(vals) > 1 {
- out[key] = vals
- }
- }
- return out
-}
-
-// NormalizeFilterKeys flattens "filters[foo]" / "filters.foo" -> "foo".
-func NormalizeFilterKeys(filtersMap map[string]interface{}) map[string]interface{} {
- if filtersMap == nil {
- return nil
- }
- out := make(map[string]interface{}, len(filtersMap))
- for k, v := range filtersMap {
- key := strings.TrimSpace(k)
- if strings.HasPrefix(key, "filters[") && strings.HasSuffix(key, "]") {
- key = key[len("filters[") : len(key)-1]
- } else if strings.HasPrefix(key, "filters.") {
- key = key[len("filters."):]
- }
- out[key] = v
- }
- return out
-}
-
-// ParseBoolAny interprets many input types as boolean: true/false, 1/0, "true"/"false", etc.
-func ParseBoolAny(v interface{}) (bool, bool) {
- switch t := v.(type) {
- case bool:
- return t, true
- case string:
- s := strings.ToLower(strings.TrimSpace(t))
- if s == "true" || s == "1" {
- return true, true
- }
- if s == "false" || s == "0" {
- return false, true
- }
- if b, err := strconv.ParseBool(s); err == nil {
- return b, true
- }
- case []string:
- if len(t) > 0 {
- return ParseBoolAny(t[0])
- }
- case []interface{}:
- if len(t) > 0 {
- return ParseBoolAny(t[0])
- }
- default:
- s := fmt.Sprintf("%v", t)
- return ParseBoolAny(s)
- }
- return false, false
-}
-
-// BuildDockerFiltersFromMap builds Docker filters.Args from a flat filters map and a search string.
-// Only allowedKeys are forwarded to the daemon. Search is mapped to name filter when provided.
-func BuildDockerFiltersFromMap(filtersMap map[string]interface{}, search string, allowedKeys []string) filters.Args {
- f := filters.NewArgs()
- if strings.TrimSpace(search) != "" {
- f.Add("name", search)
- }
- allowed := map[string]bool{}
- for _, k := range allowedKeys {
- allowed[k] = true
- }
- for k, v := range filtersMap {
- if !allowed[k] {
- continue
- }
- switch t := v.(type) {
- case string:
- f.Add(k, t)
- case []string:
- for _, s := range t {
- f.Add(k, s)
- }
- case []interface{}:
- for _, it := range t {
- f.Add(k, fmt.Sprintf("%v", it))
- }
- default:
- f.Add(k, fmt.Sprintf("%v", t))
- }
- }
- return f
-}
-
-// PaginateSlice returns the page of items and a PaginationResponse.
-func PaginateSlice[T any](items []T, page, limit int) ([]T, PaginationResponse) {
- if limit <= 0 {
- limit = len(items)
- }
- if page <= 0 {
- page = 1
- }
- totalItems := len(items)
- startIdx := (page - 1) * limit
- if startIdx > totalItems {
- startIdx = totalItems
- }
- endIdx := startIdx + limit
- if endIdx > totalItems {
- endIdx = totalItems
- }
- var pageItems []T
- if startIdx < endIdx {
- pageItems = items[startIdx:endIdx]
- } else {
- pageItems = []T{}
- }
- totalPages := (totalItems + limit - 1) / limit
- return pageItems, PaginationResponse{
- TotalPages: int64(totalPages),
- TotalItems: int64(totalItems),
- CurrentPage: page,
- ItemsPerPage: limit,
- }
-}
diff --git a/backend/internal/utils/fs/fs_util.go b/backend/internal/utils/fs/fs_util.go
index a4c65a3a6..fb15b50d0 100644
--- a/backend/internal/utils/fs/fs_util.go
+++ b/backend/internal/utils/fs/fs_util.go
@@ -11,21 +11,6 @@ import (
"github.com/ofkm/arcane-backend/internal/utils/projects"
)
-func CountSubdirectories(path string) (int, error) {
- entries, err := os.ReadDir(path)
- if err != nil {
- return 0, fmt.Errorf("failed to read directory: %w", err)
- }
-
- count := 0
- for _, entry := range entries {
- if entry.IsDir() {
- count++
- }
- }
- return count, nil
-}
-
func GetProjectsDirectory(ctx context.Context, projectsDir string) (string, error) {
projectsDirectory := projectsDir
if projectsDirectory == "" {
diff --git a/backend/internal/utils/jwt_util.go b/backend/internal/utils/jwt_util.go
index 820a8ad7b..7fd274df9 100644
--- a/backend/internal/utils/jwt_util.go
+++ b/backend/internal/utils/jwt_util.go
@@ -161,13 +161,3 @@ func EvalMatch(v any, want []string) bool {
return false
}
}
-
-func SliceContainsFold(ss []string, want string) bool {
- want = strings.ToLower(want)
- for _, s := range ss {
- if strings.ToLower(s) == want {
- return true
- }
- }
- return false
-}
diff --git a/backend/internal/utils/page_util.go b/backend/internal/utils/page_util.go
deleted file mode 100644
index 9be2e110e..000000000
--- a/backend/internal/utils/page_util.go
+++ /dev/null
@@ -1,177 +0,0 @@
-package utils
-
-import (
- "reflect"
- "sort"
- "strconv"
- "strings"
-
- "gorm.io/gorm"
- "gorm.io/gorm/clause"
-)
-
-type PaginationResponse struct {
- TotalPages int64 `json:"totalPages"`
- TotalItems int64 `json:"totalItems"`
- CurrentPage int `json:"currentPage"`
- ItemsPerPage int `json:"itemsPerPage"`
- GrandTotalItems int64 `json:"grandTotalItems,omitempty"`
-}
-
-type SortedPaginationRequest struct {
- Pagination struct {
- Page int `form:"pagination[page]"`
- Limit int `form:"pagination[limit]"`
- } `form:"pagination"`
- Sort struct {
- Column string `form:"sort[column]"`
- Direction string `form:"sort[direction]"`
- } `form:"sort"`
- Search string `form:"search"`
- Filters map[string]interface{} `form:"filters"`
-}
-
-type SimplePaginationRequest struct {
- Page int `form:"page" json:"page"`
- Limit int `form:"limit" json:"limit"`
-}
-
-type SimpleSortRequest struct {
- Column string `form:"column" json:"column"`
- Direction string `form:"direction" json:"direction"`
-}
-
-type PaginationOptions struct {
- DefaultPageSize int
- MaxPageSize int
- AllowedSorts []string
-}
-
-func PaginateAndSort(sortedPaginationRequest SortedPaginationRequest, query *gorm.DB, result interface{}) (PaginationResponse, error) {
- pagination := sortedPaginationRequest.Pagination
- sort := sortedPaginationRequest.Sort
-
- capitalizedSortColumn := CapitalizeFirstLetter(sort.Column)
-
- sortField, sortFieldFound := reflect.TypeOf(result).Elem().Elem().FieldByName(capitalizedSortColumn)
- isSortable, _ := strconv.ParseBool(sortField.Tag.Get("sortable"))
-
- sort.Direction = NormalizeSortDirection(sort.Direction)
-
- if sortFieldFound && isSortable {
- columnName := CamelCaseToSnakeCase(sort.Column)
- query = query.Clauses(clause.OrderBy{
- Columns: []clause.OrderByColumn{
- {Column: clause.Column{Name: columnName}, Desc: sort.Direction == "desc"},
- },
- })
- }
-
- return Paginate(pagination.Page, pagination.Limit, query, result)
-}
-
-func NormalizeSortDirection(direction string) string {
- d := strings.ToLower(strings.TrimSpace(direction))
- if d != "asc" && d != "desc" {
- return "asc"
- }
- return d
-}
-
-func Paginate(page int, pageSize int, query *gorm.DB, result interface{}) (PaginationResponse, error) {
- if page < 1 {
- page = 1
- }
-
- if pageSize < 1 {
- pageSize = 20
- } else if pageSize > 100 {
- pageSize = 100
- }
-
- offset := (page - 1) * pageSize
-
- var totalItems int64
- if err := query.Count(&totalItems).Error; err != nil {
- return PaginationResponse{}, err
- }
-
- if err := query.Offset(offset).Limit(pageSize).Find(result).Error; err != nil {
- return PaginationResponse{}, err
- }
-
- totalPages := (totalItems + int64(pageSize) - 1) / int64(pageSize)
- if totalItems == 0 {
- totalPages = 1
- }
-
- return PaginationResponse{
- TotalPages: totalPages,
- TotalItems: totalItems,
- CurrentPage: page,
- ItemsPerPage: pageSize,
- }, nil
-}
-
-//nolint:gocognit
-func SortSliceByField(data []map[string]interface{}, field, direction string) {
- if field == "" {
- return
- }
-
- sort.Slice(data, func(i, j int) bool {
- val1, exists1 := data[i][field]
- val2, exists2 := data[j][field]
-
- if !exists1 && !exists2 {
- return false
- }
- if !exists1 {
- return direction == "desc"
- }
- if !exists2 {
- return direction == "asc"
- }
-
- switch v1 := val1.(type) {
- case string:
- v2, ok := val2.(string)
- if !ok {
- return false
- }
- if direction == "desc" {
- return v1 > v2
- }
- return v1 < v2
- case int:
- v2, ok := val2.(int)
- if !ok {
- return false
- }
- if direction == "desc" {
- return v1 > v2
- }
- return v1 < v2
- case int64:
- v2, ok := val2.(int64)
- if !ok {
- return false
- }
- if direction == "desc" {
- return v1 > v2
- }
- return v1 < v2
- case float64:
- v2, ok := val2.(float64)
- if !ok {
- return false
- }
- if direction == "desc" {
- return v1 > v2
- }
- return v1 < v2
- default:
- return false
- }
- })
-}
diff --git a/backend/internal/utils/pagination/helpers.go b/backend/internal/utils/pagination/helpers.go
deleted file mode 100644
index b93422994..000000000
--- a/backend/internal/utils/pagination/helpers.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package pagination
-
-func ConvertQueryParamsToSortedRequest(q QueryParams) SortedPaginationRequest {
- limit := q.Limit
- if limit <= 0 {
- limit = 20
- }
-
- page := 1
- if limit > 0 {
- page = (q.Start / limit) + 1
- }
-
- var r SortedPaginationRequest
- r.Search = q.Search
- r.Sort.Column = q.sort
-
- // Convert SortOrder to string and default to asc when empty
- order := q.order
- if order == "" {
- order = SortAsc
- }
- r.Sort.Direction = string(order)
-
- r.Pagination.Page = page
- r.Pagination.Limit = limit
-
- return r
-}
diff --git a/backend/internal/utils/pagination/reflect.go b/backend/internal/utils/pagination/reflect.go
index ea0822ecb..df2c815c6 100644
--- a/backend/internal/utils/pagination/reflect.go
+++ b/backend/internal/utils/pagination/reflect.go
@@ -4,6 +4,7 @@ import (
"reflect"
"strconv"
+ "github.com/ofkm/arcane-backend/internal/utils"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
@@ -16,14 +17,14 @@ func PaginateAndSortDB(params QueryParams, query *gorm.DB, result interface{}) (
sortDirection = "asc"
}
- capitalizedSortColumn := capitalizeFirstLetter(sortColumn)
+ capitalizedSortColumn := utils.CapitalizeFirstLetter(sortColumn)
sortField, sortFieldFound := reflect.TypeOf(result).Elem().Elem().FieldByName(capitalizedSortColumn)
isSortable, _ := strconv.ParseBool(sortField.Tag.Get("sortable"))
sortDirection = normalizeSortDirection(sortDirection)
if sortFieldFound && isSortable {
- columnName := camelCaseToSnakeCase(sortColumn)
+ columnName := utils.CamelCaseToSnakeCase(sortColumn)
query = query.Clauses(clause.OrderBy{
Columns: []clause.OrderByColumn{
{Column: clause.Column{Name: columnName}, Desc: sortDirection == "desc"},
@@ -81,25 +82,3 @@ func normalizeSortDirection(direction string) string {
}
return direction
}
-
-func capitalizeFirstLetter(str string) string {
- if len(str) == 0 {
- return str
- }
- return string(str[0]-32) + str[1:]
-}
-
-func camelCaseToSnakeCase(str string) string {
- var result []rune
- for i, r := range str {
- if i > 0 && r >= 'A' && r <= 'Z' {
- result = append(result, '_')
- }
- if r >= 'A' && r <= 'Z' {
- result = append(result, r+32)
- } else {
- result = append(result, r)
- }
- }
- return string(result)
-}
diff --git a/backend/internal/utils/pagination/types.go b/backend/internal/utils/pagination/types.go
index 0be080c5f..5aac560b4 100644
--- a/backend/internal/utils/pagination/types.go
+++ b/backend/internal/utils/pagination/types.go
@@ -7,16 +7,3 @@ type Response struct {
ItemsPerPage int `json:"itemsPerPage"`
GrandTotalItems int64 `json:"grandTotalItems,omitempty"`
}
-
-type SortedPaginationRequest struct {
- Pagination struct {
- Page int `form:"pagination[page]"`
- Limit int `form:"pagination[limit]"`
- } `form:"pagination"`
- Sort struct {
- Column string `form:"sort[column]"`
- Direction string `form:"sort[direction]"`
- } `form:"sort"`
- Search string `form:"search"`
- Filters map[string]interface{} `form:"filters"`
-}
diff --git a/backend/internal/utils/projects/cmds.go b/backend/internal/utils/projects/cmds.go
index dfff9ea8f..8b9f26320 100644
--- a/backend/internal/utils/projects/cmds.go
+++ b/backend/internal/utils/projects/cmds.go
@@ -6,6 +6,8 @@ import (
"github.com/compose-spec/compose-go/v2/types"
"github.com/docker/compose/v2/pkg/api"
+ "github.com/docker/docker/api/types/container"
+ "github.com/docker/docker/api/types/filters"
)
func ComposeRestart(ctx context.Context, proj *types.Project, services []string) error {
@@ -65,3 +67,20 @@ func ComposeLogs(ctx context.Context, projectName string, out io.Writer, follow
return c.svc.Logs(ctx, projectName, writerConsumer{out: out}, api.LogOptions{Follow: follow, Tail: tail})
}
+
+func ListGlobalComposeContainers(ctx context.Context) ([]container.Summary, error) {
+ c, err := NewClient(ctx)
+ if err != nil {
+ return nil, err
+ }
+ defer c.Close()
+
+ cli := c.dockerCli.Client()
+ filter := filters.NewArgs()
+ filter.Add("label", "com.docker.compose.project")
+
+ return cli.ContainerList(ctx, container.ListOptions{
+ All: true,
+ Filters: filter,
+ })
+}
diff --git a/backend/internal/utils/projects/env.go b/backend/internal/utils/projects/env.go
index e55390423..5fc7745fe 100644
--- a/backend/internal/utils/projects/env.go
+++ b/backend/internal/utils/projects/env.go
@@ -63,29 +63,6 @@ func (l *EnvLoader) LoadEnvironment(ctx context.Context) (envMap EnvMap, injecti
return envMap, injectionVars, nil
}
-// LoadGlobalEnvironment loads only global environment variables:
-// 1. Process environment
-// 2. Global .env.global file (from projects directory)
-// This allows compose-go to load project-specific .env files and do interpolation
-func (l *EnvLoader) LoadGlobalEnvironment(ctx context.Context) (envMap EnvMap, injectionVars EnvMap, err error) {
- envMap = l.loadProcessEnv()
- injectionVars = make(EnvMap)
-
- globalEnvPath := filepath.Join(l.projectsDir, globalEnvFileName)
- if err := l.ensureGlobalEnvFile(ctx, globalEnvPath); err != nil {
- slog.WarnContext(ctx, "Failed to ensure global env file", "path", globalEnvPath, "error", err)
- }
-
- if err := l.loadAndMergeGlobalEnv(ctx, globalEnvPath, envMap, injectionVars); err != nil {
- slog.WarnContext(ctx, "Failed to load global env", "path", globalEnvPath, "error", err)
- }
-
- // Note: Project-specific .env file is NOT loaded here
- // compose-go loader will load it automatically and handle interpolation
-
- return envMap, injectionVars, nil
-}
-
func (l *EnvLoader) loadProcessEnv() EnvMap {
envMap := make(EnvMap)
for _, kv := range os.Environ() {
diff --git a/backend/internal/utils/projects/includes.go b/backend/internal/utils/projects/includes.go
index 0a9b517ba..b4292760f 100644
--- a/backend/internal/utils/projects/includes.go
+++ b/backend/internal/utils/projects/includes.go
@@ -112,15 +112,6 @@ func parseIncludeItem(item interface{}, baseDir string) (IncludeFile, error) {
}, nil
}
-// ValidateIncludePathForRead validates that an include path is safe to read
-// Allows reading from anywhere (Docker Compose includes can reference external files)
-func ValidateIncludePathForRead(includePath string) error {
- if includePath == "" {
- return fmt.Errorf("include path cannot be empty")
- }
- return nil
-}
-
// ValidateIncludePathForWrite ensures the include path is safe for write operations
// Returns the validated absolute path to prevent recomputation after validation
// Only allows writing within the project directory
@@ -250,19 +241,3 @@ func WriteIncludeFile(projectDir, includePath, content string) error {
return nil
}
-
-// DeleteIncludeFile removes an include file
-func DeleteIncludeFile(projectDir, includePath string) error {
- // Get validated absolute path - only allows deletes within project
- validatedPath, err := ValidateIncludePathForWrite(projectDir, includePath)
- if err != nil {
- return err
- }
-
- // Use the validated path for the operation
- if err := os.Remove(validatedPath); err != nil && !os.IsNotExist(err) {
- return fmt.Errorf("failed to delete include file: %w", err)
- }
-
- return nil
-}
diff --git a/backend/internal/utils/registry/registry_test.go b/backend/internal/utils/registry/registry_test.go
index 24fd36e8a..ea6481e11 100644
--- a/backend/internal/utils/registry/registry_test.go
+++ b/backend/internal/utils/registry/registry_test.go
@@ -7,9 +7,7 @@ import (
"net/http"
"net/http/httptest"
"net/url"
- "strings"
"testing"
- "time"
)
func TestCheckAuthParsesRealmAndService(t *testing.T) {
@@ -88,41 +86,3 @@ func TestGetLatestDigestLowerCaseHeader(t *testing.T) {
t.Fatalf("digest %q", d)
}
}
-
-func TestGetImageTagsPagination(t *testing.T) {
- t.Parallel()
- var server *httptest.Server
- type tagsResp struct {
- Tags []string `json:"tags"`
- }
- handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- switch {
- case r.URL.Path == "/v2/org/repo/tags/list" && (r.URL.RawQuery == "" || r.URL.RawQuery == "page=1"):
- page2 := server.URL + "/v2/org/repo/tags/list?page=2"
- w.Header().Set("Link", `<`+page2+`>; rel="next"`)
- if err := json.NewEncoder(w).Encode(tagsResp{Tags: []string{"a", "b"}}); err != nil {
- http.Error(w, "encode error: "+err.Error(), http.StatusInternalServerError)
- }
- case r.URL.Path == "/v2/org/repo/tags/list" && r.URL.RawQuery == "page=2":
- if err := json.NewEncoder(w).Encode(tagsResp{Tags: []string{"c"}}); err != nil {
- http.Error(w, "encode error: "+err.Error(), http.StatusInternalServerError)
- }
- default:
- http.NotFound(w, r)
- }
- })
- server = httptest.NewServer(handler)
- defer server.Close()
-
- c := NewClient()
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- defer cancel()
-
- tags, err := c.GetImageTags(ctx, server.URL, "org/repo", "")
- if err != nil {
- t.Fatalf("err: %v", err)
- }
- if strings.Join(tags, ",") != "a,b,c" {
- t.Fatalf("tags %v", tags)
- }
-}
diff --git a/backend/internal/utils/registry/tags.go b/backend/internal/utils/registry/tags.go
deleted file mode 100644
index b2bed000d..000000000
--- a/backend/internal/utils/registry/tags.go
+++ /dev/null
@@ -1,83 +0,0 @@
-package registry
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "net/http"
- "strings"
- "time"
-)
-
-func (c *Client) GetImageTags(ctx context.Context, registry, repository, token string) ([]string, error) {
- url := fmt.Sprintf("%s/v2/%s/tags/list", c.GetRegistryURL(registry), repository)
-
- var all []string
- next := url
- for next != "" {
- reqCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
- defer cancel()
-
- req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, next, nil)
- if err != nil {
- return nil, err
- }
- req.Header.Set("Accept", "application/json")
- if token != "" {
- req.Header.Set("Authorization", "Bearer "+token)
- }
- resp, err := c.http.Do(req)
- if err != nil {
- return nil, err
- }
- func() {
- defer resp.Body.Close()
- if resp.StatusCode == http.StatusUnauthorized {
- h := resp.Header.Get("WWW-Authenticate")
- if h == "" {
- h = resp.Header.Get("Www-Authenticate")
- }
- if h != "" {
- err = fmt.Errorf("unauthorized: %s", h)
- } else {
- err = fmt.Errorf("tags request failed with status: 401")
- }
- return
- }
- if resp.StatusCode != http.StatusOK {
- err = fmt.Errorf("tags request failed with status: %d", resp.StatusCode)
- return
- }
- var body struct {
- Tags []string `json:"tags"`
- }
- if decErr := json.NewDecoder(resp.Body).Decode(&body); decErr != nil {
- err = decErr
- return
- }
- all = append(all, body.Tags...)
- next = parseLinkHeader(resp.Header.Get("Link"))
- }()
- if err != nil {
- return nil, err
- }
- }
- return all, nil
-}
-
-func parseLinkHeader(h string) string {
- if h == "" {
- return ""
- }
- for _, part := range strings.Split(h, ",") {
- p := strings.TrimSpace(part)
- if strings.Contains(p, `rel="next"`) {
- l := strings.Index(p, "<")
- r := strings.Index(p, ">")
- if l != -1 && r > l {
- return p[l+1 : r]
- }
- }
- }
- return ""
-}
diff --git a/backend/internal/utils/sort.go b/backend/internal/utils/sort.go
deleted file mode 100644
index 579476f68..000000000
--- a/backend/internal/utils/sort.go
+++ /dev/null
@@ -1,57 +0,0 @@
-package utils
-
-import (
- "sort"
- "strings"
- "time"
-
- "github.com/ofkm/arcane-backend/internal/dto"
-)
-
-// SortUserResponses sorts a slice of UserResponseDto structs by the specified column and direction
-func SortUserResponses(users []dto.UserResponseDto, column, direction string) {
- sort.Slice(users, func(i, j int) bool {
- var aVal, bVal interface{}
-
- switch column {
- case "username":
- aVal, bVal = users[i].Username, users[j].Username
- case "displayName":
- aVal, bVal = getStringPtrValue(users[i].DisplayName), getStringPtrValue(users[j].DisplayName)
- case "email":
- aVal, bVal = getStringPtrValue(users[i].Email), getStringPtrValue(users[j].Email)
- case "roles":
- aVal, bVal = strings.Join(users[i].Roles, ","), strings.Join(users[j].Roles, ",")
- case "createdAt", "updatedAt":
- aTime, _ := time.Parse("2006-01-02T15:04:05.999999Z", users[i].CreatedAt)
- bTime, _ := time.Parse("2006-01-02T15:04:05.999999Z", users[j].CreatedAt)
- if column == "updatedAt" {
- aTime, _ = time.Parse("2006-01-02T15:04:05.999999Z", users[i].UpdatedAt)
- bTime, _ = time.Parse("2006-01-02T15:04:05.999999Z", users[j].UpdatedAt)
- }
- if direction == "desc" {
- return aTime.After(bTime)
- }
- return aTime.Before(bTime)
- default:
- return false
- }
-
- // Handle string comparison
- aStr := strings.ToLower(aVal.(string))
- bStr := strings.ToLower(bVal.(string))
-
- if direction == "desc" {
- return aStr > bStr
- }
- return aStr < bStr
- })
-}
-
-// getStringPtrValue safely gets the value from a string pointer
-func getStringPtrValue(ptr *string) string {
- if ptr == nil {
- return ""
- }
- return *ptr
-}
diff --git a/backend/internal/utils/string_util.go b/backend/internal/utils/string_util.go
index 9ffaf1436..4d148fa7c 100644
--- a/backend/internal/utils/string_util.go
+++ b/backend/internal/utils/string_util.go
@@ -2,7 +2,6 @@ package utils
import (
"crypto/rand"
- "crypto/sha256"
"encoding/base64"
"regexp"
"strings"
@@ -43,8 +42,3 @@ func GenerateRandomString(length int) string {
}
return base64.URLEncoding.EncodeToString(bytes)[:length]
}
-
-func GenerateCodeChallenge(verifier string) string {
- hash := sha256.Sum256([]byte(verifier))
- return base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(hash[:])
-}
diff --git a/backend/internal/utils/ws/bridge.go b/backend/internal/utils/ws/bridge.go
index edc78a614..9fadd591f 100644
--- a/backend/internal/utils/ws/bridge.go
+++ b/backend/internal/utils/ws/bridge.go
@@ -57,8 +57,8 @@ func ForwardLogJSONBatched(ctx context.Context, hub *Hub, logs <-chan LogMessage
ForwardLogJSON(ctx, hub, logs)
return
}
- t := time.NewTimer(flushInterval)
- defer t.Stop()
+ ticker := time.NewTicker(flushInterval)
+ defer ticker.Stop()
buf := make([]LogMessage, 0, maxBatch)
@@ -89,14 +89,9 @@ func ForwardLogJSONBatched(ctx context.Context, hub *Hub, logs <-chan LogMessage
buf = append(buf, m)
if len(buf) >= maxBatch {
flush()
- if !t.Stop() {
- <-t.C
- }
- t.Reset(flushInterval)
}
- case <-t.C:
+ case <-ticker.C:
flush()
- t.Reset(flushInterval)
}
}
}
diff --git a/backend/internal/utils/ws/client.go b/backend/internal/utils/ws/client.go
index 13e8f9a52..6b5c3a5f6 100644
--- a/backend/internal/utils/ws/client.go
+++ b/backend/internal/utils/ws/client.go
@@ -15,7 +15,8 @@ const (
pongWait = 60 * time.Second
pingPeriod = pongWait * 9 / 10
- maxMessageSize = 64 * 1024
+ maxMessageSize = 64 * 1024
+ clientSendBuffer = 256
)
// Client represents a single WebSocket connection.
@@ -37,7 +38,7 @@ func NewClient(conn *websocket.Conn, sendBuffer int) *Client {
// ServeClient registers the client with the hub and starts read/write pumps.
// Caller is responsible for creating/closing the websocket.Conn.
func ServeClient(ctx context.Context, hub *Hub, conn *websocket.Conn) {
- c := NewClient(conn, 256)
+ c := NewClient(conn, clientSendBuffer)
hub.register <- c
go c.writePump(ctx, hub)
diff --git a/backend/internal/utils/ws/hub.go b/backend/internal/utils/ws/hub.go
index 1b7ff47f8..4409cfddd 100644
--- a/backend/internal/utils/ws/hub.go
+++ b/backend/internal/utils/ws/hub.go
@@ -38,10 +38,11 @@ func (h *Hub) SetOnEmpty(fn func()) {
}
func (h *Hub) Run(ctx context.Context) {
+ defer h.closeAll()
+
for {
select {
case <-ctx.Done():
- h.closeAll()
return
case c := <-h.register:
h.mu.Lock()
@@ -50,12 +51,16 @@ func (h *Hub) Run(ctx context.Context) {
case c := <-h.unregister:
h.remove(c)
if h.ClientCount() == 0 {
+ // Run onEmpty callback in a separate goroutine to avoid blocking the hub
go func() {
+ // Yield to allow other goroutines to run
runtime.Gosched()
+
h.mu.RLock()
empty := len(h.clients) == 0
onEmpty := h.onEmpty
h.mu.RUnlock()
+
if empty && onEmpty != nil {
onEmpty()
}
@@ -63,15 +68,21 @@ func (h *Hub) Run(ctx context.Context) {
}
case msg := <-h.broadcast:
h.mu.RLock()
+ var slowClients []*Client
for c := range h.clients {
select {
case c.send <- msg:
default:
// backpressure: drop slow client
- go h.remove(c)
+ // Collect them to remove outside the lock to avoid spawning goroutines
+ slowClients = append(slowClients, c)
}
}
h.mu.RUnlock()
+
+ for _, c := range slowClients {
+ h.remove(c)
+ }
}
}
}
@@ -81,6 +92,7 @@ func (h *Hub) Broadcast(msg []byte) {
case h.broadcast <- msg:
default:
// prevent global stall if hub buffer fills
+ // This indicates the hub is not processing messages fast enough
slog.Warn("websocket hub broadcast buffer full; dropping message")
}
}
diff --git a/backend/internal/utils/ws/parse.go b/backend/internal/utils/ws/parse.go
index 1ba373062..d74951cc0 100644
--- a/backend/internal/utils/ws/parse.go
+++ b/backend/internal/utils/ws/parse.go
@@ -14,36 +14,51 @@ var (
// NormalizeContainerLine parses a raw container log line into level + cleaned message.
// It extracts Docker's timestamp if present (when timestamps=true in Docker API).
func NormalizeContainerLine(raw string) (level string, msg string, timestamp string) {
- line := strings.TrimRight(raw, "\r\n")
+ // Fast trim right for common cases to avoid scanning the whole string
+ end := len(raw)
+ for end > 0 {
+ c := raw[end-1]
+ if c != '\n' && c != '\r' {
+ break
+ }
+ end--
+ }
+ line := raw[:end]
level = "stdout"
+ // Check prefixes using slicing for performance
switch {
case strings.HasPrefix(line, "[STDERR] "):
level = "stderr"
- line = strings.TrimPrefix(line, "[STDERR] ")
+ line = line[9:]
case strings.HasPrefix(line, "stderr:"):
level = "stderr"
- line = strings.TrimPrefix(line, "stderr:")
+ line = line[7:]
case strings.HasPrefix(line, "stdout:"):
level = "stdout"
- line = strings.TrimPrefix(line, "stdout:")
+ line = line[7:]
}
// Extract and strip Docker's RFC3339 timestamp (when timestamps=true)
- timestamp = ""
- if match := dockerTimestamp.FindString(line); match != "" {
- trimmed := strings.TrimSpace(match)
- if parsed, err := time.Parse(time.RFC3339Nano, trimmed); err == nil {
- timestamp = parsed.UTC().Format(time.RFC3339Nano)
- } else if parsed, err := time.Parse(time.RFC3339, trimmed); err == nil {
- timestamp = parsed.UTC().Format(time.RFC3339Nano)
+ // Optimization: Check if it looks like a timestamp before running regex
+ if len(line) > 20 && line[0] >= '0' && line[0] <= '9' {
+ if loc := dockerTimestamp.FindStringIndex(line); loc != nil {
+ // loc[0] is start, loc[1] is end
+ matchStr := line[loc[0]:loc[1]]
+ trimmed := strings.TrimSpace(matchStr)
+
+ if parsed, err := time.Parse(time.RFC3339Nano, trimmed); err == nil {
+ timestamp = parsed.UTC().Format(time.RFC3339Nano)
+ } else if parsed, err := time.Parse(time.RFC3339, trimmed); err == nil {
+ timestamp = parsed.UTC().Format(time.RFC3339Nano)
+ }
+
+ // Strip the timestamp from the line
+ line = line[loc[1]:]
}
- line = strings.TrimPrefix(line, match)
}
// Return the message as-is (including any application-level timestamps)
- // The frontend will display Docker's timestamp, and applications can
- // include their own timestamps in the message if they want
return level, strings.TrimSpace(line), timestamp
}