Skip to content

Modern Docker Management, Designed for Everyone

chore: fix go lint issues (#312)

Kyle Mendellc2b09924fcd0
diff --git a/backend/frontend/frontend.go b/backend/frontend/frontend.go
index 165aa9692..eca716424 100644
--- a/backend/frontend/frontend.go
+++ b/backend/frontend/frontend.go
@@ -52,7 +52,6 @@ func RegisterFrontend(router *gin.Engine) error {
if _, err := fs.Stat(distFS, requestedPath); os.IsNotExist(err) {
c.Request.URL.Path = "/"
- requestedPath = "index.html"
}
fileServer.ServeHTTP(c.Writer, c.Request)
diff --git a/backend/internal/api/auth_handler.go b/backend/internal/api/auth_handler.go
index 72564fa6b..10f4d0cef 100644
--- a/backend/internal/api/auth_handler.go
+++ b/backend/internal/api/auth_handler.go
@@ -1,6 +1,7 @@
package api
import (
+ "errors"
"net/http"
"time"
@@ -70,7 +71,6 @@ func (h *AuthHandler) Login(c *gin.Context) {
return
}
- // Check if local auth is enabled
localAuthEnabled, err := h.authService.IsLocalAuthEnabled(c.Request.Context())
if err != nil {
c.JSON(http.StatusInternalServerError, LoginResponse{
@@ -88,11 +88,10 @@ func (h *AuthHandler) Login(c *gin.Context) {
return
}
- // Authenticate user
user, tokenPair, err := h.authService.Login(c.Request.Context(), req.Username, req.Password)
// Handle password change required
- if err == services.ErrPasswordChangeRequired && user != nil {
+ if errors.Is(err, services.ErrPasswordChangeRequired) && user != nil {
c.JSON(http.StatusOK, LoginResponse{
Success: true,
RequirePasswordChange: true,
@@ -112,11 +111,11 @@ func (h *AuthHandler) Login(c *gin.Context) {
var statusCode int
var errorMsg string
- switch err {
- case services.ErrInvalidCredentials:
+ switch {
+ case errors.Is(err, services.ErrInvalidCredentials):
statusCode = http.StatusUnauthorized
errorMsg = "Invalid username or password"
- case services.ErrLocalAuthDisabled:
+ case errors.Is(err, services.ErrLocalAuthDisabled):
statusCode = http.StatusBadRequest
errorMsg = "Local authentication is disabled"
default:
@@ -222,8 +221,8 @@ func (h *AuthHandler) RefreshToken(c *gin.Context) {
var statusCode int
var errorMsg string
- switch err {
- case services.ErrInvalidToken, services.ErrExpiredToken:
+ switch {
+ case errors.Is(err, services.ErrInvalidToken), errors.Is(err, services.ErrExpiredToken):
statusCode = http.StatusUnauthorized
errorMsg = "Invalid or expired refresh token"
default:
@@ -296,8 +295,8 @@ func (h *AuthHandler) ChangePassword(c *gin.Context) {
var statusCode int
var errorMsg string
- switch err {
- case services.ErrInvalidCredentials:
+ switch {
+ case errors.Is(err, services.ErrInvalidCredentials):
statusCode = http.StatusUnauthorized
errorMsg = "Current password is incorrect"
default:
diff --git a/backend/internal/api/environment_handler.go b/backend/internal/api/environment_handler.go
index 79244b48b..26a1a4f53 100644
--- a/backend/internal/api/environment_handler.go
+++ b/backend/internal/api/environment_handler.go
@@ -55,143 +55,192 @@ func (h *EnvironmentHandler) routeRequest(c *gin.Context, endpoint string) {
}
func (h *EnvironmentHandler) handleLocalRequest(c *gin.Context, endpoint string) {
+ if h.handleContainerEndpoints(c, endpoint) {
+ return
+ }
+ if h.handleImageEndpoints(c, endpoint) {
+ return
+ }
+ if h.handleNetworkEndpoints(c, endpoint) {
+ return
+ }
+ if h.handleVolumeEndpoints(c, endpoint) {
+ return
+ }
+ if h.handleStackEndpoints(c, endpoint) {
+ return
+ }
+
+ c.JSON(http.StatusNotFound, gin.H{
+ "success": false,
+ "error": "Endpoint not found",
+ })
+}
+
+func (h *EnvironmentHandler) handleContainerEndpoints(c *gin.Context, endpoint string) bool {
+ containerHandler := NewContainerHandler(h.containerService, h.imageService)
+
switch {
- case endpoint == "/containers" && c.Request.Method == "GET":
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
+ case endpoint == "/containers" && c.Request.Method == http.MethodGet:
containerHandler.List(c)
- case endpoint == "/containers" && c.Request.Method == "POST":
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
+ return true
+ case endpoint == "/containers" && c.Request.Method == http.MethodPost:
containerHandler.Create(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/start"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.Start(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/stop"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.Stop(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/restart"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.Restart(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/pull"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.PullImage(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/logs"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.GetLogs(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/stats/stream"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.GetStatsStream(c)
+ return true
case strings.HasPrefix(endpoint, "/containers/") && strings.HasSuffix(endpoint, "/stats"):
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
containerHandler.GetStats(c)
- case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == "GET":
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
+ return true
+ case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == http.MethodGet:
containerHandler.GetByID(c)
- case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == "DELETE":
- containerHandler := NewContainerHandler(h.containerService, h.imageService)
+ return true
+ case strings.HasPrefix(endpoint, "/containers/") && c.Request.Method == http.MethodDelete:
containerHandler.Delete(c)
+ return true
+ }
+ return false
+}
+
+func (h *EnvironmentHandler) handleImageEndpoints(c *gin.Context, endpoint string) bool {
+ imageHandler := NewImageHandler(h.imageService, nil)
- case endpoint == "/images" && c.Request.Method == "GET":
- imageHandler := NewImageHandler(h.imageService, nil)
+ switch {
+ case endpoint == "/images" && c.Request.Method == http.MethodGet:
imageHandler.List(c)
- case endpoint == "/images/pull" && c.Request.Method == "POST":
- imageHandler := NewImageHandler(h.imageService, nil)
+ return true
+ case endpoint == "/images/pull" && c.Request.Method == http.MethodPost:
imageHandler.Pull(c)
- case endpoint == "/images/prune" && c.Request.Method == "POST":
- imageHandler := NewImageHandler(h.imageService, nil)
+ return true
+ case endpoint == "/images/prune" && c.Request.Method == http.MethodPost:
imageHandler.Prune(c)
- case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == "GET":
- imageHandler := NewImageHandler(h.imageService, nil)
+ return true
+ case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == http.MethodGet:
imageHandler.GetByID(c)
- case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == "DELETE":
- imageHandler := NewImageHandler(h.imageService, nil)
+ return true
+ case strings.HasPrefix(endpoint, "/images/") && c.Request.Method == http.MethodDelete:
imageHandler.Remove(c)
+ return true
+ }
+ return false
+}
+
+func (h *EnvironmentHandler) handleNetworkEndpoints(c *gin.Context, endpoint string) bool {
+ networkHandler := NewNetworkHandler(h.networkService)
- case endpoint == "/networks" && c.Request.Method == "GET":
- networkHandler := NewNetworkHandler(h.networkService)
+ switch {
+ case endpoint == "/networks" && c.Request.Method == http.MethodGet:
networkHandler.List(c)
- case endpoint == "/networks" && c.Request.Method == "POST":
- networkHandler := NewNetworkHandler(h.networkService)
+ return true
+ case endpoint == "/networks" && c.Request.Method == http.MethodPost:
networkHandler.Create(c)
- case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == "GET":
- networkHandler := NewNetworkHandler(h.networkService)
+ return true
+ case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == http.MethodGet:
networkHandler.GetByID(c)
- case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == "DELETE":
- networkHandler := NewNetworkHandler(h.networkService)
+ return true
+ case strings.HasPrefix(endpoint, "/networks/") && c.Request.Method == http.MethodDelete:
networkHandler.Remove(c)
+ return true
+ }
+ return false
+}
- case endpoint == "/volumes" && c.Request.Method == "GET":
- volumeHandler := NewVolumeHandler(h.volumeService)
+func (h *EnvironmentHandler) handleVolumeEndpoints(c *gin.Context, endpoint string) bool {
+ volumeHandler := NewVolumeHandler(h.volumeService)
+
+ switch {
+ case endpoint == "/volumes" && c.Request.Method == http.MethodGet:
volumeHandler.List(c)
- case endpoint == "/volumes" && c.Request.Method == "POST":
- volumeHandler := NewVolumeHandler(h.volumeService)
+ return true
+ case endpoint == "/volumes" && c.Request.Method == http.MethodPost:
volumeHandler.Create(c)
- case endpoint == "/volumes/prune" && c.Request.Method == "POST":
- volumeHandler := NewVolumeHandler(h.volumeService)
+ return true
+ case endpoint == "/volumes/prune" && c.Request.Method == http.MethodPost:
volumeHandler.Prune(c)
- case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == "GET":
- volumeHandler := NewVolumeHandler(h.volumeService)
- volumeHandler.GetByName(c)
- case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == "DELETE":
- volumeHandler := NewVolumeHandler(h.volumeService)
- volumeHandler.Remove(c)
+ return true
case strings.HasPrefix(endpoint, "/volumes/") && strings.HasSuffix(endpoint, "/usage"):
- volumeHandler := NewVolumeHandler(h.volumeService)
volumeHandler.GetUsage(c)
+ return true
+ case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == http.MethodGet:
+ volumeHandler.GetByName(c)
+ return true
+ case strings.HasPrefix(endpoint, "/volumes/") && c.Request.Method == http.MethodDelete:
+ volumeHandler.Remove(c)
+ return true
+ }
+ return false
+}
- case endpoint == "/stacks" && c.Request.Method == "GET":
- stackHandler := NewStackHandler(h.stackService)
+func (h *EnvironmentHandler) handleStackEndpoints(c *gin.Context, endpoint string) bool {
+ stackHandler := NewStackHandler(h.stackService)
+
+ switch {
+ case endpoint == "/stacks" && c.Request.Method == http.MethodGet:
stackHandler.ListStacks(c)
- case endpoint == "/stacks" && c.Request.Method == "POST":
- stackHandler := NewStackHandler(h.stackService)
+ return true
+ case endpoint == "/stacks" && c.Request.Method == http.MethodPost:
stackHandler.CreateStack(c)
+ return true
+ case endpoint == "/stacks/convert" && c.Request.Method == http.MethodPost:
+ stackHandler.ConvertDockerRun(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/deploy"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.DeployStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/start"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.StartStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/stop"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.StopStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/restart"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.RestartStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/services"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.GetStackServices(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/pull"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.PullImages(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/redeploy"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.RedeployStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/down"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.DownStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/destroy"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.DestroyStack(c)
+ return true
case strings.HasPrefix(endpoint, "/stacks/") && strings.HasSuffix(endpoint, "/logs/stream"):
- stackHandler := NewStackHandler(h.stackService)
stackHandler.GetStackLogsStream(c)
- case endpoint == "/stacks/convert" && c.Request.Method == "POST":
- stackHandler := NewStackHandler(h.stackService)
- stackHandler.ConvertDockerRun(c)
- case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == "GET":
- stackHandler := NewStackHandler(h.stackService)
+ return true
+ case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == http.MethodGet:
stackHandler.GetStack(c)
- case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == "PUT":
- stackHandler := NewStackHandler(h.stackService)
+ return true
+ case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == http.MethodPut:
stackHandler.UpdateStack(c)
- case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == "DELETE":
- stackHandler := NewStackHandler(h.stackService)
+ return true
+ case strings.HasPrefix(endpoint, "/stacks/") && c.Request.Method == http.MethodDelete:
stackHandler.DeleteStack(c)
- default:
- c.JSON(http.StatusNotFound, gin.H{
- "success": false,
- "error": "Endpoint not found",
- })
+ return true
}
+ return false
}
func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID string, endpoint string) {
@@ -223,7 +272,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s
}
}
- req, err := http.NewRequest(c.Request.Method, url, reqBody)
+ req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, url, reqBody)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
@@ -271,7 +320,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s
resp, err := client.Do(req)
if err != nil {
- h.environmentService.UpdateEnvironmentStatus(c.Request.Context(), environmentID, "offline")
+ _ = h.environmentService.UpdateEnvironmentStatus(c.Request.Context(), environmentID, "offline")
c.JSON(http.StatusServiceUnavailable, gin.H{
"success": false,
"error": fmt.Sprintf("Failed to connect to environment: %v", err),
@@ -280,7 +329,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s
}
defer resp.Body.Close()
- h.environmentService.UpdateEnvironmentHeartbeat(c.Request.Context(), environmentID)
+ _ = h.environmentService.UpdateEnvironmentHeartbeat(c.Request.Context(), environmentID)
responseBody, err := io.ReadAll(resp.Body)
if err != nil {
@@ -298,7 +347,7 @@ func (h *EnvironmentHandler) handleRemoteRequest(c *gin.Context, environmentID s
}
c.Status(resp.StatusCode)
- c.Writer.Write(responseBody)
+ _, _ = c.Writer.Write(responseBody)
}
func (h *EnvironmentHandler) CreateEnvironment(c *gin.Context) {
@@ -512,7 +561,7 @@ func (h *EnvironmentHandler) CreateStack(c *gin.Context) {
h.routeRequest(c, "/stacks")
}
-//Containers
+// Containers
func (h *EnvironmentHandler) GetContainer(c *gin.Context) {
containerID := c.Param("containerId")
@@ -565,7 +614,7 @@ func (h *EnvironmentHandler) GetContainerStatsStream(c *gin.Context) {
// End Containers
-//Images
+// Images
func (h *EnvironmentHandler) GetImage(c *gin.Context) {
imageID := c.Param("imageId")
@@ -585,7 +634,7 @@ func (h *EnvironmentHandler) PruneImages(c *gin.Context) {
h.routeRequest(c, "/images/prune")
}
-//End Images
+// End Images
func (h *EnvironmentHandler) GetNetwork(c *gin.Context) {
networkID := c.Param("networkId")
diff --git a/backend/internal/api/image_handler.go b/backend/internal/api/image_handler.go
index 463ab3b9e..d3c6d7819 100644
--- a/backend/internal/api/image_handler.go
+++ b/backend/internal/api/image_handler.go
@@ -57,24 +57,22 @@ func (h *ImageHandler) List(c *gin.Context) {
"version": img.MaturityRecord.CurrentVersion,
"date": img.MaturityRecord.CurrentImageDate,
}
- } else {
- if len(img.RepoTags) > 0 && img.RepoTags[0] != "<none>:<none>" && img.Repo != "<none>" && h.imageMaturityService != nil {
- go func(imageID string, repo string, tag string, createdTime time.Time) {
- maturityData, checkErr := h.imageMaturityService.CheckImageInRegistry(context.Background(), repo, tag, imageID)
- if checkErr == nil {
- setErr := h.imageMaturityService.SetImageMaturity(context.Background(), imageID, repo, tag, *maturityData, map[string]interface{}{
- "registryDomain": utils.ExtractRegistryDomain(repo),
- "isPrivateRegistry": utils.IsPrivateRegistry(repo),
- "currentImageDate": createdTime,
- })
- if setErr != nil {
- fmt.Printf("Error setting image maturity for %s: %v\n", imageID, setErr)
- }
- } else {
- fmt.Printf("Error checking image maturity for %s (%s:%s): %v\n", imageID, repo, tag, checkErr)
+ } else if len(img.RepoTags) > 0 && img.RepoTags[0] != "<none>:<none>" && img.Repo != "<none>" && h.imageMaturityService != nil {
+ go func(imageID string, repo string, tag string, createdTime time.Time) {
+ maturityData, checkErr := h.imageMaturityService.CheckImageInRegistry(context.Background(), repo, tag, imageID)
+ if checkErr == nil {
+ setErr := h.imageMaturityService.SetImageMaturity(context.Background(), imageID, repo, tag, *maturityData, map[string]interface{}{
+ "registryDomain": utils.ExtractRegistryDomain(repo),
+ "isPrivateRegistry": utils.IsPrivateRegistry(repo),
+ "currentImageDate": createdTime,
+ })
+ if setErr != nil {
+ fmt.Printf("Error setting image maturity for %s: %v\n", imageID, setErr)
}
- }(img.ID, img.Repo, img.Tag, img.Created)
- }
+ } else {
+ fmt.Printf("Error checking image maturity for %s (%s:%s): %v\n", imageID, repo, tag, checkErr)
+ }
+ }(img.ID, img.Repo, img.Tag, img.Created)
}
result = append(result, imageData)
}
@@ -279,12 +277,17 @@ func (h *ImageHandler) CheckMaturity(c *gin.Context) {
return
}
- err = h.imageMaturityService.SetImageMaturity(c.Request.Context(), imageID, repo, tag, *maturityData, map[string]interface{}{
+ errSet := h.imageMaturityService.SetImageMaturity(c.Request.Context(), imageID, repo, tag, *maturityData, map[string]interface{}{
"registryDomain": utils.ExtractRegistryDomain(repo),
"isPrivateRegistry": utils.IsPrivateRegistry(repo),
"currentImageDate": time.Unix(targetImage.Created, 0),
})
- if err != nil {
+ if errSet != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": "Failed to set image maturity: " + errSet.Error(),
+ })
+ return
}
c.JSON(http.StatusOK, gin.H{
diff --git a/backend/internal/api/system_handler.go b/backend/internal/api/system_handler.go
index d870dc37c..fa794fbe5 100644
--- a/backend/internal/api/system_handler.go
+++ b/backend/internal/api/system_handler.go
@@ -251,7 +251,7 @@ func (h *SystemHandler) PruneAll(c *gin.Context) {
slog.Int("images_deleted", len(result.ImagesDeleted)),
slog.Int("volumes_deleted", len(result.VolumesDeleted)),
slog.Int("networks_deleted", len(result.NetworksDeleted)),
- slog.Int64("space_reclaimed", result.SpaceReclaimed),
+ slog.Uint64("space_reclaimed", result.SpaceReclaimed),
slog.Bool("success", result.Success),
slog.Int("error_count", len(result.Errors)))
diff --git a/backend/internal/api/template_handler.go b/backend/internal/api/template_handler.go
index b05be7519..525a95269 100644
--- a/backend/internal/api/template_handler.go
+++ b/backend/internal/api/template_handler.go
@@ -440,7 +440,7 @@ func (h *TemplateHandler) FetchRegistry(c *gin.Context) {
Timeout: 30 * time.Second,
}
- req, err := http.NewRequest("GET", url, nil)
+ req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, url, nil)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"success": false,
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index f8fd368f4..5a147f0e1 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -77,7 +77,9 @@ func InitializeApp() (*App, error) {
log.Println("Initial Docker image synchronization complete.")
}
- appServices.User.CreateDefaultAdmin()
+ if err := appServices.User.CreateDefaultAdmin(); err != nil {
+ log.Printf("Warning: failed to create default admin user: %v", err)
+ }
if cfg.PublicOidcEnabled {
if err := appServices.Auth.SyncOidcEnvToDatabase(context.Background()); err != nil {
@@ -113,8 +115,9 @@ func (app *App) Start() {
}()
srv := &http.Server{
- Addr: ":" + app.Config.Port,
- Handler: app.Router,
+ Addr: ":" + app.Config.Port,
+ Handler: app.Router,
+ ReadHeaderTimeout: 5 * time.Second,
}
go func() {
@@ -135,7 +138,7 @@ func (app *App) Start() {
defer cancelShutdown()
if err := srv.Shutdown(shutdownCtx); err != nil {
- log.Fatalf("Server forced to shutdown: %v", err)
+ log.Printf("Server forced to shutdown: %v", err)
}
log.Println("Server exiting")
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index e2ec9293d..553f599e0 100644
--- a/backend/internal/bootstrap/router_bootstrap.go
+++ b/backend/internal/bootstrap/router_bootstrap.go
@@ -32,7 +32,7 @@ func setupRouter(cfg *config.Config, appServices *api.Services) *gin.Engine {
api.SetupRoutes(router, appServices, cfg)
if err := frontend.RegisterFrontend(router); err != nil {
- gin.DefaultErrorWriter.Write([]byte("Failed to register frontend: " + err.Error() + "\n"))
+ _, _ = gin.DefaultErrorWriter.Write([]byte("Failed to register frontend: " + err.Error() + "\n"))
}
return router
diff --git a/backend/internal/database/database.go b/backend/internal/database/database.go
index eb5e1148d..09c57ac70 100644
--- a/backend/internal/database/database.go
+++ b/backend/internal/database/database.go
@@ -22,18 +22,16 @@ type DB struct {
func Initialize(databaseURL string, environment string) (*DB, error) {
var dialector gorm.Dialector
- if strings.HasPrefix(databaseURL, "sqlite://") || strings.HasPrefix(databaseURL, "sqlite3://") {
- // Handle both sqlite:// and sqlite3:// prefixes
- dbPath := databaseURL
- if strings.HasPrefix(databaseURL, "sqlite://") {
- dbPath = strings.TrimPrefix(databaseURL, "sqlite://")
- } else if strings.HasPrefix(databaseURL, "sqlite3://") {
- dbPath = strings.TrimPrefix(databaseURL, "sqlite3://")
- }
+ switch {
+ case strings.HasPrefix(databaseURL, "sqlite://"):
+ dbPath := strings.TrimPrefix(databaseURL, "sqlite://")
dialector = sqlite.Open(dbPath)
- } else if strings.HasPrefix(databaseURL, "postgres") {
+ case strings.HasPrefix(databaseURL, "sqlite3://"):
+ dbPath := strings.TrimPrefix(databaseURL, "sqlite3://")
+ dialector = sqlite.Open(dbPath)
+ case strings.HasPrefix(databaseURL, "postgres"):
dialector = postgres.Open(databaseURL)
- } else {
+ default:
return nil, fmt.Errorf("unsupported database type in URL: %s", databaseURL)
}
diff --git a/backend/internal/job/job.go b/backend/internal/job/job.go
index b21212f2b..ed78e8c36 100644
--- a/backend/internal/job/job.go
+++ b/backend/internal/job/job.go
@@ -9,12 +9,10 @@ import (
"github.com/google/uuid"
)
-// Scheduler manages jobs using gocron.
type Scheduler struct {
scheduler gocron.Scheduler
}
-// NewScheduler creates and returns a new Scheduler.
func NewScheduler() (*Scheduler, error) {
s, err := gocron.NewScheduler()
if err != nil {
@@ -23,8 +21,6 @@ func NewScheduler() (*Scheduler, error) {
return &Scheduler{scheduler: s}, nil
}
-// Run starts the scheduler and blocks until the context is canceled.
-// It handles the graceful shutdown of the scheduler.
func (s *Scheduler) Run(ctx context.Context) error {
slog.Info("Starting job scheduler")
s.scheduler.Start() // Start the scheduler, non-blocking
@@ -43,8 +39,6 @@ func (s *Scheduler) Run(ctx context.Context) error {
return nil
}
-// RegisterJob adds a new job to the scheduler with specified definition, task, and options.
-// It includes logging for job lifecycle events.
func (s *Scheduler) RegisterJob(
ctx context.Context,
name string,
@@ -53,11 +47,11 @@ func (s *Scheduler) RegisterJob(
runImmediately bool,
) error {
jobOptions := []gocron.JobOption{
- gocron.WithContext(ctx), // Associates the job with a context
+ gocron.WithContext(ctx),
gocron.WithEventListeners(
gocron.BeforeJobRuns(func(jobID uuid.UUID, jobName string) {
slog.Info("Job starting",
- slog.String("name", name), // Use the provided name for clarity
+ slog.String("name", name),
slog.String("id", jobID.String()),
)
}),
@@ -77,17 +71,8 @@ func (s *Scheduler) RegisterJob(
),
}
- // Create the gocron task
task := gocron.NewTask(func() {
- // The task function passed to gocron.NewTask should not return an error directly.
- // Errors should be handled within the taskFunc or will be caught by AfterJobRunsWithError.
- // We pass a new context to the taskFunc to ensure it has its own lifecycle if needed,
- // though gocron.WithContext already associates one.
- jobCtx := context.Background() // Or derive from the initial ctx if appropriate
- if err := taskFunc(jobCtx); err != nil {
- // This error won't be directly caught by gocron's error handling for the task itself,
- // but AfterJobRunsWithError will catch panics or errors returned by the job's execution logic.
- // It's good practice to log it here if taskFunc can return errors.
+ if err := taskFunc(ctx); err != nil {
slog.Error("Error executing task function",
slog.String("name", name),
slog.Any("error", err),
diff --git a/backend/internal/models/base.go b/backend/internal/models/base.go
index 0f9e762ea..767224f65 100644
--- a/backend/internal/models/base.go
+++ b/backend/internal/models/base.go
@@ -16,11 +16,11 @@ type BaseModel struct {
// JSON type for handling JSON columns
type JSON map[string]interface{}
-func (j JSON) Value() (driver.Value, error) {
- if j == nil {
+func (j *JSON) Value() (driver.Value, error) {
+ if *j == nil {
return nil, nil
}
- return json.Marshal(j)
+ return json.Marshal(*j)
}
func (j *JSON) Scan(value interface{}) error {
@@ -45,11 +45,11 @@ func (j *JSON) Scan(value interface{}) error {
// StringSlice for handling []string columns
type StringSlice []string
-func (s StringSlice) Value() (driver.Value, error) {
- if s == nil {
+func (s *StringSlice) Value() (driver.Value, error) {
+ if *s == nil {
return nil, nil
}
- return json.Marshal(s)
+ return json.Marshal(*s)
}
func (s *StringSlice) Scan(value interface{}) error {
diff --git a/backend/internal/models/docker.go b/backend/internal/models/docker.go
index 1c9fa86cc..c1bfdb07b 100644
--- a/backend/internal/models/docker.go
+++ b/backend/internal/models/docker.go
@@ -89,7 +89,7 @@ type Image struct {
BaseModel
}
-func (Image) TableName() string {
+func (i *Image) TableName() string {
return "images_table"
}
diff --git a/backend/internal/models/errors.go b/backend/internal/models/errors.go
index 1196b938d..bc1723fb3 100644
--- a/backend/internal/models/errors.go
+++ b/backend/internal/models/errors.go
@@ -1,6 +1,9 @@
package models
-import "net/http"
+import (
+ "errors"
+ "net/http"
+)
type APIErrorCode string
@@ -141,18 +144,25 @@ func (e *ValidationError) Error() string {
// Helper function to convert any error to APIError
func ToAPIError(err error) *APIError {
- switch e := err.(type) {
- case *APIError:
- return e
- case *NotFoundError:
- return NewNotFoundError(e.Message)
- case *ConflictError:
- return NewConflictError(e.Message)
- case *ValidationError:
- return NewValidationError(e.Message, map[string]string{"field": e.Field})
- case *DockerAPIError:
- return NewAPIErrorWithDetails(e.Message, APIErrorCodeDockerAPIError, e.HTTPStatus(), e.Details)
- default:
- return NewInternalServerError(err.Error())
+ var apiErr *APIError
+ if errors.As(err, &apiErr) {
+ return apiErr
+ }
+ var notFoundErr *NotFoundError
+ if errors.As(err, &notFoundErr) {
+ return NewNotFoundError(notFoundErr.Message)
+ }
+ var conflictErr *ConflictError
+ if errors.As(err, &conflictErr) {
+ return NewConflictError(conflictErr.Message)
+ }
+ var validationErr *ValidationError
+ if errors.As(err, &validationErr) {
+ return NewValidationError(validationErr.Message, map[string]string{"field": validationErr.Field})
+ }
+ var dockerAPIErr *DockerAPIError
+ if errors.As(err, &dockerAPIErr) {
+ return NewAPIErrorWithDetails(dockerAPIErr.Message, APIErrorCodeDockerAPIError, dockerAPIErr.HTTPStatus(), dockerAPIErr.Details)
}
+ return NewInternalServerError(err.Error())
}
diff --git a/backend/internal/models/image_maturity.go b/backend/internal/models/image_maturity.go
index e59bf2418..a4f170bce 100644
--- a/backend/internal/models/image_maturity.go
+++ b/backend/internal/models/image_maturity.go
@@ -28,7 +28,7 @@ type ImageMaturityRecord struct {
BaseModel
}
-func (ImageMaturityRecord) TableName() string {
+func (i *ImageMaturityRecord) TableName() string {
return "image_maturity_table"
}
diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.go
index 070cd2dd1..cad818317 100644
--- a/backend/internal/services/auth_service.go
+++ b/backend/internal/services/auth_service.go
@@ -399,7 +399,7 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mo
user, err := s.userService.GetUserByOidcSubjectId(ctx, userInfo.Subject)
- if err != nil && err != ErrUserNotFound {
+ if err != nil && !errors.Is(err, ErrUserNotFound) {
return nil, nil, err
}
@@ -421,11 +421,12 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo OidcUserInfo) (*mo
username := generateUsernameFromEmail(userInfo.Email, userInfo.Subject)
var displayName string
- if userInfo.Name != "" {
+ switch {
+ case userInfo.Name != "":
displayName = userInfo.Name
- } else if userInfo.GivenName != "" || userInfo.FamilyName != "" {
+ case userInfo.GivenName != "" || userInfo.FamilyName != "":
displayName = strings.TrimSpace(fmt.Sprintf("%s %s", userInfo.GivenName, userInfo.FamilyName))
- } else {
+ default:
displayName = username
}
diff --git a/backend/internal/services/auto_update_service.go b/backend/internal/services/auto_update_service.go
index e2d8af724..c9a4c46e4 100644
--- a/backend/internal/services/auto_update_service.go
+++ b/backend/internal/services/auto_update_service.go
@@ -270,6 +270,26 @@ func (s *AutoUpdateService) CheckAndUpdateStacks(ctx context.Context) (*UpdateRe
log.Println("Starting stack auto-update check...")
+ eligibleStacks, err := s.getEligibleStacks(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ result.Checked = len(eligibleStacks)
+ log.Printf("Found %d stacks eligible for auto-update", len(eligibleStacks))
+
+ s.processStackUpdates(ctx, eligibleStacks, settings, result)
+
+ result.EndTime = time.Now()
+ result.Duration = result.EndTime.Sub(result.StartTime).String()
+
+ log.Printf("Stack auto-update completed: %d checked, %d updated, %d skipped, %d errors",
+ result.Checked, result.Updated, result.Skipped, len(result.Errors))
+
+ return result, nil
+}
+
+func (s *AutoUpdateService) getEligibleStacks(ctx context.Context) ([]models.Stack, error) {
stacks, err := s.stackService.ListStacks(ctx)
if err != nil {
return nil, fmt.Errorf("failed to list stacks: %w", err)
@@ -292,102 +312,133 @@ func (s *AutoUpdateService) CheckAndUpdateStacks(ctx context.Context) (*UpdateRe
}
}
- result.Checked = len(eligibleStacks)
- log.Printf("Found %d stacks eligible for auto-update", len(eligibleStacks))
+ return eligibleStacks, nil
+}
+func (s *AutoUpdateService) processStackUpdates(ctx context.Context, eligibleStacks []models.Stack, settings *models.Settings, result *UpdateResult) {
for _, stack := range eligibleStacks {
- stackID := stack.ID
- stackName := stack.Name
-
- s.mutex.RLock()
- isUpdating := s.updatingStacks[stackID]
- s.mutex.RUnlock()
-
- if isUpdating {
- log.Printf("Stack %s is already being updated, skipping", stackName)
- result.Skipped++
+ if s.shouldSkipStack(stack.ID, stack.Name, result) {
continue
}
+ s.updateSingleStack(ctx, stack, settings, result)
+ }
+}
+
+func (s *AutoUpdateService) shouldSkipStack(stackID, stackName string, result *UpdateResult) bool {
+ s.mutex.RLock()
+ isUpdating := s.updatingStacks[stackID]
+ s.mutex.RUnlock()
+
+ if isUpdating {
+ log.Printf("Stack %s is already being updated, skipping", stackName)
+ result.Skipped++
+ return true
+ }
+
+ return false
+}
+
+func (s *AutoUpdateService) updateSingleStack(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) {
+ stackID := stack.ID
+ stackName := stack.Name
+
+ s.mutex.Lock()
+ s.updatingStacks[stackID] = true
+ s.mutex.Unlock()
+
+ defer func() {
s.mutex.Lock()
- s.updatingStacks[stackID] = true
+ delete(s.updatingStacks, stackID)
s.mutex.Unlock()
+ }()
- func() {
- defer func() {
- s.mutex.Lock()
- delete(s.updatingStacks, stackID)
- s.mutex.Unlock()
- }()
+ log.Printf("Checking stack for updates: %s", stackName)
- log.Printf("Checking stack for updates: %s", stackName)
-
- updateAvailable, err := s.checkStackForUpdate(ctx, stack, settings)
- if err != nil {
- log.Printf("Error checking stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: err.Error(),
- })
- return
- }
+ updateAvailable, err := s.checkStackForUpdate(ctx, stack, settings)
+ if err != nil {
+ log.Printf("Error checking stack %s: %v", stackName, err)
+ result.Errors = append(result.Errors, UpdateError{
+ ID: stackID,
+ Name: stackName,
+ Type: "stack",
+ Error: err.Error(),
+ })
+ return
+ }
+
+ if updateAvailable {
+ s.performStackUpdate(ctx, stack, settings, result)
+ } else {
+ log.Printf("Stack %s is up-to-date", stackName)
+ }
+}
- if updateAvailable {
- log.Printf("Updates available for stack %s, stopping, pulling images and redeploying...", stackName)
+func (s *AutoUpdateService) performStackUpdate(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) {
+ stackID := stack.ID
+ stackName := stack.Name
- log.Printf("Stopping stack %s...", stackName)
- if err := s.stackService.StopStack(ctx, stackID); err != nil {
- log.Printf("Error stopping stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: fmt.Sprintf("Failed to stop stack: %v", err),
- })
- return
- }
+ log.Printf("Updates available for stack %s, stopping, pulling images and redeploying...", stackName)
- log.Printf("Pulling updated images for stack %s...", stackName)
- if err := s.pullStackImages(ctx, stack, settings); err != nil {
- log.Printf("Error pulling images for stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: fmt.Sprintf("Failed to pull images: %v", err),
- })
- return
- }
+ if err := s.stopStackForUpdate(ctx, stackID, stackName, result); err != nil {
+ return
+ }
- log.Printf("Deploying stack %s with updated images...", stackName)
- if err := s.stackService.DeployStack(ctx, stackID); err != nil {
- log.Printf("Error redeploying stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: fmt.Sprintf("Failed to redeploy: %v", err),
- })
- return
- }
+ if err := s.pullStackImagesForUpdate(ctx, stack, settings, result); err != nil {
+ return
+ }
- log.Printf("Successfully updated stack %s", stackName)
- result.Updated++
- } else {
- log.Printf("Stack %s is up-to-date", stackName)
- }
- }()
+ if err := s.redeployStackAfterUpdate(ctx, stackID, stackName, result); err != nil {
+ return
}
- result.EndTime = time.Now()
- result.Duration = result.EndTime.Sub(result.StartTime).String()
+ log.Printf("Successfully updated stack %s", stackName)
+ result.Updated++
+}
- log.Printf("Stack auto-update completed: %d checked, %d updated, %d skipped, %d errors",
- result.Checked, result.Updated, result.Skipped, len(result.Errors))
+func (s *AutoUpdateService) stopStackForUpdate(ctx context.Context, stackID, stackName string, result *UpdateResult) error {
+ log.Printf("Stopping stack %s...", stackName)
+ if err := s.stackService.StopStack(ctx, stackID); err != nil {
+ log.Printf("Error stopping stack %s: %v", stackName, err)
+ result.Errors = append(result.Errors, UpdateError{
+ ID: stackID,
+ Name: stackName,
+ Type: "stack",
+ Error: fmt.Sprintf("Failed to stop stack: %v", err),
+ })
+ return err
+ }
+ return nil
+}
- return result, nil
+func (s *AutoUpdateService) pullStackImagesForUpdate(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) error {
+ log.Printf("Pulling updated images for stack %s...", stack.Name)
+ if err := s.pullStackImages(ctx, stack, settings); err != nil {
+ log.Printf("Error pulling images for stack %s: %v", stack.Name, err)
+ result.Errors = append(result.Errors, UpdateError{
+ ID: stack.ID,
+ Name: stack.Name,
+ Type: "stack",
+ Error: fmt.Sprintf("Failed to pull images: %v", err),
+ })
+ return err
+ }
+ return nil
+}
+
+func (s *AutoUpdateService) redeployStackAfterUpdate(ctx context.Context, stackID, stackName string, result *UpdateResult) error {
+ log.Printf("Deploying stack %s with updated images...", stackName)
+ if err := s.stackService.DeployStack(ctx, stackID); err != nil {
+ log.Printf("Error redeploying stack %s: %v", stackName, err)
+ result.Errors = append(result.Errors, UpdateError{
+ ID: stackID,
+ Name: stackName,
+ Type: "stack",
+ Error: fmt.Sprintf("Failed to redeploy: %v", err),
+ })
+ return err
+ }
+ return nil
}
// pullStackImages pulls all images for a stack before redeployment
@@ -463,15 +514,16 @@ func (s *AutoUpdateService) pullImageWithAuth(ctx context.Context, imageRef stri
reader, err := dockerClient.ImagePull(ctx, imageRef, pullOptions)
if err != nil {
- if strings.Contains(err.Error(), "not found") {
+ switch {
+ case strings.Contains(err.Error(), "not found"):
return fmt.Errorf("image not found: %s - please verify the image exists and you have access", imageRef)
- } else if strings.Contains(err.Error(), "unauthorized") {
+ case strings.Contains(err.Error(), "unauthorized"):
return fmt.Errorf("authentication failed for %s - please verify your credentials", imageRef)
- } else if strings.Contains(err.Error(), "denied") {
+ case strings.Contains(err.Error(), "denied"):
return fmt.Errorf("access denied for %s - please verify your permissions", imageRef)
+ default:
+ return fmt.Errorf("failed to pull image %s: %w", imageRef, err)
}
-
- return fmt.Errorf("failed to pull image %s: %w", imageRef, err)
}
defer reader.Close()
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index ab4e852c2..38b7439ed 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -4,6 +4,7 @@ import (
"bufio"
"context"
"encoding/json"
+ "errors"
"fmt"
"io"
"strings"
@@ -218,7 +219,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe
}
if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
- dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
return nil, fmt.Errorf("failed to start container: %w", err)
}
@@ -334,8 +335,7 @@ func (s *ContainerService) streamMultiplexedLogs(ctx context.Context, logs io.Re
defer stdoutWriter.Close()
defer stderrWriter.Close()
_, err := stdcopy.StdCopy(stdoutWriter, stderrWriter, logs)
- if err != nil && err != io.EOF {
- // Log error but don't stop the stream
+ if err != nil && !errors.Is(err, io.EOF) {
fmt.Printf("Error demultiplexing logs: %v\n", err)
}
}()
@@ -358,7 +358,7 @@ func (s *ContainerService) streamMultiplexedLogs(ctx context.Context, logs io.Re
case <-ctx.Done():
return ctx.Err()
case err := <-done:
- if err != nil && err != io.EOF {
+ if err != nil && !errors.Is(err, io.EOF) {
return err
}
// Wait for the other goroutine or context cancellation
@@ -406,7 +406,7 @@ func (s *ContainerService) readAllLogs(logs io.ReadCloser, logsChan chan<- strin
stderrBuf := &strings.Builder{}
_, err := stdcopy.StdCopy(stdoutBuf, stderrBuf, logs)
- if err != nil && err != io.EOF {
+ if err != nil && !errors.Is(err, io.EOF) {
return fmt.Errorf("failed to demultiplex logs: %w", err)
}
diff --git a/backend/internal/services/converter_service.go b/backend/internal/services/converter_service.go
index 1eff705bf..b15c789ab 100644
--- a/backend/internal/services/converter_service.go
+++ b/backend/internal/services/converter_service.go
@@ -21,7 +21,6 @@ func (s *ConverterService) ParseDockerRunCommand(command string) (*models.Docker
return nil, fmt.Errorf("docker run command must be a non-empty string")
}
- // Remove 'docker run' from the beginning
cmd := strings.TrimSpace(command)
cmd = regexp.MustCompile(`^docker\s+run\s+`).ReplaceAllString(cmd, "")
@@ -39,180 +38,151 @@ func (s *ConverterService) ParseDockerRunCommand(command string) (*models.Docker
return nil, fmt.Errorf("no valid tokens found in docker run command")
}
+ if err := s.parseTokens(tokens, result); err != nil {
+ return nil, err
+ }
+
+ if result.Image == "" {
+ return nil, fmt.Errorf("no Docker image specified in command")
+ }
+
+ return result, nil
+}
+
+func (s *ConverterService) parseTokens(tokens []string, result *models.DockerRunCommand) error {
for i := 0; i < len(tokens); i++ {
token := tokens[i]
- switch token {
- case "-d", "--detach":
- result.Detached = true
- case "-i", "--interactive":
- result.Interactive = true
- case "-t", "--tty":
- result.TTY = true
- case "--rm":
- result.Remove = true
- case "--privileged":
- result.Privileged = true
- case "--name":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --name flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --name flag")
- }
- result.Name = tokens[i]
- case "-p", "--port", "--publish":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for port flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for port flag")
- }
- result.Ports = append(result.Ports, tokens[i])
- case "-v", "--volume":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for volume flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for volume flag")
- }
- result.Volumes = append(result.Volumes, tokens[i])
- case "-e", "--env":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for environment flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for environment flag")
- }
- result.Environment = append(result.Environment, tokens[i])
- case "--network":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --network flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --network flag")
- }
- result.Networks = append(result.Networks, tokens[i])
- case "--restart":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --restart flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --restart flag")
- }
- result.Restart = tokens[i]
- case "-w", "--workdir":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for workdir flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for workdir flag")
- }
- result.Workdir = tokens[i]
- case "-u", "--user":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for user flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for user flag")
- }
- result.User = tokens[i]
- case "--entrypoint":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --entrypoint flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --entrypoint flag")
- }
- result.Entrypoint = tokens[i]
- case "--health-cmd":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --health-cmd flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --health-cmd flag")
- }
- result.HealthCheck = tokens[i]
- case "-m", "--memory":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for memory flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for memory flag")
- }
- result.MemoryLimit = tokens[i]
- case "--cpus":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --cpus flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --cpus flag")
+ if strings.HasPrefix(token, "-") {
+ advance, err := s.parseFlag(token, tokens, i, result)
+ if err != nil {
+ return err
}
- result.CPULimit = tokens[i]
- case "--label":
- if i+1 >= len(tokens) {
- return nil, fmt.Errorf("missing value for --label flag")
- }
- i++
- if tokens[i] == "" || strings.HasPrefix(tokens[i], "-") {
- return nil, fmt.Errorf("invalid value for --label flag")
- }
- result.Labels = append(result.Labels, tokens[i])
- default:
- if strings.HasPrefix(token, "-") {
- // Handle combined short flags like -dit
- if strings.HasPrefix(token, "-") && !strings.HasPrefix(token, "--") && len(token) > 2 {
- flags := strings.Split(token[1:], "")
- for _, flag := range flags {
- switch flag {
- case "d":
- result.Detached = true
- case "i":
- result.Interactive = true
- case "t":
- result.TTY = true
- }
- }
- } else {
- // Unknown flag - skip it and potential value
- if i+1 < len(tokens) && !strings.HasPrefix(tokens[i+1], "-") && result.Image == "" {
- i++ // Skip potential value
- }
+ i += advance
+ } else {
+ if result.Image == "" {
+ if token == "" {
+ return fmt.Errorf("image name cannot be empty")
}
+ result.Image = token
} else {
- // Token doesn't start with '-', it's either image or command
- if result.Image == "" {
- if token == "" {
- return nil, fmt.Errorf("image name cannot be empty")
- }
- result.Image = token
- } else {
- // Everything from this point forward is part of the command
- remainingTokens := tokens[i:]
- result.Command = strings.Join(remainingTokens, " ")
- break
- }
+ remainingTokens := tokens[i:]
+ result.Command = strings.Join(remainingTokens, " ")
+ break
}
}
}
+ return nil
+}
- if result.Image == "" {
- return nil, fmt.Errorf("no Docker image specified in command")
+func (s *ConverterService) parseFlag(token string, tokens []string, index int, result *models.DockerRunCommand) (int, error) {
+ switch token {
+ case "-d", "--detach":
+ result.Detached = true
+ return 0, nil
+ case "-i", "--interactive":
+ result.Interactive = true
+ return 0, nil
+ case "-t", "--tty":
+ result.TTY = true
+ return 0, nil
+ case "--rm":
+ result.Remove = true
+ return 0, nil
+ case "--privileged":
+ result.Privileged = true
+ return 0, nil
+ default:
+ return s.parseFlagWithValue(token, tokens, index, result)
}
+}
- return result, nil
+func (s *ConverterService) parseFlagWithValue(token string, tokens []string, index int, result *models.DockerRunCommand) (int, error) {
+ switch token {
+ case "--name":
+ return s.parseStringFlag(token, tokens, index, &result.Name)
+ case "-p", "--port", "--publish":
+ return s.parseSliceFlag(token, tokens, index, &result.Ports)
+ case "-v", "--volume":
+ return s.parseSliceFlag(token, tokens, index, &result.Volumes)
+ case "-e", "--env":
+ return s.parseSliceFlag(token, tokens, index, &result.Environment)
+ case "--network":
+ return s.parseSliceFlag(token, tokens, index, &result.Networks)
+ case "--restart":
+ return s.parseStringFlag(token, tokens, index, &result.Restart)
+ case "-w", "--workdir":
+ return s.parseStringFlag(token, tokens, index, &result.Workdir)
+ case "-u", "--user":
+ return s.parseStringFlag(token, tokens, index, &result.User)
+ case "--entrypoint":
+ return s.parseStringFlag(token, tokens, index, &result.Entrypoint)
+ case "--health-cmd":
+ return s.parseStringFlag(token, tokens, index, &result.HealthCheck)
+ case "-m", "--memory":
+ return s.parseStringFlag(token, tokens, index, &result.MemoryLimit)
+ case "--cpus":
+ return s.parseStringFlag(token, tokens, index, &result.CPULimit)
+ case "--label":
+ return s.parseSliceFlag(token, tokens, index, &result.Labels)
+ default:
+ return s.parseUnknownFlag(token, tokens, index, result)
+ }
+}
+
+func (s *ConverterService) parseStringFlag(flagName string, tokens []string, index int, target *string) (int, error) {
+ if index+1 >= len(tokens) {
+ return 0, fmt.Errorf("missing value for %s flag", flagName)
+ }
+
+ value := tokens[index+1]
+ if value == "" || strings.HasPrefix(value, "-") {
+ return 0, fmt.Errorf("invalid value for %s flag", flagName)
+ }
+
+ *target = value
+ return 1, nil
+}
+
+func (s *ConverterService) parseSliceFlag(flagName string, tokens []string, index int, target *[]string) (int, error) {
+ if index+1 >= len(tokens) {
+ return 0, fmt.Errorf("missing value for %s flag", flagName)
+ }
+
+ value := tokens[index+1]
+ if value == "" || strings.HasPrefix(value, "-") {
+ return 0, fmt.Errorf("invalid value for %s flag", flagName)
+ }
+
+ *target = append(*target, value)
+ return 1, nil
+}
+
+func (s *ConverterService) parseUnknownFlag(token string, tokens []string, index int, result *models.DockerRunCommand) (int, error) {
+ if !strings.HasPrefix(token, "--") && len(token) > 2 {
+ s.parseCombinedFlags(token, result)
+ return 0, nil
+ }
+
+ if index+1 < len(tokens) && !strings.HasPrefix(tokens[index+1], "-") && result.Image == "" {
+ return 1, nil
+ }
+
+ return 0, nil
+}
+
+func (s *ConverterService) parseCombinedFlags(token string, result *models.DockerRunCommand) {
+ flags := strings.Split(token[1:], "")
+ for _, flag := range flags {
+ switch flag {
+ case "d":
+ result.Detached = true
+ case "i":
+ result.Interactive = true
+ case "t":
+ result.TTY = true
+ }
+ }
}
// ConvertToDockerCompose converts a parsed docker run command to docker-compose YAML
diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.go
index c143a4784..308290ded 100644
--- a/backend/internal/services/environment_service.go
+++ b/backend/internal/services/environment_service.go
@@ -79,19 +79,24 @@ func (s *EnvironmentService) TestConnection(ctx context.Context, id string) (str
}
client := &http.Client{Timeout: 10 * time.Second}
- resp, err := client.Get(environment.ApiUrl + "/health")
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, environment.ApiUrl+"/health", nil)
if err != nil {
- s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))
+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))
+ return "offline", fmt.Errorf("failed to create request: %w", err)
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))
return "offline", fmt.Errorf("connection failed: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusOK {
- s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOnline))
+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOnline))
return "online", nil
}
- s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusError))
+ _ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusError))
return "error", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
}
diff --git a/backend/internal/services/image_maturity_service.go b/backend/internal/services/image_maturity_service.go
index 20b4c46be..42d0950c2 100644
--- a/backend/internal/services/image_maturity_service.go
+++ b/backend/internal/services/image_maturity_service.go
@@ -74,7 +74,7 @@ func (s *ImageMaturityService) SetImageMaturity(ctx context.Context, imageID, re
existing, err := s.GetImageMaturity(ctx, imageID)
if err == nil {
record.CheckCount = existing.CheckCount + 1
- record.BaseModel.CreatedAt = existing.BaseModel.CreatedAt
+ record.CreatedAt = existing.CreatedAt
}
if err := s.db.WithContext(ctx).Save(record).Error; err != nil {
@@ -256,7 +256,7 @@ func (s *ImageMaturityService) ProcessImagesForMaturityCheck(ctx context.Context
maturityData, err := s.CheckImageInRegistry(ctx, repo, tag, img.ID)
if err != nil {
errMsg := err.Error()
- s.UpdateCheckStatus(ctx, img.ID, models.ImageStatusError, &errMsg)
+ _ = s.UpdateCheckStatus(ctx, img.ID, models.ImageStatusError, &errMsg)
continue
}
@@ -308,8 +308,8 @@ func (s *ImageMaturityService) CheckImageInRegistry(ctx context.Context, repo, t
func (s *ImageMaturityService) checkAgainstSameTagOnly(ctx context.Context, registryURL, repo, tag, token string, localManifest *RegistryManifest) (*models.ImageMaturity, error) {
hasTagUpdates := s.hasTagUpdates(ctx, registryURL, repo, tag, token, localManifest)
- status := models.ImageStatusUnknown
imageAge := time.Since(localManifest.CreatedAt)
+ var status string
if imageAge > 30*24*time.Hour {
status = models.ImageStatusMatured
} else {
@@ -518,7 +518,7 @@ func (s *ImageMaturityService) getDockerHubManifest(ctx context.Context, repo, t
manifestURL := fmt.Sprintf("https://registry-1.docker.io/v2/%s/manifests/%s", normalizedRepo, tag)
client := &http.Client{Timeout: 30 * time.Second}
- req, err := http.NewRequestWithContext(ctx, "GET", manifestURL, nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, manifestURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create manifest request: %w", err)
}
@@ -567,7 +567,7 @@ func (s *ImageMaturityService) getGenericRegistryManifest(ctx context.Context, r
manifestURL := fmt.Sprintf("%s/%s/manifests/%s", registryURL, repo, tag)
client := &http.Client{Timeout: 30 * time.Second}
- req, err := http.NewRequestWithContext(ctx, "GET", manifestURL, nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, manifestURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create manifest request: %w", err)
}
@@ -617,7 +617,7 @@ func (s *ImageMaturityService) getDockerHubTags(ctx context.Context, repo, token
tagsURL := fmt.Sprintf("https://registry-1.docker.io/v2/%s/tags/list", normalizedRepo)
client := &http.Client{Timeout: 30 * time.Second}
- req, err := http.NewRequestWithContext(ctx, "GET", tagsURL, nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, tagsURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create tags request: %w", err)
}
@@ -649,7 +649,7 @@ func (s *ImageMaturityService) getGenericRegistryTags(ctx context.Context, regis
tagsURL := fmt.Sprintf("%s/%s/tags/list", registryURL, normalizedRepo)
client := &http.Client{Timeout: 30 * time.Second}
- req, err := http.NewRequestWithContext(ctx, "GET", tagsURL, nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, tagsURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create tags request: %w", err)
}
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index 1cdb44184..9c3e95dc6 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -295,92 +295,115 @@ func (s *ImageService) GetImageHistory(ctx context.Context, id string) ([]image.
}
func (s *ImageService) syncImagesToDatabase(ctx context.Context, dockerImages []image.Summary, dockerClient *client.Client) error {
+ inUseImageIDs := s.getInUseImageIDs(ctx, dockerClient)
+ currentDockerImageIDs := make([]string, 0, len(dockerImages))
+ var lastErr error
+
+ for _, di := range dockerImages {
+ currentDockerImageIDs = append(currentDockerImageIDs, di.ID)
+ if err := s.syncSingleImage(ctx, di, inUseImageIDs); err != nil {
+ fmt.Printf("Error syncing image %s to database: %v\n", di.ID, err)
+ lastErr = err
+ }
+ }
+
+ if err := s.cleanupStaleImages(ctx, currentDockerImageIDs); err != nil {
+ lastErr = err
+ }
+
+ return lastErr
+}
+
+func (s *ImageService) getInUseImageIDs(ctx context.Context, dockerClient *client.Client) map[string]bool {
inUseImageIDs := make(map[string]bool)
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
fmt.Printf("Error listing containers for InUse check: %v. InUse status may be inaccurate.\n", err)
- } else {
- for _, cont := range containers {
- inUseImageIDs[cont.ImageID] = true
- }
+ return inUseImageIDs
}
- var lastErr error
- currentDockerImageIDs := make([]string, 0, len(dockerImages))
+ for _, cont := range containers {
+ inUseImageIDs[cont.ImageID] = true
+ }
+ return inUseImageIDs
+}
- for _, di := range dockerImages {
- currentDockerImageIDs = append(currentDockerImageIDs, di.ID)
- _, isInUse := inUseImageIDs[di.ID]
-
- imageModel := models.Image{
- ID: di.ID,
- RepoTags: models.StringSlice(di.RepoTags),
- RepoDigests: models.StringSlice(di.RepoDigests),
- Size: di.Size,
- Created: time.Unix(di.Created, 0),
- InUse: isInUse,
- }
+func (s *ImageService) syncSingleImage(ctx context.Context, di image.Summary, inUseImageIDs map[string]bool) error {
+ _, isInUse := inUseImageIDs[di.ID]
- if di.Labels != nil {
- labelsJSON := make(map[string]interface{})
- for k, v := range di.Labels {
- labelsJSON[k] = v
- }
- imageModel.Labels = models.JSON(labelsJSON)
- }
+ imageModel := s.buildImageModel(di, isInUse)
- if len(di.RepoTags) > 0 && di.RepoTags[0] != "" {
- repoTag := di.RepoTags[0]
- if strings.Contains(repoTag, ":") {
- parts := strings.SplitN(repoTag, ":", 2)
- imageModel.Repo = parts[0]
- imageModel.Tag = parts[1]
- } else {
- imageModel.Repo = repoTag
- imageModel.Tag = "latest"
- }
- } else {
- imageModel.Repo = "<none>"
- imageModel.Tag = "<none>"
- }
+ return s.db.WithContext(ctx).Clauses(clause.OnConflict{
+ Columns: []clause.Column{{Name: "id"}},
+ DoUpdates: clause.AssignmentColumns([]string{"repo_tags", "repo_digests", "size", "virtual_size", "created", "labels", "repo", "tag", "in_use"}),
+ }).Create(&imageModel).Error
+}
- dbErr := s.db.WithContext(ctx).Clauses(clause.OnConflict{
- Columns: []clause.Column{{Name: "id"}},
- DoUpdates: clause.AssignmentColumns([]string{"repo_tags", "repo_digests", "size", "virtual_size", "created", "labels", "repo", "tag", "in_use"}),
- }).Create(&imageModel).Error
+func (s *ImageService) buildImageModel(di image.Summary, isInUse bool) models.Image {
+ imageModel := models.Image{
+ ID: di.ID,
+ RepoTags: models.StringSlice(di.RepoTags),
+ RepoDigests: models.StringSlice(di.RepoDigests),
+ Size: di.Size,
+ Created: time.Unix(di.Created, 0),
+ InUse: isInUse,
+ }
- if dbErr != nil {
- fmt.Printf("Error syncing image %s to database: %v\n", di.ID, dbErr)
- lastErr = dbErr
+ if di.Labels != nil {
+ labelsJSON := make(map[string]interface{})
+ for k, v := range di.Labels {
+ labelsJSON[k] = v
}
+ imageModel.Labels = models.JSON(labelsJSON)
}
- if len(currentDockerImageIDs) > 0 {
- deleteResult := s.db.WithContext(ctx).Where("id NOT IN ?", currentDockerImageIDs).Delete(&models.Image{})
- if deleteResult.Error != nil {
- errMsg := fmt.Sprintf("Error deleting stale images from database: %v", deleteResult.Error)
- fmt.Println(errMsg)
- if lastErr == nil {
- lastErr = deleteResult.Error
- }
+ s.setRepoAndTag(&imageModel, di.RepoTags)
+ return imageModel
+}
+
+func (s *ImageService) setRepoAndTag(imageModel *models.Image, repoTags []string) {
+ if len(repoTags) > 0 && repoTags[0] != "" {
+ repoTag := repoTags[0]
+ if strings.Contains(repoTag, ":") {
+ parts := strings.SplitN(repoTag, ":", 2)
+ imageModel.Repo = parts[0]
+ imageModel.Tag = parts[1]
} else {
- fmt.Printf("%d stale image records deleted from database.\n", deleteResult.RowsAffected)
+ imageModel.Repo = repoTag
+ imageModel.Tag = "latest"
}
} else {
- fmt.Println("No images found in Docker daemon, attempting to delete all image records from database.")
- deleteAllResult := s.db.WithContext(ctx).Delete(&models.Image{}, "1 = 1")
- if deleteAllResult.Error != nil {
- errMsg := fmt.Sprintf("Error deleting all image records from database when Docker is empty: %v", deleteAllResult.Error)
- fmt.Println(errMsg)
- if lastErr == nil {
- lastErr = deleteAllResult.Error
- }
- } else {
- fmt.Printf("All (%d) image records deleted from database as Docker reported no images.\n", deleteAllResult.RowsAffected)
- }
+ imageModel.Repo = "<none>"
+ imageModel.Tag = "<none>"
}
+}
- return lastErr
+func (s *ImageService) cleanupStaleImages(ctx context.Context, currentDockerImageIDs []string) error {
+ if len(currentDockerImageIDs) > 0 {
+ return s.deleteStaleImages(ctx, currentDockerImageIDs)
+ }
+ return s.deleteAllImages(ctx)
+}
+
+func (s *ImageService) deleteStaleImages(ctx context.Context, currentDockerImageIDs []string) error {
+ deleteResult := s.db.WithContext(ctx).Where("id NOT IN ?", currentDockerImageIDs).Delete(&models.Image{})
+ if deleteResult.Error != nil {
+ fmt.Printf("Error deleting stale images from database: %v\n", deleteResult.Error)
+ return deleteResult.Error
+ }
+ fmt.Printf("%d stale image records deleted from database.\n", deleteResult.RowsAffected)
+ return nil
+}
+
+func (s *ImageService) deleteAllImages(ctx context.Context) error {
+ fmt.Println("No images found in Docker daemon, attempting to delete all image records from database.")
+ deleteAllResult := s.db.WithContext(ctx).Delete(&models.Image{}, "1 = 1")
+ if deleteAllResult.Error != nil {
+ fmt.Printf("Error deleting all image records from database when Docker is empty: %v\n", deleteAllResult.Error)
+ return deleteAllResult.Error
+ }
+ fmt.Printf("All (%d) image records deleted from database as Docker reported no images.\n", deleteAllResult.RowsAffected)
+ return nil
}
func (s *ImageService) GetImageByIDFromDB(ctx context.Context, id string) (*models.Image, error) {
diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.go
index f895f2ed0..5141efb3d 100644
--- a/backend/internal/services/oidc_service.go
+++ b/backend/internal/services/oidc_service.go
@@ -129,13 +129,13 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta
}
// Exchange code for tokens
- tokenResponse, err := s.exchangeCodeForTokens(config, code, stateData.CodeVerifier)
+ tokenResponse, err := s.exchangeCodeForTokens(ctx, config, code, stateData.CodeVerifier)
if err != nil {
return nil, fmt.Errorf("failed to exchange code for tokens: %w", err)
}
// Get user info from the userinfo endpoint
- userInfo, err := s.getUserInfo(config, tokenResponse.AccessToken)
+ userInfo, err := s.getUserInfo(ctx, config, tokenResponse.AccessToken)
if err != nil {
return nil, fmt.Errorf("failed to get user info: %w", err)
}
@@ -144,8 +144,7 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta
}
// exchangeCodeForTokens exchanges the authorization code for access tokens
-func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, codeVerifier string) (*TokenResponse, error) {
- // Prepare token request
+func (s *OidcService) exchangeCodeForTokens(ctx context.Context, config *models.OidcConfig, code, codeVerifier string) (*TokenResponse, error) {
data := url.Values{}
data.Set("grant_type", "authorization_code")
data.Set("code", code)
@@ -154,8 +153,7 @@ func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, cod
data.Set("client_secret", config.ClientSecret)
data.Set("code_verifier", codeVerifier)
- // Make token request
- req, err := http.NewRequest("POST", config.TokenEndpoint, strings.NewReader(data.Encode()))
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, config.TokenEndpoint, strings.NewReader(data.Encode()))
if err != nil {
return nil, err
}
@@ -174,7 +172,6 @@ func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, cod
return nil, fmt.Errorf("token endpoint returned %d: %s", resp.StatusCode, string(bodyBytes))
}
- // Parse token response
var tokenResponse TokenResponse
if err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {
return nil, err
@@ -184,9 +181,8 @@ func (s *OidcService) exchangeCodeForTokens(config *models.OidcConfig, code, cod
}
// getUserInfo retrieves user information from the userinfo endpoint
-func (s *OidcService) getUserInfo(config *models.OidcConfig, accessToken string) (*OidcUserInfo, error) {
- // Make userinfo request
- req, err := http.NewRequest("GET", config.UserinfoEndpoint, nil)
+func (s *OidcService) getUserInfo(ctx context.Context, config *models.OidcConfig, accessToken string) (*OidcUserInfo, error) {
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.UserinfoEndpoint, nil)
if err != nil {
return nil, err
}
@@ -205,13 +201,11 @@ func (s *OidcService) getUserInfo(config *models.OidcConfig, accessToken string)
return nil, fmt.Errorf("userinfo endpoint returned %d: %s", resp.StatusCode, string(bodyBytes))
}
- // Parse userinfo response
var userInfo OidcUserInfo
if err := json.NewDecoder(resp.Body).Decode(&userInfo); err != nil {
return nil, err
}
- // Validate required fields
if userInfo.Subject == "" {
return nil, errors.New("missing required 'sub' field in userinfo response")
}
diff --git a/backend/internal/services/stack_service.go b/backend/internal/services/stack_service.go
index 621e03938..d0653aa7f 100644
--- a/backend/internal/services/stack_service.go
+++ b/backend/internal/services/stack_service.go
@@ -185,18 +185,18 @@ func (s *StackService) GetStackServices(ctx context.Context, stackID string) ([]
composeFile := s.findComposeFile(stack.Path)
if composeFile == "" {
- return []StackServiceInfo{}, nil
+ return nil, fmt.Errorf("no compose file found for stack")
}
- servicesFromFile, err := s.parseServicesFromComposeFile(composeFile, stack.Name)
+ servicesFromFile, err := s.parseServicesFromComposeFile(ctx, composeFile, stack.Name)
if err != nil {
- return []StackServiceInfo{}, nil
+ return nil, fmt.Errorf("failed to parse services from compose file: %w", err)
}
return servicesFromFile, nil
}
-func (s *StackService) parseServicesFromComposeFile(composeFile, stackName string) ([]StackServiceInfo, error) {
+func (s *StackService) parseServicesFromComposeFile(ctx context.Context, composeFile, stackName string) ([]StackServiceInfo, error) {
options, err := cli.NewProjectOptions(
[]string{composeFile},
cli.WithOsEnv,
@@ -208,7 +208,7 @@ func (s *StackService) parseServicesFromComposeFile(composeFile, stackName strin
return nil, fmt.Errorf("failed to create project options: %w", err)
}
- project, err := options.LoadProject(context.Background())
+ project, err := options.LoadProject(ctx)
if err != nil {
return nil, fmt.Errorf("failed to load project: %w", err)
}
@@ -384,7 +384,7 @@ func (s *StackService) UpdateStackContent(ctx context.Context, stackID string, c
composePath = filepath.Join(stack.Path, "compose.yaml")
}
- if err := os.WriteFile(composePath, []byte(*composeContent), 0644); err != nil {
+ if err := os.WriteFile(composePath, []byte(*composeContent), 0600); err != nil {
return fmt.Errorf("failed to update compose file: %w", err)
}
}
@@ -394,7 +394,7 @@ func (s *StackService) UpdateStackContent(ctx context.Context, stackID string, c
if *envContent == "" {
os.Remove(envPath)
} else {
- if err := os.WriteFile(envPath, []byte(*envContent), 0644); err != nil {
+ if err := os.WriteFile(envPath, []byte(*envContent), 0600); err != nil {
return fmt.Errorf("failed to update env file: %w", err)
}
}
@@ -495,14 +495,12 @@ func (s *StackService) RedeployStack(ctx context.Context, stackID string, profil
}
func (s *StackService) DiscoverExternalStacks(ctx context.Context) ([]models.Stack, error) {
- // This would use docker commands to find compose projects not in our database
- // For now, return empty slice - implement based on your requirements
+ // TODO
return []models.Stack{}, nil
}
func (s *StackService) ImportExternalStack(ctx context.Context, stackID, stackName string) (*models.Stack, error) {
- // Implementation would depend on how you want to handle external stack import
- // For now, return error indicating not implemented
+ // TODO
return nil, fmt.Errorf("external stack import not implemented yet")
}
@@ -513,8 +511,8 @@ func (s *StackService) ValidateStackCompose(ctx context.Context, composeContent
}
defer os.RemoveAll(tempDir)
- composePath := filepath.Join(tempDir, "docker-compose.yml")
- if err := os.WriteFile(composePath, []byte(composeContent), 0644); err != nil {
+ composePath := filepath.Join(tempDir, "compose.yaml")
+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {
return fmt.Errorf("failed to write compose file: %w", err)
}
@@ -625,14 +623,14 @@ func (s *StackService) StreamStackLogs(ctx context.Context, stackID string, logs
select {
case <-ctx.Done():
if cmd.Process != nil {
- cmd.Process.Kill()
+ _ = cmd.Process.Kill()
}
return ctx.Err()
case err := <-done:
if cmd.Process != nil {
- cmd.Process.Kill()
+ _ = cmd.Process.Kill()
}
- if err != nil && err != io.EOF {
+ if err != nil && !errors.Is(err, io.EOF) {
return err
}
return nil
@@ -757,13 +755,13 @@ func (s *StackService) saveStackFiles(stackPath, composeContent string, envConte
composePath = filepath.Join(stackPath, "compose.yaml")
}
- if err := os.WriteFile(composePath, []byte(composeContent), 0644); err != nil {
+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {
return fmt.Errorf("failed to save compose file: %w", err)
}
if envContent != nil && *envContent != "" {
envPath := filepath.Join(stackPath, ".env")
- if err := os.WriteFile(envPath, []byte(*envContent), 0644); err != nil {
+ if err := os.WriteFile(envPath, []byte(*envContent), 0600); err != nil {
return fmt.Errorf("failed to save env file: %w", err)
}
}
diff --git a/backend/internal/services/system_service.go b/backend/internal/services/system_service.go
index f0dda5d6c..f10709ebf 100644
--- a/backend/internal/services/system_service.go
+++ b/backend/internal/services/system_service.go
@@ -46,7 +46,7 @@ type PruneAllResult struct {
ImagesDeleted []string `json:"imagesDeleted,omitempty"`
VolumesDeleted []string `json:"volumesDeleted,omitempty"`
NetworksDeleted []string `json:"networksDeleted,omitempty"`
- SpaceReclaimed int64 `json:"spaceReclaimed"`
+ SpaceReclaimed uint64 `json:"spaceReclaimed"`
Success bool `json:"success"`
Errors []string `json:"errors,omitempty"`
}
@@ -126,7 +126,7 @@ func (s *SystemService) PruneAll(ctx context.Context, req dto.PruneSystemDto) (*
slog.Int("images_deleted", len(result.ImagesDeleted)),
slog.Int("volumes_deleted", len(result.VolumesDeleted)),
slog.Int("networks_deleted", len(result.NetworksDeleted)),
- slog.Int64("space_reclaimed", result.SpaceReclaimed),
+ slog.Uint64("space_reclaimed", result.SpaceReclaimed),
slog.Int("error_count", len(result.Errors)))
return result, nil
@@ -246,7 +246,7 @@ func (s *SystemService) pruneContainers(ctx context.Context, result *PruneAllRes
}
result.ContainersPruned = report.ContainersDeleted
- result.SpaceReclaimed += int64(report.SpaceReclaimed)
+ result.SpaceReclaimed += report.SpaceReclaimed
return nil
}
@@ -296,7 +296,7 @@ func (s *SystemService) pruneImages(ctx context.Context, danglingOnly bool, resu
}
}
}
- result.SpaceReclaimed += int64(report.SpaceReclaimed)
+ result.SpaceReclaimed += report.SpaceReclaimed
return nil
}
@@ -325,7 +325,7 @@ func (s *SystemService) pruneBuildCache(ctx context.Context, result *PruneAllRes
slog.Int("cache_entries_deleted", len(report.CachesDeleted)),
slog.Uint64("bytes_reclaimed", report.SpaceReclaimed))
- result.SpaceReclaimed += int64(report.SpaceReclaimed)
+ result.SpaceReclaimed += report.SpaceReclaimed
return nil
}
@@ -336,7 +336,7 @@ func (s *SystemService) pruneVolumes(ctx context.Context, result *PruneAllResult
}
result.VolumesDeleted = report.VolumesDeleted
- result.SpaceReclaimed += int64(report.SpaceReclaimed)
+ result.SpaceReclaimed += report.SpaceReclaimed
return nil
}
@@ -413,7 +413,7 @@ func (s *SystemService) PruneSystem(ctx context.Context, all bool) (*PruneAllRes
slog.Int("images_deleted", len(result.ImagesDeleted)),
slog.Int("volumes_deleted", len(result.VolumesDeleted)),
slog.Int("networks_deleted", len(result.NetworksDeleted)),
- slog.Int64("space_reclaimed", result.SpaceReclaimed),
+ slog.Uint64("space_reclaimed", result.SpaceReclaimed),
slog.Int("error_count", len(result.Errors)))
return result, nil
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 58f033e13..6b61a104a 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -3,6 +3,7 @@ package services
import (
"context"
"encoding/json"
+ "errors"
"fmt"
"io"
"net/http"
@@ -47,7 +48,7 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.C
var template models.ComposeTemplate
err := s.db.WithContext(ctx).Preload("Registry").Where("id = ?", id).First(&template).Error
if err != nil {
- if err == gorm.ErrRecordNotFound {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fmt.Errorf("template not found")
}
return nil, fmt.Errorf("failed to get template: %w", err)
@@ -75,7 +76,7 @@ func (s *TemplateService) UpdateTemplate(ctx context.Context, id string, updates
var existing models.ComposeTemplate
err := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Error
if err != nil {
- if err == gorm.ErrRecordNotFound {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
return fmt.Errorf("template not found")
}
return fmt.Errorf("failed to find template: %w", err)
@@ -121,7 +122,7 @@ func (s *TemplateService) SaveEnvTemplate(content string) error {
}
envPath := filepath.Join(templateDir, ".env.template")
- if err := os.WriteFile(envPath, []byte(content), 0644); err != nil {
+ if err := os.WriteFile(envPath, []byte(content), 0600); err != nil {
return fmt.Errorf("failed to save env template: %w", err)
}
@@ -149,7 +150,7 @@ func (s *TemplateService) UpdateRegistry(ctx context.Context, id uint, updates *
var existing models.TemplateRegistry
err := s.db.WithContext(ctx).Where("id = ?", id).First(&existing).Error
if err != nil {
- if err == gorm.ErrRecordNotFound {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
return fmt.Errorf("registry not found")
}
return fmt.Errorf("failed to find registry: %w", err)
@@ -192,7 +193,7 @@ func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.Com
continue
}
- remoteTemplates, err := s.fetchRegistryTemplates(registry.URL)
+ remoteTemplates, err := s.fetchRegistryTemplates(ctx, registry.URL)
if err != nil {
fmt.Printf("Warning: failed to fetch templates from registry %s: %v\n", registry.Name, err)
continue
@@ -207,9 +208,13 @@ func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.Com
return templates, nil
}
-func (s *TemplateService) fetchRegistryTemplates(url string) ([]models.RemoteTemplate, error) {
+func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, url string) ([]models.RemoteTemplate, error) {
client := &http.Client{Timeout: 30 * time.Second}
- resp, err := client.Get(url)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create request: %w", err)
+ }
+ resp, err := client.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to fetch registry: %w", err)
}
@@ -301,22 +306,26 @@ func (s *TemplateService) FetchTemplateContent(ctx context.Context, template *mo
return template.Content, "", fmt.Errorf("not a remote template")
}
- composeContent, err := s.fetchURL(*template.Metadata.RemoteURL)
+ composeContent, err := s.fetchURL(ctx, *template.Metadata.RemoteURL)
if err != nil {
return "", "", fmt.Errorf("failed to fetch compose content: %w", err)
}
var envContent string
if template.Metadata.EnvURL != nil && *template.Metadata.EnvURL != "" {
- envContent, _ = s.fetchURL(*template.Metadata.EnvURL)
+ envContent, _ = s.fetchURL(ctx, *template.Metadata.EnvURL)
}
return composeContent, envContent, nil
}
-func (s *TemplateService) fetchURL(url string) (string, error) {
+func (s *TemplateService) fetchURL(ctx context.Context, url string) (string, error) {
client := &http.Client{Timeout: 30 * time.Second}
- resp, err := client.Get(url)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ if err != nil {
+ return "", err
+ }
+ resp, err := client.Do(req)
if err != nil {
return "", err
}
diff --git a/backend/internal/services/user_service.go b/backend/internal/services/user_service.go
index dcf5260c1..064294439 100644
--- a/backend/internal/services/user_service.go
+++ b/backend/internal/services/user_service.go
@@ -2,11 +2,9 @@ package services
import (
"context"
- "crypto/rand"
"errors"
"fmt"
"log"
- "math/big"
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
@@ -132,21 +130,6 @@ func (s *UserService) CreateDefaultAdmin() error {
return nil
}
-func (s *UserService) generateRandomPassword(length int) (string, error) {
- const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*"
- password := make([]byte, length)
-
- for i := range password {
- num, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
- if err != nil {
- return "", err
- }
- password[i] = charset[num.Int64()]
- }
-
- return string(password), nil
-}
-
func (s *UserService) ListUsers(ctx context.Context) ([]models.User, error) {
var users []models.User
if err := s.db.WithContext(ctx).Find(&users).Error; err != nil {
diff --git a/backend/internal/utils/registry_utils.go b/backend/internal/utils/registry_utils.go
index 54531becc..732453aeb 100644
--- a/backend/internal/utils/registry_utils.go
+++ b/backend/internal/utils/registry_utils.go
@@ -80,7 +80,7 @@ func getDockerHubToken(ctx context.Context, repo string, creds *RegistryCredenti
authURL := fmt.Sprintf("https://auth.docker.io/token?service=registry.docker.io&scope=repository:%s:pull", normalizedRepo)
client := &http.Client{Timeout: 30 * time.Second}
- req, err := http.NewRequestWithContext(ctx, "GET", authURL, nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, authURL, nil)
if err != nil {
return "", fmt.Errorf("failed to create auth request: %w", err)
}
@@ -201,7 +201,7 @@ type RegistryTestResult struct {
}
func testPing(ctx context.Context, client *http.Client, registryURL string, creds *RegistryCredentials) error {
- req, err := http.NewRequestWithContext(ctx, "GET", registryURL+"/", nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, registryURL+"/", nil)
if err != nil {
return err
}
@@ -231,7 +231,7 @@ func testAuth(ctx context.Context, client *http.Client, registryURL string, cred
return nil // Skip auth test if no credentials
}
- req, err := http.NewRequestWithContext(ctx, "GET", registryURL+"/_catalog?n=1", nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, registryURL+"/_catalog?n=1", nil)
if err != nil {
return err
}
@@ -253,7 +253,7 @@ func testAuth(ctx context.Context, client *http.Client, registryURL string, cred
}
func testCatalog(ctx context.Context, client *http.Client, registryURL string, creds *RegistryCredentials) error {
- req, err := http.NewRequestWithContext(ctx, "GET", registryURL+"/_catalog?n=5", nil)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, registryURL+"/_catalog?n=5", nil)
if err != nil {
return err
}