Skip to content

Modern Docker Management, Designed for Everyone

refactor: inject default http client into services

Kyle Mendell441f8a429798
diff --git a/backend/internal/api/template_handler.go b/backend/internal/api/template_handler.go
index 8d4da3f27..859d593f3 100644
--- a/backend/internal/api/template_handler.go
+++ b/backend/internal/api/template_handler.go
@@ -1,13 +1,8 @@
package api
import (
- "compress/gzip"
"encoding/json"
- "fmt"
- "io"
"net/http"
- "strings"
- "time"
"github.com/gin-gonic/gin"
"github.com/ofkm/arcane-backend/internal/dto"
@@ -514,46 +509,11 @@ func (h *TemplateHandler) FetchRegistry(c *gin.Context) {
return
}
- client := &http.Client{Timeout: 30 * time.Second}
- req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, url, nil)
- if err != nil {
- c.JSON(http.StatusBadRequest, gin.H{"success": false, "data": gin.H{"error": "Invalid URL: " + err.Error()}})
- return
- }
-
- req.Header.Set("User-Agent", "Arcane-Backend/1.0")
- req.Header.Set("Accept", "application/json")
- req.Header.Set("Accept-Encoding", "gzip, deflate")
- req.Header.Set("Cache-Control", "no-cache")
-
- resp, err := client.Do(req)
+ body, err := h.templateService.FetchRaw(c.Request.Context(), url)
if err != nil {
c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": "Failed to fetch registry: " + err.Error()}})
return
}
- defer resp.Body.Close()
-
- if resp.StatusCode != http.StatusOK {
- c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": fmt.Sprintf("Registry returned status %d", resp.StatusCode)}})
- return
- }
-
- var reader io.Reader = resp.Body
- if strings.Contains(resp.Header.Get("Content-Encoding"), "gzip") {
- gzipReader, err := gzip.NewReader(resp.Body)
- if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{"success": false, "data": gin.H{"error": "Failed to create gzip reader: " + err.Error()}})
- return
- }
- defer gzipReader.Close()
- reader = gzipReader
- }
-
- body, err := io.ReadAll(reader)
- if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{"success": false, "data": gin.H{"error": "Failed to read response: " + err.Error()}})
- return
- }
var registry interface{}
if err := json.Unmarshal(body, &registry); err != nil {
diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.go
index 3a3634da2..e2238dc8a 100644
--- a/backend/internal/bootstrap/services_bootstrap.go
+++ b/backend/internal/bootstrap/services_bootstrap.go
@@ -43,13 +43,13 @@ func initializeServices(db *database.DB, cfg *config.Config, httpClient *http.Cl
svc.ImageUpdate = services.NewImageUpdateService(db, svc.Settings, svc.ContainerRegistry, svc.Docker, svc.Event)
svc.Image = services.NewImageService(db, svc.Docker, svc.ContainerRegistry, svc.ImageUpdate, svc.Event)
svc.Stack = services.NewStackService(db, svc.Settings, svc.Event, svc.Image)
- svc.Environment = services.NewEnvironmentService(db)
+ svc.Environment = services.NewEnvironmentService(db, httpClient)
svc.Container = services.NewContainerService(db, svc.Event, svc.Docker)
svc.Volume = services.NewVolumeService(db, svc.Docker, svc.Event)
svc.Network = services.NewNetworkService(db, svc.Docker, svc.Event)
- svc.Template = services.NewTemplateService(db)
+ svc.Template = services.NewTemplateService(db, httpClient)
svc.Auth = services.NewAuthService(svc.User, svc.Settings, svc.Event, cfg.JWTSecret, cfg)
- svc.Oidc = services.NewOidcService(svc.Auth, cfg)
+ svc.Oidc = services.NewOidcService(svc.Auth, cfg, httpClient)
svc.Updater = services.NewUpdaterService(db, svc.Settings, svc.Docker, svc.Stack, svc.ImageUpdate, svc.ContainerRegistry, svc.Event, svc.Image)
svc.System = services.NewSystemService(db, svc.Docker, svc.Container, svc.Image, svc.Volume, svc.Network, svc.Settings)
svc.Version = services.NewVersionService(httpClient, cfg.UpdateCheckDisabled)
diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.go
index 9c5143b27..74f13e8bd 100644
--- a/backend/internal/services/environment_service.go
+++ b/backend/internal/services/environment_service.go
@@ -19,11 +19,15 @@ import (
)
type EnvironmentService struct {
- db *database.DB
+ db *database.DB
+ httpClient *http.Client
}
-func NewEnvironmentService(db *database.DB) *EnvironmentService {
- return &EnvironmentService{db: db}
+func NewEnvironmentService(db *database.DB, httpClient *http.Client) *EnvironmentService {
+ if httpClient == nil {
+ httpClient = http.DefaultClient
+ }
+ return &EnvironmentService{db: db, httpClient: httpClient}
}
func (s *EnvironmentService) CreateEnvironment(ctx context.Context, environment *models.Environment) (*models.Environment, error) {
@@ -124,14 +128,15 @@ func (s *EnvironmentService) TestConnection(ctx context.Context, id string) (str
return "error", err
}
- client := &http.Client{Timeout: 10 * time.Second}
+ reqCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
url := strings.TrimRight(environment.ApiUrl, "/") + "/api/health"
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, url, nil)
if err != nil {
_ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))
return "offline", fmt.Errorf("failed to create request: %w", err)
}
- resp, err := client.Do(req)
+ resp, err := s.httpClient.Do(req)
if err != nil {
_ = s.updateEnvironmentStatus(ctx, id, string(models.EnvironmentStatusOffline))
return "offline", fmt.Errorf("connection failed: %w", err)
@@ -220,14 +225,15 @@ func (s *EnvironmentService) IsEnvironmentOnline(environment *models.Environment
}
func (s *EnvironmentService) PairAgentWithBootstrap(ctx context.Context, apiUrl, bootstrapToken string) (string, error) {
- client := &http.Client{Timeout: 10 * time.Second}
- req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(apiUrl, "/")+"/api/environments/0/agent/pair", nil)
+ reqCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
+ req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, strings.TrimRight(apiUrl, "/")+"/api/environments/0/agent/pair", nil)
if err != nil {
return "", fmt.Errorf("create request: %w", err)
}
req.Header.Set("X-Arcane-Agent-Bootstrap", bootstrapToken)
- resp, err := client.Do(req)
+ resp, err := s.httpClient.Do(req)
if err != nil {
return "", fmt.Errorf("request failed: %w", err)
}
diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.go
index 1a3722e0b..975ee06ee 100644
--- a/backend/internal/services/oidc_service.go
+++ b/backend/internal/services/oidc_service.go
@@ -31,11 +31,14 @@ type OidcState struct {
CreatedAt time.Time `json:"created_at"`
}
-func NewOidcService(authService *AuthService, cfg *config.Config) *OidcService {
+func NewOidcService(authService *AuthService, cfg *config.Config, httpClient *http.Client) *OidcService {
+ if httpClient == nil {
+ httpClient = http.DefaultClient
+ }
return &OidcService{
authService: authService,
config: cfg,
- httpClient: &http.Client{Timeout: 30 * time.Second},
+ httpClient: httpClient,
}
}
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 231fe909e..d03f65bde 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -48,10 +48,13 @@ func makeRemoteID(registryID, slug string) string {
return fmt.Sprintf("%s:%s:%s", remoteIDPrefix, registryID, slug)
}
-func NewTemplateService(db *database.DB) *TemplateService {
+func NewTemplateService(db *database.DB, httpClient *http.Client) *TemplateService {
+ if httpClient == nil {
+ httpClient = http.DefaultClient
+ }
s := &TemplateService{
db: db,
- httpClient: &http.Client{Timeout: 30 * time.Second},
+ httpClient: httpClient,
cacheCmdCh: make(chan cacheCmd, 1),
}
s.remoteCache.Store(remoteCache{})
@@ -376,6 +379,10 @@ func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.Com
return templates, nil
}
+func (s *TemplateService) FetchRaw(ctx context.Context, url string) ([]byte, error) {
+ return s.doGET(ctx, url)
+}
+
func (s *TemplateService) doGET(ctx context.Context, url string) ([]byte, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {