Skip to content

Modern Docker Management, Designed for Everyone

refactor: move to coder/websocket library as it is actively maintained (#3431)

Kyle Mendell2f1a16a4facb
diff --git a/.custom-gcl.yml b/.custom-gcl.yml
new file mode 100644
index 000000000..b5289dede
--- /dev/null
+++ b/.custom-gcl.yml
@@ -0,0 +1,7 @@
+version: v2.12.2
+name: golangci-lint-custom
+destination: ./.bin
+
+plugins:
+ - module: go.ofkm.dev/shimbad
+ version: v0.1.2
\ No newline at end of file
diff --git a/.github/.golangci.yml b/.github/.golangci.yml
index e3b5689b6..5cf3b7a46 100644
--- a/.github/.golangci.yml
+++ b/.github/.golangci.yml
@@ -5,6 +5,7 @@ run:
linters:
default: none
enable:
+ - shimbad
- arangolint
- asasalint
- asciicheck
@@ -88,12 +89,16 @@ linters:
- whitespace
- zerologlint
settings:
+ custom:
+ shimbad:
+ type: module
+ description: Detects suspicious Go function implementations.
+ original-url: https://go.ofkm.dev/shimbad
forbidigo:
forbid:
- pattern: ^errors\.(Wrap|Wrapf|WithStack)$
msg: use WrapIf, WrapIff, or WithStackIf so an existing stack is preserved
gomoddirectives:
- # replace directives (=> ../cli, => ../types). Allow them.
replace-local: true
importas:
alias:
@@ -107,21 +112,15 @@ linters:
- legacy
- std-error-handling
rules:
- # Initialism naming (ApiKey -> APIKey, AppUrl -> AppURL, etc.) is intentional,
- # widespread, and API-surface; track separately rather than churn it here.
- linters:
- revive
text: "var-naming:"
- # Unused params are required by interface/callback/gorm-hook signatures.
- linters:
- revive
text: "unused-parameter:"
- # Package-prefixed exported names (swarm.SwarmInfo, port.PortMapping, etc.) are
- # an intentional, monorepo-wide convention; renaming is a large public-API change.
- linters:
- revive
text: "exported:"
- # The cli command package is a CLI entrypoint; printing to stdout is correct.
- linters:
- forbidigo
path: cli/
@@ -130,6 +129,9 @@ linters:
- third_party$
- builtin$
- examples$
+issues:
+ max-issues-per-linter: 0
+ max-same-issues: 0
formatters:
enable:
- gofmt
diff --git a/Justfile b/Justfile
index 5994914e7..086a56934 100644
--- a/Justfile
+++ b/Justfile
@@ -319,7 +319,8 @@ _lint-js:
# Lint Go backend
[group('quality')]
_lint-backend:
- cd backend && golangci-lint run -c ../.github/.golangci.yml ./...
+ golangci-lint custom
+ cd backend && ../.bin/golangci-lint-custom run -c ../.github/.golangci.yml ./...
# Lint Go CLI
[group('quality')]
diff --git a/backend/.custom-gcl.yml b/backend/.custom-gcl.yml
new file mode 120000
index 000000000..982ca0f91
--- /dev/null
+++ b/backend/.custom-gcl.yml
@@ -0,0 +1 @@
+../.custom-gcl.yml
\ No newline at end of file
diff --git a/backend/api/handlers/activities.go b/backend/api/handlers/activities.go
index 8cb3cbceb..c99f99bc2 100644
--- a/backend/api/handlers/activities.go
+++ b/backend/api/handlers/activities.go
@@ -253,7 +253,7 @@ func (h *ActivityHandler) proxyCancelActivityInternal(ctx context.Context, input
// audit message, preferring the authenticated user and falling back to a name
// forwarded from a proxying controller.
func (h *ActivityHandler) cancelRequestedByInternal(ctx context.Context, forwarded string) string {
- if user, ok := humamw.GetCurrentUserFromContext(ctx); ok && user != nil {
+ if user, ok := models.CurrentUserFromContext(ctx); ok && user != nil {
if user.DisplayName != nil && strings.TrimSpace(*user.DisplayName) != "" {
return strings.TrimSpace(*user.DisplayName)
}
diff --git a/backend/api/handlers/auth.go b/backend/api/handlers/auth.go
index ffae5c3b3..a79c9dc1a 100644
--- a/backend/api/handlers/auth.go
+++ b/backend/api/handlers/auth.go
@@ -20,6 +20,7 @@ import (
"github.com/danielgtaylor/huma/v2"
humamw "github.com/getarcaneapp/arcane/backend/v2/api/middleware"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/models"
"github.com/getarcaneapp/arcane/backend/v2/internal/services"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cookie"
"github.com/getarcaneapp/arcane/types/v2/auth"
@@ -273,7 +274,7 @@ func (h *AuthHandler) Logout(ctx context.Context, input *struct{}) (*LogoutOutpu
slog.ErrorContext(ctx, "Failed to revoke session on logout; clearing cookie anyway", "sessionID", sessionID, "error", err)
}
}
- if userModel, exists := humamw.GetCurrentUserFromContext(ctx); exists {
+ if userModel, exists := models.CurrentUserFromContext(ctx); exists {
h.authService.LogLogout(ctx, userModel)
}
}
diff --git a/backend/api/handlers/containers.go b/backend/api/handlers/containers.go
index afad02d58..4cd831100 100644
--- a/backend/api/handlers/containers.go
+++ b/backend/api/handlers/containers.go
@@ -715,7 +715,7 @@ func (h *ContainerHandler) runContainerActionInternal(ctx context.Context, input
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, cfg.ActivityType, "container", input.ContainerID, input.ContainerID, user, cfg.Step, cfg.StartMessage, models.JSON{"containerID": input.ContainerID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(runtimeCtx, h.activityService, input.EnvironmentID, cfg.ActivityType, "container", input.ContainerID, input.ContainerID, user, cfg.Step, cfg.StartMessage, models.JSON{"containerID": input.ContainerID}, false)
if err := cfg.Action(runtimeCtx, input.ContainerID, *user); err != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, cfg.CompleteMessage, err)
return nil, cfg.Error(err)
@@ -760,7 +760,7 @@ func (h *ContainerHandler) RedeployContainer(ctx context.Context, input *Contain
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID, runtimeCtx := activitylib.StartQueuedHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerRedeploy, "container", input.ContainerID, input.ContainerID, user, "Starting redeploy", "Container redeploy requested", models.JSON{"containerID": input.ContainerID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerRedeploy, "container", input.ContainerID, input.ContainerID, user, "Starting redeploy", "Container redeploy requested", models.JSON{"containerID": input.ContainerID}, true)
activitylib.AwaitHandlerActivitySlot(runtimeCtx, h.activityService, activityID, input.EnvironmentID)
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Redeploying container")
redeployCtx := context.WithValue(runtimeCtx, dockerutils.ProgressWriterKey{}, activityWriter)
@@ -806,7 +806,7 @@ func (h *ContainerHandler) DeleteContainer(ctx context.Context, input *DeleteCon
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerDelete, "container", input.ContainerID, input.ContainerID, user, "Deleting container", "Container delete requested", models.JSON{"containerID": input.ContainerID, "force": input.Force, "removeVolumes": input.RemoveVolumes})
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerDelete, "container", input.ContainerID, input.ContainerID, user, "Deleting container", "Container delete requested", models.JSON{"containerID": input.ContainerID, "force": input.Force, "removeVolumes": input.RemoveVolumes}, false)
if err := h.containerService.DeleteContainer(runtimeCtx, input.ContainerID, input.Force, input.RemoveVolumes, *user); err != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container deleted", err)
return nil, huma.Error500InternalServerError(errors.WithMessage(err, "Failed to delete container").Error())
diff --git a/backend/api/handlers/environments.go b/backend/api/handlers/environments.go
index b3c91fb2d..88a642023 100644
--- a/backend/api/handlers/environments.go
+++ b/backend/api/handlers/environments.go
@@ -705,7 +705,7 @@ func (h *EnvironmentHandler) UpdateEnvironment(ctx context.Context, input *Updat
h.handleEnvironmentPairingInternal(ctx, input.ID, &input.Body, updates, isLocalEnv)
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
var userID, username *string
if user != nil {
userID = new(user.ID)
@@ -794,7 +794,7 @@ func (h *EnvironmentHandler) DeleteEnvironment(ctx context.Context, input *Delet
return nil, huma.Error400BadRequest("Cannot delete local environment")
}
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
var userID, username *string
if user != nil {
userID = new(user.ID)
@@ -1445,7 +1445,7 @@ func (h *EnvironmentHandler) logMTLSAuditEventInternal(ctx context.Context, env
return
}
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
var userID, username *string
if user != nil {
userID = new(user.ID)
diff --git a/backend/api/handlers/git_repositories.go b/backend/api/handlers/git_repositories.go
index 76b6113b8..43c9ed10b 100644
--- a/backend/api/handlers/git_repositories.go
+++ b/backend/api/handlers/git_repositories.go
@@ -109,15 +109,15 @@ type SyncGitRepositoriesOutput struct {
func RegisterGitRepositories(api huma.API, repoService *services.GitRepositoryService) {
h := &GitRepositoryHandler{repoService: repoService}
- registerCustomizeSecuredInternal(api, "listGitRepositories", "GET", "/customize/git-repositories", "List git repositories", "Get a paginated list of git repositories", authz.PermGitReposList, h.ListRepositories)
- registerCustomizeSecuredInternal(api, "createGitRepository", "POST", "/customize/git-repositories", "Create a git repository", "Create a new git repository configuration", authz.PermGitReposCreate, h.CreateRepository)
- registerCustomizeSecuredInternal(api, "getGitRepository", "GET", "/customize/git-repositories/{id}", "Get a git repository", "Get a git repository by ID", authz.PermGitReposRead, h.GetRepository)
- registerCustomizeSecuredInternal(api, "updateGitRepository", "PUT", "/customize/git-repositories/{id}", "Update a git repository", "Update an existing git repository configuration", authz.PermGitReposUpdate, h.UpdateRepository)
- registerCustomizeSecuredInternal(api, "deleteGitRepository", "DELETE", "/customize/git-repositories/{id}", "Delete a git repository", "Delete a git repository configuration by ID", authz.PermGitReposDelete, h.DeleteRepository)
- registerCustomizeSecuredInternal(api, "testGitRepository", "POST", "/customize/git-repositories/{id}/test", "Test a git repository", "Test connectivity and authentication to a git repository", authz.PermGitReposTest, h.TestRepository)
- registerCustomizeSecuredInternal(api, "listGitRepositoryBranches", "GET", "/customize/git-repositories/{id}/branches", "List repository branches", "Get all branches from a git repository with default branch detection", authz.PermGitReposRead, h.ListBranches)
- registerCustomizeSecuredInternal(api, "browseGitRepositoryFiles", "GET", "/customize/git-repositories/{id}/files", "Browse repository files", "Browse files and directories in a git repository", authz.PermGitReposRead, h.BrowseFiles)
- registerTaggedSecuredInternal(api, "syncGitRepositories", "POST", "/git-repositories/sync", "Sync git repositories", "Sync git repositories from a manager to this agent instance", "Git Repositories", authz.PermGitReposSync, h.SyncRepositories)
+ registerSecuredInternal(api, operationInternal("listGitRepositories", "GET", "/customize/git-repositories", "List git repositories", "Get a paginated list of git repositories", "Customize"), authz.PermGitReposList, h.ListRepositories)
+ registerSecuredInternal(api, operationInternal("createGitRepository", "POST", "/customize/git-repositories", "Create a git repository", "Create a new git repository configuration", "Customize"), authz.PermGitReposCreate, h.CreateRepository)
+ registerSecuredInternal(api, operationInternal("getGitRepository", "GET", "/customize/git-repositories/{id}", "Get a git repository", "Get a git repository by ID", "Customize"), authz.PermGitReposRead, h.GetRepository)
+ registerSecuredInternal(api, operationInternal("updateGitRepository", "PUT", "/customize/git-repositories/{id}", "Update a git repository", "Update an existing git repository configuration", "Customize"), authz.PermGitReposUpdate, h.UpdateRepository)
+ registerSecuredInternal(api, operationInternal("deleteGitRepository", "DELETE", "/customize/git-repositories/{id}", "Delete a git repository", "Delete a git repository configuration by ID", "Customize"), authz.PermGitReposDelete, h.DeleteRepository)
+ registerSecuredInternal(api, operationInternal("testGitRepository", "POST", "/customize/git-repositories/{id}/test", "Test a git repository", "Test connectivity and authentication to a git repository", "Customize"), authz.PermGitReposTest, h.TestRepository)
+ registerSecuredInternal(api, operationInternal("listGitRepositoryBranches", "GET", "/customize/git-repositories/{id}/branches", "List repository branches", "Get all branches from a git repository with default branch detection", "Customize"), authz.PermGitReposRead, h.ListBranches)
+ registerSecuredInternal(api, operationInternal("browseGitRepositoryFiles", "GET", "/customize/git-repositories/{id}/files", "Browse repository files", "Browse files and directories in a git repository", "Customize"), authz.PermGitReposRead, h.BrowseFiles)
+ registerSecuredInternal(api, operationInternal("syncGitRepositories", "POST", "/git-repositories/sync", "Sync git repositories", "Sync git repositories from a manager to this agent instance", "Git Repositories"), authz.PermGitReposSync, h.SyncRepositories)
}
// ============================================================================
diff --git a/backend/api/handlers/gitops_syncs.go b/backend/api/handlers/gitops_syncs.go
index 278d2a964..7d8f55288 100644
--- a/backend/api/handlers/gitops_syncs.go
+++ b/backend/api/handlers/gitops_syncs.go
@@ -117,15 +117,18 @@ type ImportGitOpsSyncsOutput struct {
func RegisterGitOpsSyncs(api huma.API, syncService *services.GitOpsSyncService) {
h := &GitOpsSyncHandler{syncService: syncService}
- registerGitOpsSecuredInternal(api, "listGitOpsSyncs", "GET", "/environments/{id}/gitops-syncs", "List GitOps syncs", "Get a paginated list of GitOps syncs for an environment", authz.PermGitOpsList, h.ListSyncs)
- registerGitOpsSecuredInternal(api, "createGitOpsSync", "POST", "/environments/{id}/gitops-syncs", "Create a GitOps sync", "Create a new GitOps sync configuration for an environment", authz.PermGitOpsCreate, h.CreateSync)
- registerGitOpsSecuredInternal(api, "importGitOpsSyncs", "POST", "/environments/{id}/gitops-syncs/import", "Import GitOps syncs", "Import multiple GitOps sync configurations from JSON", authz.PermGitOpsCreate, h.ImportSyncs)
- registerGitOpsSecuredInternal(api, "getGitOpsSync", "GET", "/environments/{id}/gitops-syncs/{syncId}", "Get a GitOps sync", "Get a GitOps sync by ID", authz.PermGitOpsRead, h.GetSync)
- registerGitOpsSecuredInternal(api, "updateGitOpsSync", "PUT", "/environments/{id}/gitops-syncs/{syncId}", "Update a GitOps sync", "Update an existing GitOps sync configuration", authz.PermGitOpsUpdate, h.UpdateSync)
- registerGitOpsSecuredInternal(api, "deleteGitOpsSync", "DELETE", "/environments/{id}/gitops-syncs/{syncId}", "Delete a GitOps sync", "Delete a GitOps sync configuration by ID", authz.PermGitOpsDelete, h.DeleteSync)
- registerGitOpsSecuredInternal(api, "performGitOpsSync", "POST", "/environments/{id}/gitops-syncs/{syncId}/sync", "Perform a GitOps sync", "Manually trigger a sync operation", authz.PermGitOpsSync, h.PerformSync)
- registerGitOpsSecuredInternal(api, "getGitOpsSyncStatus", "GET", "/environments/{id}/gitops-syncs/{syncId}/status", "Get GitOps sync status", "Get the current status of a GitOps sync", authz.PermGitOpsRead, h.GetStatus)
- registerGitOpsSecuredInternal(api, "browseGitOpsSyncFiles", "GET", "/environments/{id}/gitops-syncs/{syncId}/files", "Browse GitOps sync files", "Browse files in the synced repository", authz.PermGitOpsRead, h.BrowseFiles)
+ const basePath = "/environments/{id}/gitops-syncs"
+ const syncPath = basePath + "/{syncId}"
+
+ registerSecuredInternal(api, operationInternal("listGitOpsSyncs", "GET", basePath, "List GitOps syncs", "Get a paginated list of GitOps syncs for an environment", "GitOps Syncs"), authz.PermGitOpsList, h.ListSyncs)
+ registerSecuredInternal(api, operationInternal("createGitOpsSync", "POST", basePath, "Create a GitOps sync", "Create a new GitOps sync configuration for an environment", "GitOps Syncs"), authz.PermGitOpsCreate, h.CreateSync)
+ registerSecuredInternal(api, operationInternal("importGitOpsSyncs", "POST", basePath+"/import", "Import GitOps syncs", "Import multiple GitOps sync configurations from JSON", "GitOps Syncs"), authz.PermGitOpsCreate, h.ImportSyncs)
+ registerSecuredInternal(api, operationInternal("getGitOpsSync", "GET", syncPath, "Get a GitOps sync", "Get a GitOps sync by ID", "GitOps Syncs"), authz.PermGitOpsRead, h.GetSync)
+ registerSecuredInternal(api, operationInternal("updateGitOpsSync", "PUT", syncPath, "Update a GitOps sync", "Update an existing GitOps sync configuration", "GitOps Syncs"), authz.PermGitOpsUpdate, h.UpdateSync)
+ registerSecuredInternal(api, operationInternal("deleteGitOpsSync", "DELETE", syncPath, "Delete a GitOps sync", "Delete a GitOps sync configuration by ID", "GitOps Syncs"), authz.PermGitOpsDelete, h.DeleteSync)
+ registerSecuredInternal(api, operationInternal("performGitOpsSync", "POST", syncPath+"/sync", "Perform a GitOps sync", "Manually trigger a sync operation", "GitOps Syncs"), authz.PermGitOpsSync, h.PerformSync)
+ registerSecuredInternal(api, operationInternal("getGitOpsSyncStatus", "GET", syncPath+"/status", "Get GitOps sync status", "Get the current status of a GitOps sync", "GitOps Syncs"), authz.PermGitOpsRead, h.GetStatus)
+ registerSecuredInternal(api, operationInternal("browseGitOpsSyncFiles", "GET", syncPath+"/files", "Browse GitOps sync files", "Browse files in the synced repository", "GitOps Syncs"), authz.PermGitOpsRead, h.BrowseFiles)
}
// requireLifecyclePermissionInternal rejects callers lacking gitops:lifecycle
diff --git a/backend/api/handlers/helpers.go b/backend/api/handlers/helpers.go
index bc76ad8e9..4610f8ff0 100644
--- a/backend/api/handlers/helpers.go
+++ b/backend/api/handlers/helpers.go
@@ -75,7 +75,7 @@ func toPaginationResponseInternal(p pagination.Response) base.PaginationResponse
// requireUserInternal returns the authenticated user from the request context or a 401 error.
func requireUserInternal(ctx context.Context) (*models.User, error) {
- user, exists := humamw.GetCurrentUserFromContext(ctx)
+ user, exists := models.CurrentUserFromContext(ctx)
if !exists || user == nil {
return nil, huma.Error401Unauthorized("Not authenticated")
}
@@ -107,46 +107,6 @@ func registerSecuredInternal[I, O any](
humamw.RegisterWithPermission(api, op, permission, handler)
}
-func registerCustomizeSecuredInternal[I, O any](
- api huma.API,
- operationID string,
- method string,
- path string,
- summary string,
- description string,
- permission string,
- handler func(context.Context, *I) (*O, error),
-) {
- registerTaggedSecuredInternal(api, operationID, method, path, summary, description, "Customize", permission, handler)
-}
-
-func registerGitOpsSecuredInternal[I, O any](
- api huma.API,
- operationID string,
- method string,
- path string,
- summary string,
- description string,
- permission string,
- handler func(context.Context, *I) (*O, error),
-) {
- registerTaggedSecuredInternal(api, operationID, method, path, summary, description, "GitOps Syncs", permission, handler)
-}
-
-func registerTaggedSecuredInternal[I, O any](
- api huma.API,
- operationID string,
- method string,
- path string,
- summary string,
- description string,
- tag string,
- permission string,
- handler func(context.Context, *I) (*O, error),
-) {
- registerSecuredInternal(api, operationInternal(operationID, method, path, summary, description, tag), permission, handler)
-}
-
func operationInternal(operationID, method, path, summary, description string, tags ...string) huma.Operation {
return huma.Operation{
OperationID: operationID,
@@ -160,7 +120,7 @@ func operationInternal(operationID, method, path, summary, description string, t
func currentActorInternal(ctx context.Context) models.User {
actor := models.User{}
- if currentUser, exists := humamw.GetCurrentUserFromContext(ctx); exists && currentUser != nil {
+ if currentUser, exists := models.CurrentUserFromContext(ctx); exists && currentUser != nil {
actor = *currentUser
}
return actor
diff --git a/backend/api/handlers/images.go b/backend/api/handlers/images.go
index 763a01638..9a61f5cb9 100644
--- a/backend/api/handlers/images.go
+++ b/backend/api/handlers/images.go
@@ -604,7 +604,7 @@ func (h *ImageHandler) PullImage(ctx context.Context, input *PullImageInput) (*h
runtimeCtx := utils.ActivityRuntimeContext(humaCtx.Context(), h.appCtx)
rawWriter := humaCtx.BodyWriter()
- activityID, runtimeCtx := activitylib.StartQueuedHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
input.EnvironmentID,
@@ -616,6 +616,7 @@ func (h *ImageHandler) PullImage(ctx context.Context, input *PullImageInput) (*h
"Pulling image",
"Image pull started",
models.JSON{"imageName": fullImageName},
+ true,
)
activitylib.WriteStartedLine(rawWriter, activityID)
if f, ok := rawWriter.(http.Flusher); ok {
@@ -661,7 +662,7 @@ func (h *ImageHandler) BuildImage(ctx context.Context, input *BuildImageInput) (
if strings.TrimSpace(resourceName) == "" {
resourceName = input.Body.ContextDir
}
- activityID, runtimeCtx := activitylib.StartQueuedHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
input.EnvironmentID,
@@ -673,6 +674,7 @@ func (h *ImageHandler) BuildImage(ctx context.Context, input *BuildImageInput) (
"Building image",
"Image build started",
models.JSON{"contextDir": input.Body.ContextDir, "tags": input.Body.Tags},
+ true,
)
activitylib.WriteStartedLine(rawWriter, activityID)
if f, ok := rawWriter.(http.Flusher); ok {
diff --git a/backend/api/handlers/projects.go b/backend/api/handlers/projects.go
index 6d532c4c1..3bf15f8b4 100644
--- a/backend/api/handlers/projects.go
+++ b/backend/api/handlers/projects.go
@@ -507,7 +507,7 @@ func (h *ProjectHandler) streamProjectOperationInternal(environmentID, projectID
if metadata == nil {
metadata = models.JSON{"projectID": projectID}
}
- activityID, runtimeCtx := activitylib.StartQueuedHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
environmentID,
@@ -519,6 +519,7 @@ func (h *ProjectHandler) streamProjectOperationInternal(environmentID, projectID
cfg.Step,
cfg.StartMessage,
metadata,
+ true,
)
activitylib.WriteStartedLine(rawWriter, activityID)
if f, ok := rawWriter.(http.Flusher); ok {
@@ -577,7 +578,7 @@ func (h *ProjectHandler) DownProject(ctx context.Context, input *DownProjectInpu
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectDown, "project", input.ProjectID, input.ProjectID, user, "Stopping project", "Project stop requested", models.JSON{"projectID": input.ProjectID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectDown, "project", input.ProjectID, input.ProjectID, user, "Stopping project", "Project stop requested", models.JSON{"projectID": input.ProjectID}, false)
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Stopping project")
downCtx := context.WithValue(runtimeCtx, dockerutils.ProgressWriterKey{}, activityWriter)
if err := h.projectService.DownProject(downCtx, input.ProjectID, *user); err != nil {
@@ -831,7 +832,7 @@ func (h *ProjectHandler) DestroyProject(ctx context.Context, input *DestroyProje
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectDestroy, "project", input.ProjectID, input.ProjectID, user, "Destroying project", "Project destroy requested", models.JSON{"projectID": input.ProjectID, "removeFiles": removeFiles, "removeVolumes": removeVolumes})
+ activityID, runtimeCtx := activitylib.StartHandlerActivity(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectDestroy, "project", input.ProjectID, input.ProjectID, user, "Destroying project", "Project destroy requested", models.JSON{"projectID": input.ProjectID, "removeFiles": removeFiles, "removeVolumes": removeVolumes}, false)
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Destroying project")
destroyCtx := context.WithValue(runtimeCtx, dockerutils.ProgressWriterKey{}, activityWriter)
if err := h.projectService.DestroyProject(destroyCtx, input.ProjectID, removeFiles, removeVolumes, *user); err != nil {
@@ -1088,10 +1089,10 @@ func (h *ProjectHandler) runProjectActivityActionInternal(ctx context.Context, e
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
var activityID string
if cfg.Queue {
- activityID, runtimeCtx = activitylib.StartQueuedHandlerActivityForUser(runtimeCtx, h.activityService, environmentID, cfg.ActivityType, "project", projectID, projectID, user, cfg.Step, cfg.StartMessage, models.JSON{"projectID": projectID})
+ activityID, runtimeCtx = activitylib.StartHandlerActivity(runtimeCtx, h.activityService, environmentID, cfg.ActivityType, "project", projectID, projectID, user, cfg.Step, cfg.StartMessage, models.JSON{"projectID": projectID}, true)
activitylib.AwaitHandlerActivitySlot(runtimeCtx, h.activityService, activityID, environmentID)
} else {
- activityID, runtimeCtx = activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, environmentID, cfg.ActivityType, "project", projectID, projectID, user, cfg.Step, cfg.StartMessage, models.JSON{"projectID": projectID})
+ activityID, runtimeCtx = activitylib.StartHandlerActivity(runtimeCtx, h.activityService, environmentID, cfg.ActivityType, "project", projectID, projectID, user, cfg.Step, cfg.StartMessage, models.JSON{"projectID": projectID}, false)
}
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, cfg.WriterStep)
actionCtx := context.WithValue(runtimeCtx, dockerutils.ProgressWriterKey{}, activityWriter)
diff --git a/backend/api/handlers/swarm.go b/backend/api/handlers/swarm.go
index ef598da66..2497cccf2 100644
--- a/backend/api/handlers/swarm.go
+++ b/backend/api/handlers/swarm.go
@@ -1828,7 +1828,7 @@ func (h *SwarmHandler) auditSwarmMutation(ctx context.Context, environmentID, ac
var userID *string
var username *string
- if user, ok := humamw.GetCurrentUserFromContext(ctx); ok {
+ if user, ok := models.CurrentUserFromContext(ctx); ok {
userID = new(user.ID)
username = new(user.Username)
}
diff --git a/backend/api/handlers/users.go b/backend/api/handlers/users.go
index ea4815be3..0ab121ec5 100644
--- a/backend/api/handlers/users.go
+++ b/backend/api/handlers/users.go
@@ -290,7 +290,7 @@ func (h *UserHandler) UpdateUser(ctx context.Context, input *UpdateUserInput) (*
// target, nor set another user's password. The service re-enforces the
// target-admin check.
callerPerms, _ := humamw.PermissionsFromContext(ctx)
- caller, _ := humamw.GetCurrentUserFromContext(ctx)
+ caller, _ := models.CurrentUserFromContext(ctx)
if callerPerms != nil && !callerPerms.IsGlobalAdmin() {
if input.Body.Password != nil && *input.Body.Password != "" && caller != nil && caller.ID != userModel.ID {
return nil, huma.Error403Forbidden(services.ErrInsufficientPrivilege.Error())
@@ -341,7 +341,7 @@ func (h *UserHandler) DeleteUser(ctx context.Context, input *DeleteUserInput) (*
// target. The service enforces the same check; this pre-check produces a
// clean 403 without entering the delete path.
callerPerms, _ := humamw.PermissionsFromContext(ctx)
- caller, _ := humamw.GetCurrentUserFromContext(ctx)
+ caller, _ := models.CurrentUserFromContext(ctx)
if callerPerms != nil && !callerPerms.IsGlobalAdmin() && caller != nil && caller.ID != input.UserID {
targetPerms, err := h.userService.ResolveUserPermissions(ctx, input.UserID)
if err != nil {
diff --git a/backend/api/handlers/users_test.go b/backend/api/handlers/users_test.go
index eb93d1be1..b504f033a 100644
--- a/backend/api/handlers/users_test.go
+++ b/backend/api/handlers/users_test.go
@@ -71,7 +71,7 @@ func TestDeleteUserReturnsConflictForLastAdmin(t *testing.T) {
// PermissionSet, matching what the auth bridge attaches in production.
func callerContext(u *models.User, ps *authz.PermissionSet) context.Context {
ctx := context.WithValue(context.Background(), humamw.ContextKeyUserPermissions, ps)
- return models.WithCurrentUser(ctx, u)
+ return context.WithValue(ctx, models.CurrentUserContextKey{}, u)
}
func grantRole(t *testing.T, roleSvc *services.RoleService, userID, roleID string) {
diff --git a/backend/api/handlers/volumes.go b/backend/api/handlers/volumes.go
index c9c63b963..0c439f902 100644
--- a/backend/api/handlers/volumes.go
+++ b/backend/api/handlers/volumes.go
@@ -846,7 +846,7 @@ func (h *VolumeHandler) UploadFile(ctx context.Context, input *UploadFileInput)
}
defer func() { _ = file.Close() }()
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, err := activitylib.RunHandlerActivity(runtimeCtx, h.activityService, activitylib.HandlerOptions{
EnvironmentID: input.EnvironmentID,
@@ -908,7 +908,7 @@ type volumePathActivityConfigInternal struct {
}
func (h *VolumeHandler) runVolumePathActivityInternal(ctx context.Context, environmentID, volumeName, volumePath string, cfg volumePathActivityConfigInternal) (*base.ApiResponse[base.MessageResponse], error) {
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, err := activitylib.RunHandlerActivity(runtimeCtx, h.activityService, activitylib.HandlerOptions{
EnvironmentID: environmentID,
@@ -1124,7 +1124,7 @@ func (h *VolumeHandler) ListBackupFiles(ctx context.Context, input *ListBackupFi
}
func (h *VolumeHandler) DeleteBackup(ctx context.Context, input *DeleteBackupInput) (*DeleteBackupOutput, error) {
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, err := activitylib.RunHandlerActivity(runtimeCtx, h.activityService, activitylib.HandlerOptions{
EnvironmentID: input.EnvironmentID,
@@ -1155,7 +1155,7 @@ func (h *VolumeHandler) DeleteBackup(ctx context.Context, input *DeleteBackupInp
}
func (h *VolumeHandler) DownloadBackup(ctx context.Context, input *DownloadBackupInput) (*huma.StreamResponse, error) {
- user, _ := humamw.GetCurrentUserFromContext(ctx)
+ user, _ := models.CurrentUserFromContext(ctx)
reader, size, err := h.volumeService.DownloadBackup(ctx, input.BackupID, user)
if err != nil {
return nil, huma.Error500InternalServerError(err.Error())
diff --git a/backend/api/handlers/volumes_upload_test.go b/backend/api/handlers/volumes_upload_test.go
index 11e3d533f..880e15b62 100644
--- a/backend/api/handlers/volumes_upload_test.go
+++ b/backend/api/handlers/volumes_upload_test.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"mime/multipart"
"net/http"
"testing"
@@ -32,7 +33,7 @@ func TestUploadFileReturnsBadRequestWhenNoFileProvided(t *testing.T) {
func TestUploadAndRestoreReturnsBadRequestWhenNoFileProvided(t *testing.T) {
h := &VolumeHandler{volumeService: &services.VolumeService{}}
- ctx := models.WithCurrentUser(adminTestContextInternal(), &models.User{BaseModel: models.BaseModel{ID: "u-1"}})
+ ctx := context.WithValue(adminTestContextInternal(), models.CurrentUserContextKey{}, &models.User{BaseModel: models.BaseModel{ID: "u-1"}})
_, err := h.UploadAndRestore(ctx, &UploadAndRestoreInput{
EnvironmentID: "0",
diff --git a/backend/api/handlers/webhooks.go b/backend/api/handlers/webhooks.go
index 91e7366f6..8267a6a68 100644
--- a/backend/api/handlers/webhooks.go
+++ b/backend/api/handlers/webhooks.go
@@ -124,7 +124,7 @@ func (h *WebhookHandler) CreateWebhook(ctx context.Context, input *CreateWebhook
}
actor := models.User{}
- if currentUser, exists := humamw.GetCurrentUserFromContext(ctx); exists && currentUser != nil {
+ if currentUser, exists := models.CurrentUserFromContext(ctx); exists && currentUser != nil {
actor = *currentUser
}
@@ -173,7 +173,7 @@ func (h *WebhookHandler) UpdateWebhook(ctx context.Context, input *UpdateWebhook
}
actor := models.User{}
- if currentUser, exists := humamw.GetCurrentUserFromContext(ctx); exists && currentUser != nil {
+ if currentUser, exists := models.CurrentUserFromContext(ctx); exists && currentUser != nil {
actor = *currentUser
}
@@ -194,7 +194,7 @@ func (h *WebhookHandler) UpdateWebhook(ctx context.Context, input *UpdateWebhook
// DeleteWebhook removes a webhook.
func (h *WebhookHandler) DeleteWebhook(ctx context.Context, input *DeleteWebhookInput) (*DeleteWebhookOutput, error) {
actor := models.User{}
- if currentUser, exists := humamw.GetCurrentUserFromContext(ctx); exists && currentUser != nil {
+ if currentUser, exists := models.CurrentUserFromContext(ctx); exists && currentUser != nil {
actor = *currentUser
}
diff --git a/backend/api/middleware/auth.go b/backend/api/middleware/auth.go
index 2278837f5..faefb18bb 100644
--- a/backend/api/middleware/auth.go
+++ b/backend/api/middleware/auth.go
@@ -39,11 +39,6 @@ func GetUserIDFromContext(ctx context.Context) (string, bool) {
return userID, ok
}
-// GetCurrentUserFromContext retrieves the current user from the context.
-func GetCurrentUserFromContext(ctx context.Context) (*models.User, bool) {
- return models.CurrentUserFromContext(ctx)
-}
-
// GetCurrentSessionIDFromContext retrieves the current session ID from the context.
func GetCurrentSessionIDFromContext(ctx context.Context) (string, bool) {
sessionID, ok := ctx.Value(ContextKeyCurrentSessionID).(string)
@@ -195,7 +190,7 @@ func tryAgentAuthInternal(ctx huma.Context, cfg *config.Config) (*models.User, b
}
// createAgentSudoUserInternal creates a sudo user for agent authentication.
-// The PermissionSet attached to the context (via setUserInContextWithSudoInternal)
+// The sudo PermissionSet attached to the context by the agent token path
// bypasses every check; the user's Roles field is intentionally empty.
func createAgentSudoUserInternal() *models.User {
return &models.User{
@@ -268,7 +263,9 @@ func tryAgentAuthCtxInternal(ctx huma.Context, cfg *config.Config) (huma.Context
if !ok {
return ctx, false
}
- return huma.WithContext(ctx, setUserInContextWithSudoInternal(ctx.Context(), user)), true
+ // The agent token path is infrastructure-level and not per-user, so it
+ // gets a sudo PermissionSet that bypasses every check.
+ return huma.WithContext(ctx, setUserInContextInternal(ctx.Context(), user, authz.SudoPermissionSet())), true
}
// opportunisticBearerAuthInternal populates the user/session context if a valid
@@ -414,14 +411,7 @@ func setUserInContextInternal(ctx context.Context, user *models.User, ps *authz.
ps = authz.NewPermissionSet()
}
ctx = context.WithValue(ctx, ContextKeyUserID, user.ID)
- ctx = models.WithCurrentUser(ctx, user)
+ ctx = context.WithValue(ctx, models.CurrentUserContextKey{}, user)
ctx = context.WithValue(ctx, ContextKeyUserPermissions, ps)
return ctx
}
-
-// setUserInContextWithSudoInternal attaches a sudo PermissionSet (bypasses
-// every check) plus the user. Used by the agent token path, which is
-// infrastructure-level and not per-user.
-func setUserInContextWithSudoInternal(ctx context.Context, user *models.User) context.Context {
- return setUserInContextInternal(ctx, user, authz.SudoPermissionSet())
-}
diff --git a/backend/api/middleware/auth_test.go b/backend/api/middleware/auth_test.go
index c343d150f..4647ae70b 100644
--- a/backend/api/middleware/auth_test.go
+++ b/backend/api/middleware/auth_test.go
@@ -109,7 +109,7 @@ func TestNewAuthBridge_AcceptsEnvironmentAccessTokenViaAPIKey(t *testing.T) {
Path: "/secure",
Security: []map[string][]string{{"ApiKeyAuth": {}}},
}, func(ctx context.Context, _ *secureInput) (*secureOutput, error) {
- user, ok := GetCurrentUserFromContext(ctx)
+ user, ok := models.CurrentUserFromContext(ctx)
require.True(t, ok)
require.Equal(t, "environment:env-self", user.ID)
require.Equal(t, "Self Target", user.Username)
@@ -180,7 +180,7 @@ func TestNewAuthBridge_UsesBearerWhenLoopbackProxySendsEnvironmentAccessToken(t
ID string `path:"id"`
CID string `path:"cid"`
}) (*secureOutput, error) {
- user, ok := GetCurrentUserFromContext(ctx)
+ user, ok := models.CurrentUserFromContext(ctx)
require.True(t, ok)
require.Equal(t, "u-loopback", user.ID)
diff --git a/backend/api/ws/diagnostics.go b/backend/api/ws/diagnostics.go
index 1133766ad..ac47e16ae 100644
--- a/backend/api/ws/diagnostics.go
+++ b/backend/api/ws/diagnostics.go
@@ -1,18 +1,19 @@
package ws
import (
+ "context"
"encoding/json/v2"
"log/slog"
"net/http"
"net/http/pprof"
"time"
+ "github.com/coder/websocket"
"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
"github.com/getarcaneapp/arcane/backend/v2/internal/services"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
wshub "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
systemtypes "github.com/getarcaneapp/arcane/types/v2/system"
- "github.com/gorilla/websocket"
"github.com/labstack/echo/v5"
"go.getarcane.app/streams/logs"
)
@@ -21,14 +22,13 @@ import (
const diagnosticsStreamInterval = 2 * time.Second
// Keepalive/liveness bounds for the diagnostics sockets, mirroring the system
-// stats stream. Without them a silently dead peer wedges WriteMessage forever,
+// stats stream. Without them a silently dead peer wedges the writer forever,
// which also strands the writer's deferred cleanup (log subscription, conn).
const (
- diagnosticsReadLimit = 512
- diagnosticsPongWait = 60 * time.Second
- diagnosticsWriteWait = 10 * time.Second
- diagnosticsPingWriteWait = 1 * time.Second
- diagnosticsPingPeriod = diagnosticsPongWait * 9 / 10
+ diagnosticsReadLimit = 512
+ diagnosticsWriteWait = 10 * time.Second
+ diagnosticsPingWait = 10 * time.Second
+ diagnosticsPingPeriod = 54 * time.Second
)
// BuildDiagnostics assembles a full diagnostics snapshot: runtime/memory/GC from
@@ -72,24 +72,26 @@ func (h *WebSocketHandler) registerDiagnosticsRoutesInternal(group *echo.Group,
// DiagnosticsStream pushes a fresh diagnostics snapshot on connect and then every
// diagnosticsStreamInterval until the client disconnects.
func (h *WebSocketHandler) DiagnosticsStream(c *echo.Context) error {
- conn, err := h.wsUpgrader.Upgrade(c.Response(), c.Request(), nil)
+ conn, err := wshub.Accept(c.Response(), c.Request(), h.checkWSOrigin)
if err != nil {
return nil
}
defer func() {
- if err := conn.Close(); err != nil {
+ if err := conn.CloseNow(); err != nil {
slog.Debug("Failed to close diagnostics websocket connection", "error", err)
}
}()
- done := diagnosticsReadLoopInternal(conn)
+ ctx := c.Request().Context()
+ done := diagnosticsReadLoopInternal(ctx, conn)
write := func() bool {
b, marshalErr := json.Marshal(BuildDiagnostics(h.diagnosticsService))
if marshalErr != nil {
return true
}
- _ = conn.SetWriteDeadline(time.Now().Add(diagnosticsWriteWait))
- return conn.WriteMessage(websocket.TextMessage, b) == nil
+ wctx, cancel := context.WithTimeout(ctx, diagnosticsWriteWait)
+ defer cancel()
+ return conn.Write(wctx, websocket.MessageText, b) == nil
}
if !write() {
@@ -108,8 +110,7 @@ func (h *WebSocketHandler) DiagnosticsStream(c *echo.Context) error {
return nil
}
case <-pingTicker.C:
- _ = conn.SetWriteDeadline(time.Now().Add(diagnosticsPingWriteWait))
- if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+ if !pingDiagnosticsConnInternal(ctx, conn) {
return nil
}
}
@@ -118,12 +119,12 @@ func (h *WebSocketHandler) DiagnosticsStream(c *echo.Context) error {
// ServerLogsStream replays the recent backend log backlog then streams new entries live.
func (h *WebSocketHandler) ServerLogsStream(c *echo.Context) error {
- conn, err := h.wsUpgrader.Upgrade(c.Response(), c.Request(), nil)
+ conn, err := wshub.Accept(c.Response(), c.Request(), h.checkWSOrigin)
if err != nil {
return nil
}
defer func() {
- if err := conn.Close(); err != nil {
+ if err := conn.CloseNow(); err != nil {
slog.Debug("Failed to close server logs websocket connection", "error", err)
}
}()
@@ -133,14 +134,16 @@ func (h *WebSocketHandler) ServerLogsStream(c *echo.Context) error {
ch, cancel := defaultLogBroadcaster.Subscribe()
defer cancel()
- done := diagnosticsReadLoopInternal(conn)
+ ctx := c.Request().Context()
+ done := diagnosticsReadLoopInternal(ctx, conn)
write := func(e logs.Entry) bool {
b, marshalErr := json.Marshal(e)
if marshalErr != nil {
return true
}
- _ = conn.SetWriteDeadline(time.Now().Add(diagnosticsWriteWait))
- return conn.WriteMessage(websocket.TextMessage, b) == nil
+ wctx, wcancel := context.WithTimeout(ctx, diagnosticsWriteWait)
+ defer wcancel()
+ return conn.Write(wctx, websocket.MessageText, b) == nil
}
for _, e := range defaultLogBroadcaster.Recent() {
@@ -162,31 +165,32 @@ func (h *WebSocketHandler) ServerLogsStream(c *echo.Context) error {
return nil
}
case <-pingTicker.C:
- _ = conn.SetWriteDeadline(time.Now().Add(diagnosticsPingWriteWait))
- if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+ if !pingDiagnosticsConnInternal(ctx, conn) {
return nil
}
}
}
}
+// pingDiagnosticsConnInternal reports whether the peer answered a ping in time.
+// The pong is serviced by the diagnosticsReadLoopInternal reader, so a peer
+// that stops answering fails here within diagnosticsPingWait.
+func pingDiagnosticsConnInternal(ctx context.Context, conn *websocket.Conn) bool {
+ pctx, cancel := context.WithTimeout(ctx, diagnosticsPingWait)
+ defer cancel()
+ return conn.Ping(pctx) == nil
+}
+
// diagnosticsReadLoopInternal drains incoming frames; the returned channel closes
-// when the peer disconnects, signaling the writer loop to stop. The read deadline
-// is what makes a half-open connection observable: pongs from the writer's pings
-// extend it, and a peer that stops answering trips it within diagnosticsPongWait.
-func diagnosticsReadLoopInternal(conn *websocket.Conn) <-chan struct{} {
+// when the peer disconnects, signaling the writer loop to stop.
+func diagnosticsReadLoopInternal(ctx context.Context, conn *websocket.Conn) <-chan struct{} {
conn.SetReadLimit(diagnosticsReadLimit)
- _ = conn.SetReadDeadline(time.Now().Add(diagnosticsPongWait))
- conn.SetPongHandler(func(string) error {
- _ = conn.SetReadDeadline(time.Now().Add(diagnosticsPongWait))
- return nil
- })
done := make(chan struct{})
go func() {
defer close(done)
for {
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(ctx); err != nil {
return
}
}
diff --git a/backend/api/ws/handler.go b/backend/api/ws/handler.go
index 167b86001..7d08f4578 100644
--- a/backend/api/ws/handler.go
+++ b/backend/api/ws/handler.go
@@ -15,7 +15,7 @@ import (
"emperror.dev/errors"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/labstack/echo/v5"
"github.com/samber/hot"
"github.com/shirou/gopsutil/v4/cpu"
@@ -49,7 +49,7 @@ type WebSocketHandler struct {
swarmService *services.SwarmService
systemService *services.SystemService
diagnosticsService *services.DiagnosticsService
- wsUpgrader websocket.Upgrader
+ checkWSOrigin func(*http.Request) bool
wsMetrics *wshub.WebSocketMetrics
activeConnections sync.Map
logStreamsMu sync.Mutex
@@ -232,12 +232,7 @@ func NewWebSocketHandler(
diskUsagePathCache: hot.NewHotCache[struct{}, string](hot.LRU, 1).
WithTTL(5 * time.Minute).
Build(),
- wsUpgrader: websocket.Upgrader{
- CheckOrigin: httputil.ValidateWebSocketOrigin(cfg.GetAppURL()),
- ReadBufferSize: 32 * 1024,
- WriteBufferSize: 32 * 1024,
- EnableCompression: true,
- },
+ checkWSOrigin: httputil.ValidateWebSocketOrigin(cfg.GetAppURL()),
}
wsGroup := group.Group("/environments/:id/ws", authMiddleware.WithAdminNotRequired().Add())
for _, r := range handler.proxiedRoutes() {
@@ -298,7 +293,7 @@ func (h *WebSocketHandler) serveLogStreamInternal(
params logStreamParams,
hubBuilder func(streamKey string, onEmpty func(*wsLogStream)) *wsLogStream,
) {
- conn, err := h.wsUpgrader.Upgrade(c.Response(), c.Request(), nil)
+ conn, err := wshub.Accept(c.Response(), c.Request(), h.checkWSOrigin)
if err != nil {
return
}
@@ -320,7 +315,7 @@ func (h *WebSocketHandler) serveLogStreamInternal(
// here means it was torn down out from under us; drop our reference
// rather than leaking the connection and the metrics entry.
slog.Debug("log stream hub stopped before client registration", "streamKey", streamKey)
- _ = conn.Close()
+ _ = conn.CloseNow()
release()
}
}
@@ -650,7 +645,7 @@ func (h *WebSocketHandler) ContainerStats(c *echo.Context) error {
return c.JSON(http.StatusBadRequest, map[string]any{"success": false, "error": "Container ID is required"})
}
- conn, err := h.wsUpgrader.Upgrade(c.Response(), c.Request(), nil)
+ conn, err := wshub.Accept(c.Response(), c.Request(), h.checkWSOrigin)
if err != nil {
slog.DebugContext(c.Request().Context(), "Failed to upgrade WebSocket for container stats", "containerID", containerID, "error", err)
return nil
@@ -677,7 +672,7 @@ func (h *WebSocketHandler) ContainerStats(c *echo.Context) error {
}
slog.WarnContext(c.Request().Context(), "failed to register container stats client", "containerID", containerID)
- _ = conn.Close()
+ _ = conn.CloseNow()
onRemove()
return nil
}
@@ -808,37 +803,36 @@ func (h *WebSocketHandler) ContainerExec(c *echo.Context) error {
shell := queryParamWithDefaultInternal(c, "shell", "/bin/sh")
- conn, err := h.wsUpgrader.Upgrade(c.Response(), c.Request(), nil)
+ conn, err := wshub.Accept(c.Response(), c.Request(), h.checkWSOrigin)
if err != nil {
return nil
}
connID := h.wsMetrics.RegisterConnection(buildWSConnectionInfoInternal(c, systemtypes.WSKindContainerExec, containerID))
defer h.wsMetrics.UnregisterConnection(connID)
defer func() {
- if err := conn.Close(); err != nil {
+ if err := conn.CloseNow(); err != nil {
slog.Debug("Failed to close container exec websocket connection", "containerID", containerID, "error", err)
}
}()
+ // Allow large terminal pastes; coder/websocket's default limit is 32KB.
+ conn.SetReadLimit(1 << 20)
+
ctx, cancel := context.WithCancel(c.Request().Context())
defer cancel()
- const execPongWait = 60 * time.Second
- _ = conn.SetReadDeadline(time.Now().Add(execPongWait))
- conn.SetPongHandler(func(string) error {
- _ = conn.SetReadDeadline(time.Now().Add(execPongWait))
- return nil
- })
- go h.pingExecConnInternal(ctx, conn, execPongWait*9/10)
+ go h.pingExecConnInternal(ctx, cancel, conn, 54*time.Second)
h.runContainerExecInternal(ctx, cancel, conn, containerID, shell)
return nil
}
-// pingExecConnInternal keeps the exec websocket alive; pongs refresh the read
-// deadline so a silently-dead client fails the next read instead of blocking
-// forever. WriteControl is safe concurrently with the exec output writer.
-func (h *WebSocketHandler) pingExecConnInternal(ctx context.Context, conn *websocket.Conn, period time.Duration) {
+// pingExecConnInternal keeps the exec websocket alive. Ping round-trips (the
+// pong is serviced by the concurrent stdin reader) and is safe concurrently
+// with the exec output writer. A failed ping means the client is gone, so it
+// cancels the exec session — a silently-dead client would otherwise keep the
+// session open until an output write fails.
+func (h *WebSocketHandler) pingExecConnInternal(ctx context.Context, cancel context.CancelFunc, conn *websocket.Conn, period time.Duration) {
ticker := time.NewTicker(period)
defer ticker.Stop()
for {
@@ -846,7 +840,11 @@ func (h *WebSocketHandler) pingExecConnInternal(ctx context.Context, conn *webso
case <-ctx.Done():
return
case <-ticker.C:
- if err := conn.WriteControl(websocket.PingMessage, nil, time.Now().Add(time.Second)); err != nil {
+ pctx, pcancel := context.WithTimeout(ctx, 10*time.Second)
+ err := conn.Ping(pctx)
+ pcancel()
+ if err != nil {
+ cancel()
return
}
}
@@ -857,14 +855,14 @@ func (h *WebSocketHandler) runContainerExecInternal(ctx context.Context, cancel
// Create exec instance
execID, err := h.containerService.CreateExec(ctx, containerID, []string{shell})
if err != nil {
- h.writeExecErrorInternal(conn, errors.WithMessage(err, "Error creating exec"))
+ h.writeExecErrorInternal(ctx, conn, errors.WithMessage(err, "Error creating exec"))
return
}
// Attach to exec
execSession, err := h.containerService.AttachExec(ctx, containerID, execID)
if err != nil {
- h.writeExecErrorInternal(conn, errors.WithMessage(err, "Error attaching to exec"))
+ h.writeExecErrorInternal(ctx, conn, errors.WithMessage(err, "Error attaching to exec"))
return
}
cleanup := h.execCleanupFuncInternal(ctx, execSession, execID, containerID)
@@ -878,8 +876,10 @@ func (h *WebSocketHandler) runContainerExecInternal(ctx context.Context, cancel
<-done
}
-func (h *WebSocketHandler) writeExecErrorInternal(conn *websocket.Conn, err error) {
- _ = conn.WriteMessage(websocket.TextMessage, []byte(err.Error()+"\r\n"))
+func (h *WebSocketHandler) writeExecErrorInternal(ctx context.Context, conn *websocket.Conn, err error) {
+ wctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
+ _ = conn.Write(wctx, websocket.MessageText, []byte(err.Error()+"\r\n"))
}
func (h *WebSocketHandler) execCleanupFuncInternal(ctx context.Context, execSession *services.ExecSession, execID, containerID string) func() {
@@ -918,7 +918,7 @@ func (h *WebSocketHandler) pipeExecOutputInternal(ctx context.Context, conn *web
return
}
if n > 0 {
- if err := conn.WriteMessage(websocket.BinaryMessage, buf[:n]); err != nil {
+ if err := conn.Write(ctx, websocket.MessageBinary, buf[:n]); err != nil {
slog.Debug("Exec websocket write error", "execID", execID, "containerID", containerID, "error", err)
return
}
@@ -928,13 +928,7 @@ func (h *WebSocketHandler) pipeExecOutputInternal(ctx context.Context, conn *web
func (h *WebSocketHandler) pipeExecInputInternal(ctx context.Context, cancel context.CancelFunc, conn *websocket.Conn, stdin io.Writer, execID, containerID string) {
for {
- select {
- case <-ctx.Done():
- return
- default:
- }
-
- _, data, err := conn.ReadMessage()
+ _, data, err := conn.Read(ctx)
if err != nil {
slog.Debug("Exec websocket read error", "execID", execID, "containerID", containerID, "error", err)
cancel()
@@ -1307,14 +1301,14 @@ func (h *WebSocketHandler) SystemStats(c *echo.Context) error {
}
defer h.releaseRateLimitInternal(clientIP, count)
- conn, err := h.wsUpgrader.Upgrade(c.Response(), c.Request(), nil)
+ conn, err := wshub.Accept(c.Response(), c.Request(), h.checkWSOrigin)
if err != nil {
return nil
}
connID := h.wsMetrics.RegisterConnection(buildWSConnectionInfoInternal(c, systemtypes.WSKindSystemStats, ""))
defer h.wsMetrics.UnregisterConnection(connID)
defer func() {
- if err := conn.Close(); err != nil {
+ if err := conn.CloseNow(); err != nil {
slog.Debug("Failed to close system stats websocket connection", "clientIP", clientIP, "error", err)
}
}()
@@ -1324,18 +1318,9 @@ func (h *WebSocketHandler) SystemStats(c *echo.Context) error {
interval = 2
}
- const (
- statsPongWait = 60 * time.Second
- statsPingWriteWait = 1 * time.Second
- )
- statsPingPeriod := statsPongWait * 9 / 10
+ const statsPingPeriod = 54 * time.Second
conn.SetReadLimit(512)
- _ = conn.SetReadDeadline(time.Now().Add(statsPongWait))
- conn.SetPongHandler(func(string) error {
- _ = conn.SetReadDeadline(time.Now().Add(statsPongWait))
- return nil
- })
ticker := time.NewTicker(time.Duration(interval) * time.Second)
defer ticker.Stop()
@@ -1354,8 +1339,13 @@ func (h *WebSocketHandler) SystemStats(c *echo.Context) error {
send := func() error {
stats := h.latestSystemStatsSnapshotInternal()
- _ = conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
- return conn.WriteJSON(stats)
+ b, err := json.Marshal(stats)
+ if err != nil {
+ return err
+ }
+ wctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
+ return conn.Write(wctx, websocket.MessageText, b)
}
if err := send(); err != nil {
@@ -1371,8 +1361,11 @@ func (h *WebSocketHandler) SystemStats(c *echo.Context) error {
return nil
}
case <-pingTicker.C:
- _ = conn.SetWriteDeadline(time.Now().Add(statsPingWriteWait))
- if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+ // Ping round-trips; the pong is serviced by readSystemStatsPumpInternal.
+ pctx, pcancel := context.WithTimeout(ctx, 10*time.Second)
+ err := conn.Ping(pctx)
+ pcancel()
+ if err != nil {
return nil
}
}
@@ -1383,14 +1376,9 @@ func (h *WebSocketHandler) SystemStats(c *echo.Context) error {
// Do not add additional readers for this connection.
func (h *WebSocketHandler) readSystemStatsPumpInternal(ctx context.Context, cancel context.CancelFunc, conn *websocket.Conn) {
for {
- select {
- case <-ctx.Done():
+ if _, _, err := conn.Read(ctx); err != nil {
+ cancel()
return
- default:
- if _, _, err := conn.ReadMessage(); err != nil {
- cancel()
- return
- }
}
}
}
diff --git a/backend/api/ws/handler_test.go b/backend/api/ws/handler_test.go
index 4e973f617..1ceec8462 100644
--- a/backend/api/ws/handler_test.go
+++ b/backend/api/ws/handler_test.go
@@ -12,7 +12,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/labstack/echo/v5"
"github.com/stretchr/testify/require"
@@ -39,8 +39,7 @@ func TestBroadcastLogStreamErrorInternal_JSON(t *testing.T) {
broadcastLogStreamErrorInternal("container log stream", "Failed to stream container logs: ", "container-1", "json", errors.New("boom"), stream)
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, payload, err := clientConn.ReadMessage()
+ payload, err := readMessageInternal(t, clientConn)
require.NoError(t, err)
var message wshub.LogMessage
@@ -68,8 +67,7 @@ func TestBroadcastLogStreamErrorInternal_Text(t *testing.T) {
broadcastLogStreamErrorInternal("container log stream", "Failed to stream container logs: ", "container-1", "text", errors.New("boom"), stream)
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, payload, err := clientConn.ReadMessage()
+ payload, err := readMessageInternal(t, clientConn)
require.NoError(t, err)
require.Equal(t, "Failed to stream container logs: boom", string(payload))
}
@@ -78,9 +76,8 @@ func newTestWSPairInternal(t *testing.T) (clientConn *websocket.Conn, serverConn
t.Helper()
serverReady := make(chan *websocket.Conn, 1)
- upgrader := websocket.Upgrader{CheckOrigin: func(_ *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true})
if err != nil {
return
}
@@ -88,30 +85,25 @@ func newTestWSPairInternal(t *testing.T) (clientConn *websocket.Conn, serverConn
}))
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- _ = resp.Body.Close()
- }
serverConn = <-serverReady
return clientConn, serverConn, func() {
- _ = clientConn.Close()
- _ = serverConn.Close()
+ _ = clientConn.CloseNow()
+ _ = serverConn.CloseNow()
server.Close()
}
}
func newTestWebSocketHandler() *WebSocketHandler {
return &WebSocketHandler{
- wsMetrics: wshub.NewWebSocketMetrics(),
- logStreams: make(map[string]*wsLogStream),
- cgroupCache: cgroup.NewCache(cgroupCacheTTL),
- gpuMonitor: system.NewGPUMonitor(false, ""),
- wsUpgrader: websocket.Upgrader{
- CheckOrigin: func(r *http.Request) bool { return true },
- },
+ wsMetrics: wshub.NewWebSocketMetrics(),
+ logStreams: make(map[string]*wsLogStream),
+ cgroupCache: cgroup.NewCache(cgroupCacheTTL),
+ gpuMonitor: system.NewGPUMonitor(false, ""),
+ checkWSOrigin: func(*http.Request) bool { return true },
}
}
@@ -119,15 +111,21 @@ func dialWebSocket(t *testing.T, serverURL, path string) *websocket.Conn {
t.Helper()
wsURL := "ws" + strings.TrimPrefix(serverURL, "http") + path
- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ conn, _, err := websocket.Dial(t.Context(), wsURL, nil)
require.NoError(t, err)
- if resp != nil {
- _ = resp.Body.Close()
- }
return conn
}
+func readMessageInternal(t *testing.T, conn *websocket.Conn) ([]byte, error) {
+ t.Helper()
+
+ ctx, cancel := context.WithTimeout(t.Context(), 2*time.Second)
+ defer cancel()
+ _, payload, err := conn.Read(ctx)
+ return payload, err
+}
+
func TestWebSocketHandler_ProjectLogs_SharedStreamPerTarget(t *testing.T) {
handler := newTestWebSocketHandler()
@@ -162,12 +160,10 @@ func TestWebSocketHandler_ProjectLogs_SharedStreamPerTarget(t *testing.T) {
conn1 := dialWebSocket(t, server.URL, "/api/environments/0/ws/projects/project-1/logs")
conn2 := dialWebSocket(t, server.URL, "/api/environments/0/ws/projects/project-1/logs")
- _ = conn1.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, err := conn1.ReadMessage()
+ _, err := readMessageInternal(t, conn1)
require.NoError(t, err)
- _ = conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, err = conn2.ReadMessage()
+ _, err = readMessageInternal(t, conn2)
require.NoError(t, err)
require.Eventually(t, func() bool {
@@ -180,7 +176,7 @@ func TestWebSocketHandler_ProjectLogs_SharedStreamPerTarget(t *testing.T) {
return len(handler.logStreams) == 1
}, time.Second, 20*time.Millisecond)
- require.NoError(t, conn1.Close())
+ require.NoError(t, conn1.CloseNow())
require.Eventually(t, func() bool {
handler.logStreamsMu.Lock()
@@ -194,7 +190,7 @@ func TestWebSocketHandler_ProjectLogs_SharedStreamPerTarget(t *testing.T) {
require.Equal(t, 1, activeAfterFirstClose)
require.Equal(t, int32(0), cancels.Load())
- require.NoError(t, conn2.Close())
+ require.NoError(t, conn2.CloseNow())
require.Eventually(t, func() bool {
handler.logStreamsMu.Lock()
@@ -233,11 +229,10 @@ func TestWebSocketHandler_ProjectLogs_CompletedSourceStartsFreshStream(t *testin
path := "/api/environments/0/ws/projects/project-1/logs?follow=false"
conn1 := dialWebSocket(t, server.URL, path)
defer func() {
- require.NoError(t, conn1.Close())
+ _ = conn1.CloseNow()
}()
- _ = conn1.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg1, err := conn1.ReadMessage()
+ msg1, err := readMessageInternal(t, conn1)
require.NoError(t, err)
require.Equal(t, "finite project log", string(msg1))
@@ -249,11 +244,10 @@ func TestWebSocketHandler_ProjectLogs_CompletedSourceStartsFreshStream(t *testin
conn2 := dialWebSocket(t, server.URL, path)
defer func() {
- require.NoError(t, conn2.Close())
+ _ = conn2.CloseNow()
}()
- _ = conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg2, err := conn2.ReadMessage()
+ msg2, err := readMessageInternal(t, conn2)
require.NoError(t, err)
require.Equal(t, "finite project log", string(msg2))
@@ -281,18 +275,16 @@ func TestWebSocketHandler_ContainerLogs_BroadcastsStreamErrors(t *testing.T) {
conn := dialWebSocket(t, server.URL, "/api/environments/0/ws/containers/container-1/logs")
defer func() {
- require.NoError(t, conn.Close())
+ _ = conn.CloseNow()
}()
var got []string
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg, err := conn.ReadMessage()
+ msg, err := readMessageInternal(t, conn)
require.NoError(t, err)
got = append(got, string(msg))
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg, err = conn.ReadMessage()
+ msg, err = readMessageInternal(t, conn)
require.NoError(t, err)
got = append(got, string(msg))
@@ -324,13 +316,12 @@ func TestWebSocketHandler_ContainerLogs_ErrorStartsFreshStreamForNewSubscribers(
path := "/api/environments/0/ws/containers/container-1/logs"
conn1 := dialWebSocket(t, server.URL, path)
defer func() {
- require.NoError(t, conn1.Close())
+ _ = conn1.CloseNow()
}()
got1 := make([]string, 0, 2)
for range 2 {
- _ = conn1.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg, err := conn1.ReadMessage()
+ msg, err := readMessageInternal(t, conn1)
require.NoError(t, err)
got1 = append(got1, string(msg))
}
@@ -341,13 +332,12 @@ func TestWebSocketHandler_ContainerLogs_ErrorStartsFreshStreamForNewSubscribers(
conn2 := dialWebSocket(t, server.URL, path)
defer func() {
- require.NoError(t, conn2.Close())
+ _ = conn2.CloseNow()
}()
got2 := make([]string, 0, 2)
for range 2 {
- _ = conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg, err := conn2.ReadMessage()
+ msg, err := readMessageInternal(t, conn2)
require.NoError(t, err)
got2 = append(got2, string(msg))
}
@@ -381,20 +371,18 @@ func TestWebSocketHandler_SystemStats_UsesSharedSampler(t *testing.T) {
conn1 := dialWebSocket(t, server.URL, "/api/environments/0/ws/system/stats?interval=1")
conn2 := dialWebSocket(t, server.URL, "/api/environments/0/ws/system/stats?interval=1")
- _ = conn1.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, err := conn1.ReadMessage()
+ _, err := readMessageInternal(t, conn1)
require.NoError(t, err)
- _ = conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, err = conn2.ReadMessage()
+ _, err = readMessageInternal(t, conn2)
require.NoError(t, err)
require.Eventually(t, func() bool {
return collects.Load() >= 1
}, 2*time.Second, 50*time.Millisecond)
- require.NoError(t, conn1.Close())
- require.NoError(t, conn2.Close())
+ require.NoError(t, conn1.CloseNow())
+ require.NoError(t, conn2.CloseNow())
require.Eventually(t, func() bool {
handler.systemStatsSampler.lifecycleMu.Lock()
@@ -585,12 +573,16 @@ func TestWebSocketHandler_GetCachedCgroupLimitsInternal_DeduplicatesRefresh(t *t
var calls atomic.Int32
start := make(chan struct{})
+ var startOnce sync.Once
release := make(chan struct{})
// A fresh cache has a zero timestamp, so the first Get takes the refresh path
- // and subsequent concurrent Gets dedupe behind the write lock.
+ // and subsequent concurrent Gets dedupe behind the write lock. A goroutine
+ // can miss both the cached value and the in-flight refresh at the flight
+ // boundary and run the detector a second time after the first completes, so
+ // close(start) must be idempotent.
handler.cgroupCache = cgroup.NewCacheWithDetector(cgroupCacheTTL, func() (*cgroup.Limits, error) {
calls.Add(1)
- close(start)
+ startOnce.Do(func() { close(start) })
<-release
return &cgroup.Limits{CPUCount: 2}, nil
})
@@ -628,5 +620,8 @@ func TestWebSocketHandler_GetCachedCgroupLimitsInternal_DeduplicatesRefresh(t *t
require.NotNil(t, result)
require.Equal(t, 2, result.CPUCount)
}
- require.Equal(t, int32(1), calls.Load())
+ // Dedup guarantees no concurrent detector calls (asserted above while the
+ // refresh was in flight); a single boundary straggler may legitimately
+ // trigger one extra refresh after the first flight completes.
+ require.LessOrEqual(t, calls.Load(), int32(2))
}
diff --git a/backend/buildables/disabled.go b/backend/buildables/disabled.go
index 14a829ac7..81053c331 100644
--- a/backend/buildables/disabled.go
+++ b/backend/buildables/disabled.go
@@ -6,6 +6,8 @@ package buildables
var EnabledFeatures = ""
// HasBuildFeature always returns false when the buildables tag is not set.
+//
+//nolint:shimbad // build-tag stub: the real implementation is compiled under the buildables tag
func HasBuildFeature(feature string) bool {
return false
}
diff --git a/backend/cli/upgrade/upgrade.go b/backend/cli/upgrade/upgrade.go
index db2e4dd2f..f6dd5a453 100644
--- a/backend/cli/upgrade/upgrade.go
+++ b/backend/cli/upgrade/upgrade.go
@@ -430,7 +430,7 @@ func upgradeContainer(ctx context.Context, dockerClient *client.Client, oldConta
)
if !nm.IsContainer() {
apiVersion = libarcane.DetectDockerAPIVersion(ctx, dockerClient)
- if apiVersion != "" && !libarcane.SupportsDockerCreatePerNetworkMACAddress(apiVersion) {
+ if apiVersion != "" && !libarcane.IsDockerAPIVersionAtLeast(apiVersion, libarcane.NetworkScopedMacAddressMinAPIVersion) {
slog.Info("daemon API does not support per-network mac-address on create; stripping endpoint mac addresses",
"dockerAPIVersion", apiVersion,
"minimumRequiredAPIVersion", libarcane.NetworkScopedMacAddressMinAPIVersion,
diff --git a/backend/frontend/excluded.go b/backend/frontend/excluded.go
index 1653a0b85..d9d01773b 100644
--- a/backend/frontend/excluded.go
+++ b/backend/frontend/excluded.go
@@ -4,6 +4,7 @@ package frontend
import "github.com/labstack/echo/v5"
+//nolint:shimbad // build-tag stub: the real implementation lives in frontend.go
func RegisterFrontend(e *echo.Echo) error {
_ = e
return ErrFrontendNotIncluded
diff --git a/backend/go.mod b/backend/go.mod
index 711e6a0db..ac1e5c98f 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -14,6 +14,7 @@ require (
github.com/aws/aws-sdk-go-v2/credentials v1.19.30
github.com/aws/aws-sdk-go-v2/service/ecr v1.60.0
github.com/cenkalti/backoff/v5 v5.0.3
+ github.com/coder/websocket v1.8.15
github.com/compose-spec/compose-go/v2 v2.13.0
github.com/containerd/errdefs v1.0.0
github.com/containerd/platforms v1.0.0-rc.4
@@ -31,7 +32,6 @@ require (
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/google/go-containerregistry v0.21.7
github.com/google/uuid v1.6.0
- github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674
github.com/jinzhu/copier v0.4.0
github.com/klauspost/compress v1.19.1
github.com/labstack/echo/v5 v5.3.1
@@ -136,6 +136,7 @@ require (
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
github.com/google/go-cmp v0.7.0 // indirect
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
+ github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect
github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
diff --git a/backend/go.sum b/backend/go.sum
index c4e2c9aff..5e757d509 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -80,6 +80,8 @@ github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg
github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb h1:EDmT6Q9Zs+SbUoc7Ik9EfrFqcylYqgPZ9ANSbTAntnE=
github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb/go.mod h1:ZjrT6AXHbDs86ZSdt/osfBi5qfexBrKUdONk989Wnk4=
+github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
+github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
github.com/compose-spec/compose-go/v2 v2.13.0 h1:2+2oS3v4SrtAOBdZRAZYBsBy47D571p5EXMSCppmTtE=
github.com/compose-spec/compose-go/v2 v2.13.0/go.mod h1:ZU6zlcweCZKyiB7BVfCizQT9XmkEIMFE+PRZydVcsZg=
github.com/containerd/cgroups/v3 v3.1.3 h1:eUNflyMddm18+yrDmZPn3jI7C5hJ9ahABE5q6dyLYXQ=
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index 90bc57e1e..0ac4597fe 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -52,7 +52,7 @@ func Bootstrap(ctx context.Context) error {
// Tee all slog output into the in-memory ring buffer that powers the
// diagnostics live log tail.
slog.SetDefault(slog.New(logs.NewSlogHandler(slog.Default().Handler(), ws.LogBroadcaster())))
- ConfigureGormLogger(cfg)
+ database.SetGormLogger(BuildGormLogger(cfg))
slog.InfoContext(ctx, "Arcane is starting...", "version", config.Version)
slog.InfoContext(ctx, "Arcane Identity Configuration", "PUID", os.Getuid(), "PGID", os.Getgid())
diff --git a/backend/internal/bootstrap/edge_bootstrap.go b/backend/internal/bootstrap/edge_bootstrap.go
index f08131e91..fdce88495 100644
--- a/backend/internal/bootstrap/edge_bootstrap.go
+++ b/backend/internal/bootstrap/edge_bootstrap.go
@@ -90,7 +90,7 @@ func registerEdgeTunnelRoutes(
return nil
}
- server := edge.NewTunnelServer(resolver, statusCallback)
+ server := edge.NewTunnelServerWithRegistry(edge.GetRegistry(), resolver, statusCallback)
server.SetConfig(&edge.Config{
EdgeMTLSMode: cfg.EdgeMTLSMode,
EdgeMTLSCAFile: cfg.EdgeMTLSCAFile,
diff --git a/backend/internal/bootstrap/logger_bootstrap.go b/backend/internal/bootstrap/logger_bootstrap.go
index 33d0e3cf1..1fee15e37 100644
--- a/backend/internal/bootstrap/logger_bootstrap.go
+++ b/backend/internal/bootstrap/logger_bootstrap.go
@@ -13,7 +13,6 @@ import (
slogGorm "github.com/orandin/slog-gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
- "github.com/getarcaneapp/arcane/backend/v2/internal/database"
"gorm.io/gorm/logger"
)
@@ -277,7 +276,3 @@ func BuildGormLogger(cfg *config.Config) logger.Interface {
return slogGorm.New(opts...)
}
-
-func ConfigureGormLogger(cfg *config.Config) {
- database.SetGormLogger(BuildGormLogger(cfg))
-}
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index 018be93d4..0cc697927 100644
--- a/backend/internal/bootstrap/router_bootstrap.go
+++ b/backend/internal/bootstrap/router_bootstrap.go
@@ -234,12 +234,13 @@ func newRouter(p RouterParams) (*echo.Echo, *edge.TunnelServer) {
permissionMatcher := authz.NewPermissionMatcher()
- envProxyMiddleware := middleware.NewEnvProxyMiddlewareWithParam(
+ envProxyMiddleware := middleware.NewEnvProxyMiddlewareWithParamAndRegistry(
types.LocalDockerEnvironmentID,
"id",
envResolver,
createAuthValidatorInternal(deps),
permissionMatcher,
+ tunnelRegistry,
// Proxied WebSocket upgrades enforce the same Origin policy as the local
// endpoints, so a cross-origin page cannot ride a session cookie into a
// remote environment.
@@ -339,7 +340,7 @@ func secureCookieContextMiddlewareInternal(trustedProxyNets []*net.IPNet) echo.M
secure = true
}
if secure {
- c.SetRequest(req.WithContext(cookie.WithSecureCookieContext(req.Context(), true)))
+ c.SetRequest(req.WithContext(context.WithValue(req.Context(), cookie.SecureCookieContextKey{}, true)))
}
return next(c)
}
diff --git a/backend/internal/configschema/schema.go b/backend/internal/configschema/schema.go
index 74bcf7c7d..224f22933 100644
--- a/backend/internal/configschema/schema.go
+++ b/backend/internal/configschema/schema.go
@@ -251,9 +251,9 @@ func parseStructEnvFieldsInternal(filename, structName string, opts envFieldOpti
return nil, errors.WrapIff(err, "render type for %s.%s", structName, field.Names[0].Name)
}
- description := normalizeCommentInternal(field.Doc.Text())
+ description := strings.TrimSpace(strings.Join(strings.Fields(field.Doc.Text()), " "))
if description == "" {
- description = normalizeCommentInternal(field.Comment.Text())
+ description = strings.TrimSpace(strings.Join(strings.Fields(field.Comment.Text()), " "))
}
for _, name := range field.Names {
@@ -320,7 +320,7 @@ func collectSettingEnvOverridesInternal() ([]SettingOverrideEntry, error) {
}
entries = append(entries, SettingOverrideEntry{
- Env: utils.CamelCaseToScreamingSnakeCase(key),
+ Env: strings.ToUpper(utils.CamelCaseToSnakeCase(key)),
SettingKey: key,
Description: meta["description"],
DefaultValue: defaultValue,
@@ -398,10 +398,6 @@ func splitTagListInternal(value string) []string {
return result
}
-func normalizeCommentInternal(comment string) string {
- return strings.TrimSpace(strings.Join(strings.Fields(comment), " "))
-}
-
func joinRequirementsInternal(parts ...string) string {
filtered := make([]string, 0, len(parts))
for _, part := range parts {
diff --git a/backend/internal/database/database.go b/backend/internal/database/database.go
index 43a9d9605..ccb9310ca 100644
--- a/backend/internal/database/database.go
+++ b/backend/internal/database/database.go
@@ -192,7 +192,7 @@ func migrateDatabaseToVersionInternal(ctx context.Context, db *sql.DB, dbProvide
return errors.WrapIff(err, "failed to determine current migration version for %s", dbProvider)
}
- logMigrationStateInternal(dbProvider, currentVersion, requiredVersion)
+ slog.Info("Resolved database migration state", "provider", dbProvider, "currentVersion", currentVersion, "requiredVersion", requiredVersion)
if currentVersion > requiredVersion {
if !options.AllowDowngrade {
@@ -216,7 +216,7 @@ func migrateDatabaseToVersionInternal(ctx context.Context, db *sql.DB, dbProvide
}
if currentVersion == requiredVersion {
- logUpToDateStateInternal(dbProvider, currentVersion)
+ slog.Info("Database schema is up to date", "provider", dbProvider, "migrationVersion", currentVersion)
return nil
}
@@ -514,10 +514,6 @@ func appliedLiteralInternal(dbProvider string) string {
return "1"
}
-func logUpToDateStateInternal(dbProvider string, version int64) {
- slog.Info("Database schema is up to date", "provider", dbProvider, "migrationVersion", version)
-}
-
func getHighestEmbeddedMigrationVersionInternal(dbProvider string) (int64, error) {
versions, err := getEmbeddedMigrationVersionsInternal(dbProvider)
if err != nil {
@@ -612,10 +608,6 @@ func missingEmbeddedDowngradeMigrationsInternal(ctx context.Context, db *sql.DB,
return missing, nil
}
-func logMigrationStateInternal(dbProvider string, currentVersion, requiredVersion int64) {
- slog.Info("Resolved database migration state", "provider", dbProvider, "currentVersion", currentVersion, "requiredVersion", requiredVersion)
-}
-
func parseSqliteConnectionStringInternal(connString string) (string, error) {
if !strings.HasPrefix(connString, "file:") {
connString = "file:" + connString
diff --git a/backend/internal/di/di.go b/backend/internal/di/di.go
index 71ac676fe..df25cb880 100644
--- a/backend/internal/di/di.go
+++ b/backend/internal/di/di.go
@@ -71,7 +71,7 @@ var JobOptions = fx.Options(
scheduler.NewAutoUpdateJob,
scheduler.NewImageUpdateWatcher,
scheduler.NewDockerClientRefreshJob,
- provideAnalyticsJobInternal,
+ scheduler.NewAnalyticsJob,
scheduler.NewEventCleanupJob,
scheduler.NewPruningVolumeHelperJob,
scheduler.NewExpiredSessionsCleanupJob,
diff --git a/backend/internal/di/providers.go b/backend/internal/di/providers.go
index bd8c28026..57d85560b 100644
--- a/backend/internal/di/providers.go
+++ b/backend/internal/di/providers.go
@@ -70,8 +70,28 @@ func provideProjectServiceInternal(db *database.DB, settings *services.SettingsS
WithRegistryCredentialsProvider(environment.GetEnabledRegistryCredentials)
}
-func provideUpdaterServiceInternal(db *database.DB, settings *services.SettingsService, docker *services.DockerClientService, project *services.ProjectService, imageUpdate *services.ImageUpdateService, registry *services.ContainerRegistryService, event *services.EventService, image *services.ImageService, notification *services.NotificationService, systemUpgrade *services.SystemUpgradeService, activity *services.ActivityService) (*services.UpdaterService, error) {
- return services.NewUpdaterService(db, settings, docker, project, imageUpdate, registry, event, image, notification, systemUpgrade, activity)
+// updaterServiceParams collects the updater's dependencies. The dedicated
+// provider exists because NewUpdaterService takes its self-upgrade dependency
+// as an unexported interface, which fx cannot supply directly; the adapter
+// narrows *SystemUpgradeService to that interface.
+type updaterServiceParams struct {
+ fx.In
+
+ DB *database.DB
+ Settings *services.SettingsService
+ Docker *services.DockerClientService
+ Project *services.ProjectService
+ ImageUpdate *services.ImageUpdateService
+ Registry *services.ContainerRegistryService
+ Event *services.EventService
+ Image *services.ImageService
+ Notification *services.NotificationService
+ SystemUpgrade *services.SystemUpgradeService
+ Activity *services.ActivityService
+}
+
+func provideUpdaterServiceInternal(p updaterServiceParams) (*services.UpdaterService, error) {
+ return services.NewUpdaterService(p.DB, p.Settings, p.Docker, p.Project, p.ImageUpdate, p.Registry, p.Event, p.Image, p.Notification, p.SystemUpgrade, p.Activity)
}
func provideUserServiceInternal(db *database.DB, role *services.RoleService) *services.UserService {
@@ -93,10 +113,6 @@ func provideAuthMiddlewareInternal(auth *services.AuthService, apiKey *services.
WithPermissionResolver(role)
}
-func provideAnalyticsJobInternal(settings *services.SettingsService, kv *services.KVService, cfg *config.Config) *scheduler.AnalyticsJob {
- return scheduler.NewAnalyticsJob(settings, kv, nil, cfg)
-}
-
func provideFilesystemWatcherJobInternal(ctx context.Context, project *services.ProjectService, template *services.TemplateService, settings *services.SettingsService, cfg *config.Config) *scheduler.FilesystemWatcherJob {
job, err := scheduler.RegisterFilesystemWatcherJob(ctx, project, template, settings, cfg.ProjectScanMaxDepth)
if err != nil {
diff --git a/backend/internal/middleware/environment_middleware.go b/backend/internal/middleware/environment_middleware.go
index 38e77ffc1..927f11e88 100644
--- a/backend/internal/middleware/environment_middleware.go
+++ b/backend/internal/middleware/environment_middleware.go
@@ -17,7 +17,6 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge"
wsutil "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
httputils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
- "github.com/gorilla/websocket"
"github.com/labstack/echo/v5"
)
@@ -71,11 +70,6 @@ type EnvironmentMiddleware struct {
checkOrigin func(*http.Request) bool
}
-// NewEnvProxyMiddlewareWithParam creates middleware that proxies requests to remote environments.
-func NewEnvProxyMiddlewareWithParam(localID, paramName string, resolver EnvResolver, authValidator AuthValidator, matcher *authz.PermissionMatcher, checkOrigin func(*http.Request) bool) echo.MiddlewareFunc {
- return NewEnvProxyMiddlewareWithParamAndRegistry(localID, paramName, resolver, authValidator, matcher, edge.GetRegistry(), checkOrigin)
-}
-
// NewEnvProxyMiddlewareWithParamAndRegistry creates middleware with an injected tunnel registry.
func NewEnvProxyMiddlewareWithParamAndRegistry(
localID,
@@ -176,7 +170,7 @@ func (m *EnvironmentMiddleware) Handle(c *echo.Context, next echo.HandlerFunc) e
target := m.buildTargetURL(c, envID, apiURL)
- if m.isWebSocketUpgrade(c) {
+ if httputils.IsWebSocketUpgradeRequest(c.Request()) {
return m.proxyWebSocket(c, target, accessToken, envID)
}
return m.proxyHTTP(c, target, accessToken)
@@ -258,7 +252,7 @@ func (m *EnvironmentMiddleware) setProxyContextHeadersInternal(c *echo.Context,
func (m *EnvironmentMiddleware) proxyThroughTunnelInternal(c *echo.Context, tunnel *edge.AgentTunnel, envID string) error {
proxyPath := m.buildProxyPath(c, envID)
- if m.isWebSocketUpgrade(c) {
+ if httputils.IsWebSocketUpgradeRequest(c.Request()) {
return edge.ProxyWebSocketRequest(c, tunnel, proxyPath, m.checkOrigin)
}
return edge.ProxyHTTPRequest(c, tunnel, proxyPath)
@@ -369,11 +363,6 @@ func (m *EnvironmentMiddleware) buildProxyPath(c *echo.Context, envID string) st
return path.Join(apiEnvironmentsPrefix, m.localID) + m.buildResourceSuffix(c.Request().URL.Path, envID)
}
-// isWebSocketUpgrade checks if this is a WebSocket upgrade request.
-func (m *EnvironmentMiddleware) isWebSocketUpgrade(c *echo.Context) bool {
- return websocket.IsWebSocketUpgrade(c.Request())
-}
-
func isEdgeEnvironmentURLInternal(apiURL string) bool {
normalized := strings.ToLower(strings.TrimSpace(apiURL))
return strings.HasPrefix(normalized, "edge://")
diff --git a/backend/internal/middleware/environment_middleware_test.go b/backend/internal/middleware/environment_middleware_test.go
index 7a56af4f4..9d418e584 100644
--- a/backend/internal/middleware/environment_middleware_test.go
+++ b/backend/internal/middleware/environment_middleware_test.go
@@ -295,67 +295,6 @@ func TestEnvironmentMiddleware_ProxyHTTPRejectsEdgeTargetsWithoutTunnel(t *testi
assert.Contains(t, recorder.Body.String(), "Edge agent is not connected")
}
-func TestIsWebSocketUpgrade(t *testing.T) {
- middleware := newTestEnvironmentMiddleware()
-
- tests := []struct {
- name string
- headers map[string]string
- expected bool
- }{
- {
- name: "valid websocket upgrade",
- headers: map[string]string{"Upgrade": "websocket", "Connection": "Upgrade", "Sec-Websocket-Key": "dGhlIHNhbXBsZSBub25jZQ==", "Sec-Websocket-Version": "13"},
- expected: true,
- },
- {
- name: "normal GET request",
- headers: map[string]string{},
- expected: false,
- },
- {
- name: "only upgrade header from reverse proxy",
- headers: map[string]string{"Upgrade": "websocket"},
- expected: false,
- },
- {
- name: "only connection upgrade from reverse proxy",
- headers: map[string]string{"Connection": "Upgrade"},
- expected: false,
- },
- {
- name: "connection upgrade with keep-alive from nginx",
- headers: map[string]string{"Connection": "upgrade, keep-alive"},
- expected: false,
- },
- {
- name: "only sec-websocket-key leaked by proxy",
- headers: map[string]string{"Sec-Websocket-Key": "dGhlIHNhbXBsZSBub25jZQ=="},
- expected: false,
- },
- {
- name: "upgrade and connection but no sec-websocket-key",
- headers: map[string]string{"Upgrade": "websocket", "Connection": "Upgrade"},
- expected: true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- e := echo.New()
- recorder := httptest.NewRecorder()
- req := httptest.NewRequest(http.MethodGet, "/api/environments/env-1/containers", nil)
- for k, v := range tt.headers {
- req.Header.Set(k, v)
- }
- c := e.NewContext(req, recorder)
-
- result := middleware.isWebSocketUpgrade(c)
- assert.Equal(t, tt.expected, result, "headers: %v", tt.headers)
- })
- }
-}
-
func TestEnvironmentMiddleware_CreateProxyRequest_RejectsInvalidProxyTarget(t *testing.T) {
middleware := newTestEnvironmentMiddleware()
e := echo.New()
diff --git a/backend/internal/models/errors.go b/backend/internal/models/errors.go
index c19a5454d..43ee73080 100644
--- a/backend/internal/models/errors.go
+++ b/backend/internal/models/errors.go
@@ -72,22 +72,6 @@ func NewAPIErrorWithDetails(message string, code APIErrorCode, statusCode int, d
}
}
-func NewNotFoundError(message string) *APIError {
- return NewAPIError(message, APIErrorCodeNotFound, http.StatusNotFound)
-}
-
-func NewConflictError(message string) *APIError {
- return NewAPIError(message, APIErrorCodeConflict, http.StatusConflict)
-}
-
-func NewInternalServerError(message string) *APIError {
- return NewAPIError(message, APIErrorCodeInternalServerError, http.StatusInternalServerError)
-}
-
-func NewValidationError(message string, details any) *APIError {
- return NewAPIErrorWithDetails(message, APIErrorCodeValidationError, http.StatusBadRequest, details)
-}
-
type DockerAPIError struct {
Message string
StatusCode int
@@ -126,7 +110,7 @@ func ToAPIError(err error) *APIError {
if len(details) == 0 {
details = nil
}
- return NewValidationError(err.Error(), details)
+ return NewAPIErrorWithDetails(err.Error(), APIErrorCodeValidationError, http.StatusBadRequest, details)
case errors.Is(err, common.ErrBadRequest):
return NewAPIError(err.Error(), APIErrorCodeBadRequest, http.StatusBadRequest)
case errors.Is(err, common.ErrUnauthorized):
@@ -134,14 +118,14 @@ func ToAPIError(err error) *APIError {
case errors.Is(err, common.ErrForbidden):
return NewAPIError(err.Error(), APIErrorCodeForbidden, http.StatusForbidden)
case errors.Is(err, common.ErrNotFound):
- return NewNotFoundError(err.Error())
+ return NewAPIError(err.Error(), APIErrorCodeNotFound, http.StatusNotFound)
case errors.Is(err, common.ErrConflict):
- return NewConflictError(err.Error())
+ return NewAPIError(err.Error(), APIErrorCodeConflict, http.StatusConflict)
case errors.Is(err, common.ErrTimeout):
return NewAPIError(err.Error(), APIErrorCodeTimeout, http.StatusGatewayTimeout)
case errors.Is(err, common.ErrUnavailable):
return NewAPIError(err.Error(), APIErrorCodeInternalServerError, http.StatusServiceUnavailable)
}
- return NewInternalServerError(err.Error())
+ return NewAPIError(err.Error(), APIErrorCodeInternalServerError, http.StatusInternalServerError)
}
diff --git a/backend/internal/models/user.go b/backend/internal/models/user.go
index 791607866..1d43ba910 100644
--- a/backend/internal/models/user.go
+++ b/backend/internal/models/user.go
@@ -36,20 +36,16 @@ func (User) TableName() string {
return "users"
}
-// currentUserContextKeyInternal is the context key holding the authenticated
-// user model. It lives here (rather than in api/middleware) so that services,
-// which cannot import the middleware package, can read the requesting user for
-// per-user preferences.
-type currentUserContextKeyInternal struct{}
-
-// WithCurrentUser returns a context carrying the authenticated user.
-func WithCurrentUser(ctx context.Context, u *User) context.Context {
- return context.WithValue(ctx, currentUserContextKeyInternal{}, u)
-}
+// CurrentUserContextKey is the context key holding the authenticated user
+// model, set via context.WithValue(ctx, models.CurrentUserContextKey{}, user).
+// It lives here (rather than in api/middleware) so that services, which cannot
+// import the middleware package, can read the requesting user for per-user
+// preferences.
+type CurrentUserContextKey struct{}
// CurrentUserFromContext retrieves the authenticated user from the context.
// Returns nil, false on unauthenticated paths (background jobs, agent proxying).
func CurrentUserFromContext(ctx context.Context) (*User, bool) {
- u, ok := ctx.Value(currentUserContextKeyInternal{}).(*User)
+ u, ok := ctx.Value(CurrentUserContextKey{}).(*User)
return u, ok
}
diff --git a/backend/internal/services/api_key_service.go b/backend/internal/services/api_key_service.go
index 079a5622e..698b60be1 100644
--- a/backend/internal/services/api_key_service.go
+++ b/backend/internal/services/api_key_service.go
@@ -82,12 +82,8 @@ func (s *ApiKeyService) validateApiKeyHash(hash, key string) error {
return s.userService.ValidatePassword(hash, key)
}
-func normalizeAPIKeyInputInternal(rawKey string) string {
- return strings.TrimSpace(rawKey)
-}
-
func parseAPIKeyPrefixInternal(rawKey string) (string, error) {
- rawKey = normalizeAPIKeyInputInternal(rawKey)
+ rawKey = strings.TrimSpace(rawKey)
if !strings.HasPrefix(rawKey, apiKeyPrefix) {
return "", ErrApiKeyInvalid
}
@@ -232,7 +228,7 @@ func (s *ApiKeyService) createAPIKeyWithRawKey(
environmentID *string,
kind string,
) (*apikey.ApiKeyCreatedDto, error) {
- rawKey = normalizeAPIKeyInputInternal(rawKey)
+ rawKey = strings.TrimSpace(rawKey)
keyPrefix, err := parseAPIKeyPrefixInternal(rawKey)
if err != nil {
return nil, err
@@ -437,7 +433,7 @@ func (s *ApiKeyService) reconcileManagedAPIKeys(tx *gorm.DB, userID string, rawK
}
func (s *ApiKeyService) ReconcileDefaultAdminAPIKey(ctx context.Context, rawKey string) error {
- rawKey = normalizeAPIKeyInputInternal(rawKey)
+ rawKey = strings.TrimSpace(rawKey)
adminUser, err := s.getDefaultAdminUser(ctx)
if err != nil || adminUser == nil {
@@ -707,7 +703,7 @@ func (s *ApiKeyService) ValidateApiKeyWithID(ctx context.Context, rawKey string)
return nil, nil, errors.WrapIf(err, "failed to find API keys")
}
- rawKey = normalizeAPIKeyInputInternal(rawKey)
+ rawKey = strings.TrimSpace(rawKey)
for _, apiKey := range apiKeys {
if err := s.validateApiKeyHash(apiKey.KeyHash, rawKey); err == nil {
if apiKey.ExpiresAt != nil && apiKey.ExpiresAt.Before(time.Now()) {
@@ -745,7 +741,7 @@ func (s *ApiKeyService) GetEnvironmentByApiKey(ctx context.Context, rawKey strin
return nil, errors.WrapIf(err, "failed to find API keys")
}
- rawKey = normalizeAPIKeyInputInternal(rawKey)
+ rawKey = strings.TrimSpace(rawKey)
for _, apiKey := range apiKeys {
if err := s.validateApiKeyHash(apiKey.KeyHash, rawKey); err == nil {
if apiKey.ExpiresAt != nil && apiKey.ExpiresAt.Before(time.Now()) {
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index 30b35a516..7f56802f0 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -157,7 +157,7 @@ func shouldStartRedeployedContainerInternal(containerInfo container.InspectRespo
func (s *ContainerService) pullRedeployImageInternal(ctx context.Context, dockerClient *client.Client, imageName, containerID, containerName string, user models.User) error {
settings := s.settingsService.GetSettingsConfig()
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))
defer pullCancel()
pullOptions, authErr := s.imageService.getPullOptionsWithAuth(ctx, imageName, nil)
@@ -816,7 +816,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe
}
settings := s.settingsService.GetSettingsConfig()
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))
defer pullCancel()
reader, pullErr := dockerClient.ImagePull(pullCtx, config.Image, pullOptions)
diff --git a/backend/internal/services/docker_client_service.go b/backend/internal/services/docker_client_service.go
index 51aafd5d4..138e3e37d 100644
--- a/backend/internal/services/docker_client_service.go
+++ b/backend/internal/services/docker_client_service.go
@@ -296,7 +296,7 @@ func (s *DockerClientService) listContainersInternal(ctx context.Context) ([]con
}
settings := s.settingsService.GetSettingsConfig()
- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ apiCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer cancel()
containerList, err := dockerClient.ContainerList(apiCtx, client.ContainerListOptions{All: true})
@@ -313,7 +313,7 @@ func (s *DockerClientService) listImagesInternal(ctx context.Context) ([]image.S
}
settings := s.settingsService.GetSettingsConfig()
- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ apiCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer cancel()
imageList, err := dockerClient.ImageList(apiCtx, client.ImageListOptions{All: true})
@@ -330,7 +330,7 @@ func (s *DockerClientService) listNetworksInternal(ctx context.Context) ([]netwo
}
settings := s.settingsService.GetSettingsConfig()
- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ apiCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer cancel()
networkList, err := libarcane.NetworkListWithCompatibility(apiCtx, dockerClient, client.NetworkListOptions{})
@@ -347,7 +347,7 @@ func (s *DockerClientService) listVolumesInternal(ctx context.Context) (*client.
}
settings := s.settingsService.GetSettingsConfig()
- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ apiCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer cancel()
volResp, err := dockerClient.VolumeList(apiCtx, client.VolumeListOptions{})
diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.go
index dc67f2b9d..125fc42a9 100644
--- a/backend/internal/services/environment_service.go
+++ b/backend/internal/services/environment_service.go
@@ -1976,7 +1976,7 @@ func buildEnvironmentEndpointURLInternal(apiURL, endpointPath string) (string, e
func (s *EnvironmentService) getProxyRequestContextInternal(ctx context.Context) (context.Context, context.CancelFunc) {
if s != nil && s.settingsService != nil {
settings := s.settingsService.GetSettingsConfig()
- return timeouts.WithTimeout(ctx, settings.ProxyRequestTimeout.AsInt(), timeouts.DefaultProxyRequest)
+ return context.WithTimeout(ctx, timeouts.GetDuration(settings.ProxyRequestTimeout.AsInt(), timeouts.DefaultProxyRequest))
}
return context.WithTimeout(ctx, timeouts.DefaultProxyRequest)
diff --git a/backend/internal/services/environment_service_test.go b/backend/internal/services/environment_service_test.go
index 42f7787ad..16fc3656c 100644
--- a/backend/internal/services/environment_service_test.go
+++ b/backend/internal/services/environment_service_test.go
@@ -17,6 +17,7 @@ import (
"github.com/stretchr/testify/require"
"gorm.io/gorm"
+ "github.com/coder/websocket"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
@@ -26,7 +27,6 @@ import (
"github.com/getarcaneapp/arcane/types/v2/containerregistry"
"github.com/getarcaneapp/arcane/types/v2/environment"
"github.com/getarcaneapp/arcane/types/v2/gitops"
- "github.com/gorilla/websocket"
"go.getarcane.app/sys/crypto"
)
@@ -1086,20 +1086,19 @@ func newTestWebSocketTunnelInternal(t *testing.T, envID string) (*edge.AgentTunn
t.Helper()
connCh := make(chan *websocket.Conn, 1)
- upgrader := websocket.Upgrader{}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
require.NoError(t, err)
connCh <- conn
}))
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), wsURL, nil)
require.NoError(t, err)
serverConn := <-connCh
return edge.NewAgentTunnelWithConn(envID, edge.NewTunnelConn(serverConn)), func() {
- _ = clientConn.Close()
+ _ = clientConn.CloseNow()
server.Close()
}
}
diff --git a/backend/internal/services/git_repository_service.go b/backend/internal/services/git_repository_service.go
index d6958816c..5cd3c0329 100644
--- a/backend/internal/services/git_repository_service.go
+++ b/backend/internal/services/git_repository_service.go
@@ -299,7 +299,7 @@ func (s *GitRepositoryService) DeleteRepository(ctx context.Context, id string,
func (s *GitRepositoryService) TestConnection(ctx context.Context, id string, branch string, actor models.User) error {
settings := s.settingsService.GetSettingsConfig()
- ctx, cancel := timeouts.WithTimeout(ctx, settings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation)
+ ctx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation))
defer cancel()
repository, err := s.GetRepositoryByID(ctx, id)
@@ -373,7 +373,7 @@ func (s *GitRepositoryService) GetAuthConfig(ctx context.Context, repository *mo
func (s *GitRepositoryService) ListBranches(ctx context.Context, id string) ([]gitops.BranchInfo, error) {
settings := s.settingsService.GetSettingsConfig()
- listCtx, cancel := timeouts.WithTimeout(ctx, settings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation)
+ listCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation))
defer cancel()
repository, err := s.GetRepositoryByID(listCtx, id)
@@ -404,7 +404,7 @@ func (s *GitRepositoryService) ListBranches(ctx context.Context, id string) ([]g
func (s *GitRepositoryService) BrowseFiles(ctx context.Context, id, branch, path string) (*gitops.BrowseResponse, error) {
settings := s.settingsService.GetSettingsConfig()
- ctx, cancel := timeouts.WithTimeout(ctx, settings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation)
+ ctx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation))
defer cancel()
repository, err := s.GetRepositoryByID(ctx, id)
diff --git a/backend/internal/services/gitops_sync_service.go b/backend/internal/services/gitops_sync_service.go
index 872fc1acf..4f0b0433d 100644
--- a/backend/internal/services/gitops_sync_service.go
+++ b/backend/internal/services/gitops_sync_service.go
@@ -2004,7 +2004,7 @@ func (s *GitOpsSyncService) seedStageEnvFromCandidateDirInternal(ctx context.Con
}
if hasEffective {
- if err := projects.WriteEnvFile(projectsDir, stagePath, effective); err != nil {
+ if err := projects.WriteProjectFile(projectsDir, stagePath, ".env", effective); err != nil {
return errors.WrapIf(err, "seed stage .env")
}
} else {
@@ -2013,7 +2013,7 @@ func (s *GitOpsSyncService) seedStageEnvFromCandidateDirInternal(ctx context.Con
if mergeErr != nil {
return errors.WrapIf(mergeErr, "build effective env from pre-existing project")
}
- if err := projects.WriteEnvFile(projectsDir, stagePath, merged); err != nil {
+ if err := projects.WriteProjectFile(projectsDir, stagePath, ".env", merged); err != nil {
return errors.WrapIf(err, "seed stage .env")
}
}
@@ -2326,13 +2326,16 @@ func (s *GitOpsSyncService) validateDirectorySyncStageInternal(ctx context.Conte
)
autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- project, err := projects.LoadComposeProjectLenient(
+ project, err := projects.LoadComposeProject(
ctx,
filepath.Join(stagePath, composeFileName),
projects.NormalizeProjectName(projectName),
projectsDir,
autoInjectEnv,
pathMapper,
+ nil,
+ nil,
+ true,
)
if err != nil {
return 0, err
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 0c7731651..bf7bed481 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -80,7 +80,7 @@ func (s *ImageUpdateService) dockerAPIContextInternal(ctx context.Context) (cont
if s != nil && s.settingsService != nil {
timeoutSeconds = s.settingsService.GetSettingsConfig().DockerAPITimeout.AsInt()
}
- return timeouts.WithTimeout(ctx, timeoutSeconds, timeouts.DefaultDockerAPI)
+ return context.WithTimeout(ctx, timeouts.GetDuration(timeoutSeconds, timeouts.DefaultDockerAPI))
}
func (s *ImageUpdateService) registryContextInternal(ctx context.Context) (context.Context, context.CancelFunc) {
@@ -88,7 +88,7 @@ func (s *ImageUpdateService) registryContextInternal(ctx context.Context) (conte
if s != nil && s.settingsService != nil {
timeoutSeconds = s.settingsService.GetSettingsConfig().RegistryTimeout.AsInt()
}
- return timeouts.WithTimeout(ctx, timeoutSeconds, timeouts.DefaultRegistry)
+ return context.WithTimeout(ctx, timeouts.GetDuration(timeoutSeconds, timeouts.DefaultRegistry))
}
func (s *ImageUpdateService) dockerClientInternal(ctx context.Context) (*client.Client, error) {
@@ -839,7 +839,7 @@ func (s *ImageUpdateService) saveUpdateResultWithSnapshotInternal(ctx context.Co
imageID, err := s.getImageIDByRef(ctx, imageRef)
if err != nil {
repository := buildImageUpdateRepositoryInternal(parts)
- syntheticID := buildSyntheticImageUpdateRecordIDInternal(repository, parts.Tag)
+ syntheticID := fmt.Sprintf("ref::%s@%s", strings.ToLower(strings.TrimSpace(repository)), strings.TrimSpace(parts.Tag))
slog.DebugContext(ctx, "Saving image update result with synthetic ref ID",
"imageRef", imageRef,
"error", err.Error(),
@@ -870,10 +870,6 @@ func buildImageUpdateRepositoryInternal(parts *ImageParts) string {
return fmt.Sprintf("%s/%s", strings.TrimSpace(parts.Registry), repository)
}
-func buildSyntheticImageUpdateRecordIDInternal(repository, tag string) string {
- return fmt.Sprintf("ref::%s@%s", strings.ToLower(strings.TrimSpace(repository)), strings.TrimSpace(tag))
-}
-
func countBatchResultOutcomesInternal(imageRefs []string, results map[string]*imageupdate.Response) (int, int) {
successCount := 0
errorCount := 0
diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.go
index db207b162..8112f5a06 100644
--- a/backend/internal/services/image_update_service_test.go
+++ b/backend/internal/services/image_update_service_test.go
@@ -611,7 +611,7 @@ func TestImageUpdateService_CheckMultipleImages_SkippedDigestPinnedReferenceClea
pinnedDigest := digest.FromString("stale-pinned-newt").String()
imageRef := "ghcr.io/fosrl/newt@" + pinnedDigest
repository := "ghcr.io/fosrl/newt"
- recordID := buildSyntheticImageUpdateRecordIDInternal(repository, "latest")
+ recordID := fmt.Sprintf("ref::%s@latest", strings.ToLower(strings.TrimSpace(repository)))
require.NoError(t, db.Create(&models.ImageUpdateRecord{
ID: recordID,
Repository: repository,
@@ -1002,7 +1002,7 @@ func TestImageUpdateService_CheckMultipleImages_PersistsRefScopedErrorsWhenLocal
var saved models.ImageUpdateRecord
repository := fmt.Sprintf("%s/library/nginx", serverURL.Host)
- require.NoError(t, db.WithContext(context.Background()).Where("id = ?", buildSyntheticImageUpdateRecordIDInternal(repository, "alpine")).First(&saved).Error)
+ require.NoError(t, db.WithContext(context.Background()).Where("id = ?", fmt.Sprintf("ref::%s@alpine", strings.ToLower(strings.TrimSpace(repository)))).First(&saved).Error)
assert.Equal(t, repository, saved.Repository)
assert.Equal(t, "alpine", saved.Tag)
require.NotNil(t, saved.LastError)
@@ -1036,7 +1036,7 @@ func TestImageUpdateService_SaveUpdateResultWithSnapshotInternal_PersistsRegistr
var saved models.ImageUpdateRecord
repository := fmt.Sprintf("%s/library/nginx", serverURL.Host)
- require.NoError(t, db.WithContext(context.Background()).Where("id = ?", buildSyntheticImageUpdateRecordIDInternal(repository, "alpine")).First(&saved).Error)
+ require.NoError(t, db.WithContext(context.Background()).Where("id = ?", fmt.Sprintf("ref::%s@alpine", strings.ToLower(strings.TrimSpace(repository)))).First(&saved).Error)
assert.Equal(t, repository, saved.Repository)
assert.Equal(t, "alpine", saved.Tag)
assert.True(t, saved.HasUpdate)
@@ -1044,12 +1044,6 @@ func TestImageUpdateService_SaveUpdateResultWithSnapshotInternal_PersistsRegistr
assert.Nil(t, saved.LastError)
}
-func TestBuildSyntheticImageUpdateRecordIDInternal_UsesUnambiguousSeparator(t *testing.T) {
- id := buildSyntheticImageUpdateRecordIDInternal("docker.io/library/nginx", "sha256:abcdef")
-
- require.Equal(t, "ref::docker.io/library/nginx@sha256:abcdef", id)
-}
-
func TestImageUpdateService_MarkImageRefUpToDateAfterPull_ClearsMatchingRecordsAndPersistsCurrentImage(t *testing.T) {
db := setupImageUpdateTestDB(t)
localDigest := digest.FromString("mark-up-to-date-local").String()
diff --git a/backend/internal/services/lifecycle_service.go b/backend/internal/services/lifecycle_service.go
index 5e361af9c..b7313623e 100644
--- a/backend/internal/services/lifecycle_service.go
+++ b/backend/internal/services/lifecycle_service.go
@@ -283,7 +283,7 @@ func (s *LifecycleService) runScriptInContainerInternal(
}
apiTimeoutSec := s.settingsService.GetSettingsConfig().DockerAPITimeout.AsInt()
- createCtx, createCancel := timeouts.WithTimeout(ctx, apiTimeoutSec, timeouts.DefaultDockerAPI)
+ createCtx, createCancel := context.WithTimeout(ctx, timeouts.GetDuration(apiTimeoutSec, timeouts.DefaultDockerAPI))
defer createCancel()
resp, err := dockerClient.ContainerCreate(createCtx, client.ContainerCreateOptions{
Config: config,
@@ -295,7 +295,7 @@ func (s *LifecycleService) runScriptInContainerInternal(
containerID := resp.ID
defer removeLifecycleContainerInternal(ctx, dockerClient, containerID, apiTimeoutSec)
- startCtx, startCancel := timeouts.WithTimeout(ctx, apiTimeoutSec, timeouts.DefaultDockerAPI)
+ startCtx, startCancel := context.WithTimeout(ctx, timeouts.GetDuration(apiTimeoutSec, timeouts.DefaultDockerAPI))
defer startCancel()
if _, err := dockerClient.ContainerStart(startCtx, containerID, client.ContainerStartOptions{}); err != nil {
return "", "", 0, errors.WrapIf(err, "start lifecycle container")
@@ -359,7 +359,7 @@ func (s *LifecycleService) ensureRunnerImageInternal(ctx context.Context, docker
}
pullTimeoutSec := s.settingsService.GetSettingsConfig().DockerImagePullTimeout.AsInt()
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, pullTimeoutSec, timeouts.DefaultDockerImagePull)
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(pullTimeoutSec, timeouts.DefaultDockerImagePull))
defer pullCancel()
pullReader, err := dockerClient.ImagePull(pullCtx, image, client.ImagePullOptions{})
@@ -694,7 +694,7 @@ func removeLifecycleContainerInternal(ctx context.Context, dockerClient *client.
return
}
cleanupCtx := context.WithoutCancel(ctx)
- cleanupCtx, cleanupCancel := timeouts.WithTimeout(cleanupCtx, apiTimeoutSec, timeouts.DefaultDockerAPI)
+ cleanupCtx, cleanupCancel := context.WithTimeout(cleanupCtx, timeouts.GetDuration(apiTimeoutSec, timeouts.DefaultDockerAPI))
defer cleanupCancel()
if _, err := dockerClient.ContainerRemove(cleanupCtx, containerID, client.ContainerRemoveOptions{Force: true}); err != nil && !cerrdefs.IsNotFound(err) {
slog.WarnContext(cleanupCtx, "failed to remove lifecycle container", "containerID", containerID, "error", err)
diff --git a/backend/internal/services/notification_service.go b/backend/internal/services/notification_service.go
index 7baacef1e..cb18f98e8 100644
--- a/backend/internal/services/notification_service.go
+++ b/backend/internal/services/notification_service.go
@@ -536,10 +536,6 @@ func collectNotificationSendResultInternal(errors *[]string, provider models.Not
return "failed", &msg
}
-func unknownNotificationProviderErrorInternal(provider models.NotificationProvider) error {
- return errors.Errorf("unknown provider: %s", provider)
-}
-
const (
notificationTestTypeSimple = "simple"
notificationTestTypeImageUpdate = "image-update"
@@ -1126,7 +1122,7 @@ func (s *NotificationService) TestNotification(ctx context.Context, environmentI
content := s.testNotificationContentInternal(target.EnvironmentName, testType)
handled, sendErr := notifications.Deliver(ctx, provider, setting.Config, content)
if !handled {
- return "", unknownNotificationProviderErrorInternal(provider)
+ return "", errors.Errorf("unknown provider: %s", provider)
}
return warning, sendErr
}
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index e6fd25f03..75309be71 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -478,7 +478,7 @@ func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Contex
dockerClient,
)
- composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, projects.NormalizeProjectName(proj.Name), projectsDirectory, utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false), pathMapper)
+ composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, projects.NormalizeProjectName(proj.Name), projectsDirectory, utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false), pathMapper, nil, nil, false)
if loadErr != nil {
return nil, "", loadErr
}
@@ -749,7 +749,7 @@ func (s *ProjectService) pullAndReconcileImageInternal(
settings := s.settingsService.GetSettingsConfig()
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))
defer pullCancel()
if err := s.imageService.PullImage(pullCtx, imageRef, progressWriter, user, credentials); err != nil {
@@ -2245,7 +2245,7 @@ func (s *ProjectService) createProjectInternal(ctx context.Context, name, compos
return nil, errors.WrapIf(err, "invalid compose file")
}
- if err := projects.SaveOrUpdateProjectFiles(projectsDirectory, projectPath, composeContent, envContent); err != nil {
+ if err := projects.WriteProjectFiles(projectsDirectory, projectPath, composeContent, envContent); err != nil {
// Best-effort cleanup to restore pre-transaction behavior.
_ = os.RemoveAll(projectPath)
return nil, errors.WrapIf(err, "failed to save project files")
@@ -3199,7 +3199,7 @@ func (s *ProjectService) prepareProjectRenameVolumeMigrationForUpdateInternal(ct
}
}()
- if err := projects.CopyDirectoryContents(proj.Path, previewPath); err != nil {
+ if err := projects.CopyDirectoryContents(proj.Path, previewPath, nil); err != nil {
return nil, errors.WrapIf(err, "failed to prepare project update preview")
}
diff --git a/backend/internal/services/settings_service.go b/backend/internal/services/settings_service.go
index af4b944ca..7eea62b58 100644
--- a/backend/internal/services/settings_service.go
+++ b/backend/internal/services/settings_service.go
@@ -271,7 +271,7 @@ func (s *SettingsService) loadDatabaseConfigFromEnv(ctx context.Context, db *dat
continue
}
- envVarName := utils.CamelCaseToScreamingSnakeCase(key)
+ envVarName := strings.ToUpper(utils.CamelCaseToSnakeCase(key))
// debug: log each env name checked and whether a value exists
if val, ok := os.LookupEnv(envVarName); ok {
@@ -334,7 +334,7 @@ func resolveSettingsEnvOverridesInternal() []settingsEnvOverride {
continue
}
- envVarName := utils.CamelCaseToScreamingSnakeCase(key)
+ envVarName := strings.ToUpper(utils.CamelCaseToSnakeCase(key))
if val, ok := os.LookupEnv(envVarName); ok && val != "" {
overrides = append(overrides, settingsEnvOverride{
fieldIndex: i,
@@ -705,7 +705,7 @@ func (s *SettingsService) processEnvField(ctx context.Context, tx *gorm.DB, fiel
return nil
}
- envVarName := utils.CamelCaseToScreamingSnakeCase(key)
+ envVarName := strings.ToUpper(utils.CamelCaseToSnakeCase(key))
envVal, ok := os.LookupEnv(envVarName)
if !ok {
return nil
@@ -978,7 +978,7 @@ func (s *SettingsService) NormalizeProjectsDirectory(ctx context.Context, projec
func (s *SettingsService) NormalizeBuildsDirectory(ctx context.Context) error {
const buildsKey = "buildsDirectory"
- envVarName := utils.CamelCaseToScreamingSnakeCase(buildsKey)
+ envVarName := strings.ToUpper(utils.CamelCaseToSnakeCase(buildsKey))
if envVal, ok := os.LookupEnv(envVarName); ok && strings.TrimSpace(envVal) != "" {
slog.DebugContext(ctx, "BUILDS_DIRECTORY environment variable is set, skipping normalization", "value", envVal)
return nil
diff --git a/backend/internal/services/system_upgrade_service.go b/backend/internal/services/system_upgrade_service.go
index e492de59c..ee34fb22b 100644
--- a/backend/internal/services/system_upgrade_service.go
+++ b/backend/internal/services/system_upgrade_service.go
@@ -178,7 +178,7 @@ func (s *SystemUpgradeService) TriggerUpgradeViaCLI(ctx context.Context, user mo
slog.Info("Pulling upgrader image", "image", upgraderImage)
settings := s.settingsService.GetSettingsConfig()
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))
defer pullCancel()
pullReader, err := dockerClient.ImagePull(pullCtx, upgraderImage, client.ImagePullOptions{})
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 53b595380..d4cb861e9 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -70,10 +70,6 @@ const remoteIDPrefix = "remote"
var errNoRemoteTemplates = errors.New("remote template registries returned no templates")
-func makeRemoteID(registryID, slug string) string {
- return fmt.Sprintf("%s:%s:%s", remoteIDPrefix, registryID, slug)
-}
-
func NewTemplateService(ctx context.Context, db *database.DB, httpClient *http.Client, settingsService *SettingsService) *TemplateService {
if httpClient == nil {
httpClient = http.DefaultClient
@@ -713,7 +709,7 @@ func (s *TemplateService) fetchRegistryManifest(ctx context.Context, url string)
}
func (s *TemplateService) convertRemoteToLocal(remote tmpl.RemoteTemplate, registry *models.TemplateRegistry) models.ComposeTemplate {
- publicID := makeRemoteID(registry.ID, remote.ID)
+ publicID := fmt.Sprintf("%s:%s:%s", remoteIDPrefix, registry.ID, remote.ID)
return models.ComposeTemplate{
BaseModel: models.BaseModel{ID: publicID},
@@ -863,7 +859,7 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
if err != nil {
return nil, err
}
- srcDesc := projects.ImportedComposeDescription(dir)
+ srcDesc := fmt.Sprintf("Imported from %s/compose.yaml", dir)
return s.downloadTemplateTransaction(ctx, remoteTemplate, base, composePath, envPath, srcDesc)
}
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index fcdc1edc9..c88b58730 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -560,7 +560,7 @@ func (s *UpdaterService) PullImage(ctx context.Context, imageRef string, progres
if s.deps.Settings != nil {
pullTimeoutSeconds = s.deps.Settings.GetSettingsConfig().DockerImagePullTimeout.AsInt()
}
- pullCtx, cancelPull := timeouts.WithTimeout(ctx, pullTimeoutSeconds, timeouts.DefaultDockerImagePull)
+ pullCtx, cancelPull := context.WithTimeout(ctx, timeouts.GetDuration(pullTimeoutSeconds, timeouts.DefaultDockerImagePull))
defer cancelPull()
if s.deps.Projects != nil {
diff --git a/backend/internal/services/user_service_test.go b/backend/internal/services/user_service_test.go
index 2b36392e6..58a5eb6cf 100644
--- a/backend/internal/services/user_service_test.go
+++ b/backend/internal/services/user_service_test.go
@@ -222,7 +222,7 @@ func TestUpdateUserAllowsGlobalAdminActorEditingAdmin(t *testing.T) {
require.NoError(t, err)
admin.DisplayName = new("Renamed Admin")
- actorCtx := models.WithCurrentUser(ctx, other)
+ actorCtx := context.WithValue(ctx, models.CurrentUserContextKey{}, other)
_, err = userSvc.UpdateUser(actorCtx, admin, otherPerms)
require.NoError(t, err)
}
@@ -258,7 +258,7 @@ func TestUpdateUserAllowsSelfEditByNonAdmin(t *testing.T) {
require.NoError(t, err)
admin.DisplayName = new("Self Rename")
- actorCtx := models.WithCurrentUser(ctx, admin)
+ actorCtx := context.WithValue(ctx, models.CurrentUserContextKey{}, admin)
_, err = userSvc.UpdateUser(actorCtx, admin, adminPerms)
require.NoError(t, err)
}
@@ -301,6 +301,6 @@ func TestDeleteUserAllowsGlobalAdminActorDeletingAdmin(t *testing.T) {
otherPerms, err := roleSvc.ResolvePermissions(ctx, other)
require.NoError(t, err)
- actorCtx := models.WithCurrentUser(ctx, other)
+ actorCtx := context.WithValue(ctx, models.CurrentUserContextKey{}, other)
require.NoError(t, userSvc.DeleteUser(actorCtx, admin.ID, otherPerms))
}
diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.go
index 50eae6247..e2ba9fd09 100644
--- a/backend/internal/services/volume_service.go
+++ b/backend/internal/services/volume_service.go
@@ -118,7 +118,7 @@ func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*volu
vol := volResult.Volume
settings := s.settingsService.GetSettingsConfig()
- usageCtx, usageCancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ usageCtx, usageCancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer usageCancel()
if usageVolumes, ok := docker.GetVolumeUsageDataStaleWhileRevalidate(usageCtx, dockerClient).Get(); ok {
for _, uv := range usageVolumes {
@@ -2051,7 +2051,7 @@ type VolumeSizeData struct {
func (s *VolumeService) GetVolumeSizes(ctx context.Context) (map[string]VolumeSizeData, error) {
slog.DebugContext(ctx, "volume service: get volume sizes")
settings := s.settingsService.GetSettingsConfig()
- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ apiCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer cancel()
dockerClient, err := s.dockerService.GetClient(apiCtx)
@@ -2317,7 +2317,7 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginat
containerChan := make(chan containerMapResult, 1)
settings := s.settingsService.GetSettingsConfig()
- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)
+ apiCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI))
defer cancel()
go func(ctx context.Context) {
diff --git a/backend/internal/services/vulnerability_service.go b/backend/internal/services/vulnerability_service.go
index 384a4b72c..ee8967a66 100644
--- a/backend/internal/services/vulnerability_service.go
+++ b/backend/internal/services/vulnerability_service.go
@@ -1561,7 +1561,15 @@ func (s *VulnerabilityService) execTrivyScanInContainer(ctx context.Context, con
if errMsg == "" {
errMsg = fmt.Sprintf("exit status %d", execInspect.ExitCode)
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, int64(execInspect.ExitCode), stdoutFile, stderrFile, "exec non-zero exit")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "exec non-zero exit",
+ "exitCode", int64(execInspect.ExitCode),
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, formatTrivyExitErrorInternal(int64(execInspect.ExitCode), errMsg, imageName)
}
@@ -1588,11 +1596,27 @@ func (s *VulnerabilityService) execTrivyScanInContainer(ctx context.Context, con
if errMsg == "" {
errMsg = "trivy scan produced no output"
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, int64(execInspect.ExitCode), stdoutFile, stderrFile, "exec empty output")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "exec empty output",
+ "exitCode", int64(execInspect.ExitCode),
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, errors.Errorf("trivy scan failed: %s", errMsg)
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, int64(execInspect.ExitCode), stdoutFile, stderrFile, "exec parse error")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "exec parse error",
+ "exitCode", int64(execInspect.ExitCode),
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, errors.WrapIf(err, "failed to parse trivy output")
}
@@ -1601,7 +1625,15 @@ func (s *VulnerabilityService) execTrivyScanInContainer(ctx context.Context, con
if errMsg == "" {
errMsg = "trivy scan produced no output"
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, int64(execInspect.ExitCode), stdoutFile, stderrFile, "exec nil report")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "exec nil report",
+ "exitCode", int64(execInspect.ExitCode),
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, errors.Errorf("trivy scan failed: %s", errMsg)
}
@@ -1784,7 +1816,7 @@ func (s *VulnerabilityService) getConfiguredTrivyNetworkModeInternal() string {
return ""
}
- return vuln.NormalizeNetworkMode(cfg.TrivyNetwork.Value)
+ return strings.TrimSpace(cfg.TrivyNetwork.Value)
}
func (s *VulnerabilityService) getEffectiveDockerHostInternal() string {
@@ -1910,7 +1942,7 @@ func selectTrivyAutoNetworkModeInternal(inspect *containertypes.InspectResponse)
}
if inspect.HostConfig != nil {
- networkMode := vuln.NormalizeNetworkMode(string(inspect.HostConfig.NetworkMode))
+ networkMode := strings.TrimSpace(string(inspect.HostConfig.NetworkMode))
if networkMode != "" && networkMode != "default" && networkMode != DefaultTrivyNetworkMode &&
!containertypes.NetworkMode(networkMode).IsContainer() {
return networkMode
@@ -1920,7 +1952,7 @@ func selectTrivyAutoNetworkModeInternal(inspect *containertypes.InspectResponse)
if inspect.NetworkSettings != nil && len(inspect.NetworkSettings.Networks) > 0 {
networkNames := make([]string, 0, len(inspect.NetworkSettings.Networks))
for networkName := range inspect.NetworkSettings.Networks {
- networkName = vuln.NormalizeNetworkMode(networkName)
+ networkName = strings.TrimSpace(networkName)
if networkName != "" {
networkNames = append(networkNames, networkName)
}
@@ -1944,7 +1976,7 @@ func selectTrivyAutoNetworkModeInternal(inspect *containertypes.InspectResponse)
}
if inspect.HostConfig != nil {
- networkMode := vuln.NormalizeNetworkMode(string(inspect.HostConfig.NetworkMode))
+ networkMode := strings.TrimSpace(string(inspect.HostConfig.NetworkMode))
if networkMode != "" && networkMode != "default" && !containertypes.NetworkMode(networkMode).IsContainer() {
return networkMode
}
@@ -2063,7 +2095,7 @@ func (s *VulnerabilityService) ensureTrivyImageInternal(ctx context.Context) (st
pullTimeoutSeconds = s.settingsService.GetSettingsConfig().DockerImagePullTimeout.AsInt()
}
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, pullTimeoutSeconds, timeouts.DefaultDockerImagePull)
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(pullTimeoutSeconds, timeouts.DefaultDockerImagePull))
defer pullCancel()
pullReader, err := dockerClient.ImagePull(pullCtx, trivyImage, client.ImagePullOptions{})
@@ -2287,7 +2319,7 @@ func buildTrivyHostConfig(
}
func selectDefaultTrivyNetworkModeInternal(networkMode string) string {
- networkMode = vuln.NormalizeNetworkMode(networkMode)
+ networkMode = strings.TrimSpace(networkMode)
if networkMode == "" {
return DefaultTrivyNetworkMode
}
@@ -2474,7 +2506,7 @@ func readTrivyStartupLogsInternal(ctx context.Context, dockerClient *client.Clie
return "", ""
}
- logsCtx, logsCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ logsCtx, logsCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer logsCancel()
logs, err := dockerClient.ContainerLogs(logsCtx, containerID, client.ContainerLogsOptions{
@@ -2509,7 +2541,7 @@ func removeDockerContainerInternal(ctx context.Context, dockerClient *client.Cli
}
cleanupCtx := context.WithoutCancel(ctx)
- cleanupCtx, cleanupCancel := timeouts.WithTimeout(cleanupCtx, 0, timeouts.DefaultDockerAPI)
+ cleanupCtx, cleanupCancel := context.WithTimeout(cleanupCtx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer cleanupCancel()
if _, err := dockerClient.ContainerRemove(cleanupCtx, containerID, client.ContainerRemoveOptions{Force: true}); err != nil && !cerrdefs.IsNotFound(err) {
@@ -2538,7 +2570,7 @@ func copyRegistryConfigToContainerInternal(ctx context.Context, dockerClient *cl
return err
}
- copyCtx, copyCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ copyCtx, copyCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer copyCancel()
_, err := dockerClient.CopyToContainer(copyCtx, containerID, client.CopyToContainerOptions{
@@ -2558,7 +2590,7 @@ func (s *VulnerabilityService) createAndStartTrivyContainerInternal(
) (string, error) {
logTrivyContainerStartupRequestInternal(ctx, scope, config, hostConfig)
- createCtx, createCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ createCtx, createCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer createCancel()
resp, err := dockerClient.ContainerCreate(createCtx, client.ContainerCreateOptions{
@@ -2583,7 +2615,7 @@ func (s *VulnerabilityService) createAndStartTrivyContainerInternal(
}
}
- startCtx, startCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ startCtx, startCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer startCancel()
if _, err := dockerClient.ContainerStart(startCtx, resp.ID, client.ContainerStartOptions{}); err != nil {
@@ -2699,7 +2731,7 @@ func (s *VulnerabilityService) getTrivyContainerResourceOptionsInternal(ctx cont
return resources, "", applyLimits
}
- infoCtx, infoCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ infoCtx, infoCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer infoCancel()
slog.DebugContext(ctx, "inspecting docker host for trivy resource strategy")
@@ -2804,7 +2836,7 @@ func readTrivyOutputFromContainerFileInternal(ctx context.Context, dockerClient
return nil, errors.New("trivy output path is empty")
}
- copyCtx, copyCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ copyCtx, copyCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer copyCancel()
copyResult, err := dockerClient.CopyFromContainer(copyCtx, containerID, client.CopyFromContainerOptions{SourcePath: outputPath})
@@ -2840,7 +2872,7 @@ func cleanupTrivyOutputFileInContainerInternal(ctx context.Context, dockerClient
return
}
- execCtx, execCancel := timeouts.WithTimeout(ctx, 0, timeouts.DefaultDockerAPI)
+ execCtx, execCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
defer execCancel()
execResp, err := dockerClient.ExecCreate(execCtx, containerID, client.ExecCreateOptions{
@@ -3048,18 +3080,6 @@ func extractTopLevelJSONObjectCandidatesInternal(rawOutput []byte) [][]byte {
return candidates
}
-func logTrivyScanFailureDiagnosticsInternal(ctx context.Context, imageName, imageID string, exitCode int64, stdoutFile, stderrFile *os.File, reason string) {
- slog.WarnContext(ctx,
- "trivy scan diagnostics",
- "image", imageName,
- "imageId", imageID,
- "reason", reason,
- "exitCode", exitCode,
- "stdoutBytes", tempFileSizeInternal(stdoutFile),
- "stderrBytes", tempFileSizeInternal(stderrFile),
- )
-}
-
func formatTrivyExitErrorInternal(exitCode int64, errMsg, imageName string) error {
errMsg = strings.TrimSpace(errMsg)
@@ -3360,7 +3380,15 @@ func (s *VulnerabilityService) runTrivyScan(ctx context.Context, trivyImage stri
if errMsg == "" {
errMsg = fmt.Sprintf("exit status %d", statusCode)
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, statusCode, stdoutFile, stderrFile, "container non-zero exit")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "container non-zero exit",
+ "exitCode", statusCode,
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, formatTrivyExitErrorInternal(statusCode, errMsg, imageName)
}
@@ -3386,11 +3414,27 @@ func (s *VulnerabilityService) runTrivyScan(ctx context.Context, trivyImage stri
if errMsg == "" {
errMsg = "trivy scan produced no output"
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, statusCode, stdoutFile, stderrFile, "container empty output")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "container empty output",
+ "exitCode", statusCode,
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, errors.Errorf("trivy scan failed: %s", errMsg)
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, statusCode, stdoutFile, stderrFile, "container parse error")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "container parse error",
+ "exitCode", statusCode,
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, errors.WrapIf(err, "failed to parse trivy output")
}
@@ -3399,7 +3443,15 @@ func (s *VulnerabilityService) runTrivyScan(ctx context.Context, trivyImage stri
if errMsg == "" {
errMsg = "trivy scan produced no output"
}
- logTrivyScanFailureDiagnosticsInternal(ctx, imageName, imageID, statusCode, stdoutFile, stderrFile, "container nil report")
+ slog.WarnContext(ctx,
+ "trivy scan diagnostics",
+ "image", imageName,
+ "imageId", imageID,
+ "reason", "container nil report",
+ "exitCode", statusCode,
+ "stdoutBytes", tempFileSizeInternal(stdoutFile),
+ "stderrBytes", tempFileSizeInternal(stderrFile),
+ )
return nil, errors.Errorf("trivy scan failed: %s", errMsg)
}
diff --git a/backend/pkg/gitutil/git.go b/backend/pkg/gitutil/git.go
index 793cc5bd1..89da48f2a 100644
--- a/backend/pkg/gitutil/git.go
+++ b/backend/pkg/gitutil/git.go
@@ -792,7 +792,7 @@ func isBinaryContent(content []byte) bool {
checkSize := min(len(content), 512)
// Use net/http's content type detection
- contentType := detectContentType(content[:checkSize])
+ contentType := nethttp.DetectContentType(content[:checkSize])
// Text types are not binary
if strings.HasPrefix(contentType, "text/") {
@@ -827,8 +827,3 @@ func isBinaryContent(content []byte) bool {
strings.HasPrefix(contentType, "video/") ||
strings.HasPrefix(contentType, "audio/")
}
-
-// detectContentType wraps nethttp.DetectContentType for easier testing
-func detectContentType(data []byte) string {
- return nethttp.DetectContentType(data)
-}
diff --git a/backend/pkg/libarcane/activity/handler.go b/backend/pkg/libarcane/activity/handler.go
index 1804635dc..7b377bb2d 100644
--- a/backend/pkg/libarcane/activity/handler.go
+++ b/backend/pkg/libarcane/activity/handler.go
@@ -49,50 +49,6 @@ type HandlerOptions struct {
Queue bool
}
-// StartHandlerActivityForUser creates a background activity and returns its ID
-// along with a work context the caller MUST use for the underlying operation.
-// When the service supports cancellation (implements Tracker), the returned
-// context is a cancelable child bound to the activity; cancelling the activity
-// cancels this context. The activity registration is released when the activity
-// is completed via the service. On failure it returns ("", ctx) unchanged.
-func StartHandlerActivityForUser(
- ctx context.Context,
- activityService Service,
- environmentID string,
- activityType models.ActivityType,
- resourceType string,
- resourceID string,
- resourceName string,
- user *models.User,
- step string,
- message string,
- metadata models.JSON,
-) (string, context.Context) {
- return startHandlerActivityInternal(ctx, activityService, environmentID, activityType, resourceType, resourceID, resourceName, user, step, message, metadata, false)
-}
-
-// StartQueuedHandlerActivityForUser behaves like StartHandlerActivityForUser
-// but routes the activity through the per-environment concurrency limiter:
-// when no slot is free the activity is created with status queued. The caller
-// MUST call AwaitHandlerActivitySlot on the returned work context before doing
-// the actual work (streaming endpoints write their started line in between,
-// so the client learns the activity ID before the queue wait begins).
-func StartQueuedHandlerActivityForUser(
- ctx context.Context,
- activityService Service,
- environmentID string,
- activityType models.ActivityType,
- resourceType string,
- resourceID string,
- resourceName string,
- user *models.User,
- step string,
- message string,
- metadata models.JSON,
-) (string, context.Context) {
- return startHandlerActivityInternal(ctx, activityService, environmentID, activityType, resourceType, resourceID, resourceName, user, step, message, metadata, true)
-}
-
// AwaitHandlerActivitySlot blocks until the queued activity holds a
// concurrency slot (flipping it to running). A cancellation while waiting is
// not an error to the caller: the work context is already cancelled, so the
@@ -111,7 +67,21 @@ func AwaitHandlerActivitySlot(ctx context.Context, activityService Service, acti
}
}
-func startHandlerActivityInternal(
+// StartHandlerActivity creates a background activity and returns its ID along
+// with a work context the caller MUST use for the underlying operation. When
+// the service supports cancellation (implements Tracker), the returned context
+// is a cancelable child bound to the activity; cancelling the activity cancels
+// this context. The activity registration is released when the activity is
+// completed via the service. On failure it returns ("", ctx) unchanged.
+//
+// When queue is true the activity is routed through the per-environment
+// concurrency limiter: when no slot is free the activity is created with
+// status queued. The caller MUST then call AwaitHandlerActivitySlot on the
+// returned work context before doing the actual work (streaming endpoints
+// write their started line in between, so the client learns the activity ID
+// before the queue wait begins). Quick actions (start/stop/delete) must pass
+// false.
+func StartHandlerActivity(
ctx context.Context,
activityService Service,
environmentID string,
@@ -186,7 +156,7 @@ func CompleteHandlerActivity(ctx context.Context, activityService Service, activ
// The action MUST use the provided context for its operation so cancellation
// propagates.
func RunHandlerActivity(ctx context.Context, activityService Service, opts HandlerOptions, action func(ctx context.Context) error) (string, error) {
- activityID, workCtx := startHandlerActivityInternal(
+ activityID, workCtx := StartHandlerActivity(
ctx,
activityService,
opts.EnvironmentID,
diff --git a/backend/pkg/libarcane/docker_compat.go b/backend/pkg/libarcane/docker_compat.go
index f2bd90a0e..d03588038 100644
--- a/backend/pkg/libarcane/docker_compat.go
+++ b/backend/pkg/libarcane/docker_compat.go
@@ -54,22 +54,6 @@ func DetectDockerAPIVersion(ctx context.Context, dockerClient client.APIClient)
return strings.TrimSpace(serverVersion.APIVersion)
}
-// SupportsDockerCreateMultiEndpointNetworking reports whether the connected
-// daemon API supports attaching multiple endpoints during ContainerCreate.
-//
-// On older daemon APIs, sending multiple EndpointsConfig entries can fail with
-// daemon-side networking errors even though newer Compose CLIs may appear to
-// "work" by using a different fallback sequence under the hood.
-func SupportsDockerCreateMultiEndpointNetworking(apiVersion string) bool {
- return IsDockerAPIVersionAtLeast(apiVersion, MultiEndpointContainerCreateMinAPIVersion)
-}
-
-// SupportsDockerCreatePerNetworkMACAddress reports whether the daemon API
-// supports per-network mac-address on container create (Docker API >= 1.44).
-func SupportsDockerCreatePerNetworkMACAddress(apiVersion string) bool {
- return IsDockerAPIVersionAtLeast(apiVersion, NetworkScopedMacAddressMinAPIVersion)
-}
-
// IsDockerAPIVersionAtLeast performs numeric dot-segment comparison for Docker
// API versions (e.g. "1.43", "1.44.1"). Returns false when either version
// cannot be parsed.
@@ -104,7 +88,7 @@ func SanitizeContainerCreateEndpointSettingsForDockerAPI(endpoints map[string]*n
return nil
}
- keepPerNetworkMAC := SupportsDockerCreatePerNetworkMACAddress(apiVersion)
+ keepPerNetworkMAC := IsDockerAPIVersionAtLeast(apiVersion, NetworkScopedMacAddressMinAPIVersion)
cloned := make(map[string]*network.EndpointSettings, len(endpoints))
for networkName, endpoint := range endpoints {
@@ -136,7 +120,7 @@ func SanitizeContainerCreateEndpointSettingsForDockerAPI(endpoints map[string]*n
// explains why a shell `docker compose up` can succeed while Arcane's embedded
// or manual create paths fail unless we perform the split ourselves.
func PrepareContainerCreateOptionsForDockerAPI(options client.ContainerCreateOptions, apiVersion string) (client.ContainerCreateOptions, map[string]*network.EndpointSettings) {
- if SupportsDockerCreateMultiEndpointNetworking(apiVersion) || options.NetworkingConfig == nil || len(options.NetworkingConfig.EndpointsConfig) <= 1 {
+ if IsDockerAPIVersionAtLeast(apiVersion, MultiEndpointContainerCreateMinAPIVersion) || options.NetworkingConfig == nil || len(options.NetworkingConfig.EndpointsConfig) <= 1 {
return options, nil
}
diff --git a/backend/pkg/libarcane/docker_compat_test.go b/backend/pkg/libarcane/docker_compat_test.go
index ae832ae73..9e1046197 100644
--- a/backend/pkg/libarcane/docker_compat_test.go
+++ b/backend/pkg/libarcane/docker_compat_test.go
@@ -101,20 +101,6 @@ func TestIsDockerAPIVersionAtLeast(t *testing.T) {
}
}
-func TestSupportsDockerCreatePerNetworkMACAddress(t *testing.T) {
- require.True(t, SupportsDockerCreatePerNetworkMACAddress("1.44"))
- require.True(t, SupportsDockerCreatePerNetworkMACAddress("1.46"))
- require.False(t, SupportsDockerCreatePerNetworkMACAddress("1.43"))
- require.False(t, SupportsDockerCreatePerNetworkMACAddress("1.41"))
-}
-
-func TestSupportsDockerCreateMultiEndpointNetworking(t *testing.T) {
- require.True(t, SupportsDockerCreateMultiEndpointNetworking("1.44"))
- require.True(t, SupportsDockerCreateMultiEndpointNetworking("1.46"))
- require.False(t, SupportsDockerCreateMultiEndpointNetworking("1.43"))
- require.False(t, SupportsDockerCreateMultiEndpointNetworking("1.41"))
-}
-
func TestSanitizeContainerCreateEndpointSettingsForDockerAPI(t *testing.T) {
input := map[string]*network.EndpointSettings{
"bridge": {
diff --git a/backend/pkg/libarcane/edge/client.go b/backend/pkg/libarcane/edge/client.go
index c12c09eb2..924e767e0 100644
--- a/backend/pkg/libarcane/edge/client.go
+++ b/backend/pkg/libarcane/edge/client.go
@@ -14,8 +14,9 @@ import (
"emperror.dev/errors"
"github.com/cenkalti/backoff/v5"
+ "github.com/coder/websocket"
+ wshub "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
"github.com/google/uuid"
- "github.com/gorilla/websocket"
"github.com/samber/mo"
)
@@ -29,9 +30,7 @@ const (
// maxPollRetryInterval caps the exponential backoff applied to failed poll
// control requests. Successful polls return to the manager-advertised interval.
maxPollRetryInterval = 60 * time.Second
-)
-const (
// DefaultHeartbeatInterval is how often the client sends heartbeats
DefaultHeartbeatInterval = 30 * time.Second
// DefaultWriteTimeout is the timeout for write operations
@@ -50,11 +49,11 @@ const (
// broken gRPC path is retried at most this often but never disabled.
maxWebSocketPreferenceTTL = 30 * time.Minute
defaultCommandChunkSize = 256 * 1024
-)
-// errTunnelRegistrationTimeout marks a registration attempt where the manager
-// accepted the connection but never answered the register message.
-const errTunnelRegistrationTimeout = errors.Sentinel("timed out waiting for tunnel registration response")
+ // errTunnelRegistrationTimeout marks a registration attempt where the manager
+ // accepted the connection but never answered the register message.
+ errTunnelRegistrationTimeout = errors.Sentinel("timed out waiting for tunnel registration response")
+)
func (t *commandRequestTransfer) stopInternal() {
if t == nil {
@@ -67,13 +66,6 @@ func (t *commandRequestTransfer) stopInternal() {
}
}
-// setConn stores the active tunnel connection. The connection is reassigned on
-// every (re)connect while goroutines (heartbeat, request handlers, stream send
-// helpers) read it, so access goes through an atomic swap.
-func (c *TunnelClient) setConn(conn TunnelConnection) {
- c.conn.Store(&connBox{conn: conn})
-}
-
// getConn returns the active tunnel connection, or nil if none is established.
func (c *TunnelClient) getConn() TunnelConnection {
if box := c.conn.Load(); box != nil {
@@ -227,7 +219,8 @@ func (c *TunnelClient) connectAndServe(ctx context.Context) error {
}
func (c *TunnelClient) connectAndServeManagedTunnelInternal(ctx context.Context) error {
- if c.shouldAttemptGRPCTunnelInternal() {
+ transports := c.managedTunnelTransportsInternal()
+ if transports.grpc {
if preferredUntil, ok := c.preferredWebSocketUntilInternal(time.Now()).Get(); ok {
slog.InfoContext(ctx, "Temporarily preferring websocket edge tunnel transport after recent websocket success",
"preferred_until", preferredUntil,
@@ -242,7 +235,7 @@ func (c *TunnelClient) connectAndServeManagedTunnelInternal(ctx context.Context)
return ctx.Err()
}
c.noteGRPCTunnelFailureInternal()
- if c.shouldFallbackToWebSocketInternal() {
+ if transports.websocket {
managerWSURL := c.managerWebSocketURLInternal()
slog.WarnContext(ctx, "gRPC edge tunnel connection failed, falling back to websocket transport",
"error", err,
@@ -259,26 +252,12 @@ func (c *TunnelClient) connectAndServeManagedTunnelInternal(ctx context.Context)
}
return nil
}
- if c.shouldAttemptWebSocketTunnelInternal() {
+ if transports.websocket {
return c.connectAndServeWebSocket(ctx)
}
return errors.New("no edge tunnel transport is available")
}
-func (c *TunnelClient) shouldFallbackToWebSocketInternal() bool {
- return c.shouldAttemptWebSocketTunnelInternal()
-}
-
-func (c *TunnelClient) shouldAttemptGRPCTunnelInternal() bool {
- transports := c.managedTunnelTransportsInternal()
- return transports.grpc
-}
-
-func (c *TunnelClient) shouldAttemptWebSocketTunnelInternal() bool {
- transports := c.managedTunnelTransportsInternal()
- return transports.websocket
-}
-
func (c *TunnelClient) managedTunnelTransportsInternal() managedTunnelTransportsInternal {
if c == nil || c.cfg == nil {
return managedTunnelTransportsInternal{}
@@ -351,7 +330,9 @@ func (c *TunnelClient) websocketPreferenceTTLInternal() time.Duration {
}
func (c *TunnelClient) preferredWebSocketUntilInternal(now time.Time) mo.Option[time.Time] {
- if c == nil || !c.shouldAttemptGRPCTunnelInternal() || !c.shouldAttemptWebSocketTunnelInternal() {
+ // A nil client yields a zero transports struct, so this also guards nil.
+ transports := c.managedTunnelTransportsInternal()
+ if !transports.grpc || !transports.websocket {
return mo.None[time.Time]()
}
@@ -378,7 +359,7 @@ func (c *TunnelClient) markTransportConnectedInternal(transport string) {
c.preferWebSocketUntil = time.Time{}
c.grpcFailureStreak = 0
case EdgeTransportWebSocket:
- if c.shouldAttemptGRPCTunnelInternal() && c.shouldAttemptWebSocketTunnelInternal() {
+ if transports := c.managedTunnelTransportsInternal(); transports.grpc && transports.websocket {
// Back the preference window off exponentially while gRPC keeps
// failing so each reconnect does not re-pay the registration
// timeout against a persistently broken gRPC path.
@@ -474,7 +455,7 @@ func (c *TunnelClient) awaitRegistrationInternal(ctx context.Context) (*TunnelMe
// serveTunnelSessionInternal runs the shared register/heartbeat/message
// lifecycle on an established tunnel connection, for every transport.
func (c *TunnelClient) serveTunnelSessionInternal(ctx context.Context, conn TunnelConnection, managerAddr string) error {
- c.setConn(conn)
+ c.conn.Store(&connBox{conn: conn})
setActiveAgentTunnelConn(conn)
defer clearActiveAgentTunnelConn(conn)
// Always tear down through the wrapper so the peer sees a clean close
@@ -776,7 +757,7 @@ func (c *TunnelClient) handleRequest(ctx context.Context, conn TunnelConnection,
reqCtx, cancel := context.WithTimeout(ctx, c.requestTimeoutInternal())
defer cancel()
- reqCtx = withInternalTunnelRequestInternal(reqCtx)
+ reqCtx = context.WithValue(reqCtx, internalTunnelRequestContextKey{}, true)
slog.DebugContext(reqCtx, "Processing tunneled request", "id", msg.ID, "method", msg.Method, "path", msg.Path, "bodyLength", len(msg.Body))
@@ -828,7 +809,7 @@ func isGRPCConnection(conn TunnelConnection) bool {
func (c *TunnelClient) handleRequestStreaming(ctx context.Context, conn TunnelConnection, msg *TunnelMessage) {
reqCtx, cancel := context.WithTimeout(ctx, c.requestTimeoutInternal())
defer cancel()
- reqCtx = withInternalTunnelRequestInternal(reqCtx)
+ reqCtx = context.WithValue(reqCtx, internalTunnelRequestContextKey{}, true)
slog.DebugContext(reqCtx, "Processing tunneled request (streaming)", "id", msg.ID, "method", msg.Method, "path", msg.Path, "bodyLength", len(msg.Body))
@@ -860,7 +841,8 @@ func (c *TunnelClient) handleWebSocketStart(ctx context.Context, conn TunnelConn
headers := c.buildLocalWebSocketHeadersInternal(msg)
ws, resp, err := c.dialLocalWebSocket(ctx, localURL, headers)
- if resp != nil {
+ // coder/websocket leaves resp.Body nil on a successful handshake.
+ if resp != nil && resp.Body != nil {
defer func() { _ = resp.Body.Close() }()
}
if err != nil {
@@ -940,13 +922,13 @@ func (c *TunnelClient) localWebSocketHostInternal() string {
// localDialSkipHeaders lists headers that must not be forwarded when the
// agent dials its own local HTTP server for a proxied WebSocket stream.
// This includes:
-// - Standard WebSocket handshake headers (gorilla/websocket sets its own)
+// - Standard WebSocket handshake headers (coder/websocket sets its own)
// - Browser-specific headers that were forwarded through the tunnel from
// the manager. These cause handshake failures because the agent's
// WebSocket upgrader validates the Origin against localhost, not the
// browser's remote origin.
var localDialSkipHeaders = map[string]bool{
- // WebSocket handshake (gorilla/websocket adds its own)
+ // WebSocket handshake (coder/websocket adds its own)
"Sec-Websocket-Key": true,
"Sec-Websocket-Version": true,
"Sec-Websocket-Extensions": true,
@@ -987,11 +969,18 @@ func (c *TunnelClient) buildLocalWebSocketHeadersInternal(msg *TunnelMessage) ht
}
func (c *TunnelClient) dialLocalWebSocket(ctx context.Context, localURL string, headers http.Header) (*websocket.Conn, *http.Response, error) {
- dialer := websocket.Dialer{
- HandshakeTimeout: 30 * time.Second,
- }
+ dialCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+ defer cancel()
- return dialer.DialContext(ctx, localURL, headers)
+ ws, resp, err := websocket.Dial(dialCtx, localURL, &websocket.DialOptions{HTTPHeader: headers})
+ if err != nil {
+ return nil, resp, err
+ }
+ // Local stream frames (exec output, log lines) are forwarded into tunnel
+ // messages capped at maxGRPCTunnelMessageSize; allow the same size here
+ // instead of coder/websocket's 32KB default.
+ ws.SetReadLimit(maxGRPCTunnelMessageSize)
+ return ws, resp, nil
}
func (c *TunnelClient) registerStream(conn TunnelConnection, streamID string, ws *websocket.Conn, cancel context.CancelFunc) *activeWSStream {
@@ -1016,7 +1005,7 @@ func (c *TunnelClient) closeWebSocketStream(streamID string, stream *activeWSStr
stream.mu.Unlock()
stream.cancel()
- _ = stream.ws.Close()
+ _ = stream.ws.CloseNow()
c.activeStreams.Delete(streamID)
}
@@ -1043,23 +1032,16 @@ func (c *TunnelClient) startLocalWebSocketReadLoop(ctx context.Context, streamCt
}()
for {
- if streamCtx.Err() != nil {
- return
- }
-
- msgType, data, err := ws.ReadMessage()
+ msgType, data, err := ws.Read(streamCtx)
if err != nil {
- if !websocket.IsCloseError(err,
- websocket.CloseNormalClosure,
- websocket.CloseGoingAway,
- websocket.CloseNoStatusReceived) {
+ if !wshub.IsExpectedClose(err) {
slog.DebugContext(ctx, "Local WebSocket read error", "error", err)
}
c.sendWebSocketClose(stream.conn, streamID)
return
}
- if err := c.sendWebSocketData(stream.conn, streamID, msgType, data); err != nil {
+ if err := c.sendWebSocketData(stream.conn, streamID, int(msgType), data); err != nil {
slog.DebugContext(ctx, "Failed to send WebSocket data to manager", "error", err)
return
}
@@ -1075,12 +1057,12 @@ func (c *TunnelClient) startLocalWebSocketWriteLoop(ctx context.Context, streamC
if !ok {
return
}
- msgType := payload.messageType
- if msgType != websocket.TextMessage && msgType != websocket.BinaryMessage {
- slog.WarnContext(ctx, "Dropping WebSocket message with unsupported type", "messageType", msgType)
+ msgType := websocket.MessageType(payload.messageType)
+ if msgType != websocket.MessageText && msgType != websocket.MessageBinary {
+ slog.WarnContext(ctx, "Dropping WebSocket message with unsupported type", "messageType", payload.messageType)
continue
}
- if err := ws.WriteMessage(msgType, payload.data); err != nil {
+ if err := ws.Write(streamCtx, msgType, payload.data); err != nil {
slog.DebugContext(ctx, "Failed to write to local WebSocket", "error", err)
cancel()
return
diff --git a/backend/pkg/libarcane/edge/client_test.go b/backend/pkg/libarcane/edge/client_test.go
index 8e6895a00..beca1a404 100644
--- a/backend/pkg/libarcane/edge/client_test.go
+++ b/backend/pkg/libarcane/edge/client_test.go
@@ -19,9 +19,9 @@ import (
"testing"
"time"
+ "github.com/coder/websocket"
httputil "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
- "github.com/gorilla/websocket"
"github.com/labstack/echo/v5"
slogecho "github.com/samber/slog-echo/v2"
"github.com/stretchr/testify/assert"
@@ -43,11 +43,13 @@ func TestTunnelClient_HandleRequest(t *testing.T) {
// 2. Setup Mock Manager (that agent connects TO)
managerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
- _, registerData, _ := conn.ReadMessage()
+ _, registerData, _ := conn.Read(r.Context())
var registerMsg TunnelMessage
_ = json.Unmarshal(registerData, &registerMsg)
assert.Equal(t, MessageTypeRegister, registerMsg.Type)
@@ -56,7 +58,7 @@ func TestTunnelClient_HandleRequest(t *testing.T) {
Accepted: true,
SessionID: "session-1",
})
- _ = conn.WriteMessage(websocket.TextMessage, registerResp)
+ _ = conn.Write(r.Context(), websocket.MessageText, registerResp)
// Send a request to the agent
reqMsg := &TunnelMessage{
@@ -66,10 +68,10 @@ func TestTunnelClient_HandleRequest(t *testing.T) {
Path: "/local/api",
}
data, _ := json.Marshal(reqMsg)
- _ = conn.WriteMessage(websocket.TextMessage, data)
+ _ = conn.Write(r.Context(), websocket.MessageText, data)
// Wait for response
- _, respData, _ := conn.ReadMessage()
+ _, respData, _ := conn.Read(r.Context())
var resp TunnelMessage
_ = json.Unmarshal(respData, &resp)
@@ -105,20 +107,19 @@ func TestTunnelClient_HandleRequest(t *testing.T) {
func TestTunnelClient_WebSocketProxy(t *testing.T) {
// 1. Setup Local Service with WS
localServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
for {
- mt, data, err := conn.ReadMessage()
+ mt, data, err := conn.Read(r.Context())
if err != nil {
return
}
// Echo
- _ = conn.WriteMessage(mt, append([]byte("local echo: "), data...))
+ _ = conn.Write(r.Context(), mt, append([]byte("local echo: "), data...))
}
}))
defer localServer.Close()
@@ -127,11 +128,13 @@ func TestTunnelClient_WebSocketProxy(t *testing.T) {
// 2. Setup Mock Manager
managerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
- _, registerData, _ := conn.ReadMessage()
+ _, registerData, _ := conn.Read(r.Context())
var registerMsg TunnelMessage
_ = json.Unmarshal(registerData, &registerMsg)
assert.Equal(t, MessageTypeRegister, registerMsg.Type)
@@ -140,7 +143,7 @@ func TestTunnelClient_WebSocketProxy(t *testing.T) {
Accepted: true,
SessionID: "session-1",
})
- _ = conn.WriteMessage(websocket.TextMessage, registerResp)
+ _ = conn.Write(r.Context(), websocket.MessageText, registerResp)
// Send WS Start
startMsg := &TunnelMessage{
@@ -149,20 +152,20 @@ func TestTunnelClient_WebSocketProxy(t *testing.T) {
Path: "/", // Connect to root of local server
}
data, _ := json.Marshal(startMsg)
- _ = conn.WriteMessage(websocket.TextMessage, data)
+ _ = conn.Write(r.Context(), websocket.MessageText, data)
// Send Data
dataMsg := &TunnelMessage{
ID: "ws-1",
Type: MessageTypeWebSocketData,
Body: []byte("hello"),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
}
data, _ = json.Marshal(dataMsg)
- _ = conn.WriteMessage(websocket.TextMessage, data)
+ _ = conn.Write(r.Context(), websocket.MessageText, data)
// Read Echo
- _, respData, _ := conn.ReadMessage()
+ _, respData, _ := conn.Read(r.Context())
var resp TunnelMessage
_ = json.Unmarshal(respData, &resp)
@@ -195,18 +198,17 @@ func TestTunnelClient_WebSocketProxy(t *testing.T) {
func TestTunnelClient_WebSocket_ReconnectClosesStreams(t *testing.T) {
// Local WS echo server the agent proxies to.
localServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
for {
- mt, data, err := conn.ReadMessage()
+ mt, data, err := conn.Read(r.Context())
if err != nil {
return
}
- _ = conn.WriteMessage(mt, append([]byte("local echo: "), data...))
+ _ = conn.Write(r.Context(), mt, append([]byte("local echo: "), data...))
}
}))
defer localServer.Close()
@@ -218,15 +220,14 @@ func TestTunnelClient_WebSocket_ReconnectClosesStreams(t *testing.T) {
stopManager := make(chan struct{})
managerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
// Every connection registers first.
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(r.Context()); err != nil {
return
}
registerResp, _ := json.Marshal(&TunnelMessage{
@@ -234,7 +235,7 @@ func TestTunnelClient_WebSocket_ReconnectClosesStreams(t *testing.T) {
Accepted: true,
SessionID: "session-1",
})
- _ = conn.WriteMessage(websocket.TextMessage, registerResp)
+ _ = conn.Write(r.Context(), websocket.MessageText, registerResp)
if connCount.Add(1) > 1 {
// Post-reconnect connection: stay up so the agent stops reconnecting
@@ -246,16 +247,16 @@ func TestTunnelClient_WebSocket_ReconnectClosesStreams(t *testing.T) {
// First connection: open a stream and prove it is live by round-tripping
// data through the local echo server, then force a disconnect.
startMsg, _ := json.Marshal(&TunnelMessage{ID: "ws-1", Type: MessageTypeWebSocketStart, Path: "/"})
- _ = conn.WriteMessage(websocket.TextMessage, startMsg)
+ _ = conn.Write(r.Context(), websocket.MessageText, startMsg)
dataMsg, _ := json.Marshal(&TunnelMessage{
ID: "ws-1",
Type: MessageTypeWebSocketData,
Body: []byte("hello"),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
})
- _ = conn.WriteMessage(websocket.TextMessage, dataMsg)
+ _ = conn.Write(r.Context(), websocket.MessageText, dataMsg)
- _, respData, err := conn.ReadMessage()
+ _, respData, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -307,11 +308,13 @@ func TestTunnelClient_WebSocket_ReconnectClosesStreams(t *testing.T) {
func TestTunnelClient_HandleRequest_Errors(t *testing.T) {
// Setup Mock Manager
managerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
- _, registerData, _ := conn.ReadMessage()
+ _, registerData, _ := conn.Read(r.Context())
var registerMsg TunnelMessage
_ = json.Unmarshal(registerData, &registerMsg)
assert.Equal(t, MessageTypeRegister, registerMsg.Type)
@@ -320,7 +323,7 @@ func TestTunnelClient_HandleRequest_Errors(t *testing.T) {
Accepted: true,
SessionID: "session-1",
})
- _ = conn.WriteMessage(websocket.TextMessage, registerResp)
+ _ = conn.Write(r.Context(), websocket.MessageText, registerResp)
// 1. Send request with invalid URL to trigger error
reqMsg := &TunnelMessage{
@@ -330,10 +333,10 @@ func TestTunnelClient_HandleRequest_Errors(t *testing.T) {
Path: "://invalid-url",
}
data, _ := json.Marshal(reqMsg)
- _ = conn.WriteMessage(websocket.TextMessage, data)
+ _ = conn.Write(r.Context(), websocket.MessageText, data)
// Expect error response
- _, respData, _ := conn.ReadMessage()
+ _, respData, _ := conn.Read(r.Context())
var resp TunnelMessage
_ = json.Unmarshal(respData, &resp)
@@ -346,7 +349,7 @@ func TestTunnelClient_HandleRequest_Errors(t *testing.T) {
Type: "unknown_type",
}
data, _ = json.Marshal(unknownMsg)
- _ = conn.WriteMessage(websocket.TextMessage, data)
+ _ = conn.Write(r.Context(), websocket.MessageText, data)
}))
defer managerServer.Close()
@@ -368,12 +371,14 @@ func TestTunnelClient_HandleRequest_Errors(t *testing.T) {
func TestTunnelClient_InternalHelpers(t *testing.T) {
// Mock connection
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
for {
- _, _, err := conn.ReadMessage()
+ _, _, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -389,18 +394,15 @@ func TestTunnelClient_InternalHelpers(t *testing.T) {
// Manually connect
serverURL := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(serverURL, nil)
+ conn, _, err := websocket.Dial(t.Context(), serverURL, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnelConn := NewTunnelConn(conn)
- client.setConn(tunnelConn)
+ client.conn.Store(&connBox{conn: tunnelConn})
// Test sendWebSocketData
- err = client.sendWebSocketData(tunnelConn, "stream-1", websocket.TextMessage, []byte("data"))
+ err = client.sendWebSocketData(tunnelConn, "stream-1", int(websocket.MessageText), []byte("data"))
require.NoError(t, err)
// Test sendWebSocketClose
@@ -589,16 +591,17 @@ func TestTunnelClient_DialLocalWebSocket_StripsForwardedBrowserHeaders(t *testin
return
}
- upgrader := websocket.Upgrader{
- CheckOrigin: httputil.ValidateWebSocketOrigin(managerURL),
+ if !httputil.ValidateWebSocketOrigin(managerURL)(r) {
+ http.Error(w, "forbidden", http.StatusForbidden)
+ return
}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true})
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
- require.NoError(t, conn.WriteMessage(websocket.TextMessage, []byte("ok")))
+ require.NoError(t, conn.Write(r.Context(), websocket.MessageText, []byte("ok")))
}))
defer localServer.Close()
@@ -630,16 +633,13 @@ func TestTunnelClient_DialLocalWebSocket_StripsForwardedBrowserHeaders(t *testin
assert.Empty(t, headers.Get("Cookie"))
assert.Empty(t, headers.Get("Authorization"))
- ws, resp, err := client.dialLocalWebSocket(t.Context(), client.buildLocalWebSocketURLInternal(msg), headers)
+ ws, _, err := client.dialLocalWebSocket(t.Context(), client.buildLocalWebSocketURLInternal(msg), headers)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = ws.Close() }()
+ defer func() { _ = ws.CloseNow() }()
- msgType, body, err := ws.ReadMessage()
+ msgType, body, err := ws.Read(t.Context())
require.NoError(t, err)
- assert.Equal(t, websocket.TextMessage, msgType)
+ assert.Equal(t, websocket.MessageText, msgType)
assert.Equal(t, "ok", string(body))
}
@@ -669,7 +669,7 @@ func TestTunnelClient_HandleRequest_GRPCConfigWithWebSocketConnUsesNonStreamingR
EdgeTransport: EdgeTransportGRPC,
}, localHandler)
conn := &capturingTunnelConnForHandleRequest{}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
client.handleRequest(context.Background(), conn, &TunnelMessage{
ID: "req-fallback-1",
@@ -689,7 +689,7 @@ func TestTunnelClient_HeartbeatLoop_ClosesConnectionOnSendFailure(t *testing.T)
client := &TunnelClient{
heartbeatInterval: 5 * time.Millisecond,
}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
@@ -857,7 +857,7 @@ func TestTunnelClient_GRPC_EndToEnd(t *testing.T) {
return envID, nil
}
- tunnelServer := NewTunnelServer(resolver, nil)
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
go tunnelServer.StartCleanupLoop(ctx)
defer func() {
cancel()
@@ -920,7 +920,7 @@ func TestTunnelClient_GRPC_ChunkedRequestBodyEndToEnd(t *testing.T) {
GetRegistry().Unregister(envID)
defer GetRegistry().Unregister(envID)
- tunnelServer := NewTunnelServer(func(_ context.Context, token string) (string, error) {
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(), func(_ context.Context, token string) (string, error) {
if token != "valid-token" {
return "", errors.New("invalid token")
}
@@ -1068,7 +1068,7 @@ func TestTunnelClient_connectAndServeGRPC_RegistrationRejected(t *testing.T) {
return envID, nil
}
- tunnelServer := NewTunnelServer(resolver, nil)
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
go tunnelServer.StartCleanupLoop(ctx)
defer func() {
cancel()
@@ -1124,7 +1124,7 @@ func TestTunnelClient_awaitRegistrationInternal_ClosesConnOnContextDone(t *testi
client := &TunnelClient{
registrationTimeout: time.Second,
}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
msg, err := client.awaitRegistrationInternal(ctx)
require.Nil(t, msg)
@@ -1147,7 +1147,7 @@ func TestTunnelClient_awaitRegistrationInternal_ClosesAttemptConnWhenClientConnC
client := &TunnelClient{
registrationTimeout: time.Second,
}
- client.setConn(firstConn)
+ client.conn.Store(&connBox{conn: firstConn})
type registrationResult struct {
msg *TunnelMessage
@@ -1165,7 +1165,7 @@ func TestTunnelClient_awaitRegistrationInternal_ClosesAttemptConnWhenClientConnC
t.Fatal("registration receive did not start")
}
- client.setConn(secondConn)
+ client.conn.Store(&connBox{conn: secondConn})
cancel()
select {
@@ -1196,7 +1196,7 @@ func TestTunnelClient_GRPC_WebSocketProxyEndToEnd(t *testing.T) {
return envID, nil
}
- tunnelServer := NewTunnelServer(resolver, nil)
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
go tunnelServer.StartCleanupLoop(ctx)
defer func() {
cancel()
@@ -1226,23 +1226,18 @@ func TestTunnelClient_GRPC_WebSocketProxyEndToEnd(t *testing.T) {
default:
}
- upgrader := websocket.Upgrader{
- CheckOrigin: func(*http.Request) bool { return true },
- Error: func(_ http.ResponseWriter, _ *http.Request, status int, reason error) {
- select {
- case upgradeErrCh <- reason.Error():
- default:
- }
- },
- }
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true})
if err != nil {
+ select {
+ case upgradeErrCh <- err.Error():
+ default:
+ }
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
for {
- mt, data, err := conn.ReadMessage()
+ mt, data, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -1250,7 +1245,7 @@ func TestTunnelClient_GRPC_WebSocketProxyEndToEnd(t *testing.T) {
case receivedMsgCh <- string(data):
default:
}
- if err := conn.WriteMessage(mt, append([]byte("local echo: "), data...)); err != nil {
+ if err := conn.Write(r.Context(), mt, append([]byte("local echo: "), data...)); err != nil {
return
}
}
@@ -1292,23 +1287,20 @@ func TestTunnelClient_GRPC_WebSocketProxyEndToEnd(t *testing.T) {
defer proxyServer.Close()
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http") + "/proxy-ws?tail=100"
- proxyConn, resp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ proxyConn, _, err := websocket.Dial(ctx, proxyURL, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = proxyConn.Close() }()
+ defer func() { _ = proxyConn.CloseNow() }()
- require.NoError(t, proxyConn.WriteMessage(websocket.TextMessage, []byte("hello-grpc-ws")))
+ require.NoError(t, proxyConn.Write(ctx, websocket.MessageText, []byte("hello-grpc-ws")))
- msgType, payload, err := proxyConn.ReadMessage()
+ msgType, payload, err := proxyConn.Read(ctx)
select {
case upgradeErr := <-upgradeErrCh:
t.Fatalf("local websocket upgrade failed: %s", upgradeErr)
default:
}
require.NoError(t, err)
- assert.Equal(t, websocket.TextMessage, msgType)
+ assert.Equal(t, websocket.MessageText, msgType)
assert.Equal(t, "local echo: hello-grpc-ws", string(payload))
select {
@@ -1357,12 +1349,11 @@ func TestTunnelClient_connectAndServe_WebSocketConfigFallsBackToWebSocket(t *tes
return
}
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
select {
case wsConnectedCh <- struct{}{}:
@@ -1519,7 +1510,7 @@ func TestTunnelClient_connectAndServe_OpensGRPCWhenAvailable(t *testing.T) {
return envID, nil
}
- tunnelServer := NewTunnelServer(resolver, nil)
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
go tunnelServer.StartCleanupLoop(ctx)
defer tunnelServer.WaitForCleanupDone()
@@ -1566,14 +1557,13 @@ func startTestWebSocketTunnelManagerInternal(t *testing.T, ctx context.Context)
return
}
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(r.Context()); err != nil {
return
}
@@ -1586,7 +1576,7 @@ func startTestWebSocketTunnelManagerInternal(t *testing.T, ctx context.Context)
if err != nil {
return
}
- if err := conn.WriteMessage(websocket.TextMessage, registerResp); err != nil {
+ if err := conn.Write(r.Context(), websocket.MessageText, registerResp); err != nil {
return
}
@@ -1725,7 +1715,7 @@ func TestTunnelClient_connectAndServePoll_OpensGRPCWhenRequired(t *testing.T) {
return envID, nil
}
- tunnelServer := NewTunnelServer(resolver, nil)
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
go tunnelServer.StartCleanupLoop(ctx)
defer tunnelServer.WaitForCleanupDone()
@@ -1777,14 +1767,13 @@ func TestTunnelClient_connectAndServePoll_OpensWebSocketWhenRequired(t *testing.
PollIntervalSeconds: 1,
}))
case "/api/tunnel/connect":
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(r.Context()); err != nil {
return
}
registerResp, err := json.Marshal(&TunnelMessage{
@@ -1796,7 +1785,7 @@ func TestTunnelClient_connectAndServePoll_OpensWebSocketWhenRequired(t *testing.
if err != nil {
return
}
- if err := conn.WriteMessage(websocket.TextMessage, registerResp); err != nil {
+ if err := conn.Write(r.Context(), websocket.MessageText, registerResp); err != nil {
return
}
@@ -1934,14 +1923,13 @@ func TestTunnelClient_connectAndServePoll_RetriesAfterTransientPollError(t *test
PollIntervalSeconds: 1,
}))
case "/api/tunnel/connect":
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(r.Context()); err != nil {
return
}
registerResp, err := json.Marshal(&TunnelMessage{
@@ -1953,7 +1941,7 @@ func TestTunnelClient_connectAndServePoll_RetriesAfterTransientPollError(t *test
if err != nil {
return
}
- if err := conn.WriteMessage(websocket.TextMessage, registerResp); err != nil {
+ if err := conn.Write(r.Context(), websocket.MessageText, registerResp); err != nil {
return
}
@@ -2108,7 +2096,7 @@ func TestTunnelClient_InternalRequestSkipsSlogEcho(t *testing.T) {
name: "legacy response",
run: func(t *testing.T, client *TunnelClient) {
conn := &capturingTunnelConnForHandleRequest{}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
client.handleRequest(context.Background(), conn, &TunnelMessage{
ID: "req-legacy",
@@ -2127,7 +2115,7 @@ func TestTunnelClient_InternalRequestSkipsSlogEcho(t *testing.T) {
name: "streaming response",
run: func(t *testing.T, client *TunnelClient) {
conn := &fakeTunnelConn{}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
client.handleRequestStreaming(context.Background(), conn, &TunnelMessage{
ID: "req-stream",
@@ -2267,14 +2255,13 @@ func TestStreamingResponseRecorder_WriteHeaderAndClose(t *testing.T) {
func TestConnectAndServeWebSocket_CancelUnblocksMessageLoop(t *testing.T) {
registered := make(chan struct{})
managerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
- _, _, err = conn.ReadMessage()
+ _, _, err = conn.Read(r.Context())
if err != nil {
return
}
@@ -2283,11 +2270,11 @@ func TestConnectAndServeWebSocket_CancelUnblocksMessageLoop(t *testing.T) {
Accepted: true,
SessionID: "session-cancel",
})
- _ = conn.WriteMessage(websocket.TextMessage, registerResp)
+ _ = conn.Write(r.Context(), websocket.MessageText, registerResp)
close(registered)
// Go silent: keep reading so the socket stays open.
for {
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(r.Context()); err != nil {
return
}
}
diff --git a/backend/pkg/libarcane/edge/client_transport_grpc_test.go b/backend/pkg/libarcane/edge/client_transport_grpc_test.go
index 102137e1c..8e7a67912 100644
--- a/backend/pkg/libarcane/edge/client_transport_grpc_test.go
+++ b/backend/pkg/libarcane/edge/client_transport_grpc_test.go
@@ -440,7 +440,7 @@ func TestGRPCTunnel_RegisterMessageRequiredOnEOF(t *testing.T) {
func startTestGRPCTunnelServer(ctx context.Context, envID string) (*bufconn.Listener, *grpc.Server, *TunnelServer) {
lis := bufconn.Listen(1024 * 1024)
- tunnelServer := NewTunnelServer(
+ tunnelServer := NewTunnelServerWithRegistry(GetRegistry(),
func(ctx context.Context, token string) (string, error) {
if token != "valid-token" {
return "", errors.New("invalid token")
diff --git a/backend/pkg/libarcane/edge/client_transport_websocket.go b/backend/pkg/libarcane/edge/client_transport_websocket.go
index 60b367ee0..740ebd58b 100644
--- a/backend/pkg/libarcane/edge/client_transport_websocket.go
+++ b/backend/pkg/libarcane/edge/client_transport_websocket.go
@@ -11,7 +11,7 @@ import (
"emperror.dev/errors"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
)
func (c *TunnelClient) connectAndServeWebSocket(ctx context.Context) error {
@@ -21,10 +21,7 @@ func (c *TunnelClient) connectAndServeWebSocket(ctx context.Context) error {
}
c.managerURL = managerWSURL
- dialer := websocket.Dialer{
- Proxy: http.ProxyFromEnvironment,
- HandshakeTimeout: 30 * time.Second,
- }
+ transport := &http.Transport{Proxy: http.ProxyFromEnvironment}
if strings.HasPrefix(strings.ToLower(managerWSURL), "wss://") {
tlsConfig, err := buildManagerClientTLSConfigInternal(c.cfg)
if err != nil {
@@ -33,7 +30,7 @@ func (c *TunnelClient) connectAndServeWebSocket(ctx context.Context) error {
if tlsConfig == nil {
tlsConfig = &tls.Config{MinVersion: tls.VersionTLS12}
}
- dialer.TLSClientConfig = tlsConfig
+ transport.TLSClientConfig = tlsConfig
}
headers := http.Header{}
@@ -43,9 +40,15 @@ func (c *TunnelClient) connectAndServeWebSocket(ctx context.Context) error {
slog.DebugContext(ctx, "Dialing manager for websocket edge tunnel", "url", managerWSURL)
- conn, resp, err := dialer.DialContext(ctx, managerWSURL, headers)
+ // The dial context bounds only the handshake; the connection outlives it.
+ dialCtx, dialCancel := context.WithTimeout(ctx, 30*time.Second)
+ defer dialCancel()
+ conn, resp, err := websocket.Dial(dialCtx, managerWSURL, &websocket.DialOptions{
+ HTTPClient: &http.Client{Transport: transport},
+ HTTPHeader: headers,
+ })
if err != nil {
- if resp != nil {
+ if resp != nil && resp.Body != nil {
defer func() { _ = resp.Body.Close() }()
body, _ := io.ReadAll(resp.Body)
return errors.WrapIff(err, "failed to connect to manager websocket endpoint (status: %d, body: %s)", resp.StatusCode, string(body))
diff --git a/backend/pkg/libarcane/edge/proxy_test.go b/backend/pkg/libarcane/edge/proxy_test.go
index 250927062..7d36511cb 100644
--- a/backend/pkg/libarcane/edge/proxy_test.go
+++ b/backend/pkg/libarcane/edge/proxy_test.go
@@ -12,8 +12,8 @@ import (
"testing"
"time"
+ "github.com/coder/websocket"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
- "github.com/gorilla/websocket"
"github.com/labstack/echo/v5"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -25,15 +25,14 @@ import (
// It receives requests and sends back responses
func setupMockAgentServer(t *testing.T, handler func(*TunnelMessage) *TunnelMessage) (*httptest.Server, *AgentTunnel) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
for {
- _, data, err := conn.ReadMessage()
+ _, data, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -44,17 +43,14 @@ func setupMockAgentServer(t *testing.T, handler func(*TunnelMessage) *TunnelMess
if msg.Type == MessageTypeRequest || msg.Type == MessageTypeCommandRequest {
resp := handler(&msg)
respData, _ := json.Marshal(resp)
- _ = conn.WriteMessage(websocket.TextMessage, respData)
+ _ = conn.Write(r.Context(), websocket.MessageText, respData)
}
}
}))
url := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnel := newWebSocketAgentTunnel("env-1", conn)
@@ -304,7 +300,7 @@ func TestCommandRequestFailsWhenTunnelCloses(t *testing.T) {
func TestHasActiveTunnel(t *testing.T) {
conn := createTestConn(t)
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnel := newWebSocketAgentTunnel("env-active", conn)
registry := GetRegistry()
@@ -457,7 +453,7 @@ func TestHandleRequest_SetsHostField(t *testing.T) {
client := NewTunnelClient(&Config{}, localHandler)
conn := &capturingTunnelConnForHandleRequest{}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
client.handleRequest(context.Background(), conn, &TunnelMessage{
ID: "req-host-1",
@@ -489,7 +485,7 @@ func TestHandleRequest_ForwardsBody(t *testing.T) {
client := NewTunnelClient(&Config{}, localHandler)
conn := &capturingTunnelConnForHandleRequest{}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
client.handleRequest(context.Background(), conn, &TunnelMessage{
ID: "req-body-1",
@@ -521,7 +517,7 @@ func TestHandleRequest_NoBrowserHeadersInTunnelMessage(t *testing.T) {
client := NewTunnelClient(&Config{}, localHandler)
conn := &capturingTunnelConnForHandleRequest{}
- client.setConn(conn)
+ client.conn.Store(&connBox{conn: conn})
// Simulate an old manager that doesn't strip Origin
client.handleRequest(context.Background(), conn, &TunnelMessage{
@@ -593,15 +589,14 @@ func TestProxyHTTPRequest_BodyPreservation_WebSocket(t *testing.T) {
var receivedBody string
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
for {
- _, data, err := conn.ReadMessage()
+ _, data, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -619,18 +614,15 @@ func TestProxyHTTPRequest_BodyPreservation_WebSocket(t *testing.T) {
Body: []byte(`{"ok":true}`),
}
respData, _ := json.Marshal(resp)
- _ = conn.WriteMessage(websocket.TextMessage, respData)
+ _ = conn.Write(r.Context(), websocket.MessageText, respData)
}
}
}))
defer server.Close()
url := "ws" + server.URL[4:]
- wsConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ wsConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnel := newWebSocketAgentTunnel("env-body-test", wsConn)
defer func() { _ = tunnel.CloseWithReason("") }()
diff --git a/backend/pkg/libarcane/edge/registry_test.go b/backend/pkg/libarcane/edge/registry_test.go
index 77073b8fc..1bb96949f 100644
--- a/backend/pkg/libarcane/edge/registry_test.go
+++ b/backend/pkg/libarcane/edge/registry_test.go
@@ -7,24 +7,25 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func createTestConn(t *testing.T) *websocket.Conn {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- _, _ = upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ // Block until the peer closes so close handshakes complete promptly.
+ _, _, _ = conn.Read(r.Context())
}))
t.Cleanup(server.Close)
url := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
return conn
}
@@ -34,7 +35,7 @@ func TestTunnelRegistry(t *testing.T) {
// Create a tunnel
conn := createTestConn(t)
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnel := newWebSocketAgentTunnel(envID, conn)
// Register
@@ -59,12 +60,12 @@ func TestTunnelRegistry_RegisterReplace(t *testing.T) {
envID := "env-1"
conn1 := createTestConn(t)
- defer func() { _ = conn1.Close() }()
+ defer func() { _ = conn1.CloseNow() }()
tunnel1 := newWebSocketAgentTunnel(envID, conn1)
r.Register(envID, tunnel1)
conn2 := createTestConn(t)
- defer func() { _ = conn2.Close() }()
+ defer func() { _ = conn2.CloseNow() }()
tunnel2 := newWebSocketAgentTunnel(envID, conn2)
// Register replacement
@@ -85,7 +86,7 @@ func TestTunnelRegistry_RegisterSessionRejectsCompetingAgent(t *testing.T) {
envID := "env-session-reject"
conn1 := createTestConn(t)
- defer func() { _ = conn1.Close() }()
+ defer func() { _ = conn1.CloseNow() }()
tunnel1 := newWebSocketAgentTunnel(envID, conn1)
tunnel1.AgentInstance = "agent-a"
tunnel1.SessionID = "session-a"
@@ -96,7 +97,7 @@ func TestTunnelRegistry_RegisterSessionRejectsCompetingAgent(t *testing.T) {
assert.Equal(t, "", reason)
conn2 := createTestConn(t)
- defer func() { _ = conn2.Close() }()
+ defer func() { _ = conn2.CloseNow() }()
tunnel2 := newWebSocketAgentTunnel(envID, conn2)
tunnel2.AgentInstance = "agent-b"
tunnel2.SessionID = "session-b"
@@ -117,7 +118,7 @@ func TestTunnelRegistry_RegisterSessionReplacesSameAgentInstance(t *testing.T) {
envID := "env-session-replace"
conn1 := createTestConn(t)
- defer func() { _ = conn1.Close() }()
+ defer func() { _ = conn1.CloseNow() }()
tunnel1 := newWebSocketAgentTunnel(envID, conn1)
tunnel1.AgentInstance = "agent-a"
tunnel1.SessionID = "session-a"
@@ -127,7 +128,7 @@ func TestTunnelRegistry_RegisterSessionReplacesSameAgentInstance(t *testing.T) {
assert.Equal(t, "", reason)
conn2 := createTestConn(t)
- defer func() { _ = conn2.Close() }()
+ defer func() { _ = conn2.CloseNow() }()
tunnel2 := newWebSocketAgentTunnel(envID, conn2)
tunnel2.AgentInstance = "agent-a"
tunnel2.SessionID = "session-b"
@@ -147,7 +148,7 @@ func TestTunnelRegistry_CleanupStale(t *testing.T) {
envID := "env-1"
conn := createTestConn(t)
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnel := newWebSocketAgentTunnel(envID, conn)
// Manually set last heartbeat to past
@@ -175,7 +176,7 @@ func TestGetRegistry(t *testing.T) {
func TestAgentTunnel_Heartbeat(t *testing.T) {
conn := createTestConn(t)
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnel := newWebSocketAgentTunnel("env-1", conn)
initial := tunnel.GetLastHeartbeat()
diff --git a/backend/pkg/libarcane/edge/request_context.go b/backend/pkg/libarcane/edge/request_context.go
index 384a65073..b996a99c7 100644
--- a/backend/pkg/libarcane/edge/request_context.go
+++ b/backend/pkg/libarcane/edge/request_context.go
@@ -11,7 +11,3 @@ func IsInternalTunnelRequest(ctx context.Context) bool {
isInternal, _ := ctx.Value(internalTunnelRequestContextKey{}).(bool)
return isInternal
}
-
-func withInternalTunnelRequestInternal(ctx context.Context) context.Context {
- return context.WithValue(ctx, internalTunnelRequestContextKey{}, true)
-}
diff --git a/backend/pkg/libarcane/edge/server.go b/backend/pkg/libarcane/edge/server.go
index 9a7533642..61cada4f6 100644
--- a/backend/pkg/libarcane/edge/server.go
+++ b/backend/pkg/libarcane/edge/server.go
@@ -13,10 +13,11 @@ import (
"emperror.dev/emperror"
"emperror.dev/errors"
+ wshub "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
"github.com/getarcaneapp/arcane/backend/v2/pkg/remenv"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
+ certgen "github.com/getarcaneapp/arcane/cli/v2/pkg/generate"
"github.com/google/uuid"
- "github.com/gorilla/websocket"
"github.com/labstack/echo/v5"
"github.com/samber/mo"
"google.golang.org/grpc"
@@ -39,13 +40,6 @@ const (
streamDeliveryTimeout = 5 * time.Second
)
-var tunnelUpgrader = websocket.Upgrader{
- ReadBufferSize: 64 * 1024,
- WriteBufferSize: 64 * 1024,
- EnableCompression: true,
- CheckOrigin: func(r *http.Request) bool { return true },
-}
-
// EnvironmentResolver resolves an agent token to an environment ID.
type EnvironmentResolver func(ctx context.Context, token string) (environmentID string, err error)
@@ -66,11 +60,6 @@ type EventCallback func(ctx context.Context, environmentID string, event *Tunnel
// assets again after the enrollment cooldown.
type EnrollmentCallback func(ctx context.Context, environmentID, remoteAddr string, certIssued bool, caGenerated bool, reenrolled bool)
-// NewTunnelServer creates a new tunnel server.
-func NewTunnelServer(resolver EnvironmentResolver, statusCallback StatusUpdateCallback) *TunnelServer {
- return NewTunnelServerWithRegistry(GetRegistry(), resolver, statusCallback)
-}
-
// NewTunnelServerWithRegistry creates a new tunnel server using an injected tunnel registry.
func NewTunnelServerWithRegistry(registry *TunnelRegistry, resolver EnvironmentResolver, statusCallback StatusUpdateCallback) *TunnelServer {
if registry == nil {
@@ -134,8 +123,9 @@ func (s *TunnelServer) HandleConnect(c *echo.Context) error {
ctx := req.Context()
callbackCtx := context.WithoutCancel(ctx)
- // Upgrade to WebSocket.
- conn, err := tunnelUpgrader.Upgrade(c.Response(), req, nil)
+ // Upgrade to WebSocket. Agents authenticate with tokens/mTLS, not browser
+ // cookies, so no Origin check is needed here.
+ conn, err := wshub.Accept(c.Response(), req, nil)
if err != nil {
slog.ErrorContext(ctx, "Failed to upgrade edge tunnel connection", "error", err)
return nil
@@ -707,7 +697,7 @@ func (s *TunnelServer) requireCertificateIdentityInternal(state *tls.ConnectionS
if NormalizeEdgeMTLSMode(s.edgeMTLSModeInternal()) == EdgeMTLSModeDisabled {
return nil
}
- return verifiedPeerCertificateEnvironmentIDMatchesInternal(state, envID, edgeMTLSTrustDomainInternal(s.cfg))
+ return verifiedPeerCertificateEnvironmentIDMatchesInternal(state, envID, certgen.EdgeMTLSTrustDomain(edgeMTLSAppURLInternal(s.cfg)))
}
func (s *TunnelServer) requireRequestCertificateIdentityInternal(req *http.Request, envID string) error {
@@ -741,7 +731,7 @@ func (s *TunnelServer) requireCertificateIdentityFromContextInternal(ctx context
}
return nil
}
- return verifiedPeerCertificateEnvironmentIDMatchesInternal(&tlsInfo.State, envID, edgeMTLSTrustDomainInternal(s.cfg))
+ return verifiedPeerCertificateEnvironmentIDMatchesInternal(&tlsInfo.State, envID, certgen.EdgeMTLSTrustDomain(edgeMTLSAppURLInternal(s.cfg)))
}
func (s *TunnelServer) edgeMTLSModeInternal() string {
diff --git a/backend/pkg/libarcane/edge/server_test.go b/backend/pkg/libarcane/edge/server_test.go
index ae26a704f..0c0f279c9 100644
--- a/backend/pkg/libarcane/edge/server_test.go
+++ b/backend/pkg/libarcane/edge/server_test.go
@@ -14,7 +14,8 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
+ "github.com/coder/websocket/wsjson"
"github.com/labstack/echo/v5"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -41,7 +42,7 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
}
}
- server := NewTunnelServer(resolver, callback)
+ server := NewTunnelServerWithRegistry(GetRegistry(), resolver, callback)
router := echo.New()
router.GET("/connect", server.HandleConnect)
@@ -54,16 +55,13 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
headers := http.Header{}
headers.Set(HeaderAgentToken, "valid-token")
- conn, resp, err := websocket.DefaultDialer.Dial(url, headers)
+ conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
- err = conn.WriteJSON(&TunnelMessage{
+ err = wsjson.Write(t.Context(), conn, &TunnelMessage{
Type: MessageTypeRegister,
AgentToken: "valid-token",
AgentInstance: "agent-connected",
@@ -71,7 +69,7 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
require.NoError(t, err)
var registerResp TunnelMessage
- err = conn.ReadJSON(&registerResp)
+ err = wsjson.Read(t.Context(), conn, &registerResp)
require.NoError(t, err)
assert.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
assert.True(t, registerResp.Accepted)
@@ -98,12 +96,12 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
ID: "hb-1",
Type: MessageTypeHeartbeat,
}
- err = conn.WriteJSON(heartbeat)
+ err = wsjson.Write(t.Context(), conn, heartbeat)
require.NoError(t, err)
// Should receive Ack
var ack TunnelMessage
- err = conn.ReadJSON(&ack)
+ err = wsjson.Read(t.Context(), conn, &ack)
require.NoError(t, err)
assert.Equal(t, MessageTypeHeartbeatAck, ack.Type)
assert.Equal(t, "hb-1", ack.ID)
@@ -119,7 +117,7 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
Type: MessageTypeResponse,
Body: []byte("response"),
}
- err = conn.WriteJSON(respMsg)
+ err = wsjson.Write(t.Context(), conn, respMsg)
require.NoError(t, err)
// 3. Verify received on channel
@@ -142,7 +140,7 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
Type: MessageTypeStreamData,
Body: []byte("stream"),
}
- err = conn.WriteJSON(streamMsg)
+ err = wsjson.Write(t.Context(), conn, streamMsg)
require.NoError(t, err)
// 3. Verify received
@@ -155,20 +153,22 @@ func TestTunnelServer_HandleConnect(t *testing.T) {
// Test Ignored/Unknown Messages
ignoredMsg := &TunnelMessage{ID: "ignore", Type: MessageTypeRequest} // Request coming FROM agent is ignored/unexpected
- _ = conn.WriteJSON(ignoredMsg)
+ _ = wsjson.Write(t.Context(), conn, ignoredMsg)
unknownMsg := &TunnelMessage{ID: "unknown", Type: "unknown_type"}
- _ = conn.WriteJSON(unknownMsg)
+ _ = wsjson.Write(t.Context(), conn, unknownMsg)
// Allow time for processing
time.Sleep(100 * time.Millisecond)
- // Clean up
+ // Clean up; close the client first so the server-side close handshake
+ // does not wait on a peer that is no longer reading.
+ _ = conn.CloseNow()
reg.Unregister("env-connected")
}
func TestTunnelServer_HandleConnect_AcceptsTokenAfterProxyTerminatedMTLS(t *testing.T) {
- server := NewTunnelServer(func(ctx context.Context, token string) (string, error) {
+ server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
if token == "valid-token" {
return "env-proxy-mtls", nil
}
@@ -189,15 +189,12 @@ func TestTunnelServer_HandleConnect_AcceptsTokenAfterProxyTerminatedMTLS(t *test
headers := http.Header{}
headers.Set(HeaderAgentToken, "valid-token")
- conn, resp, err := websocket.DefaultDialer.Dial(url, headers)
+ conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
- err = conn.WriteJSON(&TunnelMessage{
+ err = wsjson.Write(t.Context(), conn, &TunnelMessage{
Type: MessageTypeRegister,
AgentToken: "valid-token",
AgentInstance: "agent-proxy-mtls",
@@ -205,12 +202,13 @@ func TestTunnelServer_HandleConnect_AcceptsTokenAfterProxyTerminatedMTLS(t *test
require.NoError(t, err)
var registerResp TunnelMessage
- err = conn.ReadJSON(&registerResp)
+ err = wsjson.Read(t.Context(), conn, &registerResp)
require.NoError(t, err)
require.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
require.True(t, registerResp.Accepted)
require.Equal(t, "token", registerResp.SecurityMode)
+ _ = conn.CloseNow()
GetRegistry().Unregister("env-proxy-mtls")
}
@@ -219,7 +217,7 @@ func TestTunnelServer_HandleConnect_InvalidToken(t *testing.T) {
return "", errors.New("invalid")
}
- server := NewTunnelServer(resolver, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
router := echo.New()
router.GET("/connect", server.HandleConnect)
@@ -230,19 +228,16 @@ func TestTunnelServer_HandleConnect_InvalidToken(t *testing.T) {
headers := http.Header{}
headers.Set(HeaderAgentToken, "bad-token")
- conn, resp, err := websocket.DefaultDialer.Dial(url, headers)
+ conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
- err = conn.WriteJSON(&TunnelMessage{Type: MessageTypeRegister, AgentToken: "bad-token"})
+ err = wsjson.Write(t.Context(), conn, &TunnelMessage{Type: MessageTypeRegister, AgentToken: "bad-token"})
require.NoError(t, err)
var registerResp TunnelMessage
- err = conn.ReadJSON(&registerResp)
+ err = wsjson.Read(t.Context(), conn, &registerResp)
require.NoError(t, err)
assert.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
assert.False(t, registerResp.Accepted)
@@ -259,7 +254,7 @@ func TestTunnelServer_HandleConnect_PrefersHeaderTokenOverRegisterMessage(t *tes
return "", errors.New("invalid token")
}
- server := NewTunnelServer(resolver, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
router := echo.New()
router.GET("/connect", server.HandleConnect)
@@ -270,29 +265,27 @@ func TestTunnelServer_HandleConnect_PrefersHeaderTokenOverRegisterMessage(t *tes
headers := http.Header{}
headers.Set(HeaderAgentToken, "valid-token")
- conn, resp, err := websocket.DefaultDialer.Dial(url, headers)
+ conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
- err = conn.WriteJSON(&TunnelMessage{Type: MessageTypeRegister, AgentToken: "bad-token"})
+ err = wsjson.Write(t.Context(), conn, &TunnelMessage{Type: MessageTypeRegister, AgentToken: "bad-token"})
require.NoError(t, err)
var registerResp TunnelMessage
- err = conn.ReadJSON(&registerResp)
+ err = wsjson.Read(t.Context(), conn, &registerResp)
require.NoError(t, err)
require.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
require.True(t, registerResp.Accepted)
require.Equal(t, "valid-token", resolvedToken)
+ _ = conn.CloseNow()
GetRegistry().Unregister("env-header-token")
}
func TestTunnelServer_HandleConnect_NoToken(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
router := echo.New()
router.GET("/connect", server.HandleConnect)
@@ -301,19 +294,16 @@ func TestTunnelServer_HandleConnect_NoToken(t *testing.T) {
url := "ws" + strings.TrimPrefix(ts.URL, "http") + "/connect"
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, resp, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
- err = conn.WriteJSON(&TunnelMessage{Type: MessageTypeRegister})
+ err = wsjson.Write(t.Context(), conn, &TunnelMessage{Type: MessageTypeRegister})
require.NoError(t, err)
var registerResp TunnelMessage
- err = conn.ReadJSON(&registerResp)
+ err = wsjson.Read(t.Context(), conn, &registerResp)
require.NoError(t, err)
require.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
require.False(t, registerResp.Accepted)
@@ -324,7 +314,7 @@ func TestTunnelConnectRouteRegistration(t *testing.T) {
router := echo.New()
group := router.Group("/api")
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
group.GET("/tunnel/connect", server.HandleConnect)
// Verify route exists (simplistic check by trying to hit it)
@@ -332,12 +322,13 @@ func TestTunnelConnectRouteRegistration(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/api/tunnel/connect", nil)
router.ServeHTTP(w, req)
- // Plain HTTP requests hit the route but fail websocket upgrade.
- assert.Equal(t, http.StatusBadRequest, w.Code)
+ // Plain HTTP requests hit the route but fail the websocket upgrade;
+ // coder/websocket responds with 426 Upgrade Required.
+ assert.Equal(t, http.StatusUpgradeRequired, w.Code)
}
func TestTunnelServer_HandleMTLSEnroll(t *testing.T) {
- server := NewTunnelServer(func(ctx context.Context, token string) (string, error) {
+ server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
if token != "valid-token" {
return "", errors.New("invalid token")
}
@@ -381,7 +372,7 @@ func TestTunnelServer_HandleMTLSEnroll(t *testing.T) {
}
func TestTunnelServer_HandleMTLSEnroll_ServesCachedAssetsDuringCooldown(t *testing.T) {
- server := NewTunnelServer(func(ctx context.Context, token string) (string, error) {
+ server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
if token != "valid-token" {
return "", errors.New("invalid token")
}
@@ -421,7 +412,7 @@ func TestTunnelServer_HandleMTLSEnroll_AllowsRepeatAfterCooldownAndMarksReenroll
EdgeMTLSMode: EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: t.TempDir(),
}
- server := NewTunnelServer(func(ctx context.Context, token string) (string, error) {
+ server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
if token != "valid-token" {
return "", errors.New("invalid token")
}
@@ -459,7 +450,7 @@ func TestTunnelServer_HandleMTLSEnroll_AllowsRepeatAfterCooldownAndMarksReenroll
}
func TestTunnelServer_CleanupLoop(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
ctx, cancel := context.WithCancel(context.Background())
// Run cleanup loop
@@ -473,7 +464,7 @@ func TestTunnelServer_CleanupLoop(t *testing.T) {
func TestTunnelServer_resolveEnvironment_TrimsToken(t *testing.T) {
var resolvedToken string
- server := NewTunnelServer(func(ctx context.Context, token string) (string, error) {
+ server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
resolvedToken = token
return "env-trimmed", nil
}, nil)
@@ -486,14 +477,14 @@ func TestTunnelServer_resolveEnvironment_TrimsToken(t *testing.T) {
func TestTunnelServer_resolveEnvironment_Errors(t *testing.T) {
t.Run("missing resolver", func(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
_, err := server.resolveEnvironment(context.Background(), "token")
require.Error(t, err)
assert.Contains(t, err.Error(), "edge resolver is not configured")
})
t.Run("missing token", func(t *testing.T) {
- server := NewTunnelServer(func(ctx context.Context, token string) (string, error) {
+ server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
return "env", nil
}, nil)
@@ -560,7 +551,7 @@ func TestIsExpectedTunnelReceiveError(t *testing.T) {
func TestTunnelServer_HandleEventCallback(t *testing.T) {
called := make(chan struct{}, 1)
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.SetEventCallback(func(ctx context.Context, environmentID string, event *TunnelEvent) error {
assert.Equal(t, "env-edge", environmentID)
require.NotNil(t, event)
@@ -634,7 +625,7 @@ func (f *registerResponseOrderConn) IsClosed() bool { return false }
func (f *registerResponseOrderConn) Transport() string { return EdgeTransportGRPC }
func TestTunnelServer_ManageConnectedTunnel_RegistersBeforeSendingGRPCRegisterResponse(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
envID := "env-grpc-register-order"
server.registry.Unregister(envID)
t.Cleanup(func() { server.registry.Unregister(envID) })
diff --git a/backend/pkg/libarcane/edge/tls.go b/backend/pkg/libarcane/edge/tls.go
index e675ec03a..9c928343e 100644
--- a/backend/pkg/libarcane/edge/tls.go
+++ b/backend/pkg/libarcane/edge/tls.go
@@ -633,10 +633,6 @@ func edgeMTLSAppURLInternal(cfg *Config) string {
return strings.TrimSpace(cfg.GetManagerBaseURL())
}
-func edgeMTLSTrustDomainInternal(cfg *Config) string {
- return certgen.EdgeMTLSTrustDomain(edgeMTLSAppURLInternal(cfg))
-}
-
func expectedEdgeMTLSURIPathInternal(envID string) string {
safeEnvID := generatedAssetNameSanitizer.ReplaceAllString(strings.TrimSpace(envID), "_")
if safeEnvID == "" {
diff --git a/backend/pkg/libarcane/edge/tls_test.go b/backend/pkg/libarcane/edge/tls_test.go
index eca73ff2a..163ebbfda 100644
--- a/backend/pkg/libarcane/edge/tls_test.go
+++ b/backend/pkg/libarcane/edge/tls_test.go
@@ -270,7 +270,7 @@ func TestTunnelServerRequireCertificateIdentityInternal_RejectsWrongEnvironmentU
PeerCertificates: []*x509.Certificate{cert},
VerifiedChains: [][]*x509.Certificate{{cert}},
}
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.SetConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
AppURL: "https://manager.example.com",
@@ -320,7 +320,7 @@ func TestValidateManagerMTLSConfig_RejectsMissingOrMalformedCAFile(t *testing.T)
}
func TestTunnelServerRequiredMTLS_AllowsHTTPRequestsWithoutVisibleTLSState(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.SetConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
AppURL: "https://manager.example.com",
@@ -331,7 +331,7 @@ func TestTunnelServerRequiredMTLS_AllowsHTTPRequestsWithoutVisibleTLSState(t *te
}
func TestTunnelServerRequiredMTLS_RejectsDirectTLSWithoutVerifiedClientCertificate(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.SetConfig(&Config{EdgeMTLSMode: EdgeMTLSModeRequired})
req := httptest.NewRequest(http.MethodGet, "https://manager.example.com/api/tunnel/connect", nil)
@@ -343,7 +343,7 @@ func TestTunnelServerRequiredMTLS_RejectsDirectTLSWithoutVerifiedClientCertifica
}
func TestTunnelServerRequiredMTLS_DetectsOnlyDirectTLSForRequestSecurityMode(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.SetConfig(&Config{
EdgeMTLSMode: EdgeMTLSModeRequired,
AppURL: "https://manager.example.com",
@@ -387,7 +387,7 @@ func TestTunnelServerRequiredMTLS_IgnoresProxyVerificationHeaders(t *testing.T)
}
func TestTunnelServerRequiredMTLS_AllowsGRPCContextsWithoutVisibleTLSState(t *testing.T) {
- server := NewTunnelServer(nil, nil)
+ server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
server.SetConfig(&Config{EdgeMTLSMode: EdgeMTLSModeRequired})
t.Run("missing peer", func(t *testing.T) {
diff --git a/backend/pkg/libarcane/edge/transport_test.go b/backend/pkg/libarcane/edge/transport_test.go
index 87b89c90f..2c0fb48dd 100644
--- a/backend/pkg/libarcane/edge/transport_test.go
+++ b/backend/pkg/libarcane/edge/transport_test.go
@@ -12,8 +12,9 @@ import (
"testing"
"time"
+ "github.com/coder/websocket"
+ "github.com/coder/websocket/wsjson"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
- "github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
@@ -88,7 +89,7 @@ func TestGetActiveTunnelTransport(t *testing.T) {
defer GetRegistry().Unregister(envID)
conn := createTestConn(t)
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnel := newWebSocketAgentTunnel(envID, conn)
GetRegistry().Register(envID, tunnel)
@@ -332,18 +333,17 @@ func setupWebSocketBenchmarkTunnel(b *testing.B, payloadSize int) (*AgentTunnel,
b.Helper()
responseBody := make([]byte, payloadSize)
- upgrader := websocket.Upgrader{CheckOrigin: func(_ *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
for {
var msg TunnelMessage
- if err := conn.ReadJSON(&msg); err != nil {
- _ = conn.Close()
+ if err := wsjson.Read(r.Context(), conn, &msg); err != nil {
+ _ = conn.CloseNow()
return
}
@@ -357,22 +357,19 @@ func setupWebSocketBenchmarkTunnel(b *testing.B, payloadSize int) (*AgentTunnel,
Status: http.StatusOK,
Body: responseBody,
}
- if err := conn.WriteJSON(resp); err != nil {
- _ = conn.Close()
+ if err := wsjson.Write(r.Context(), conn, resp); err != nil {
+ _ = conn.CloseNow()
return
}
}
}))
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ conn, _, err := websocket.Dial(context.Background(), wsURL, nil)
if err != nil {
server.Close()
b.Fatalf("failed to dial websocket server: %v", err)
}
- if resp != nil {
- _ = resp.Body.Close()
- }
tunnel := NewAgentTunnelWithConn("bench-websocket", NewTunnelConn(conn))
dispatchDone := make(chan struct{})
diff --git a/backend/pkg/libarcane/edge/tunnel.go b/backend/pkg/libarcane/edge/tunnel.go
index 8e524b2df..f425eb7cd 100644
--- a/backend/pkg/libarcane/edge/tunnel.go
+++ b/backend/pkg/libarcane/edge/tunnel.go
@@ -6,12 +6,12 @@ import (
"io"
"log/slog"
"net"
- "time"
"emperror.dev/errors"
+ "github.com/coder/websocket"
+ wshub "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
- "github.com/gorilla/websocket"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
@@ -107,9 +107,10 @@ func (t *TunnelConn) Send(msg *TunnelMessage) error {
if err != nil {
return err
}
- _ = t.conn.SetWriteDeadline(time.Now().Add(DefaultWriteTimeout))
- if err := t.conn.WriteMessage(websocket.TextMessage, data); err != nil {
- // A gorilla connection is unusable after a write error.
+ wctx, cancel := context.WithTimeout(context.Background(), DefaultWriteTimeout)
+ defer cancel()
+ if err := t.conn.Write(wctx, websocket.MessageText, data); err != nil {
+ // coder/websocket closes the connection after a failed or expired write.
t.closed.Store(true)
return err
}
@@ -122,10 +123,12 @@ func (t *TunnelConn) Receive() (*TunnelMessage, error) {
return nil, ErrTunnelConnectionClosed
}
- _ = t.conn.SetReadDeadline(time.Now().Add(tunnelReadWait))
- _, data, err := t.conn.ReadMessage()
+ rctx, cancel := context.WithTimeout(context.Background(), tunnelReadWait)
+ defer cancel()
+ _, data, err := t.conn.Read(rctx)
if err != nil {
- // Read-deadline expiry and network errors are terminal for gorilla conns.
+ // Read-timeout expiry and network errors are terminal: coder/websocket
+ // closes the connection when a read context expires.
t.closed.Store(true)
return nil, err
}
@@ -150,26 +153,22 @@ func (t *TunnelConn) IsExpectedReceiveError(err error) bool {
return true
}
- return websocket.IsCloseError(err,
- websocket.CloseNormalClosure,
- websocket.CloseGoingAway,
- websocket.CloseNoStatusReceived,
- )
+ return wshub.IsExpectedClose(err)
}
// Close closes the WebSocket tunnel connection, sending a close frame on the
// first call so the peer observes a normal closure instead of 1006.
func (t *TunnelConn) Close() error {
if t.closed.Swap(true) {
- return t.conn.Close()
+ return t.conn.CloseNow()
}
- // WriteControl is safe concurrently with a data writer, so a stuck Send
- // cannot block teardown.
- _ = t.conn.WriteControl(websocket.CloseMessage,
- websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
- time.Now().Add(DefaultWriteTimeout))
- return t.conn.Close()
+ // Close performs the close handshake with its own internal timeout and is
+ // safe concurrently with a data writer, so a stuck Send cannot block teardown.
+ if err := t.conn.Close(websocket.StatusNormalClosure, ""); err != nil {
+ return t.conn.CloseNow()
+ }
+ return nil
}
// IsClosed returns whether the connection is closed.
diff --git a/backend/pkg/libarcane/edge/tunnel_proto_adapter.go b/backend/pkg/libarcane/edge/tunnel_proto_adapter.go
index b310e9c46..e9103fca2 100644
--- a/backend/pkg/libarcane/edge/tunnel_proto_adapter.go
+++ b/backend/pkg/libarcane/edge/tunnel_proto_adapter.go
@@ -168,9 +168,11 @@ func managerProtoToTunnelMessage(msg *tunnelpb.ManagerMessage) (*TunnelMessage,
}, nil
case *tunnelpb.ManagerMessage_WsData:
return &TunnelMessage{
- ID: payload.WsData.GetStreamId(),
- Type: MessageTypeWebSocketData,
- Body: payload.WsData.GetData(),
+ ID: payload.WsData.GetStreamId(),
+ Type: MessageTypeWebSocketData,
+ Body: payload.WsData.GetData(),
+ // WSMessageType carries RFC 6455 opcodes (text=1, binary=2) on the
+ // wire; a mixed-version fleet depends on these exact values.
WSMessageType: int(payload.WsData.GetMessageType()),
}, nil
case *tunnelpb.ManagerMessage_WsClose:
diff --git a/backend/pkg/libarcane/edge/tunnel_proto_adapter_test.go b/backend/pkg/libarcane/edge/tunnel_proto_adapter_test.go
index 8750adc88..a413ddfea 100644
--- a/backend/pkg/libarcane/edge/tunnel_proto_adapter_test.go
+++ b/backend/pkg/libarcane/edge/tunnel_proto_adapter_test.go
@@ -5,8 +5,8 @@ import (
"io"
"testing"
+ "github.com/coder/websocket"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
- "github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -42,7 +42,7 @@ func TestTunnelMessageToManagerProto_StreamDataUsesWebSocketPayload(t *testing.T
ID: "stream-1",
Type: MessageTypeStreamData,
Body: []byte("hello"),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
}
protoMsg, err := tunnelMessageToManagerProto(original, false)
@@ -138,7 +138,7 @@ func TestTunnelMessageToAgentProto_RoundTripStreamDataPreservesWebSocketType(t *
ID: "stream-1",
Type: MessageTypeStreamData,
Body: []byte(`{"cpu":10}`),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
}
protoMsg, err := tunnelMessageToAgentProto(original)
@@ -194,7 +194,7 @@ func TestTunnelMessageToManagerProto_StreamDataParityEncoding(t *testing.T) {
ID: "stream-1",
Type: MessageTypeStreamData,
Body: []byte("hello"),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
}
// Legacy agents receive the ws_data re-encode and see ws_data.
diff --git a/backend/pkg/libarcane/edge/tunnel_test.go b/backend/pkg/libarcane/edge/tunnel_test.go
index 46dd8c55e..727adea28 100644
--- a/backend/pkg/libarcane/edge/tunnel_test.go
+++ b/backend/pkg/libarcane/edge/tunnel_test.go
@@ -10,8 +10,8 @@ import (
"testing"
"time"
+ "github.com/coder/websocket"
tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
- "github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -39,20 +39,19 @@ func TestTunnelMessage_MarshalJSON(t *testing.T) {
func TestTunnelConn(t *testing.T) {
// Start a test server
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
for {
- mt, message, err := conn.ReadMessage()
+ mt, message, err := conn.Read(r.Context())
if err != nil {
break
}
// Echo back
- err = conn.WriteMessage(mt, message)
+ err = conn.Write(r.Context(), mt, message)
if err != nil {
break
}
@@ -62,12 +61,9 @@ func TestTunnelConn(t *testing.T) {
// Connect to the server
url := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnelConn := NewTunnelConn(conn)
@@ -153,30 +149,26 @@ func (b *blockingGRPCManagerStream) Context() context.Context { return b.ctx }
func TestTunnelConn_CloseSendsCloseFrame(t *testing.T) {
peerRead := make(chan error, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
- _, _, err = conn.ReadMessage()
+ defer func() { _ = conn.CloseNow() }()
+ _, _, err = conn.Read(r.Context())
peerRead <- err
}))
defer server.Close()
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ conn, _, err := websocket.Dial(t.Context(), wsURL, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnelConn := NewTunnelConn(conn)
require.NoError(t, tunnelConn.Close())
select {
case err := <-peerRead:
- assert.True(t, websocket.IsCloseError(err, websocket.CloseNormalClosure),
+ assert.Equal(t, websocket.StatusNormalClosure, websocket.CloseStatus(err),
"peer should observe a normal closure, got: %v", err)
case <-time.After(5 * time.Second):
t.Fatal("timed out waiting for peer read to return")
@@ -189,23 +181,19 @@ func TestTunnelConn_ReceiveDeadlineMarksClosed(t *testing.T) {
t.Cleanup(func() { tunnelReadWait = previousReadWait })
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
// Keep the socket open but never send anything.
- _, _, _ = conn.ReadMessage()
+ _, _, _ = conn.Read(r.Context())
}))
defer server.Close()
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ conn, _, err := websocket.Dial(t.Context(), wsURL, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnelConn := NewTunnelConn(conn)
_, err = tunnelConn.Receive()
diff --git a/backend/pkg/libarcane/edge/types.go b/backend/pkg/libarcane/edge/types.go
index 85eab3715..be8aa4f1e 100644
--- a/backend/pkg/libarcane/edge/types.go
+++ b/backend/pkg/libarcane/edge/types.go
@@ -8,7 +8,7 @@ import (
"sync/atomic"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"google.golang.org/grpc"
)
diff --git a/backend/pkg/libarcane/edge/ws_proxy.go b/backend/pkg/libarcane/edge/ws_proxy.go
index 59795c3ad..f15b5dc16 100644
--- a/backend/pkg/libarcane/edge/ws_proxy.go
+++ b/backend/pkg/libarcane/edge/ws_proxy.go
@@ -6,29 +6,22 @@ import (
"net/http"
"time"
+ "github.com/coder/websocket"
+ wshub "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
"github.com/google/uuid"
- "github.com/gorilla/websocket"
"github.com/labstack/echo/v5"
)
const (
- // tunnelWSPongWait is the deadline for the next pong (or any read) on the
- // browser-facing side of a proxied WebSocket. Reverse proxies (Caddy,
- // Nginx, ...) silently drop idle TCP connections; without a heartbeat the
- // master would hold a dead stream open until something else terminates it.
- tunnelWSPongWait = 60 * time.Second
- tunnelWSPingWriteWait = 1 * time.Second
+ // tunnelWSPingWait bounds the ping round-trip on the browser-facing side of
+ // a proxied WebSocket. Reverse proxies (Caddy, Nginx, ...) silently drop
+ // idle TCP connections; without a heartbeat the master would hold a dead
+ // stream open until something else terminates it.
+ tunnelWSPingWait = 10 * time.Second
+ tunnelWSPingPeriod = 54 * time.Second
tunnelWSDataWriteWait = 10 * time.Second
)
-var tunnelWSPingPeriod = tunnelWSPongWait * 9 / 10
-
-var wsUpgraderForProxy = websocket.Upgrader{
- ReadBufferSize: 64 * 1024,
- WriteBufferSize: 64 * 1024,
- EnableCompression: true,
-}
-
// ProxyWebSocketRequest proxies a WebSocket upgrade through an edge tunnel.
// This handles logs, stats, and other streaming endpoints.
//
@@ -44,22 +37,16 @@ func ProxyWebSocketRequest(c *echo.Context, tunnel *AgentTunnel, targetPath stri
slog.ErrorContext(ctx, "Refusing edge WebSocket proxy without an origin validator", "path", targetPath)
return echo.NewHTTPError(http.StatusForbidden, "websocket origin validation unavailable")
}
-
- proxyUpgrader := wsUpgraderForProxy
- proxyUpgrader.CheckOrigin = checkOrigin
-
- clientWS, err := proxyUpgrader.Upgrade(c.Response(), req, nil)
+ clientWS, err := wshub.Accept(c.Response(), req, checkOrigin)
if err != nil {
slog.ErrorContext(ctx, "Failed to upgrade WebSocket for edge proxy", "error", err)
return nil
}
- defer func() { _ = clientWS.Close() }()
-
- _ = clientWS.SetReadDeadline(time.Now().Add(tunnelWSPongWait))
- clientWS.SetPongHandler(func(string) error {
- _ = clientWS.SetReadDeadline(time.Now().Add(tunnelWSPongWait))
- return nil
- })
+ defer func() { _ = clientWS.CloseNow() }()
+ // Client frames are forwarded into tunnel messages capped at
+ // maxGRPCTunnelMessageSize; allow the same size here instead of
+ // coder/websocket's 32KB default.
+ clientWS.SetReadLimit(maxGRPCTunnelMessageSize)
streamID := uuid.New().String()
streamCtx, cancel := context.WithCancel(ctx)
@@ -114,27 +101,20 @@ func buildWebSocketHeaders(req *http.Request) map[string]string {
func forwardClientToAgent(ctx context.Context, streamCtx context.Context, clientWS *websocket.Conn, tunnel *AgentTunnel, streamID string, doneCh chan<- struct{}) {
defer close(doneCh)
for {
- if streamCtx.Err() != nil {
- return
- }
-
- msgType, data, err := clientWS.ReadMessage()
+ msgType, data, err := clientWS.Read(streamCtx)
if err != nil {
- if !websocket.IsCloseError(err,
- websocket.CloseNormalClosure,
- websocket.CloseGoingAway,
- websocket.CloseNoStatusReceived) {
+ if !wshub.IsExpectedClose(err) {
slog.DebugContext(ctx, "Client WebSocket read error", "error", err)
}
sendWebSocketClose(tunnel, streamID)
return
}
- if !isForwardableWSMessage(msgType) {
+ if !isForwardableWSMessage(int(msgType)) {
continue
}
- if err := sendWebSocketData(tunnel, streamID, msgType, data); err != nil {
+ if err := sendStreamDataInternal(tunnel, streamID, int(msgType), data); err != nil {
slog.DebugContext(ctx, "Failed to send WebSocket data to agent", "error", err)
return
}
@@ -156,8 +136,11 @@ func forwardAgentToClient(ctx context.Context, streamCtx context.Context, client
case <-clientDoneCh:
return
case <-pingTicker.C:
- _ = clientWS.SetWriteDeadline(time.Now().Add(tunnelWSPingWriteWait))
- if err := clientWS.WriteMessage(websocket.PingMessage, nil); err != nil {
+ // Ping round-trips; the pong is serviced by forwardClientToAgent's read.
+ pctx, pcancel := context.WithTimeout(streamCtx, tunnelWSPingWait)
+ err := clientWS.Ping(pctx)
+ pcancel()
+ if err != nil {
slog.DebugContext(ctx, "Failed to ping client WebSocket", "stream_id", streamID, "error", err)
sendWebSocketClose(tunnel, streamID)
return
@@ -166,7 +149,7 @@ func forwardAgentToClient(ctx context.Context, streamCtx context.Context, client
if !ok {
return
}
- if shouldStop, err := handleAgentMessage(ctx, clientWS, msg, streamID); err != nil {
+ if shouldStop, err := handleAgentMessage(ctx, streamCtx, clientWS, msg, streamID); err != nil {
slog.DebugContext(ctx, "Failed to write to client WebSocket", "error", err)
return
} else if shouldStop {
@@ -176,10 +159,10 @@ func forwardAgentToClient(ctx context.Context, streamCtx context.Context, client
}
}
-func handleAgentMessage(ctx context.Context, clientWS *websocket.Conn, msg *TunnelMessage, streamID string) (bool, error) {
+func handleAgentMessage(ctx context.Context, streamCtx context.Context, clientWS *websocket.Conn, msg *TunnelMessage, streamID string) (bool, error) {
switch msg.Type {
case MessageTypeWebSocketData, MessageTypeStreamData:
- return false, writeWebSocketData(clientWS, msg)
+ return false, writeWebSocketData(streamCtx, clientWS, msg)
case MessageTypeWebSocketClose, MessageTypeStreamClose, MessageTypeStreamEnd:
slog.DebugContext(ctx, "Agent closed WebSocket stream", "stream_id", streamID)
return true, nil
@@ -206,14 +189,15 @@ func handleAgentMessage(ctx context.Context, clientWS *websocket.Conn, msg *Tunn
}
}
-func writeWebSocketData(clientWS *websocket.Conn, msg *TunnelMessage) error {
- msgType := msg.WSMessageType
- if msgType != websocket.TextMessage && msgType != websocket.BinaryMessage {
- slog.Warn("Dropping WebSocket message with unsupported type", "messageType", msgType)
+func writeWebSocketData(streamCtx context.Context, clientWS *websocket.Conn, msg *TunnelMessage) error {
+ msgType := websocket.MessageType(msg.WSMessageType)
+ if msgType != websocket.MessageText && msgType != websocket.MessageBinary {
+ slog.Warn("Dropping WebSocket message with unsupported type", "messageType", msg.WSMessageType)
return nil
}
- _ = clientWS.SetWriteDeadline(time.Now().Add(tunnelWSDataWriteWait))
- return clientWS.WriteMessage(msgType, msg.Body)
+ wctx, cancel := context.WithTimeout(streamCtx, tunnelWSDataWriteWait)
+ defer cancel()
+ return clientWS.Write(wctx, msgType, msg.Body)
}
func sendStreamDataInternal(tunnel *AgentTunnel, streamID string, msgType int, data []byte) error {
@@ -234,10 +218,6 @@ func sendWebSocketClose(tunnel *AgentTunnel, streamID string) {
_ = tunnel.Conn.Send(closeMsg)
}
-func sendWebSocketData(tunnel *AgentTunnel, streamID string, msgType int, data []byte) error {
- return sendStreamDataInternal(tunnel, streamID, msgType, data)
-}
-
func isForwardableWSMessage(msgType int) bool {
- return msgType == websocket.TextMessage || msgType == websocket.BinaryMessage
+ return msgType == int(websocket.MessageText) || msgType == int(websocket.MessageBinary)
}
diff --git a/backend/pkg/libarcane/edge/ws_proxy_test.go b/backend/pkg/libarcane/edge/ws_proxy_test.go
index 66390187f..29a0b1475 100644
--- a/backend/pkg/libarcane/edge/ws_proxy_test.go
+++ b/backend/pkg/libarcane/edge/ws_proxy_test.go
@@ -8,7 +8,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/labstack/echo/v5"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -17,12 +17,14 @@ import (
func TestProxyWebSocketRequest(t *testing.T) {
// Custom Mock Agent Server
agentServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
for {
- _, data, err := conn.ReadMessage()
+ _, data, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -36,10 +38,10 @@ func TestProxyWebSocketRequest(t *testing.T) {
ID: msg.ID,
Type: MessageTypeStreamData,
Body: []byte("hello"),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
}
respData, _ := json.Marshal(resp)
- _ = conn.WriteMessage(websocket.TextMessage, respData)
+ _ = conn.Write(r.Context(), websocket.MessageText, respData)
// 2. Send Unknown Type (should be ignored by proxy)
unknown := &TunnelMessage{
@@ -47,7 +49,7 @@ func TestProxyWebSocketRequest(t *testing.T) {
Type: "unknown_proxy_type",
}
unknownData, _ := json.Marshal(unknown)
- _ = conn.WriteMessage(websocket.TextMessage, unknownData)
+ _ = conn.Write(r.Context(), websocket.MessageText, unknownData)
// 3. Send Close
closeMsg := &TunnelMessage{
@@ -55,7 +57,7 @@ func TestProxyWebSocketRequest(t *testing.T) {
Type: MessageTypeStreamClose,
}
closeData, _ := json.Marshal(closeMsg)
- _ = conn.WriteMessage(websocket.TextMessage, closeData)
+ _ = conn.Write(r.Context(), websocket.MessageText, closeData)
}
}
}))
@@ -63,11 +65,8 @@ func TestProxyWebSocketRequest(t *testing.T) {
// Connect Agent Tunnel
url := "ws" + strings.TrimPrefix(agentServer.URL, "http")
- agentConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ agentConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnel := newWebSocketAgentTunnel("env-ws-proxy", agentConn)
defer func() { _ = tunnel.CloseWithReason("") }()
@@ -101,27 +100,24 @@ func TestProxyWebSocketRequest(t *testing.T) {
// Client Connect
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http") + "/proxy-ws"
- clientConn, clientResp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if clientResp != nil {
- defer func() { _ = clientResp.Body.Close() }()
- }
- defer func() { _ = clientConn.Close() }()
+ defer func() { _ = clientConn.CloseNow() }()
// Read Hello
- _, msg, err := clientConn.ReadMessage()
+ _, msg, err := clientConn.Read(t.Context())
require.NoError(t, err)
assert.Equal(t, "hello", string(msg))
// Send data from Client to Agent
- err = clientConn.WriteMessage(websocket.TextMessage, []byte("client-data"))
+ err = clientConn.Write(t.Context(), websocket.MessageText, []byte("client-data"))
require.NoError(t, err)
// Give a bit of time for the forward to happen
time.Sleep(50 * time.Millisecond)
// So client should see connection close.
- _, _, err = clientConn.ReadMessage()
+ _, _, err = clientConn.Read(t.Context())
// Should be EOF or close error
assert.Error(t, err)
}
@@ -129,11 +125,13 @@ func TestProxyWebSocketRequest(t *testing.T) {
func TestProxyWebSocketRequest_ClientClose(t *testing.T) {
// Setup simple agent that just reads
agentServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
for {
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(r.Context()); err != nil {
return
}
}
@@ -141,11 +139,8 @@ func TestProxyWebSocketRequest_ClientClose(t *testing.T) {
defer agentServer.Close()
url := "ws" + strings.TrimPrefix(agentServer.URL, "http")
- agentConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ agentConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnel := newWebSocketAgentTunnel("env-ws-close", agentConn)
defer func() { _ = tunnel.CloseWithReason("") }()
@@ -166,36 +161,37 @@ func TestProxyWebSocketRequest_ClientClose(t *testing.T) {
defer proxyServer.Close()
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http") + "/proxy-ws"
- clientConn, clientResp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if clientResp != nil {
- defer func() { _ = clientResp.Body.Close() }()
- }
// Client closes
- _ = clientConn.Close()
+ _ = clientConn.CloseNow()
// Server side should handle it gracefully
time.Sleep(100 * time.Millisecond)
}
func TestIsForwardableWSMessage(t *testing.T) {
- assert.True(t, isForwardableWSMessage(websocket.TextMessage))
- assert.True(t, isForwardableWSMessage(websocket.BinaryMessage))
- assert.False(t, isForwardableWSMessage(websocket.PingMessage))
- assert.False(t, isForwardableWSMessage(websocket.PongMessage))
- assert.False(t, isForwardableWSMessage(websocket.CloseMessage))
+ assert.True(t, isForwardableWSMessage(int(websocket.MessageText)))
+ assert.True(t, isForwardableWSMessage(int(websocket.MessageBinary)))
+ // coder/websocket does not export control-frame message types; use the
+ // raw RFC 6455 opcodes (close=8, ping=9, pong=10).
+ assert.False(t, isForwardableWSMessage(9))
+ assert.False(t, isForwardableWSMessage(10))
+ assert.False(t, isForwardableWSMessage(8))
}
func TestSendWebSocketData(t *testing.T) {
// Mock Agent Tunnel
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
// Read message
- _, data, err := conn.ReadMessage()
+ _, data, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -205,35 +201,37 @@ func TestSendWebSocketData(t *testing.T) {
assert.Equal(t, MessageTypeStreamData, msg.Type)
assert.Equal(t, "test-stream", msg.ID)
- assert.Equal(t, websocket.TextMessage, msg.WSMessageType)
+ assert.Equal(t, int(websocket.MessageText), msg.WSMessageType)
assert.Equal(t, "payload", string(msg.Body))
+
+ // Drain until the peer closes so the close handshake completes promptly.
+ _, _, _ = conn.Read(r.Context())
}))
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = conn.Close() }()
+ defer func() { _ = conn.CloseNow() }()
tunnel := newWebSocketAgentTunnel("env-helper", conn)
defer func() { _ = tunnel.CloseWithReason("") }()
- err = sendWebSocketData(tunnel, "test-stream", websocket.TextMessage, []byte("payload"))
+ err = sendStreamDataInternal(tunnel, "test-stream", int(websocket.MessageText), []byte("payload"))
require.NoError(t, err)
}
func TestSendWebSocketClose(t *testing.T) {
// Mock Agent Tunnel
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, _ := upgrader.Upgrade(w, r, nil)
- defer func() { _ = conn.Close() }()
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer func() { _ = conn.CloseNow() }()
// Read message
- _, data, err := conn.ReadMessage()
+ _, data, err := conn.Read(r.Context())
if err != nil {
return
}
@@ -243,15 +241,15 @@ func TestSendWebSocketClose(t *testing.T) {
assert.Equal(t, MessageTypeStreamClose, msg.Type)
assert.Equal(t, "test-stream", msg.ID)
+
+ // Drain until the peer closes so the close handshake completes promptly.
+ _, _, _ = conn.Read(r.Context())
}))
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
tunnel := newWebSocketAgentTunnel("env-helper-close", conn)
defer func() { _ = tunnel.CloseWithReason("") }()
@@ -262,35 +260,31 @@ func TestSendWebSocketClose(t *testing.T) {
func TestHandleAgentMessage_StreamDataPreservesTextFrame(t *testing.T) {
serverConnCh := make(chan *websocket.Conn, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- upgrader := websocket.Upgrader{}
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
require.NoError(t, err)
serverConnCh <- conn
}))
defer server.Close()
clientURL := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(clientURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), clientURL, nil)
require.NoError(t, err)
- if resp != nil {
- defer func() { _ = resp.Body.Close() }()
- }
- defer func() { _ = clientConn.Close() }()
+ defer func() { _ = clientConn.CloseNow() }()
serverConn := <-serverConnCh
- defer func() { _ = serverConn.Close() }()
+ defer func() { _ = serverConn.CloseNow() }()
- stop, err := handleAgentMessage(t.Context(), serverConn, &TunnelMessage{
+ stop, err := handleAgentMessage(t.Context(), t.Context(), serverConn, &TunnelMessage{
ID: "stats-stream",
Type: MessageTypeStreamData,
Body: []byte(`{"cpuPercent":12.5}`),
- WSMessageType: websocket.TextMessage,
+ WSMessageType: int(websocket.MessageText),
}, "stats-stream")
require.NoError(t, err)
assert.False(t, stop)
- msgType, payload, err := clientConn.ReadMessage()
+ msgType, payload, err := clientConn.Read(t.Context())
require.NoError(t, err)
- assert.Equal(t, websocket.TextMessage, msgType)
+ assert.Equal(t, websocket.MessageText, msgType)
assert.Equal(t, `{"cpuPercent":12.5}`, string(payload))
}
diff --git a/backend/pkg/libarcane/engine_compat.go b/backend/pkg/libarcane/engine_compat.go
index 1b401e48d..cb9cca130 100644
--- a/backend/pkg/libarcane/engine_compat.go
+++ b/backend/pkg/libarcane/engine_compat.go
@@ -65,7 +65,7 @@ func sanitizeRecreateHostConfigInternal(hostConfig *containertypes.HostConfig, e
return false
}
- if !isPodmanEngineInternal(engineInfo.Name) || !isCgroupV2Internal(engineInfo.CgroupVersion) {
+ if !strings.EqualFold(strings.TrimSpace(engineInfo.Name), "podman") || !isCgroupV2Internal(engineInfo.CgroupVersion) {
return false
}
@@ -115,10 +115,6 @@ func normalizeEngineNameInternal(value string) string {
}
}
-func isPodmanEngineInternal(engineName string) bool {
- return strings.EqualFold(strings.TrimSpace(engineName), "podman")
-}
-
func isCgroupV2Internal(cgroupVersion string) bool {
normalized := strings.ToLower(strings.TrimSpace(cgroupVersion))
normalized = strings.TrimPrefix(normalized, "v")
diff --git a/backend/pkg/libarcane/startup/runtime_identity.go b/backend/pkg/libarcane/startup/runtime_identity.go
index 4866b29cb..5cf991b19 100644
--- a/backend/pkg/libarcane/startup/runtime_identity.go
+++ b/backend/pkg/libarcane/startup/runtime_identity.go
@@ -100,7 +100,7 @@ func ApplyRequestedRuntimeIdentity(ctx context.Context, cfg *RuntimeIdentityConf
return errors.WrapIf(err, "load mountpoints")
}
- if err := prepareWritablePathsInternal(runtimeUID, runtimeGID, mountpoints, projectsDir); err != nil {
+ if err := prepareWritablePathsWithRootsInternal(runtimeUID, runtimeGID, mountpoints, projectsDir, defaultDataDirectory, defaultBuildsDirectory); err != nil {
return err
}
}
@@ -279,10 +279,6 @@ func dockerSocketPathInternal(raw string) mo.Option[string] {
return mo.Some(filepath.Clean(socketPath))
}
-func prepareWritablePathsInternal(uid int, gid int, mountpoints map[string]struct{}, projectsDir string) error {
- return prepareWritablePathsWithRootsInternal(uid, gid, mountpoints, projectsDir, defaultDataDirectory, defaultBuildsDirectory)
-}
-
func prepareWritablePathsWithRootsInternal(uid int, gid int, mountpoints map[string]struct{}, projectsDir string, dataDirectory string, buildsDirectory string) error {
if err := os.MkdirAll(dataDirectory, pkgutils.DirPerm); err != nil {
return errors.WrapIf(err, "create data directory")
@@ -348,7 +344,7 @@ func ensureSQLiteFilesExistInternal(databaseURL string) error {
// Ensure the parent directory exists before creating the file.
// This covers the "already the right user" early-return path where
- // prepareWritablePathsInternal is not called.
+ // prepareWritablePathsWithRootsInternal is not called.
dir := filepath.Dir(sqlitePath)
if dir != "" && dir != "." {
if err := os.MkdirAll(dir, pkgutils.DirPerm); err != nil {
diff --git a/backend/pkg/libarcane/timeouts/timeouts.go b/backend/pkg/libarcane/timeouts/timeouts.go
index 7afdb38f0..aa7289119 100644
--- a/backend/pkg/libarcane/timeouts/timeouts.go
+++ b/backend/pkg/libarcane/timeouts/timeouts.go
@@ -1,7 +1,6 @@
package timeouts
import (
- "context"
"time"
)
@@ -36,7 +35,3 @@ func GetDuration(settingSeconds int, defaultDuration time.Duration) time.Duratio
}
return defaultDuration
}
-
-func WithTimeout(ctx context.Context, settingSeconds int, defaultDuration time.Duration) (context.Context, context.CancelFunc) {
- return context.WithTimeout(ctx, GetDuration(settingSeconds, defaultDuration))
-}
diff --git a/backend/pkg/libarcane/vuln/trivy.go b/backend/pkg/libarcane/vuln/trivy.go
index 1c6fe0fd1..21880f5e8 100644
--- a/backend/pkg/libarcane/vuln/trivy.go
+++ b/backend/pkg/libarcane/vuln/trivy.go
@@ -44,11 +44,6 @@ func ParseVersion(output string) string {
return strings.TrimSpace(output)
}
-// NormalizeNetworkMode trims a configured Trivy network mode.
-func NormalizeNetworkMode(networkMode string) string {
- return strings.TrimSpace(networkMode)
-}
-
// ParseSecurityOpts splits a comma- or newline-separated list of security options
// into a cleaned slice, returning nil when there are no non-empty entries.
func ParseSecurityOpts(value string) []string {
diff --git a/backend/pkg/libarcane/vuln/trivy_test.go b/backend/pkg/libarcane/vuln/trivy_test.go
index 57ef920f0..871c8119a 100644
--- a/backend/pkg/libarcane/vuln/trivy_test.go
+++ b/backend/pkg/libarcane/vuln/trivy_test.go
@@ -189,12 +189,6 @@ func TestParseSecurityOpts(t *testing.T) {
}
}
-func TestNormalizeNetworkMode(t *testing.T) {
- require.Equal(t, "", NormalizeNetworkMode(""))
- require.Equal(t, "", NormalizeNetworkMode(" \t\n "))
- require.Equal(t, "arcane-external", NormalizeNetworkMode("arcane-external"))
-}
-
func TestParseDockerHost(t *testing.T) {
tests := []struct {
name string
diff --git a/backend/pkg/libarcane/ws/accept.go b/backend/pkg/libarcane/ws/accept.go
new file mode 100644
index 000000000..a1304cfbd
--- /dev/null
+++ b/backend/pkg/libarcane/ws/accept.go
@@ -0,0 +1,32 @@
+package ws
+
+import (
+ "net/http"
+
+ "emperror.dev/errors"
+ "github.com/coder/websocket"
+)
+
+// Accept validates the request Origin with checkOrigin and upgrades it to a
+// WebSocket. The origin check is the CSRF barrier for cookie-authenticated
+// upgrades; a nil checkOrigin skips it and must only be used for endpoints
+// authenticated by tokens or mTLS rather than browser cookies.
+func Accept(w http.ResponseWriter, r *http.Request, checkOrigin func(*http.Request) bool) (*websocket.Conn, error) {
+ if checkOrigin != nil && !checkOrigin(r) {
+ http.Error(w, "websocket origin not allowed", http.StatusForbidden)
+ return nil, errors.New("websocket origin not allowed")
+ }
+ return websocket.Accept(w, r, &websocket.AcceptOptions{
+ InsecureSkipVerify: true, // origin validated above
+ CompressionMode: websocket.CompressionContextTakeover,
+ })
+}
+
+// IsExpectedClose reports whether err is a WebSocket close error carrying one
+// of the benign statuses peers send on ordinary disconnect.
+func IsExpectedClose(err error) bool {
+ status := websocket.CloseStatus(err)
+ return status == websocket.StatusNormalClosure ||
+ status == websocket.StatusGoingAway ||
+ status == websocket.StatusNoStatusRcvd
+}
diff --git a/backend/pkg/libarcane/ws/benchmark_test.go b/backend/pkg/libarcane/ws/benchmark_test.go
index 48419ff7b..e25190788 100644
--- a/backend/pkg/libarcane/ws/benchmark_test.go
+++ b/backend/pkg/libarcane/ws/benchmark_test.go
@@ -10,7 +10,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
)
// benchWSServer creates a test WebSocket server for benchmarks.
@@ -19,25 +19,22 @@ func benchWSServer(b *testing.B) (url string, cleanup func()) {
b.Helper()
ctx, cancel := context.WithCancel(context.Background())
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
go func() {
// Drain reads until context cancelled
for {
- if _, _, err := conn.ReadMessage(); err != nil {
+ if _, _, err := conn.Read(ctx); err != nil {
return
}
}
}()
<-ctx.Done()
- if err := conn.Close(); err != nil {
- b.Logf("close websocket connection: %v", err)
- }
+ _ = conn.CloseNow()
}))
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
@@ -60,15 +57,10 @@ func benchHub(b *testing.B, numClients int, hubBuf int) (*Hub, context.CancelFun
var conns []*websocket.Conn
for range numClients {
- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ conn, _, err := websocket.Dial(ctx, wsURL, nil)
if err != nil {
b.Fatal(err)
}
- if resp != nil {
- if err := resp.Body.Close(); err != nil {
- b.Logf("close dial response body: %v", err)
- }
- }
conns = append(conns, conn)
c := NewClient(conn, 4096)
@@ -89,9 +81,7 @@ func benchHub(b *testing.B, numClients int, hubBuf int) (*Hub, context.CancelFun
return h, cancel, func() {
cancel()
for _, c := range conns {
- if err := c.Close(); err != nil {
- b.Logf("close websocket connection: %v", err)
- }
+ _ = c.CloseNow()
}
serverCleanup()
}
@@ -309,15 +299,10 @@ func BenchmarkHub_MemoryPerClient(b *testing.B) {
b.ResetTimer()
for b.Loop() {
- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)
+ conn, _, err := websocket.Dial(ctx, wsURL, nil)
if err != nil {
b.Fatal(err)
}
- if resp != nil {
- if err := resp.Body.Close(); err != nil {
- b.Logf("close dial response body: %v", err)
- }
- }
c := NewClient(conn, sendBuf)
h.register <- c
go func() {
diff --git a/backend/pkg/libarcane/ws/client.go b/backend/pkg/libarcane/ws/client.go
index f94421e31..a11d99ec4 100644
--- a/backend/pkg/libarcane/ws/client.go
+++ b/backend/pkg/libarcane/ws/client.go
@@ -2,19 +2,20 @@ package ws
import (
"context"
+ "errors"
+ "io"
"log/slog"
+ "net"
"strings"
"sync"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
)
const (
- writeWait = 10 * time.Second
- pingWriteWait = 1 * time.Second // shorter so writePump doesn't block long on dead conns
- pongWait = 60 * time.Second
- pingPeriod = pongWait * 9 / 10
+ writeWait = 10 * time.Second
+ pingPeriod = 54 * time.Second
maxMessageSize = 64 * 1024
clientSendBuffer = 256
@@ -29,8 +30,7 @@ type Client struct {
}
func NewClient(conn *websocket.Conn, sendBuffer int) *Client {
- // Enable per-message deflate if negotiated (safe to ignore error)
- _ = conn.SetCompressionLevel(1)
+ conn.SetReadLimit(maxMessageSize)
return &Client{
conn: conn,
send: make(chan []byte, sendBuffer),
@@ -79,25 +79,14 @@ func (c *Client) readPump(ctx context.Context, hub *Hub) {
// unserviced channel. Use hub.remove which is safe when the hub has exited.
defer c.safeRemove(hub)
- c.conn.SetReadLimit(maxMessageSize)
- _ = c.conn.SetReadDeadline(time.Now().Add(pongWait))
- c.conn.SetPongHandler(func(string) error {
- _ = c.conn.SetReadDeadline(time.Now().Add(pongWait))
- return nil
- })
-
for {
- select {
- case <-ctx.Done():
- return
- default:
- // We ignore application messages; reads are only for control frames (close/pong).
- if _, _, err := c.conn.ReadMessage(); err != nil {
- if !isExpectedCloseError(err) {
- slog.Debug("websocket readPump end", "err", err)
- }
- return
+ // We ignore application messages; this read loop exists to notice the
+ // peer going away and to service control frames (close/pong).
+ if _, _, err := c.conn.Read(ctx); err != nil {
+ if !isExpectedCloseError(err) {
+ slog.Debug("websocket readPump end", "err", err)
}
+ return
}
}
}
@@ -118,12 +107,14 @@ func (c *Client) writePump(ctx context.Context, hub *Hub) {
case <-ctx.Done():
return
case msg, ok := <-c.send:
- _ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
if !ok {
- _ = c.conn.WriteMessage(websocket.CloseMessage, []byte{})
+ _ = c.conn.Close(websocket.StatusNormalClosure, "")
return
}
- if err := c.conn.WriteMessage(websocket.TextMessage, msg); err != nil {
+ wctx, cancel := context.WithTimeout(ctx, writeWait)
+ err := c.conn.Write(wctx, websocket.MessageText, msg)
+ cancel()
+ if err != nil {
if !isExpectedCloseError(err) {
slog.Debug("websocket write error", "err", err)
}
@@ -135,8 +126,12 @@ func (c *Client) writePump(ctx context.Context, hub *Hub) {
return
default:
}
- _ = c.conn.SetWriteDeadline(time.Now().Add(pingWriteWait))
- if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+ // Ping round-trips: it fails within writeWait unless the peer pongs,
+ // which readPump services. A failed ping tears the client down.
+ pctx, cancel := context.WithTimeout(ctx, writeWait)
+ err := c.conn.Ping(pctx)
+ cancel()
+ if err != nil {
return
}
pingTimer.Reset(pingPeriod)
@@ -149,10 +144,11 @@ func isExpectedCloseError(err error) bool {
return true
}
- if websocket.IsCloseError(err,
- websocket.CloseNormalClosure,
- websocket.CloseGoingAway,
- websocket.CloseNoStatusReceived) {
+ if IsExpectedClose(err) {
+ return true
+ }
+
+ if errors.Is(err, io.EOF) || errors.Is(err, net.ErrClosed) || errors.Is(err, context.Canceled) {
return true
}
diff --git a/backend/pkg/libarcane/ws/client_test.go b/backend/pkg/libarcane/ws/client_test.go
index 00cdb20fc..d98a1d5ca 100644
--- a/backend/pkg/libarcane/ws/client_test.go
+++ b/backend/pkg/libarcane/ws/client_test.go
@@ -10,7 +10,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -33,9 +33,8 @@ func TestServeClient_ReceivesBroadcast(t *testing.T) {
// Set up a test WS server that upgrades and serves the client
serverReady := make(chan struct{})
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -45,13 +44,10 @@ func TestServeClient_ReceivesBroadcast(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
<-serverReady
@@ -65,8 +61,9 @@ func TestServeClient_ReceivesBroadcast(t *testing.T) {
h.Broadcast([]byte("test message"))
// Client should receive it
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, msg, err := clientConn.ReadMessage()
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ defer readCancel()
+ _, msg, err := clientConn.Read(readCtx)
require.NoError(t, err)
assert.Equal(t, "test message", string(msg))
}
@@ -76,9 +73,8 @@ func TestServeClient_ClientDisconnect(t *testing.T) {
ctx := t.Context()
go h.Run(ctx)
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -87,18 +83,15 @@ func TestServeClient_ClientDisconnect(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
require.Eventually(t, func() bool {
return h.ClientCount() == 1
}, time.Second, 5*time.Millisecond)
// Close the client connection
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
// The hub should eventually remove the client
require.Eventually(t, func() bool {
@@ -113,9 +106,8 @@ func TestServeClient_ContextCancellation(t *testing.T) {
clientCtx, clientCancel := context.WithCancel(context.Background())
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -124,13 +116,10 @@ func TestServeClient_ContextCancellation(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
require.Eventually(t, func() bool {
@@ -159,17 +148,17 @@ func TestIsExpectedCloseError(t *testing.T) {
},
{
name: "normal closure",
- err: &websocket.CloseError{Code: websocket.CloseNormalClosure},
+ err: websocket.CloseError{Code: websocket.StatusNormalClosure},
expected: true,
},
{
name: "going away",
- err: &websocket.CloseError{Code: websocket.CloseGoingAway},
+ err: websocket.CloseError{Code: websocket.StatusGoingAway},
expected: true,
},
{
name: "no status received",
- err: &websocket.CloseError{Code: websocket.CloseNoStatusReceived},
+ err: websocket.CloseError{Code: websocket.StatusNoStatusRcvd},
expected: true,
},
{
@@ -194,7 +183,7 @@ func TestIsExpectedCloseError(t *testing.T) {
},
{
name: "protocol error",
- err: &websocket.CloseError{Code: websocket.CloseProtocolError},
+ err: websocket.CloseError{Code: websocket.StatusProtocolError},
expected: false,
},
}
@@ -213,9 +202,8 @@ func TestServeClient_MultipleMessages(t *testing.T) {
go h.Run(ctx)
serverReady := make(chan struct{})
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -225,13 +213,10 @@ func TestServeClient_MultipleMessages(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
<-serverReady
@@ -246,9 +231,10 @@ func TestServeClient_MultipleMessages(t *testing.T) {
h.Broadcast([]byte(m))
}
- _ = clientConn.SetReadDeadline(time.Now().Add(5 * time.Second))
+ readCtx, readCancel := context.WithTimeout(t.Context(), 5*time.Second)
+ defer readCancel()
for _, expected := range messages {
- _, msg, err := clientConn.ReadMessage()
+ _, msg, err := clientConn.Read(readCtx)
require.NoError(t, err)
assert.Equal(t, expected, string(msg))
}
diff --git a/backend/pkg/libarcane/ws/cpu_regression_test.go b/backend/pkg/libarcane/ws/cpu_regression_test.go
index de0250cc2..a407174b7 100644
--- a/backend/pkg/libarcane/ws/cpu_regression_test.go
+++ b/backend/pkg/libarcane/ws/cpu_regression_test.go
@@ -11,7 +11,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/stretchr/testify/require"
)
@@ -54,6 +54,14 @@ func startStatsHubPipeline(ctx context.Context, hub *Hub) {
}()
}
+// readOneWithTimeout reads a single message with a timeout, discarding the payload.
+func readOneWithTimeout(conn *websocket.Conn, timeout time.Duration) error {
+ readCtx, cancel := context.WithTimeout(context.Background(), timeout)
+ defer cancel()
+ _, _, err := conn.Read(readCtx)
+ return err
+}
+
// ============================================================================
// CPU Regression Benchmarks
//
@@ -79,10 +87,8 @@ func startStatsHubPipeline(ctx context.Context, hub *Hub) {
// A healthy result shows constant goroutine count and stable allocations.
// A regression shows goroutine count growing linearly with iterations.
func BenchmarkCPU_PageReloadSimulation(b *testing.B) {
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
-
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -105,18 +111,14 @@ func BenchmarkCPU_PageReloadSimulation(b *testing.B) {
b.ResetTimer()
for i := range b.N {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(b.Context(), url, nil)
if err != nil {
b.Fatal(err)
}
- if resp != nil {
- require.NoError(b, resp.Body.Close())
- }
// Read one message to exercise the pipeline
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, _ = conn.ReadMessage()
- require.NoError(b, conn.Close())
+ _ = readOneWithTimeout(conn, 2*time.Second)
+ _ = conn.CloseNow()
// Brief settle for cleanup
time.Sleep(50 * time.Millisecond)
@@ -141,10 +143,8 @@ func BenchmarkCPU_PageReloadSimulation(b *testing.B) {
// BenchmarkCPU_ContainerLogReloadSimulation simulates reloading a container
// logs page with JSON batched output (the most complex pipeline).
func BenchmarkCPU_ContainerLogReloadSimulation(b *testing.B) {
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
-
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -198,17 +198,13 @@ func BenchmarkCPU_ContainerLogReloadSimulation(b *testing.B) {
b.ResetTimer()
for i := range b.N {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(b.Context(), url, nil)
if err != nil {
b.Fatal(err)
}
- if resp != nil {
- require.NoError(b, resp.Body.Close())
- }
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, _ = conn.ReadMessage()
- require.NoError(b, conn.Close())
+ _ = readOneWithTimeout(conn, 2*time.Second)
+ _ = conn.CloseNow()
time.Sleep(50 * time.Millisecond)
if (i+1)%10 == 0 || i == b.N-1 {
current := runtime.NumGoroutine()
@@ -228,10 +224,8 @@ func BenchmarkCPU_ContainerLogReloadSimulation(b *testing.B) {
func BenchmarkCPU_GoroutineScaling(b *testing.B) {
for _, concurrency := range []int{1, 5, 10, 20} {
b.Run(fmt.Sprintf("concurrent_%d", concurrency), func(b *testing.B) {
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
-
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -257,24 +251,20 @@ func BenchmarkCPU_GoroutineScaling(b *testing.B) {
// Open `concurrency` connections simultaneously
conns := make([]*websocket.Conn, concurrency)
for j := range concurrency {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(b.Context(), url, nil)
if err != nil {
b.Fatal(err)
}
- if resp != nil {
- require.NoError(b, resp.Body.Close())
- }
conns[j] = conn
}
for _, c := range conns {
- _ = c.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, _ = c.ReadMessage()
+ _ = readOneWithTimeout(c, 2*time.Second)
}
// Close all
for _, conn := range conns {
- require.NoError(b, conn.Close())
+ _ = conn.CloseNow()
}
time.Sleep(100 * time.Millisecond)
@@ -294,9 +284,8 @@ func BenchmarkCPU_GoroutineScaling(b *testing.B) {
// an active streaming connection over time. This catches CPU drift from
// inefficient polling or tight loops.
func BenchmarkCPU_SustainedStreaming(b *testing.B) {
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -312,20 +301,16 @@ func BenchmarkCPU_SustainedStreaming(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(b.Context(), url, nil)
if err != nil {
b.Fatal(err)
}
- if resp != nil {
- require.NoError(b, resp.Body.Close())
- }
for range 10 {
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- if _, _, err := conn.ReadMessage(); err != nil {
+ if err := readOneWithTimeout(conn, 2*time.Second); err != nil {
break
}
}
- require.NoError(b, conn.Close())
+ _ = conn.CloseNow()
time.Sleep(50 * time.Millisecond)
}
}
@@ -338,9 +323,8 @@ func TestCPU_GoroutineCountReport(t *testing.T) {
baseline := runtime.NumGoroutine()
t.Logf("baseline goroutines: %d", baseline)
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -356,14 +340,10 @@ func TestCPU_GoroutineCountReport(t *testing.T) {
peakGoroutines := baseline
for i := range 30 {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, _ = conn.ReadMessage()
- require.NoError(t, conn.Close())
+ _ = readOneWithTimeout(conn, 2*time.Second)
+ _ = conn.CloseNow()
time.Sleep(50 * time.Millisecond)
current := runtime.NumGoroutine()
if current > peakGoroutines {
diff --git a/backend/pkg/libarcane/ws/goroutine_leak_test.go b/backend/pkg/libarcane/ws/goroutine_leak_test.go
index 77c95bb33..f20184d9f 100644
--- a/backend/pkg/libarcane/ws/goroutine_leak_test.go
+++ b/backend/pkg/libarcane/ws/goroutine_leak_test.go
@@ -10,7 +10,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -131,9 +131,8 @@ func TestLeak_ServeClientFullLifecycle(t *testing.T) {
go h.Run(ctx)
// Set up WebSocket server that calls ServeClient (mirrors ws_handler.go pattern)
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -143,11 +142,8 @@ func TestLeak_ServeClientFullLifecycle(t *testing.T) {
// Connect a client
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
require.Eventually(t, func() bool {
return h.ClientCount() == 1
@@ -159,7 +155,7 @@ func TestLeak_ServeClientFullLifecycle(t *testing.T) {
assert.Greater(t, midpoint, baseline, "should have active goroutines while connected")
// Client disconnects (simulates browser close/reload)
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
require.Eventually(t, func() bool {
return h.ClientCount() == 0
@@ -187,9 +183,8 @@ func TestLeak_OnEmptyCallbackCancelsContext(t *testing.T) {
go h.Run(ctx)
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -198,18 +193,15 @@ func TestLeak_OnEmptyCallbackCancelsContext(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
require.Eventually(t, func() bool {
return h.ClientCount() == 1
}, time.Second, 5*time.Millisecond)
// Close client -> triggers safeRemove -> hub.remove -> OnEmpty -> cancel()
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
// Hub.Run should exit because OnEmpty called cancel()
actual := waitForGoroutineCount(t, baseline, 3, 5*time.Second)
@@ -224,10 +216,8 @@ func TestLeak_OnEmptyCallbackCancelsContext(t *testing.T) {
func TestLeak_RepeatedConnectDisconnect(t *testing.T) {
baseline := goroutineCount()
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
-
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -243,17 +233,14 @@ func TestLeak_RepeatedConnectDisconnect(t *testing.T) {
url := "ws" + strings.TrimPrefix(server.URL, "http")
for i := range iterations {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err, "iteration %d", i)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
// Brief moment to let registration happen
time.Sleep(10 * time.Millisecond)
// Close (simulates page reload)
- require.NoError(t, conn.Close())
+ _ = conn.CloseNow()
// Brief moment for cleanup
time.Sleep(20 * time.Millisecond)
@@ -283,10 +270,8 @@ func TestLeak_RepeatedConnectDisconnect(t *testing.T) {
func TestLeak_HubWithForwardLinesLifecycle(t *testing.T) {
baseline := goroutineCount()
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
-
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { //nolint:contextcheck // intentional: context must outlive the HTTP request for WebSocket streaming
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -318,19 +303,17 @@ func TestLeak_HubWithForwardLinesLifecycle(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
// Read a few messages to confirm the pipeline works
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, err = clientConn.ReadMessage()
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ _, _, err = clientConn.Read(readCtx)
+ readCancel()
require.NoError(t, err)
// Close client -> OnEmpty -> cancel() -> all goroutines should exit
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
actual := waitForGoroutineCount(t, baseline, 3, 5*time.Second)
assert.LessOrEqual(t, actual, baseline+3,
@@ -343,10 +326,8 @@ func TestLeak_HubWithForwardLinesLifecycle(t *testing.T) {
func TestLeak_HubWithForwardLogJSONBatchedLifecycle(t *testing.T) {
baseline := goroutineCount()
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
-
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { //nolint:contextcheck // intentional: context must outlive the HTTP request for WebSocket streaming
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -398,15 +379,13 @@ func TestLeak_HubWithForwardLogJSONBatchedLifecycle(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
// Read a message to confirm the full pipeline works
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, raw, err := clientConn.ReadMessage()
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ _, raw, err := clientConn.Read(readCtx)
+ readCancel()
require.NoError(t, err)
// Should be a JSON array (batched)
@@ -415,7 +394,7 @@ func TestLeak_HubWithForwardLogJSONBatchedLifecycle(t *testing.T) {
assert.NotEmpty(t, batch)
// Disconnect
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
actual := waitForGoroutineCount(t, baseline, 3, 5*time.Second)
assert.LessOrEqual(t, actual, baseline+3,
@@ -503,10 +482,9 @@ func startStatsHubRepeatedTest(ctx context.Context, hub *Hub) {
// Hub.Run + stats producer + JSON broadcaster + ServeClient.
func TestLeak_ContainerStatsHubPattern(t *testing.T) {
baseline := goroutineCount()
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { //nolint:contextcheck // intentional: context must outlive the HTTP request for WebSocket streaming
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -520,17 +498,15 @@ func TestLeak_ContainerStatsHubPattern(t *testing.T) {
defer server.Close()
url := "ws" + strings.TrimPrefix(server.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, raw, err := clientConn.ReadMessage()
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ _, raw, err := clientConn.Read(readCtx)
+ readCancel()
require.NoError(t, err)
var stats map[string]any
require.NoError(t, json.Unmarshal(raw, &stats))
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
actual := waitForGoroutineCount(t, baseline, 3, 5*time.Second)
assert.LessOrEqual(t, actual, baseline+3,
@@ -541,10 +517,9 @@ func TestLeak_ContainerStatsHubPattern(t *testing.T) {
// "Go to the container page. Reload the page 20/30 times."
func TestLeak_RepeatedStatsHubCycles(t *testing.T) {
baseline := goroutineCount()
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -560,15 +535,13 @@ func TestLeak_RepeatedStatsHubCycles(t *testing.T) {
const iterations = 100
url := "ws" + strings.TrimPrefix(server.URL, "http")
for i := range iterations {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err, "iteration %d", i)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
- _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, _, _ = conn.ReadMessage()
- require.NoError(t, conn.Close())
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ _, _, _ = conn.Read(readCtx)
+ readCancel()
+ _ = conn.CloseNow()
time.Sleep(30 * time.Millisecond)
}
@@ -604,9 +577,8 @@ func TestLeak_MultipleClientsOnSameHub(t *testing.T) {
go h.Run(ctx)
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -619,11 +591,8 @@ func TestLeak_MultipleClientsOnSameHub(t *testing.T) {
var clients []*websocket.Conn
for range numClients {
- conn, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ conn, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
clients = append(clients, conn)
}
@@ -633,7 +602,7 @@ func TestLeak_MultipleClientsOnSameHub(t *testing.T) {
// Close all clients
for _, c := range clients {
- require.NoError(t, c.Close())
+ _ = c.CloseNow()
}
// OnEmpty should fire after last client leaves, cancelling context
diff --git a/backend/pkg/libarcane/ws/hub.go b/backend/pkg/libarcane/ws/hub.go
index 49663411e..35f02bfcc 100644
--- a/backend/pkg/libarcane/ws/hub.go
+++ b/backend/pkg/libarcane/ws/hub.go
@@ -132,7 +132,7 @@ func (h *Hub) remove(c *Client) {
if exists {
delete(h.clients, c)
close(c.send)
- _ = c.conn.Close()
+ _ = c.conn.CloseNow()
}
// Capture onEmpty under the lock so we can call it outside.
var onEmpty func()
@@ -152,7 +152,7 @@ func (h *Hub) closeAll() {
h.mu.Lock()
for c := range h.clients {
close(c.send)
- _ = c.conn.Close()
+ _ = c.conn.CloseNow()
delete(h.clients, c)
}
h.mu.Unlock()
diff --git a/backend/pkg/libarcane/ws/hub_test.go b/backend/pkg/libarcane/ws/hub_test.go
index 7c2483617..1151169a6 100644
--- a/backend/pkg/libarcane/ws/hub_test.go
+++ b/backend/pkg/libarcane/ws/hub_test.go
@@ -3,9 +3,7 @@ package ws
import (
"bytes"
"context"
- "errors"
"log/slog"
- "net"
"net/http"
"net/http/httptest"
"strings"
@@ -14,7 +12,7 @@ import (
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -24,9 +22,8 @@ func newTestWSPair(t *testing.T) (clientConn *websocket.Conn, serverConn *websoc
t.Helper()
serverReady := make(chan *websocket.Conn, 1)
- upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- conn, err := upgrader.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
@@ -34,21 +31,16 @@ func newTestWSPair(t *testing.T) (clientConn *websocket.Conn, serverConn *websoc
}))
url := "ws" + strings.TrimPrefix(server.URL, "http")
- cc, resp, err := websocket.DefaultDialer.Dial(url, nil)
+ cc, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
sc := <-serverReady
return cc, sc, func() {
- require.NoError(t, cc.Close())
+ _ = cc.CloseNow()
// The hub and the forwarders own the server side and may already have
- // closed it, so only an unexpected failure is worth reporting.
- if err := sc.Close(); err != nil && !errors.Is(err, net.ErrClosed) {
- t.Errorf("close server websocket connection: %v", err)
- }
+ // closed it, so close errors here are expected.
+ _ = sc.CloseNow()
server.Close()
}
}
diff --git a/backend/pkg/libarcane/ws/proxy.go b/backend/pkg/libarcane/ws/proxy.go
index cb31efe03..4ae6efc76 100644
--- a/backend/pkg/libarcane/ws/proxy.go
+++ b/backend/pkg/libarcane/ws/proxy.go
@@ -1,21 +1,16 @@
package ws
import (
+ "context"
"io"
"log/slog"
"net/http"
"time"
"emperror.dev/errors"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
)
-var upgrader = websocket.Upgrader{
- ReadBufferSize: 32 * 1024,
- WriteBufferSize: 32 * 1024,
- EnableCompression: true,
-}
-
// ProxyHTTP upgrades the incoming client connection and bridges it to remoteWS.
//
// checkOrigin must be the same Origin validator the local WebSocket endpoints
@@ -27,25 +22,24 @@ func ProxyHTTP(w http.ResponseWriter, r *http.Request, remoteWS string, header h
return errors.New("websocket proxy requires an origin validator")
}
- proxyUpgrader := upgrader
- proxyUpgrader.CheckOrigin = checkOrigin
-
- clientConn, err := proxyUpgrader.Upgrade(w, r, nil)
+ clientConn, err := Accept(w, r, checkOrigin)
if err != nil {
slog.Error("failed to upgrade client connection", "remoteWS", remoteWS, "err", err)
return err
}
- defer func() { _ = clientConn.Close() }()
-
- dialer := websocket.Dialer{
- Proxy: http.ProxyFromEnvironment,
- HandshakeTimeout: 45 * time.Second,
- }
+ defer func() { _ = clientConn.CloseNow() }()
+ // This is a pure bridge; frame-size policing is the remote endpoint's job.
+ clientConn.SetReadLimit(-1)
slog.Debug("attempting websocket dial", "remoteWS", remoteWS, "headers", header)
- remoteConn, resp, err := dialer.Dial(remoteWS, header)
+ dialCtx, dialCancel := context.WithTimeout(r.Context(), 45*time.Second)
+ remoteConn, resp, err := websocket.Dial(dialCtx, remoteWS, &websocket.DialOptions{
+ HTTPHeader: header,
+ HTTPClient: &http.Client{Transport: &http.Transport{Proxy: http.ProxyFromEnvironment}},
+ })
+ dialCancel()
// Ensure the response body is drained & closed to avoid leaking resources.
- if resp != nil {
+ if resp != nil && resp.Body != nil {
_, _ = io.Copy(io.Discard, resp.Body)
_ = resp.Body.Close()
}
@@ -56,24 +50,30 @@ func ProxyHTTP(w http.ResponseWriter, r *http.Request, remoteWS string, header h
}
return 0
}())
- _ = clientConn.WriteMessage(websocket.CloseMessage, []byte{})
+ _ = clientConn.Close(websocket.StatusBadGateway, "")
return err
}
- defer func() { _ = remoteConn.Close() }()
+ defer func() { _ = remoteConn.CloseNow() }()
+ remoteConn.SetReadLimit(-1)
slog.Debug("websocket proxy established", "remoteWS", remoteWS)
+ // When either pump ends, the handler returns and the deferred CloseNow
+ // calls unblock the other pump.
+ pumpCtx, pumpCancel := context.WithCancel(r.Context())
+ defer pumpCancel()
+
errc := make(chan struct{}, 2)
// client -> remote
go func() {
defer func() { errc <- struct{}{} }()
for {
- mt, msg, err := clientConn.ReadMessage()
+ mt, msg, err := clientConn.Read(pumpCtx)
if err != nil {
return
}
- if err := remoteConn.WriteMessage(mt, msg); err != nil {
+ if err := remoteConn.Write(pumpCtx, mt, msg); err != nil {
return
}
}
@@ -83,11 +83,11 @@ func ProxyHTTP(w http.ResponseWriter, r *http.Request, remoteWS string, header h
go func() {
defer func() { errc <- struct{}{} }()
for {
- mt, msg, err := remoteConn.ReadMessage()
+ mt, msg, err := remoteConn.Read(pumpCtx)
if err != nil {
return
}
- if err := clientConn.WriteMessage(mt, msg); err != nil {
+ if err := clientConn.Write(pumpCtx, mt, msg); err != nil {
return
}
}
diff --git a/backend/pkg/libarcane/ws/proxy_test.go b/backend/pkg/libarcane/ws/proxy_test.go
index 12018429c..fa0310e59 100644
--- a/backend/pkg/libarcane/ws/proxy_test.go
+++ b/backend/pkg/libarcane/ws/proxy_test.go
@@ -1,13 +1,14 @@
package ws
import (
+ "context"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
- "github.com/gorilla/websocket"
+ "github.com/coder/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -24,24 +25,19 @@ func TestProxyHTTP_RequiresOriginValidator(t *testing.T) {
func TestProxyHTTP_BidirectionalMessages(t *testing.T) {
// 1. Create a "remote" WebSocket server that echoes messages
remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- up := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
- conn, err := up.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() {
- if err := conn.Close(); err != nil {
- t.Logf("close websocket connection: %v", err)
- }
- }()
+ defer func() { _ = conn.CloseNow() }()
for {
- mt, msg, err := conn.ReadMessage()
+ mt, msg, err := conn.Read(r.Context())
if err != nil {
return
}
// Echo with prefix
- if err := conn.WriteMessage(mt, append([]byte("echo:"), msg...)); err != nil {
+ if err := conn.Write(r.Context(), mt, append([]byte("echo:"), msg...)); err != nil {
return
}
}
@@ -58,23 +54,21 @@ func TestProxyHTTP_BidirectionalMessages(t *testing.T) {
// 3. Connect a client to the proxy
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
// 4. Send messages and verify they get proxied and echoed
testMessages := []string{"hello", "world", "test123"}
for _, msg := range testMessages {
- err := clientConn.WriteMessage(websocket.TextMessage, []byte(msg))
+ err := clientConn.Write(t.Context(), websocket.MessageText, []byte(msg))
require.NoError(t, err)
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- _, received, err := clientConn.ReadMessage()
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ _, received, err := clientConn.Read(readCtx)
+ readCancel()
require.NoError(t, err)
assert.Equal(t, "echo:"+msg, string(received))
}
@@ -83,15 +77,12 @@ func TestProxyHTTP_BidirectionalMessages(t *testing.T) {
func TestProxyHTTP_RemoteClose(t *testing.T) {
// Remote server that closes immediately after upgrade
remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- up := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
- conn, err := up.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
// Close immediately
- _ = conn.WriteMessage(websocket.CloseMessage,
- websocket.FormatCloseMessage(websocket.CloseNormalClosure, "bye"))
- if err := conn.Close(); err != nil {
+ if err := conn.Close(websocket.StatusNormalClosure, "bye"); err != nil {
t.Logf("close websocket connection: %v", err)
}
}))
@@ -106,13 +97,10 @@ func TestProxyHTTP_RemoteClose(t *testing.T) {
defer proxyServer.Close()
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
// The proxy should complete (not hang)
@@ -132,13 +120,10 @@ func TestProxyHTTP_InvalidRemoteURL(t *testing.T) {
defer proxyServer.Close()
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
select {
@@ -152,23 +137,18 @@ func TestProxyHTTP_InvalidRemoteURL(t *testing.T) {
func TestProxyHTTP_BinaryMessages(t *testing.T) {
// Remote server that echoes binary messages
remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- up := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
- conn, err := up.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- defer func() {
- if err := conn.Close(); err != nil {
- t.Logf("close websocket connection: %v", err)
- }
- }()
+ defer func() { _ = conn.CloseNow() }()
for {
- mt, msg, err := conn.ReadMessage()
+ mt, msg, err := conn.Read(r.Context())
if err != nil {
return
}
- if err := conn.WriteMessage(mt, msg); err != nil {
+ if err := conn.Write(r.Context(), mt, msg); err != nil {
return
}
}
@@ -183,23 +163,21 @@ func TestProxyHTTP_BinaryMessages(t *testing.T) {
defer proxyServer.Close()
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
binaryData := []byte{0x00, 0x01, 0x02, 0xFF, 0xFE, 0xFD}
- err = clientConn.WriteMessage(websocket.BinaryMessage, binaryData)
+ err = clientConn.Write(t.Context(), websocket.MessageBinary, binaryData)
require.NoError(t, err)
- _ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
- mt, received, err := clientConn.ReadMessage()
+ readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
+ defer readCancel()
+ mt, received, err := clientConn.Read(readCtx)
require.NoError(t, err)
- assert.Equal(t, websocket.BinaryMessage, mt)
+ assert.Equal(t, websocket.MessageBinary, mt)
assert.Equal(t, binaryData, received)
}
@@ -207,14 +185,11 @@ func TestProxyHTTP_HeadersForwarded(t *testing.T) {
headersCh := make(chan http.Header, 1)
remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
headersCh <- r.Header.Clone()
- up := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
- conn, err := up.Upgrade(w, r, nil)
+ conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
- if err := conn.Close(); err != nil {
- t.Logf("close websocket connection: %v", err)
- }
+ _ = conn.CloseNow()
}))
defer remoteServer.Close()
@@ -231,13 +206,10 @@ func TestProxyHTTP_HeadersForwarded(t *testing.T) {
defer proxyServer.Close()
proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
- clientConn, resp, err := websocket.DefaultDialer.Dial(proxyURL, nil)
+ clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
require.NoError(t, err)
- if resp != nil {
- require.NoError(t, resp.Body.Close())
- }
defer func() {
- require.NoError(t, clientConn.Close())
+ _ = clientConn.CloseNow()
}()
select {
diff --git a/backend/pkg/projects/custom_labels.go b/backend/pkg/projects/custom_labels.go
index 5c17accf0..7ddb06124 100644
--- a/backend/pkg/projects/custom_labels.go
+++ b/backend/pkg/projects/custom_labels.go
@@ -54,7 +54,7 @@ func ParseArcaneComposeMetadata(ctx context.Context, composeFilePath, projectsDi
workdir := filepath.Dir(composeFilePath)
if strings.TrimSpace(projectsDirectory) == "" {
envMap := loadComposeEnvironment(workdir)
- return ParseArcaneComposeMetadataWithEnv(ctx, composeFilePath, envMap)
+ return parseArcaneComposeMetadataFromFileInternal(ctx, composeFilePath, envMap, map[string]struct{}{})
}
envLoader := NewEnvLoader(projectsDirectory, workdir, autoInjectEnv)
@@ -63,11 +63,6 @@ func ParseArcaneComposeMetadata(ctx context.Context, composeFilePath, projectsDi
return emptyArcaneComposeMetadataInternal(), errors.WrapIf(err, "load project environment")
}
- return ParseArcaneComposeMetadataWithEnv(ctx, composeFilePath, envMap)
-}
-
-// ParseArcaneComposeMetadataWithEnv reads a Docker Compose file and extracts Arcane-specific metadata using a provided environment.
-func ParseArcaneComposeMetadataWithEnv(ctx context.Context, composeFilePath string, envMap map[string]string) (ArcaneComposeMetadata, error) {
return parseArcaneComposeMetadataFromFileInternal(ctx, composeFilePath, envMap, map[string]struct{}{})
}
@@ -202,7 +197,7 @@ func emptyArcaneComposeMetadataInternal() ArcaneComposeMetadata {
}
func loadComposeProjectForMetadataFromFileInternal(ctx context.Context, composeFilePath string, envMap map[string]string) (*composetypes.Project, error) {
- return loadComposeProjectInternal(ctx, composeFilePath, "", "", false, nil, envMap, func(opts *loader.Options) {
+ return LoadComposeProject(ctx, composeFilePath, "", "", false, nil, envMap, func(opts *loader.Options) {
opts.SkipValidation = true
opts.SkipConsistencyCheck = true
opts.SkipResolveEnvironment = false
diff --git a/backend/pkg/projects/env.go b/backend/pkg/projects/env.go
index 5b4eaf9a0..e950b4625 100644
--- a/backend/pkg/projects/env.go
+++ b/backend/pkg/projects/env.go
@@ -4,7 +4,6 @@ import (
"context"
"crypto/sha256"
"encoding/hex"
- "io"
"log/slog"
"maps"
"os"
@@ -244,12 +243,11 @@ func cloneEnvMapInternal(src EnvMap) EnvMap {
}
func parseProjectEnvFileExistingInternal(path string, contextEnv EnvMap) (EnvMap, error) {
- f, err := os.Open(path)
+ content, err := os.ReadFile(path)
if err != nil {
- return nil, errors.WrapIf(err, "open file")
+ return nil, errors.WrapIf(err, "read file")
}
- defer func() { _ = f.Close() }()
- return parseEnvWithContext(f, contextEnv)
+ return ParseProjectEnvContent(string(content), contextEnv)
}
// ParseProjectEnvFile parses a project .env file with variable expansion using the provided
@@ -262,9 +260,23 @@ func ParseProjectEnvFile(path string, contextEnv EnvMap) (EnvMap, error) {
return parseProjectEnvFileExistingInternal(path, contextEnv)
}
-// ParseProjectEnvContent parses project .env content from a string with variable expansion.
+// ParseProjectEnvContent parses project .env content from a string using
+// compose-go's dotenv parser with variable expansion. Lookups check contextEnv
+// first (previously loaded vars), then the process environment.
func ParseProjectEnvContent(content string, contextEnv EnvMap) (EnvMap, error) {
- return parseEnvWithContext(strings.NewReader(content), contextEnv)
+ lookupFn := func(key string) (string, bool) {
+ if val, ok := contextEnv[key]; ok {
+ return val, true
+ }
+ return os.LookupEnv(key)
+ }
+
+ envMap, err := dotenv.ParseWithLookup(strings.NewReader(content), lookupFn)
+ if err != nil {
+ return nil, errors.WrapIf(err, "parse env")
+ }
+
+ return envMap, nil
}
// WithTransientValidationEnvFile temporarily writes a project .env file while
@@ -295,7 +307,7 @@ func WithTransientValidationEnvFile(projectPath string, effectiveEnvContent *str
if effectiveEnvContent != nil {
content = *effectiveEnvContent
}
- if writeErr := WriteEnvFile(projectPath, projectPath, content); writeErr != nil {
+ if writeErr := WriteProjectFile(projectPath, projectPath, ".env", content); writeErr != nil {
return errors.WrapIf(writeErr, "prepare env file for compose validation")
}
@@ -303,7 +315,7 @@ func WithTransientValidationEnvFile(projectPath string, effectiveEnvContent *str
var restoreErr error
switch {
case originalExists:
- restoreErr = WriteEnvFile(projectPath, projectPath, string(originalContent))
+ restoreErr = WriteProjectFile(projectPath, projectPath, ".env", string(originalContent))
case effectiveEnvContent != nil:
restoreErr = os.Remove(envPath)
default:
@@ -355,13 +367,6 @@ func BuildEffectiveEnvContent(gitContent, overrideContent string) (string, error
}
}
-// BuildOverrideEnvContent derives the editable override file from git-backed and
-// effective env content. Content that already contains only real overrides is
-// returned verbatim; derived or cleaned output uses Arcane's canonical format.
-func BuildOverrideEnvContent(gitContent, effectiveContent string) (string, error) {
- return buildOverrideEnvContentInternal(gitContent, effectiveContent)
-}
-
// BuildAdditiveOverrideEnvContent derives override content from a pre-git local
// .env file. Like other generated env helpers, the result is normalized and does
// not preserve comments or original key ordering.
@@ -389,7 +394,10 @@ func BuildAdditiveOverrideEnvContent(gitContent, localContent string) (string, e
return formatEnvMapInternal(override), nil
}
-func buildOverrideEnvContentInternal(gitContent, effectiveContent string) (string, error) {
+// BuildOverrideEnvContent derives the editable override file from git-backed and
+// effective env content. Content that already contains only real overrides is
+// returned verbatim; derived or cleaned output uses Arcane's canonical format.
+func BuildOverrideEnvContent(gitContent, effectiveContent string) (string, error) {
contextEnv := make(EnvMap)
gitEnv, err := ParseProjectEnvContent(gitContent, contextEnv)
@@ -500,7 +508,7 @@ func WriteManagedEnvFile(projectsDirectory, projectPath, fileName string, unread
switch fileName {
case EffectiveEnvFileName:
- return WriteEnvFile(projectsDirectory, projectPath, content)
+ return WriteProjectFile(projectsDirectory, projectPath, ".env", content)
case GitSourceEnvFileName:
return WriteProjectFile(projectsDirectory, projectPath, GitSourceEnvFileName, content)
case OverrideEnvFileName:
@@ -513,27 +521,6 @@ func WriteManagedEnvFile(projectsDirectory, projectPath, fileName string, unread
}
}
-// parseEnvWithContext parses environment variables from an io.Reader using compose-go's
-// dotenv parser with variable expansion using the provided context lookup map.
-func parseEnvWithContext(r io.Reader, contextEnv EnvMap) (EnvMap, error) {
- // Create lookup function for variable expansion
- // Checks contextEnv first (previously loaded vars), then process environment
- lookupFn := func(key string) (string, bool) {
- if val, ok := contextEnv[key]; ok {
- return val, true
- }
- return os.LookupEnv(key)
- }
-
- // Use compose-go's dotenv parser with lookup support for variable expansion
- envMap, err := dotenv.ParseWithLookup(r, lookupFn)
- if err != nil {
- return nil, errors.WrapIf(err, "parse env")
- }
-
- return envMap, nil
-}
-
// readOptionalProjectFileInternal reads fileName from projectPath. A missing
// file is reported via exists=false with no error. A permission error is
// reported via unreadable=true with no error: the file is present but its
diff --git a/backend/pkg/projects/fs_backup_test.go b/backend/pkg/projects/fs_backup_test.go
index 429c60307..943f2326b 100644
--- a/backend/pkg/projects/fs_backup_test.go
+++ b/backend/pkg/projects/fs_backup_test.go
@@ -52,7 +52,7 @@ func TestRestoreProjectUpdateBackup_RestoresExternalEnvSymlinkTarget(t *testing.
require.NoError(t, err)
require.NotNil(t, backup.envSymlink)
- require.NoError(t, WriteEnvFile(projectDir, projectDir, "VALUE=updated\n"))
+ require.NoError(t, WriteProjectFile(projectDir, projectDir, ".env", "VALUE=updated\n"))
require.NoError(t, RestoreProjectUpdateBackup(projectDir, backup))
restoredContent, err := os.ReadFile(targetPath)
@@ -86,7 +86,7 @@ func TestRestoreProjectUpdateBackup_RejectsRetargetedEnvSymlink(t *testing.T) {
backup, err := BackupProjectUpdateScope(projectDir, t.TempDir(), ProjectUpdateBackupScope{TopLevelFiles: true})
require.NoError(t, err)
- require.NoError(t, WriteEnvFile(projectDir, projectDir, "VALUE=updated\n"))
+ require.NoError(t, WriteProjectFile(projectDir, projectDir, ".env", "VALUE=updated\n"))
require.NoError(t, os.Remove(envPath))
require.NoError(t, os.Symlink(newTarget, envPath))
diff --git a/backend/pkg/projects/fs_templates.go b/backend/pkg/projects/fs_templates.go
index 5d947f4df..9e7bc3006 100644
--- a/backend/pkg/projects/fs_templates.go
+++ b/backend/pkg/projects/fs_templates.go
@@ -2,7 +2,6 @@ package projects
import (
"context"
- "fmt"
"os"
"path/filepath"
"regexp"
@@ -71,10 +70,6 @@ func EnsureTemplateDir(ctx context.Context, templatesDir, base string) (dir, com
return dir, composePath, envPath, nil
}
-func ImportedComposeDescription(dir string) string {
- return fmt.Sprintf("Imported from %s/compose.yaml", dir)
-}
-
func WriteTemplateFiles(composePath, envPath, composeContent, envContent string) (*string, error) {
if err := WriteTemplateFile(composePath, composeContent); err != nil {
return nil, err
diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.go
index 92bdaacbb..39dd885bf 100644
--- a/backend/pkg/projects/fs_util.go
+++ b/backend/pkg/projects/fs_util.go
@@ -145,10 +145,6 @@ func GetTemplatesDirectory(ctx context.Context, templatesDir string) (string, er
}
func ReadProjectDirectoryFiles(projectPath string, shownFiles map[string]bool, maxDepth int, skipDirectories string) ([]project.IncludeFile, error) {
- return readProjectDirectoryFilesInternal(projectPath, shownFiles, maxDepth, skipDirectories, false)
-}
-
-func readProjectDirectoryFilesInternal(projectPath string, shownFiles map[string]bool, maxDepth int, skipDirectories string, includeContent bool) ([]project.IncludeFile, error) {
if maxDepth <= 0 {
maxDepth = config.LoadProjectFilesConfig().ProjectScanMaxDepth
}
@@ -161,7 +157,7 @@ func readProjectDirectoryFilesInternal(projectPath string, shownFiles map[string
}
defer func() { _ = root.Close() }()
- err = collectProjectDirectoryFilesInternal(root, ".", projectPath, shownFiles, &dirFiles, 0, maxDepth, projectScanSkipDirectorySetInternal(skipDirectories), includeContent)
+ err = collectProjectDirectoryFilesInternal(root, ".", projectPath, shownFiles, &dirFiles, 0, maxDepth, projectScanSkipDirectorySetInternal(skipDirectories), false)
return dirFiles, err
}
@@ -403,10 +399,6 @@ func RemoveStaleComposeFiles(projectPath, composeFileName string, syncedFiles []
return nil
}
-func CopyDirectoryContents(srcDir, destDir string) error {
- return copyDirectoryContentsInternal(srcDir, destDir, nil)
-}
-
// CopyDirectoryContentsTolerant copies srcDir into destDir like
// CopyDirectoryContents, except that files (or whole subdirectories) which
// cannot be read because of a permission error are skipped instead of aborting
@@ -414,18 +406,18 @@ func CopyDirectoryContents(srcDir, destDir string) error {
// callers can avoid deleting them on a later restore. Any non-permission error
// still aborts the copy.
func CopyDirectoryContentsTolerant(srcDir, destDir string) (skipped []string, err error) {
- err = copyDirectoryContentsInternal(srcDir, destDir, func(relPath string) {
+ err = CopyDirectoryContents(srcDir, destDir, func(relPath string) {
skipped = append(skipped, relPath)
})
slices.Sort(skipped)
return skipped, err
}
-// copyDirectoryContentsInternal copies srcDir into destDir. When skipUnreadable
+// CopyDirectoryContents copies srcDir into destDir. When skipUnreadable
// is non-nil and a file or subdirectory cannot be read because of a permission
// error, the offending project-relative path is reported via skipUnreadable and
// the copy continues; otherwise the error aborts the copy.
-func copyDirectoryContentsInternal(srcDir, destDir string, skipUnreadable func(relPath string)) error {
+func CopyDirectoryContents(srcDir, destDir string, skipUnreadable func(relPath string)) error {
srcRoot, err := os.OpenRoot(srcDir)
if err != nil {
return err
@@ -515,7 +507,7 @@ func MirrorDirectoryContentsPreserving(srcDir, destDir string, preserve []string
if err := pruneDirectoryContentsInternal(srcDir, destDir, preserveSet); err != nil {
return err
}
- return CopyDirectoryContents(srcDir, destDir)
+ return CopyDirectoryContents(srcDir, destDir, nil)
}
func pruneDirectoryContentsInternal(srcDir, destDir string, preserve map[string]struct{}) error {
@@ -749,7 +741,3 @@ func ResolvePathWithinDir(baseDir, path string) (string, error) {
return resolvedPath, nil
}
-
-func SaveOrUpdateProjectFiles(projectsRoot, projectPath, composeContent string, envContent *string) error {
- return WriteProjectFiles(projectsRoot, projectPath, composeContent, envContent)
-}
diff --git a/backend/pkg/projects/fs_writer.go b/backend/pkg/projects/fs_writer.go
index d9a4bb80c..dff471044 100644
--- a/backend/pkg/projects/fs_writer.go
+++ b/backend/pkg/projects/fs_writer.go
@@ -201,12 +201,6 @@ func RemoveProjectFile(projectsRoot, dirPath, fileName string) error {
return nil
}
-// WriteEnvFile writes a .env file to the specified directory
-// projectsRoot is the allowed root directory to prevent path traversal attacks
-func WriteEnvFile(projectsRoot, dirPath, content string) error {
- return WriteProjectFile(projectsRoot, dirPath, ".env", content)
-}
-
func EnsureEnvFile(projectsRoot, dirPath string) error {
envPath := filepath.Join(dirPath, ".env")
if _, err := os.Stat(envPath); err == nil {
@@ -215,7 +209,7 @@ func EnsureEnvFile(projectsRoot, dirPath string) error {
return errors.WrapIf(err, "failed to stat env file")
}
- return WriteEnvFile(projectsRoot, dirPath, "")
+ return WriteProjectFile(projectsRoot, dirPath, ".env", "")
}
// WriteProjectFiles writes both compose and env files to a project directory.
@@ -231,7 +225,7 @@ func WriteProjectFiles(projectsRoot, dirPath, composeContent string, envContent
// We only create an empty one if it doesn't exist, to satisfy
// compose-go from failing when the compose file references env_file: .env
if envContent != nil {
- if err := WriteEnvFile(projectsRoot, dirPath, *envContent); err != nil {
+ if err := WriteProjectFile(projectsRoot, dirPath, ".env", *envContent); err != nil {
return err
}
} else {
diff --git a/backend/pkg/projects/fs_writer_test.go b/backend/pkg/projects/fs_writer_test.go
index d5ecc4ecf..4b6f73bd1 100644
--- a/backend/pkg/projects/fs_writer_test.go
+++ b/backend/pkg/projects/fs_writer_test.go
@@ -49,7 +49,7 @@ func TestWriteFilesPermissions(t *testing.T) {
pkgutils.FilePerm = 0o600
pkgutils.DirPerm = 0o700
- err := WriteEnvFile(projectsRoot, projectDir, "VAR=VAL")
+ err := WriteProjectFile(projectsRoot, projectDir, ".env", "VAR=VAL")
require.NoError(t, err)
envPath := filepath.Join(projectDir, ".env")
@@ -99,7 +99,7 @@ func TestWriteEnvFile_WritesThroughExternalSymlink(t *testing.T) {
originalLinkTarget, err := os.Readlink(envPath)
require.NoError(t, err)
- require.NoError(t, WriteEnvFile(projectsRoot, projectDir, "VALUE=new\n"))
+ require.NoError(t, WriteProjectFile(projectsRoot, projectDir, ".env", "VALUE=new\n"))
linkInfo, err := os.Lstat(envPath)
require.NoError(t, err)
@@ -130,7 +130,7 @@ func TestWriteEnvFile_DanglingSymlinkRemainsUntouched(t *testing.T) {
}
for range 2 {
- err := WriteEnvFile(projectsRoot, projectDir, "VALUE=new\n")
+ err := WriteProjectFile(projectsRoot, projectDir, ".env", "VALUE=new\n")
require.Error(t, err)
assert.Contains(t, err.Error(), "resolve env file symlink")
@@ -155,7 +155,7 @@ func TestWriteEnvFile_RejectsNonRegularSymlinkTarget(t *testing.T) {
t.Skipf("symlink creation is unavailable: %v", err)
}
- err := WriteEnvFile(projectsRoot, projectDir, "VALUE=new\n")
+ err := WriteProjectFile(projectsRoot, projectDir, ".env", "VALUE=new\n")
require.Error(t, err)
assert.Contains(t, err.Error(), "not a regular file")
linkInfo, statErr := os.Lstat(envPath)
diff --git a/backend/pkg/projects/image_refs_test.go b/backend/pkg/projects/image_refs_test.go
index 8364b5945..c2e1cb62c 100644
--- a/backend/pkg/projects/image_refs_test.go
+++ b/backend/pkg/projects/image_refs_test.go
@@ -54,7 +54,7 @@ func TestBuildImageRefsFromComposeProject_UsesMergedComposeOverrides(t *testing.
build: ./app
`), 0o644))
- project, err := LoadComposeProject(context.Background(), composePath, "override-demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "override-demo", dir, false, nil, nil, nil, false)
require.NoError(t, err)
assert.Equal(t, []string{"overridden-app:latest"}, BuildImageRefsFromComposeProject(project))
diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.go
index f2861605a..9f4164364 100644
--- a/backend/pkg/projects/load.go
+++ b/backend/pkg/projects/load.go
@@ -145,19 +145,6 @@ func DetectComposeFile(dir string) (string, error) {
}
}
-func LoadComposeProject(ctx context.Context, composeFile, projectName, projectsDirectory string, autoInjectEnv bool, pathMapper *PathMapper) (*composetypes.Project, error) {
- return loadComposeProjectInternal(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, false)
-}
-
-// LoadComposeProjectLenient loads a compose project tolerating undefined variables.
-// Instead of substituting undefined ${VAR} references with an empty string (which
-// produces invalid volume/bind specs like ":/path"), it replaces them with a
-// placeholder value so structural validation can succeed. This is useful during
-// GitSync validation where a .env file may not yet exist.
-func LoadComposeProjectLenient(ctx context.Context, composeFile, projectName, projectsDirectory string, autoInjectEnv bool, pathMapper *PathMapper) (*composetypes.Project, error) {
- return loadComposeProjectInternal(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, true)
-}
-
// LoadComposeProjectFromContent loads a Compose project from in-memory source content.
func LoadComposeProjectFromContent(ctx context.Context, opts projecttypes.ComposeContentOptions) (project *composetypes.Project, err error) {
defer recoverComposeLoadPanicInternal(ctx, "in-memory compose content", &project, &err)
@@ -240,7 +227,9 @@ func wrapTypeCastMappingLenientInternal(mapping map[tree.Path]interp.Cast) map[t
wrapped[path] = wrapCastWithLenientFallbackInternal(cast)
}
for _, section := range []string{"limits", "reservations"} {
- addIfAbsent(tree.NewPath("services", tree.PathMatchAll, "deploy", "resources", section, "cpus"), lenientCastFloatInternal)
+ addIfAbsent(tree.NewPath("services", tree.PathMatchAll, "deploy", "resources", section, "cpus"), func(value string) (any, error) {
+ return strconv.ParseFloat(value, 64)
+ })
addIfAbsent(tree.NewPath("services", tree.PathMatchAll, "deploy", "resources", section, "memory"), lenientCastSizeInternal)
}
return wrapped
@@ -259,10 +248,6 @@ func wrapCastWithLenientFallbackInternal(original interp.Cast) interp.Cast {
}
}
-func lenientCastFloatInternal(value string) (any, error) {
- return strconv.ParseFloat(value, 64)
-}
-
func lenientCastSizeInternal(value string) (any, error) {
n, err := strconv.ParseInt(value, 10, 64)
if err != nil {
@@ -326,7 +311,13 @@ func ApplyLenientLoaderOptions(ctx context.Context, opts *loader.Options, compos
}
}
-func loadComposeProjectInternal(
+// LoadComposeProject loads a compose project from composeFile. envOverride and
+// configureLoader are optional and may be nil. When lenient is true, undefined
+// ${VAR} references are tolerated: instead of substituting them with an empty
+// string (which produces invalid volume/bind specs like ":/path"), they are
+// replaced with a placeholder value so structural validation can succeed. This
+// is useful during GitSync validation where a .env file may not yet exist.
+func LoadComposeProject(
ctx context.Context,
composeFile string,
projectName string,
@@ -554,7 +545,7 @@ func LoadComposeProjectFromDir(ctx context.Context, dir, projectName, projectsDi
return nil, "", err
}
- proj, err := LoadComposeProject(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper)
+ proj, err := LoadComposeProject(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, false)
if err != nil {
return nil, "", err
}
diff --git a/backend/pkg/projects/load_test.go b/backend/pkg/projects/load_test.go
index 4605ec4de..8cf8e9fa2 100644
--- a/backend/pkg/projects/load_test.go
+++ b/backend/pkg/projects/load_test.go
@@ -150,7 +150,7 @@ func TestLoadComposeProject_MergesComposeOverrideFile(t *testing.T) {
require.NoError(t, os.WriteFile(basePath, []byte("services:\n app:\n image: nginx:alpine\n environment:\n FROM_BASE: \"1\"\n"), 0o600))
require.NoError(t, os.WriteFile(overridePath, []byte("services:\n app:\n image: busybox:latest\n environment:\n FROM_OVERRIDE: \"1\"\n"), 0o600))
- project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false)
require.NoError(t, err)
require.NotNil(t, project)
@@ -173,7 +173,7 @@ func TestLoadComposeProject_DoesNotMergeOverrideForCustomBaseName(t *testing.T)
require.NoError(t, os.WriteFile(basePath, []byte("services:\n app:\n image: nginx:alpine\n environment:\n FROM_BASE: \"1\"\n"), 0o600))
require.NoError(t, os.WriteFile(overridePath, []byte("services:\n app:\n image: busybox:latest\n environment:\n FROM_OVERRIDE: \"1\"\n"), 0o600))
- project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false)
require.NoError(t, err)
require.NotNil(t, project)
@@ -276,7 +276,7 @@ func TestLoadComposeProjectLenient_ToleratesUndefinedVariables(t *testing.T) {
- ${CONFIG_FILE}:/etc/app/app.conf
`), 0o600))
- project, err := LoadComposeProjectLenient(context.Background(), composePath, "demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true)
require.NoError(t, err)
require.NotNil(t, project)
assert.Len(t, project.Services, 1)
@@ -302,7 +302,7 @@ func TestLoadComposeProjectLenient_ToleratesUndefinedTypedFieldVariables(t *test
memory: ${MEMORY}
`), 0o600))
- project, err := LoadComposeProjectLenient(context.Background(), composePath, "demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true)
require.NoError(t, err)
require.NotNil(t, project)
assert.Len(t, project.Services, 1)
@@ -327,7 +327,7 @@ func TestLoadComposeProjectLenient_AppliesVariableDefaults(t *testing.T) {
- MAX_FILE_SIZE=${ARCANE_TEST_UNSET_SIZE:-104857600}
`), 0o600))
- project, err := LoadComposeProjectLenient(context.Background(), composePath, "demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true)
require.NoError(t, err)
require.NotNil(t, project)
require.Len(t, project.Services, 1)
@@ -356,7 +356,7 @@ services:
image: busybox:latest
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", projectDir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", projectDir, false, nil, nil, nil, false)
require.NoError(t, err)
require.NotNil(t, project)
@@ -406,7 +406,7 @@ services:
composePath := filepath.Join(projectDir, "compose.yaml")
require.NoError(t, os.WriteFile(composePath, []byte(tt.composeBody), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "aitools", projectDir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "aitools", projectDir, false, nil, nil, nil, false)
require.NoError(t, err)
require.NotNil(t, project)
require.Equal(t, tt.wantName, project.Name)
@@ -429,7 +429,7 @@ func TestResolveRelativeProjectPaths(t *testing.T) {
- ./config.conf:/etc/app/config.conf
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, false)
require.NoError(t, err)
ResolveRelativeProjectPaths(project, dir)
@@ -463,7 +463,7 @@ func TestLoadComposeProject_RemapsRelativeBindEscapingProjectsMount(t *testing.T
pathMapper := NewPathMapper(projectsRoot, "/docker/112/arcane/arcane-data/projects")
require.True(t, pathMapper.IsNonMatchingMount())
- project, err := LoadComposeProject(context.Background(), composePath, "goclaw", projectsRoot, false, pathMapper)
+ project, err := LoadComposeProject(context.Background(), composePath, "goclaw", projectsRoot, false, pathMapper, nil, nil, false)
require.NoError(t, err)
sources := make(map[string]string)
diff --git a/backend/pkg/projects/project_files.go b/backend/pkg/projects/project_files.go
index 7d172823d..52f74f140 100644
--- a/backend/pkg/projects/project_files.go
+++ b/backend/pkg/projects/project_files.go
@@ -357,7 +357,7 @@ func createManagedProjectFileInternal(root *os.Root, protected map[string]bool,
}
if err := root.MkdirAll(path.Dir(rel), pkgutils.DirPerm); err != nil {
- return mapProjectRootErrorInternal("create parent directory", err)
+ return errors.WrapIf(err, "create parent directory")
}
// O_EXCL makes the exists-check-and-create atomic; os.Root confines the
@@ -367,7 +367,7 @@ func createManagedProjectFileInternal(root *os.Root, protected map[string]bool,
if errors.Is(err, os.ErrExist) {
return errors.Errorf("project file already exists: %s", rel)
}
- return mapProjectRootErrorInternal("create project file", err)
+ return errors.WrapIf(err, "create project file")
}
_, writeErr := f.WriteString(content)
if closeErr := f.Close(); writeErr == nil {
@@ -390,10 +390,10 @@ func createManagedProjectFolderInternal(root *os.Root, protected map[string]bool
if _, err := root.Lstat(rel); err == nil {
return errors.Errorf("project folder already exists: %s", rel)
} else if !errors.Is(err, os.ErrNotExist) {
- return mapProjectRootErrorInternal("inspect project folder", err)
+ return errors.WrapIf(err, "inspect project folder")
}
if err := root.MkdirAll(rel, pkgutils.DirPerm); err != nil {
- return mapProjectRootErrorInternal("create project folder", err)
+ return errors.WrapIf(err, "create project folder")
}
return nil
}
@@ -414,7 +414,7 @@ func updateManagedProjectFileInternal(root *os.Root, protected map[string]bool,
if errors.Is(err, os.ErrNotExist) {
return errors.Errorf("project file not found: %s", rel)
}
- return mapProjectRootErrorInternal("inspect project file", err)
+ return errors.WrapIf(err, "inspect project file")
}
if info.IsDir() {
return errors.Errorf("path is a folder: %s", rel)
@@ -424,7 +424,7 @@ func updateManagedProjectFileInternal(root *os.Root, protected map[string]bool,
}
if err := root.WriteFile(rel, []byte(content), pkgutils.FilePerm); err != nil {
- return mapProjectRootErrorInternal("update project file", err)
+ return errors.WrapIf(err, "update project file")
}
return nil
}
@@ -442,7 +442,7 @@ func renameManagedProjectPathInternal(root *os.Root, protected map[string]bool,
if errors.Is(err, os.ErrNotExist) {
return errors.Errorf("project path not found: %s", rel)
}
- return mapProjectRootErrorInternal("inspect project path", err)
+ return errors.WrapIf(err, "inspect project path")
}
if info.Mode()&os.ModeSymlink != 0 {
return errors.WrapIf(ErrProjectFileSymlinkPath, "symlink paths are not supported")
@@ -458,11 +458,11 @@ func renameManagedProjectPathInternal(root *os.Root, protected map[string]bool,
if _, err := root.Lstat(targetRel); err == nil {
return errors.Errorf("project path already exists: %s", targetRel)
} else if !errors.Is(err, os.ErrNotExist) {
- return mapProjectRootErrorInternal("inspect project path", err)
+ return errors.WrapIf(err, "inspect project path")
}
if err := root.Rename(rel, targetRel); err != nil {
- return mapProjectRootErrorInternal("rename project path", err)
+ return errors.WrapIf(err, "rename project path")
}
return nil
}
@@ -497,7 +497,7 @@ func moveManagedProjectPathInternal(root *os.Root, protected map[string]bool, re
if errors.Is(err, os.ErrNotExist) {
return errors.Errorf("project path not found: %s", rel)
}
- return mapProjectRootErrorInternal("inspect project path", err)
+ return errors.WrapIf(err, "inspect project path")
}
if sourceInfo.Mode()&os.ModeSymlink != 0 {
return errors.WrapIf(ErrProjectFileSymlinkPath, "symlink paths are not supported")
@@ -526,11 +526,11 @@ func moveManagedProjectPathInternal(root *os.Root, protected map[string]bool, re
if _, err := root.Lstat(targetRel); err == nil {
return errors.Errorf("project path already exists: %s", targetRel)
} else if !errors.Is(err, os.ErrNotExist) {
- return mapProjectRootErrorInternal("inspect project path", err)
+ return errors.WrapIf(err, "inspect project path")
}
if err := root.Rename(rel, targetRel); err != nil {
- return mapProjectRootErrorInternal("move project path", err)
+ return errors.WrapIf(err, "move project path")
}
return nil
}
@@ -548,7 +548,7 @@ func validateProjectMoveParentInternal(root *os.Root, parentRel string) error {
if errors.Is(err, os.ErrNotExist) {
return errors.Errorf("destination folder not found: %s", parentRel)
}
- return mapProjectRootErrorInternal("inspect destination folder", err)
+ return errors.WrapIf(err, "inspect destination folder")
}
if parentInfo.Mode()&os.ModeSymlink != 0 {
return errors.WrapIf(ErrProjectFileSymlinkPath, "symlink destination folders are not supported")
@@ -572,7 +572,7 @@ func deleteManagedProjectPathInternal(root *os.Root, protected map[string]bool,
if errors.Is(err, os.ErrNotExist) {
return errors.Errorf("project path not found: %s", rel)
}
- return mapProjectRootErrorInternal("inspect project path", err)
+ return errors.WrapIf(err, "inspect project path")
}
if info.Mode()&os.ModeSymlink != 0 {
return errors.WrapIf(ErrProjectFileSymlinkPath, "symlink paths are not supported")
@@ -589,20 +589,16 @@ func deleteManagedProjectPathInternal(root *os.Root, protected map[string]bool,
if info.IsDir() {
if err := root.RemoveAll(rel); err != nil {
- return mapProjectRootErrorInternal("delete project folder", err)
+ return errors.WrapIf(err, "delete project folder")
}
return nil
}
if err := root.Remove(rel); err != nil {
- return mapProjectRootErrorInternal("delete project file", err)
+ return errors.WrapIf(err, "delete project file")
}
return nil
}
-func mapProjectRootErrorInternal(action string, err error) error {
- return errors.WrapIff(err, "%s", action)
-}
-
func ensureProjectPathHasNoSymlinkInternal(root *os.Root, rel string) error {
cleaned := path.Clean(rel)
if cleaned == "." || cleaned == "" {
@@ -622,7 +618,7 @@ func ensureProjectPathHasNoSymlinkInternal(root *os.Root, rel string) error {
if errors.Is(err, os.ErrNotExist) {
return nil
}
- return mapProjectRootErrorInternal("inspect project path", err)
+ return errors.WrapIf(err, "inspect project path")
}
if info.Mode()&os.ModeSymlink != 0 {
return errors.WrapIf(ErrProjectFileSymlinkPath, "symlink paths are not supported")
diff --git a/backend/pkg/projects/project_files_test.go b/backend/pkg/projects/project_files_test.go
index 92e17f66c..900b820ae 100644
--- a/backend/pkg/projects/project_files_test.go
+++ b/backend/pkg/projects/project_files_test.go
@@ -175,19 +175,6 @@ func TestApplyProjectFileChanges_WrapsForbiddenSentinelErrors(t *testing.T) {
assert.ErrorIs(t, err, ErrProjectFileSymlinkPath)
}
-func TestMapProjectRootErrorInternal_DoesNotClassifyByErrorMessage(t *testing.T) {
- t.Parallel()
-
- err := mapProjectRootErrorInternal("inspect project path", &os.PathError{
- Op: "lstat",
- Path: "notes.txt",
- Err: errors.New("disk check escapes normal retry path"),
- })
-
- require.Error(t, err)
- assert.NotErrorIs(t, err, ErrProjectFileOutsideProjectDirectory)
-}
-
func TestApplyProjectFileChanges_UsesRevisionConflictDetection(t *testing.T) {
t.Parallel()
diff --git a/backend/pkg/utils/cookie/cookie_util.go b/backend/pkg/utils/cookie/cookie_util.go
index a08c49cec..68a73bced 100644
--- a/backend/pkg/utils/cookie/cookie_util.go
+++ b/backend/pkg/utils/cookie/cookie_util.go
@@ -11,17 +11,15 @@ var (
OidcStateCookieName = "oidc_state"
)
-type secureCookieContextKey struct{}
-
-// WithSecureCookieContext records the router's trusted secure-cookie decision.
-func WithSecureCookieContext(ctx context.Context, secure bool) context.Context {
- return context.WithValue(ctx, secureCookieContextKey{}, secure)
-}
+// SecureCookieContextKey is the context key under which router middleware
+// records its trusted secure-cookie decision (a bool derived from TLS or
+// trusted proxy headers).
+type SecureCookieContextKey struct{}
// SecureCookieFromContext returns the secure-cookie decision that router
// middleware derived from TLS or trusted proxy headers.
func SecureCookieFromContext(ctx context.Context) bool {
- secure, _ := ctx.Value(secureCookieContextKey{}).(bool)
+ secure, _ := ctx.Value(SecureCookieContextKey{}).(bool)
return secure
}
@@ -34,12 +32,8 @@ func SecureCookieFromRequest(r *http.Request) bool {
return SecureCookieFromContext(r.Context())
}
-func isSecureInternal(r *http.Request) bool {
- return SecureCookieFromRequest(r)
-}
-
func ClearTokenCookie(w http.ResponseWriter, r *http.Request) {
- for _, cookieHeader := range BuildClearTokenCookieStringsFor(isSecureInternal(r)) {
+ for _, cookieHeader := range BuildClearTokenCookieStringsFor(SecureCookieFromRequest(r)) {
w.Header().Add("Set-Cookie", cookieHeader)
}
}
diff --git a/backend/pkg/utils/cookie/cookie_util_test.go b/backend/pkg/utils/cookie/cookie_util_test.go
index 6ffa1cdc5..d43f4eaa5 100644
--- a/backend/pkg/utils/cookie/cookie_util_test.go
+++ b/backend/pkg/utils/cookie/cookie_util_test.go
@@ -11,22 +11,22 @@ import (
"github.com/stretchr/testify/require"
)
-func TestIsSecureInternal(t *testing.T) {
+func TestSecureCookieFromRequest(t *testing.T) {
t.Run("plain http returns false", func(t *testing.T) {
req := httptest.NewRequest("GET", "http://example.com/", nil)
- assert.False(t, isSecureInternal(req))
+ assert.False(t, SecureCookieFromRequest(req))
})
t.Run("X-Forwarded-Proto https is not trusted directly", func(t *testing.T) {
req := httptest.NewRequest("GET", "http://example.com/", nil)
req.Header.Set("X-Forwarded-Proto", "https")
- assert.False(t, isSecureInternal(req))
+ assert.False(t, SecureCookieFromRequest(req))
})
t.Run("secure cookie context returns true", func(t *testing.T) {
req := httptest.NewRequest("GET", "http://example.com/", nil)
- req = req.WithContext(WithSecureCookieContext(context.Background(), true))
- assert.True(t, isSecureInternal(req))
+ req = req.WithContext(context.WithValue(context.Background(), SecureCookieContextKey{}, true))
+ assert.True(t, SecureCookieFromRequest(req))
})
}
diff --git a/backend/pkg/utils/httpx/request.go b/backend/pkg/utils/httpx/request.go
index 2e8883432..ac9cdb1af 100644
--- a/backend/pkg/utils/httpx/request.go
+++ b/backend/pkg/utils/httpx/request.go
@@ -62,6 +62,23 @@ func ValidateWebSocketOrigin(appURL string) func(r *http.Request) bool {
}
}
+// IsWebSocketUpgradeRequest reports whether r is a WebSocket handshake: the
+// Connection header contains "upgrade" (it can be a list, e.g. Firefox sends
+// "keep-alive, Upgrade") and Upgrade is "websocket".
+func IsWebSocketUpgradeRequest(r *http.Request) bool {
+ connection := strings.ToLower(r.Header.Get("Connection"))
+ upgrade := strings.ToLower(r.Header.Get("Upgrade"))
+
+ switch {
+ case !strings.Contains(connection, "upgrade"):
+ return false
+ case upgrade != "websocket":
+ return false
+ default:
+ return true
+ }
+}
+
func isLocalhost(host string) bool {
hostOnly := host
if idx := strings.LastIndex(host, ":"); idx != -1 {
diff --git a/backend/pkg/utils/httpx/request_test.go b/backend/pkg/utils/httpx/request_test.go
new file mode 100644
index 000000000..e2a99d94e
--- /dev/null
+++ b/backend/pkg/utils/httpx/request_test.go
@@ -0,0 +1,37 @@
+package httpx
+
+import (
+ "net/http/httptest"
+ "testing"
+)
+
+func TestIsWebSocketUpgradeRequest(t *testing.T) {
+ tests := []struct {
+ name string
+ connection string
+ upgrade string
+ want bool
+ }{
+ {"websocket upgrade", "Upgrade", "websocket", true},
+ {"case insensitive with token list", "keep-alive, UPGRADE", "WebSocket", true},
+ {"plain request", "", "", false},
+ {"upgrade to h2c", "Upgrade", "h2c", false},
+ {"only upgrade header from reverse proxy", "", "websocket", false},
+ {"only connection upgrade from reverse proxy", "upgrade, keep-alive", "", false},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ r := httptest.NewRequest("GET", "/", nil)
+ if tt.connection != "" {
+ r.Header.Set("Connection", tt.connection)
+ }
+ if tt.upgrade != "" {
+ r.Header.Set("Upgrade", tt.upgrade)
+ }
+ if got := IsWebSocketUpgradeRequest(r); got != tt.want {
+ t.Errorf("IsWebSocketUpgradeRequest() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/backend/pkg/utils/httpx/socket_other.go b/backend/pkg/utils/httpx/socket_other.go
index c09c27290..5b7471ba6 100644
--- a/backend/pkg/utils/httpx/socket_other.go
+++ b/backend/pkg/utils/httpx/socket_other.go
@@ -10,6 +10,8 @@ import (
// setDeadPeerTimeoutInternal is a no-op outside Linux. TCP_USER_TIMEOUT has no
// portable equivalent, and Arcane only ships Linux images; local dev builds
// keep the OS default retransmission behaviour.
+//
+//nolint:shimbad // build-tag stub: the real implementation lives in socket_linux.go
func setDeadPeerTimeoutInternal(_ syscall.RawConn, _ time.Duration) error {
return nil
}
diff --git a/backend/pkg/utils/strings.go b/backend/pkg/utils/strings.go
index 3e02e8c74..6d7a5e64e 100644
--- a/backend/pkg/utils/strings.go
+++ b/backend/pkg/utils/strings.go
@@ -143,10 +143,6 @@ func CamelCaseToSnakeCase(str string) string {
return strings.ToLower(result.String())
}
-func CamelCaseToScreamingSnakeCase(s string) string {
- return strings.ToUpper(CamelCaseToSnakeCase(s))
-}
-
func GenerateRandomString(length int) string {
bytes := make([]byte, length)
if _, err := rand.Read(bytes); err != nil {
diff --git a/backend/pkg/utils/strings_test.go b/backend/pkg/utils/strings_test.go
index 8a73ab9ad..6ce7f0b18 100644
--- a/backend/pkg/utils/strings_test.go
+++ b/backend/pkg/utils/strings_test.go
@@ -48,25 +48,6 @@ func TestCamelCaseToSnakeCase(t *testing.T) {
}
}
-func TestCamelCaseToScreamingSnakeCase(t *testing.T) {
- tests := []struct {
- name string
- input string
- expected string
- }{
- {"empty string", "", ""},
- {"simple", "camelCase", "CAMEL_CASE"},
- {"multiple words", "thisIsALongerString", "THIS_IS_A_LONGER_STRING"},
- {"with number", "version2", "VERSION2"},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- assert.Equal(t, tt.expected, CamelCaseToScreamingSnakeCase(tt.input))
- })
- }
-}
-
func TestGenerateRandomString(t *testing.T) {
t.Run("length check", func(t *testing.T) {
length := 32
diff --git a/backend/pkg/utils/validation/credential_target.go b/backend/pkg/utils/validation/credential_target.go
index b59c057f5..2f09bb192 100644
--- a/backend/pkg/utils/validation/credential_target.go
+++ b/backend/pkg/utils/validation/credential_target.go
@@ -2,6 +2,7 @@ package validation
import (
"fmt"
+ "net/http"
"slices"
"strings"
@@ -49,8 +50,10 @@ func ValidateCredentialTargetChange(
return common.Classify(common.ErrValidation, errors.WithDetails(errors.Errorf("Changing %s requires re-supplying or clearing the %s", targetName, missingFields[0]), "field", missingFields[0]))
}
- return models.NewValidationError(
+ return models.NewAPIErrorWithDetails(
fmt.Sprintf("Changing %s requires updating all stored credentials", targetName),
+ models.APIErrorCodeValidationError,
+ http.StatusBadRequest,
map[string]any{"fields": missingFields},
)
}
diff --git a/cli/.custom-gcl.yml b/cli/.custom-gcl.yml
new file mode 120000
index 000000000..982ca0f91
--- /dev/null
+++ b/cli/.custom-gcl.yml
@@ -0,0 +1 @@
+../.custom-gcl.yml
\ No newline at end of file
diff --git a/cli/internal/runtime/context.go b/cli/internal/runtime/context.go
index 9fa82c2f7..b0c8eb994 100644
--- a/cli/internal/runtime/context.go
+++ b/cli/internal/runtime/context.go
@@ -14,7 +14,9 @@ import (
type contextKey string
-const appContextKey contextKey = "arcane_app_context"
+// AppContextKey is the context key under which the CLI's AppContext is stored;
+// set it with context.WithValue and read it back with From.
+const AppContextKey contextKey = "arcane_app_context"
type OutputMode string
@@ -74,15 +76,11 @@ func New(opts Options) (*AppContext, error) {
}, nil
}
-func WithAppContext(ctx context.Context, app *AppContext) context.Context {
- return context.WithValue(ctx, appContextKey, app)
-}
-
func From(ctx context.Context) (*AppContext, bool) {
if ctx == nil {
return nil, false
}
- app, ok := ctx.Value(appContextKey).(*AppContext)
+ app, ok := ctx.Value(AppContextKey).(*AppContext)
return app, ok && app != nil
}
diff --git a/cli/pkg/root.go b/cli/pkg/root.go
index 7b7a92455..effca5909 100644
--- a/cli/pkg/root.go
+++ b/cli/pkg/root.go
@@ -139,7 +139,7 @@ var rootCmd = &cobra.Command{
if err != nil {
return err
}
- cmd.SetContext(runtimectx.WithAppContext(cmd.Context(), app))
+ cmd.SetContext(context.WithValue(cmd.Context(), runtimectx.AppContextKey, app))
runstate.Set(runstate.State{
EnvOverride: envOverride,
OutputMode: outputMode,
diff --git a/cli/pkg/selfupdate/cmd.go b/cli/pkg/selfupdate/cmd.go
index 230c94930..3e57aa141 100644
--- a/cli/pkg/selfupdate/cmd.go
+++ b/cli/pkg/selfupdate/cmd.go
@@ -121,7 +121,7 @@ func newSelfUpdateChannelValueCmdInternal(channel string) *cobra.Command {
}
func setCLIUpdateChannelAndRunInternal(cmd *cobra.Command, channel string) error {
- channel = normalizeCLIUpdateChannelInternal(channel)
+ channel = strings.ToLower(strings.TrimSpace(channel))
if channel != cliUpdateChannelNext && channel != cliUpdateChannelStable {
return errors.Errorf("invalid update channel %q (expected stable or next)", channel)
}
@@ -183,7 +183,7 @@ func buildCLIUpdatePlanInternal(ctx context.Context, overrideChannel string) (*c
return nil, err
}
- channel := normalizeCLIUpdateChannelInternal(overrideChannel)
+ channel := strings.ToLower(strings.TrimSpace(overrideChannel))
if channel == "" {
channel, err = configuredCLIUpdateChannelInternal()
if err != nil {
@@ -219,7 +219,7 @@ func configuredCLIUpdateChannelInternal() (string, error) {
if err != nil {
return "", errors.WrapIf(err, "failed to load config")
}
- channel := normalizeCLIUpdateChannelInternal(cfg.CLIUpdateChannel)
+ channel := strings.ToLower(strings.TrimSpace(cfg.CLIUpdateChannel))
if channel == "" {
return "", nil
}
@@ -259,10 +259,6 @@ func resolveCLIUpdateTargetInternal() (string, error) {
return filepath.EvalSymlinks(exe)
}
-func normalizeCLIUpdateChannelInternal(channel string) string {
- return strings.ToLower(strings.TrimSpace(channel))
-}
-
func inferCLIUpdateChannelInternal(version string) string {
normalized := strings.ToLower(strings.TrimSpace(version))
if strings.Contains(normalized, "next") || strings.Contains(normalized, "beta") {
@@ -371,7 +367,9 @@ func resolveStableCLIUpdateInternal(ctx context.Context) (*cliUpdatePlan, error)
func cliUpdateNeededInternal(channel, currentSHA, expectedSHA, remoteVersion string) bool {
if channel == cliUpdateChannelStable {
- return normalizeVersionInternal(config.Version) != normalizeVersionInternal(remoteVersion)
+ current := strings.TrimPrefix(strings.ToLower(strings.TrimSpace(config.Version)), "v")
+ remote := strings.TrimPrefix(strings.ToLower(strings.TrimSpace(remoteVersion)), "v")
+ return current != remote
}
if strings.TrimSpace(expectedSHA) == "" {
return true
@@ -379,10 +377,6 @@ func cliUpdateNeededInternal(channel, currentSHA, expectedSHA, remoteVersion str
return !strings.EqualFold(currentSHA, expectedSHA)
}
-func normalizeVersionInternal(version string) string {
- return strings.TrimPrefix(strings.ToLower(strings.TrimSpace(version)), "v")
-}
-
func fetchLatestGitHubReleaseInternal(ctx context.Context) (string, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://api.github.com/repos/getarcaneapp/arcane/releases/latest", nil)
if err != nil {
@@ -662,7 +656,7 @@ func sha256FileInternal(path string) (string, error) {
func findChecksumInternal(checksums string, artifactNames ...string) (string, error) {
wanted := make(map[string]struct{}, len(artifactNames))
for _, artifactName := range artifactNames {
- artifactName = normalizeChecksumPathInternal(artifactName)
+ artifactName = strings.TrimPrefix(path.Clean(strings.TrimSpace(artifactName)), "./")
if artifactName != "" {
wanted[artifactName] = struct{}{}
}
@@ -673,7 +667,7 @@ func findChecksumInternal(checksums string, artifactNames ...string) (string, er
if len(fields) < 2 {
continue
}
- checksumPath := normalizeChecksumPathInternal(fields[len(fields)-1])
+ checksumPath := strings.TrimPrefix(path.Clean(strings.TrimSpace(fields[len(fields)-1])), "./")
if checksumPathMatchesInternal(checksumPath, wanted) {
return strings.ToLower(fields[0]), nil
}
@@ -688,15 +682,11 @@ func checksumEntryNamesInternal(checksums string) []string {
if len(fields) < 2 {
continue
}
- names = append(names, normalizeChecksumPathInternal(fields[len(fields)-1]))
+ names = append(names, strings.TrimPrefix(path.Clean(strings.TrimSpace(fields[len(fields)-1])), "./"))
}
return names
}
-func normalizeChecksumPathInternal(value string) string {
- return strings.TrimPrefix(path.Clean(strings.TrimSpace(value)), "./")
-}
-
func checksumPathMatchesInternal(checksumPath string, wanted map[string]struct{}) bool {
if _, ok := wanted[checksumPath]; ok {
return true
diff --git a/types/.custom-gcl.yml b/types/.custom-gcl.yml
new file mode 120000
index 000000000..982ca0f91
--- /dev/null
+++ b/types/.custom-gcl.yml
@@ -0,0 +1 @@
+../.custom-gcl.yml
\ No newline at end of file