Skip to content

Modern Docker Management, Designed for Everyone

fix: add the ability to cancel ongoing activities (#2756)

Kyle Mendellfb11a53fd24a
diff --git a/backend/api/handlers/activities.go b/backend/api/handlers/activities.go
index 27cbed91a..c7a7185b1 100644
--- a/backend/api/handlers/activities.go
+++ b/backend/api/handlers/activities.go
@@ -8,6 +8,7 @@ import (
"net/http"
"net/url"
"strconv"
+ "strings"
"time"
"github.com/danielgtaylor/huma/v2"
@@ -64,6 +65,16 @@ type StreamActivitiesInput struct {
Limit int `query:"limit" default:"50" doc:"Initial snapshot limit"`
}
+type CancelActivityInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ ActivityID string `path:"activityId" doc:"Activity ID"`
+ RequestedBy string `query:"requestedBy" doc:"Display name to attribute the cancellation to (used when proxying to a remote environment)"`
+}
+
+type CancelActivityOutput struct {
+ Body base.ApiResponse[activity.Activity]
+}
+
func RegisterActivities(api huma.API, activityService *services.ActivityService, environmentService *services.EnvironmentService) {
h := &ActivityHandler{
activityService: activityService,
@@ -112,6 +123,20 @@ func RegisterActivities(api huma.API, activityService *services.ActivityService,
Middlewares: humamw.RequirePermission(api, authz.PermActivitiesRead),
}, h.StreamActivities)
+ huma.Register(api, huma.Operation{
+ OperationID: "cancel-activity",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/activities/{activityId}/cancel",
+ Summary: "Cancel a background activity",
+ Description: "Request cancellation of a running or queued background activity",
+ Tags: []string{"Activities"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ Middlewares: humamw.RequirePermission(api, authz.PermActivitiesCancel),
+ }, h.CancelActivity)
+
huma.Register(api, huma.Operation{
OperationID: "clear-activity-history",
Method: http.MethodDelete,
@@ -308,6 +333,70 @@ func (h *ActivityHandler) ClearHistory(ctx context.Context, input *ClearActivity
}, nil
}
+func (h *ActivityHandler) CancelActivity(ctx context.Context, input *CancelActivityInput) (*CancelActivityOutput, error) {
+ if input.EnvironmentID != "0" {
+ return h.proxyCancelActivityInternal(ctx, input)
+ }
+ if h.activityService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ if input.ActivityID == "" {
+ return nil, huma.Error400BadRequest("activity id is required")
+ }
+
+ requestedBy := h.cancelRequestedByInternal(ctx, input.RequestedBy)
+ cancelled, err := h.activityService.CancelActivity(ctx, input.EnvironmentID, input.ActivityID, requestedBy)
+ if err != nil {
+ switch {
+ case errors.Is(err, gorm.ErrRecordNotFound):
+ return nil, huma.Error404NotFound("activity not found")
+ case errors.Is(err, services.ErrActivityNotCancelable):
+ return nil, huma.Error409Conflict("activity is not running")
+ default:
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ }
+ h.applyActivitySourceLabelInternal(ctx, input.EnvironmentID, cancelled)
+
+ return &CancelActivityOutput{
+ Body: base.ApiResponse[activity.Activity]{
+ Success: true,
+ Data: *cancelled,
+ },
+ }, nil
+}
+
+func (h *ActivityHandler) proxyCancelActivityInternal(ctx context.Context, input *CancelActivityInput) (*CancelActivityOutput, error) {
+ if h.environmentService == nil {
+ return nil, huma.Error500InternalServerError("environment service not available")
+ }
+ path := fmt.Sprintf("/api/environments/0/activities/%s/cancel", url.PathEscape(input.ActivityID))
+ if requestedBy := h.cancelRequestedByInternal(ctx, input.RequestedBy); requestedBy != "" {
+ path += "?requestedBy=" + url.QueryEscape(requestedBy)
+ }
+ out, err := proxyRemoteJSONInternal[base.ApiResponse[activity.Activity]](ctx, h.environmentService, input.EnvironmentID, http.MethodPost, path, nil)
+ if err != nil {
+ return nil, err
+ }
+ h.applyActivitySourceLabelInternal(ctx, input.EnvironmentID, &out.Data)
+ return &CancelActivityOutput{Body: *out}, nil
+}
+
+// cancelRequestedByInternal resolves a human-readable name for the cancellation
+// 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.DisplayName != nil && strings.TrimSpace(*user.DisplayName) != "" {
+ return strings.TrimSpace(*user.DisplayName)
+ }
+ if name := strings.TrimSpace(user.Username); name != "" {
+ return name
+ }
+ }
+ return strings.TrimSpace(forwarded)
+}
+
func (h *ActivityHandler) streamRemoteActivitySnapshotsInternal(
ctx context.Context,
input *StreamActivitiesInput,
diff --git a/backend/api/handlers/containers.go b/backend/api/handlers/containers.go
index ead17960c..db8d0d62d 100644
--- a/backend/api/handlers/containers.go
+++ b/backend/api/handlers/containers.go
@@ -625,7 +625,7 @@ func (h *ContainerHandler) StartContainer(ctx context.Context, input *ContainerA
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerStart, "container", input.ContainerID, input.ContainerID, user, "Starting container", "Container start requested", models.JSON{"containerID": input.ContainerID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerStart, "container", input.ContainerID, input.ContainerID, user, "Starting container", "Container start requested", models.JSON{"containerID": input.ContainerID})
if err := h.containerService.StartContainer(runtimeCtx, input.ContainerID, *user); err != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container started", err)
return nil, huma.Error500InternalServerError((&common.ContainerStartError{Err: err}).Error())
@@ -651,7 +651,7 @@ func (h *ContainerHandler) StopContainer(ctx context.Context, input *ContainerAc
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerStop, "container", input.ContainerID, input.ContainerID, user, "Stopping container", "Container stop requested", models.JSON{"containerID": input.ContainerID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerStop, "container", input.ContainerID, input.ContainerID, user, "Stopping container", "Container stop requested", models.JSON{"containerID": input.ContainerID})
if err := h.containerService.StopContainer(runtimeCtx, input.ContainerID, *user); err != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container stopped", err)
return nil, huma.Error500InternalServerError((&common.ContainerStopError{Err: err}).Error())
@@ -677,7 +677,7 @@ func (h *ContainerHandler) RestartContainer(ctx context.Context, input *Containe
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerRestart, "container", input.ContainerID, input.ContainerID, user, "Restarting container", "Container restart requested", models.JSON{"containerID": input.ContainerID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerRestart, "container", input.ContainerID, input.ContainerID, user, "Restarting container", "Container restart requested", models.JSON{"containerID": input.ContainerID})
if err := h.containerService.RestartContainer(runtimeCtx, input.ContainerID, *user); err != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container restarted", err)
return nil, huma.Error500InternalServerError((&common.ContainerRestartError{Err: err}).Error())
@@ -703,7 +703,7 @@ func (h *ContainerHandler) RedeployContainer(ctx context.Context, input *Contain
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := activitylib.StartHandlerActivityForUser(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.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeContainerRedeploy, "container", input.ContainerID, input.ContainerID, user, "Starting redeploy", "Container redeploy requested", models.JSON{"containerID": input.ContainerID})
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Redeploying container")
redeployCtx := context.WithValue(runtimeCtx, projects.ProgressWriterKey{}, activityWriter)
newContainerID, err := h.containerService.RedeployContainer(redeployCtx, input.ContainerID, *user)
@@ -752,7 +752,7 @@ func (h *ContainerHandler) DeleteContainer(ctx context.Context, input *DeleteCon
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := 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.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})
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((&common.ContainerDeleteError{Err: err}).Error())
diff --git a/backend/api/handlers/images.go b/backend/api/handlers/images.go
index 63a85fcae..b6242dc1c 100644
--- a/backend/api/handlers/images.go
+++ b/backend/api/handlers/images.go
@@ -453,7 +453,7 @@ func (h *ImageHandler) PullImage(ctx context.Context, input *PullImageInput) (*h
runtimeCtx := utils.ActivityRuntimeContext(humaCtx.Context(), h.appCtx)
rawWriter := humaCtx.BodyWriter()
- activityID := activitylib.StartHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(
runtimeCtx,
h.activityService,
input.EnvironmentID,
@@ -512,7 +512,7 @@ func (h *ImageHandler) BuildImage(ctx context.Context, input *BuildImageInput) (
if strings.TrimSpace(resourceName) == "" {
resourceName = input.Body.ContextDir
}
- activityID := activitylib.StartHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(
runtimeCtx,
h.activityService,
input.EnvironmentID,
diff --git a/backend/api/handlers/networks.go b/backend/api/handlers/networks.go
index bd7039d42..20c06484d 100644
--- a/backend/api/handlers/networks.go
+++ b/backend/api/handlers/networks.go
@@ -302,7 +302,7 @@ func (h *NetworkHandler) CreateNetwork(ctx context.Context, input *CreateNetwork
"action": "create_network",
"driver": input.Body.Options.Driver,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
var createErr error
response, createErr = h.networkService.CreateNetwork(runtimeCtx, input.Body.Name, dockerOptions, *user)
return createErr
@@ -447,7 +447,7 @@ func (h *NetworkHandler) DeleteNetwork(ctx context.Context, input *DeleteNetwork
Metadata: models.JSON{
"action": "remove_network",
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.networkService.RemoveNetwork(runtimeCtx, input.NetworkID, *user)
})
if err != nil {
@@ -473,7 +473,7 @@ func (h *NetworkHandler) PruneNetworks(ctx context.Context, input *PruneNetworks
Message: "Pruning unused networks",
SuccessMessage: "Networks pruned successfully",
Metadata: models.JSON{"action": "prune_networks"},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
var pruneErr error
report, pruneErr = h.networkService.PruneNetworks(runtimeCtx)
return pruneErr
diff --git a/backend/api/handlers/projects.go b/backend/api/handlers/projects.go
index d2cfad1c7..92503e524 100644
--- a/backend/api/handlers/projects.go
+++ b/backend/api/handlers/projects.go
@@ -603,7 +603,7 @@ func (h *ProjectHandler) DeployProject(ctx context.Context, input *DeployProject
runtimeCtx := utils.ActivityRuntimeContext(humaCtx.Context(), h.appCtx)
rawWriter := humaCtx.BodyWriter()
- activityID := activitylib.StartHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(
runtimeCtx,
h.activityService,
input.EnvironmentID,
@@ -659,7 +659,7 @@ func (h *ProjectHandler) DownProject(ctx context.Context, input *DownProjectInpu
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := 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.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectDown, "project", input.ProjectID, input.ProjectID, user, "Stopping project", "Project stop requested", models.JSON{"projectID": input.ProjectID})
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Stopping project")
downCtx := context.WithValue(runtimeCtx, projects.ProgressWriterKey{}, activityWriter)
if err := h.projectService.DownProject(downCtx, input.ProjectID, *user); err != nil {
@@ -709,7 +709,7 @@ func (h *ProjectHandler) CreateProject(ctx context.Context, input *CreateProject
Message: "Creating project",
SuccessMessage: "Project created successfully",
Metadata: models.JSON{"action": "create_project"},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
var createErr error
proj, createErr = h.projectService.CreateProject(runtimeCtx, input.Body.Name, input.Body.ComposeContent, input.Body.EnvContent, *user)
return createErr
@@ -866,7 +866,7 @@ func (h *ProjectHandler) RedeployProject(ctx context.Context, input *RedeployPro
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := activitylib.StartHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(
runtimeCtx,
h.activityService,
input.EnvironmentID,
@@ -930,7 +930,7 @@ func (h *ProjectHandler) DestroyProject(ctx context.Context, input *DestroyProje
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := 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.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})
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Destroying project")
destroyCtx := context.WithValue(runtimeCtx, projects.ProgressWriterKey{}, activityWriter)
if err := h.projectService.DestroyProject(destroyCtx, input.ProjectID, removeFiles, removeVolumes, *user); err != nil {
@@ -979,7 +979,7 @@ func (h *ProjectHandler) UpdateProject(ctx context.Context, input *UpdateProject
Message: "Updating project",
SuccessMessage: "Project updated successfully",
Metadata: models.JSON{"action": "update_project", "projectID": input.ProjectID},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
_, updateErr := h.projectService.UpdateProject(runtimeCtx, input.ProjectID, input.Body.Name, input.Body.ComposeContent, input.Body.EnvContent, *user)
return updateErr
})
@@ -1032,7 +1032,7 @@ func (h *ProjectHandler) UpdateProjectInclude(ctx context.Context, input *Update
"projectID": input.ProjectID,
"relativePath": input.Body.RelativePath,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.projectService.UpdateProjectIncludeFile(runtimeCtx, input.ProjectID, input.Body.RelativePath, input.Body.Content, *user)
})
if err != nil {
@@ -1069,7 +1069,7 @@ func (h *ProjectHandler) RestartProject(ctx context.Context, input *RestartProje
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
- activityID := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectRestart, "project", input.ProjectID, input.ProjectID, user, "Restarting project", "Project restart requested", models.JSON{"projectID": input.ProjectID})
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(runtimeCtx, h.activityService, input.EnvironmentID, models.ActivityTypeProjectRestart, "project", input.ProjectID, input.ProjectID, user, "Restarting project", "Project restart requested", models.JSON{"projectID": input.ProjectID})
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Restarting project")
restartCtx := context.WithValue(runtimeCtx, projects.ProgressWriterKey{}, activityWriter)
if err := h.projectService.RestartProject(restartCtx, input.ProjectID, *user); err != nil {
@@ -1175,7 +1175,7 @@ func (h *ProjectHandler) PullProjectImages(ctx context.Context, input *PullProje
runtimeCtx := utils.ActivityRuntimeContext(humaCtx.Context(), h.appCtx)
rawWriter := humaCtx.BodyWriter()
- activityID := activitylib.StartHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(
runtimeCtx,
h.activityService,
input.EnvironmentID,
@@ -1247,7 +1247,7 @@ func (h *ProjectHandler) BuildProjectImages(ctx context.Context, input *BuildPro
runtimeCtx := utils.ActivityRuntimeContext(humaCtx.Context(), h.appCtx)
rawWriter := humaCtx.BodyWriter()
- activityID := activitylib.StartHandlerActivityForUser(
+ activityID, runtimeCtx := activitylib.StartHandlerActivityForUser(
runtimeCtx,
h.activityService,
input.EnvironmentID,
diff --git a/backend/api/handlers/volumes.go b/backend/api/handlers/volumes.go
index 8ace14d2a..2f318272e 100644
--- a/backend/api/handlers/volumes.go
+++ b/backend/api/handlers/volumes.go
@@ -766,7 +766,7 @@ func (h *VolumeHandler) CreateVolume(ctx context.Context, input *CreateVolumeInp
"action": "create_volume",
"driver": input.Body.Driver,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
var createErr error
response, createErr = h.volumeService.CreateVolume(runtimeCtx, options, *user)
return createErr
@@ -810,7 +810,7 @@ func (h *VolumeHandler) RemoveVolume(ctx context.Context, input *RemoveVolumeInp
"action": "remove_volume",
"force": input.Force,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.DeleteVolume(runtimeCtx, input.VolumeName, input.Force, *user)
})
if err != nil {
@@ -844,7 +844,7 @@ func (h *VolumeHandler) PruneVolumes(ctx context.Context, input *PruneVolumesInp
Message: "Pruning unused volumes",
SuccessMessage: "Volumes pruned successfully",
Metadata: models.JSON{"action": "prune_volumes"},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
var pruneErr error
report, pruneErr = h.volumeService.PruneVolumes(runtimeCtx)
return pruneErr
@@ -1032,7 +1032,7 @@ func (h *VolumeHandler) UploadFile(ctx context.Context, input *UploadFileInput)
"path": input.Path,
"filename": fileHeader.Filename,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.UploadFile(runtimeCtx, input.VolumeName, input.Path, file, fileHeader.Filename, user)
})
if err != nil {
@@ -1064,7 +1064,7 @@ func (h *VolumeHandler) CreateDirectory(ctx context.Context, input *CreateDirect
"action": "create_volume_directory",
"path": input.Path,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.CreateDirectory(runtimeCtx, input.VolumeName, input.Path, user)
})
if err != nil {
@@ -1096,7 +1096,7 @@ func (h *VolumeHandler) DeleteFile(ctx context.Context, input *DeleteFileInput)
"action": "delete_volume_file",
"path": input.Path,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.DeleteFile(runtimeCtx, input.VolumeName, input.Path, user)
})
if err != nil {
@@ -1183,7 +1183,7 @@ func (h *VolumeHandler) CreateBackup(ctx context.Context, input *CreateBackupInp
Message: "Creating volume backup",
SuccessMessage: "Volume backup created successfully",
Metadata: models.JSON{"action": "create_volume_backup"},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
var backupErr error
backup, backupErr = h.volumeService.CreateBackup(runtimeCtx, input.VolumeName, *user)
return backupErr
@@ -1224,7 +1224,7 @@ func (h *VolumeHandler) RestoreBackup(ctx context.Context, input *RestoreBackupI
"action": "restore_volume_backup",
"backupId": input.BackupID,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.RestoreBackup(runtimeCtx, input.VolumeName, input.BackupID, *user)
})
if err != nil {
@@ -1268,7 +1268,7 @@ func (h *VolumeHandler) RestoreBackupFiles(ctx context.Context, input *RestoreBa
"backupId": input.BackupID,
"paths": input.Body.Paths,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.RestoreBackupFiles(runtimeCtx, input.VolumeName, input.BackupID, input.Body.Paths, *user)
})
if err != nil {
@@ -1343,7 +1343,7 @@ func (h *VolumeHandler) DeleteBackup(ctx context.Context, input *DeleteBackupInp
"action": "delete_volume_backup",
"backupId": input.BackupID,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.DeleteBackup(runtimeCtx, input.BackupID, user)
})
if err != nil {
@@ -1417,7 +1417,7 @@ func (h *VolumeHandler) UploadAndRestore(ctx context.Context, input *UploadAndRe
"action": "upload_restore_volume_backup",
"filename": fileHeader.Filename,
},
- }, func() error {
+ }, func(runtimeCtx context.Context) error {
return h.volumeService.UploadAndRestore(runtimeCtx, input.VolumeName, file, fileHeader.Filename, *user)
})
if err != nil {
diff --git a/backend/internal/services/activity_service.go b/backend/internal/services/activity_service.go
index 99ab86605..f320d49f0 100644
--- a/backend/internal/services/activity_service.go
+++ b/backend/internal/services/activity_service.go
@@ -2,6 +2,7 @@ package services
import (
"context"
+ "errors"
"fmt"
"log/slog"
"strings"
@@ -29,8 +30,18 @@ type ActivityService struct {
subscribersMu sync.RWMutex
subscribers map[int]*activitySubscriber
nextSubID int
+
+ // running maps an active activity ID to the cancel function of its work
+ // context, so cancellation requests can interrupt in-flight work. Entries
+ // are added by Track and removed when the activity is completed.
+ runningMu sync.Mutex
+ running map[string]context.CancelCauseFunc
}
+// ErrActivityNotCancelable indicates the activity has already reached a terminal
+// state and can no longer be cancelled.
+var ErrActivityNotCancelable = errors.New("activity is not cancelable")
+
type activitySubscriber struct {
environmentID string
ch chan activitytypes.StreamEvent
@@ -45,6 +56,70 @@ func NewActivityService(db *database.DB) *ActivityService {
return &ActivityService{
db: db,
subscribers: map[int]*activitySubscriber{},
+ running: map[string]context.CancelCauseFunc{},
+ }
+}
+
+// Track derives a cancelable work context bound to activityID and registers its
+// cancel function so RequestCancel can interrupt the work. The registration is
+// released when the activity is completed (see CompleteActivity) or when the
+// returned context is otherwise no longer needed. Implements activitylib.Tracker.
+func (s *ActivityService) Track(ctx context.Context, activityID string) context.Context {
+ activityID = strings.TrimSpace(activityID)
+ if s == nil || activityID == "" {
+ return ctx
+ }
+
+ workCtx, cancel := context.WithCancelCause(ctx)
+ s.runningMu.Lock()
+ if s.running == nil {
+ s.running = map[string]context.CancelCauseFunc{}
+ }
+ if existing, ok := s.running[activityID]; ok {
+ // Replace any stale registration to avoid leaking the prior context.
+ existing(nil)
+ }
+ s.running[activityID] = cancel
+ s.runningMu.Unlock()
+ return workCtx
+}
+
+// RequestCancel cancels the work context registered for activityID, signalling
+// activitylib.ErrCanceled as the cause. It returns whether a running activity
+// was found in this process.
+func (s *ActivityService) RequestCancel(activityID string) bool {
+ activityID = strings.TrimSpace(activityID)
+ if s == nil || activityID == "" {
+ return false
+ }
+
+ s.runningMu.Lock()
+ cancel, ok := s.running[activityID]
+ s.runningMu.Unlock()
+ if !ok {
+ return false
+ }
+ cancel(activitylib.ErrCanceled)
+ return true
+}
+
+// releaseCancelInternal removes and cancels the registration for activityID.
+// Cancelling with a nil cause is a no-op if the context was already cancelled
+// (the first cause wins), so a prior ErrCanceled cause is preserved.
+func (s *ActivityService) releaseCancelInternal(activityID string) {
+ activityID = strings.TrimSpace(activityID)
+ if s == nil || activityID == "" {
+ return
+ }
+
+ s.runningMu.Lock()
+ cancel, ok := s.running[activityID]
+ if ok {
+ delete(s.running, activityID)
+ }
+ s.runningMu.Unlock()
+ if ok {
+ cancel(nil)
}
}
@@ -247,6 +322,13 @@ func (s *ActivityService) CompleteActivity(ctx context.Context, activityID strin
return nil, fmt.Errorf("activity id is required")
}
+ // The activity is reaching a terminal state; release any cancel registration.
+ s.releaseCancelInternal(activityID)
+
+ // Detach from cancellation so the terminal write always lands — completion is
+ // often triggered precisely because the work context was cancelled.
+ ctx = context.WithoutCancel(ctx)
+
now := time.Now()
var model models.Activity
if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
@@ -292,6 +374,90 @@ func (s *ActivityService) CompleteActivity(ctx context.Context, activityID strin
return &dto, nil
}
+// CancelActivity requests cancellation of a running or queued activity. When the
+// activity's work is running in this process it interrupts it (the work finalizes
+// its own terminal status); otherwise it marks the activity cancelled directly,
+// but only if it is still active. Returns ErrActivityNotCancelable if the activity
+// has already reached a terminal state, or gorm.ErrRecordNotFound if it is unknown.
+func (s *ActivityService) CancelActivity(ctx context.Context, environmentID, activityID, requestedBy string) (*activitytypes.Activity, error) {
+ if err := s.checkInitInternal(); err != nil {
+ return nil, err
+ }
+ activityID = strings.TrimSpace(activityID)
+ if activityID == "" {
+ return nil, fmt.Errorf("activity id is required")
+ }
+ environmentID = strings.TrimSpace(environmentID)
+ if environmentID == "" {
+ environmentID = "0"
+ }
+
+ var model models.Activity
+ if err := s.db.WithContext(ctx).Where("id = ? AND environment_id = ?", activityID, environmentID).First(&model).Error; err != nil {
+ return nil, err
+ }
+ switch model.Status {
+ case models.ActivityStatusSuccess, models.ActivityStatusFailed, models.ActivityStatusCancelled:
+ return nil, ErrActivityNotCancelable
+ case models.ActivityStatusQueued, models.ActivityStatusRunning:
+ // Active states — cancellation can proceed.
+ }
+
+ requestedBy = strings.TrimSpace(requestedBy)
+ if requestedBy == "" {
+ requestedBy = "a user"
+ }
+ writeCtx := utils.ActivityRuntimeContext(ctx, nil)
+ if _, err := s.AppendMessage(writeCtx, activityID, AppendActivityMessageRequest{
+ Level: models.ActivityMessageLevelWarning,
+ Message: fmt.Sprintf("Cancellation requested by %s", requestedBy),
+ }); err != nil {
+ slog.DebugContext(ctx, "failed to append cancellation message", "activityId", activityID, "error", err)
+ }
+
+ if s.RequestCancel(activityID) {
+ // The running work observes the cancelled context and writes its own
+ // terminal status, which reaches clients via the activity stream. Return
+ // the pre-cancel snapshot rather than reloading here: the worker has not
+ // finished unwinding yet, so a reload would still report "running".
+ dto := activityToDTOInternal(&model)
+ return &dto, nil
+ }
+
+ // Untracked work (e.g. after a process restart, or a queued activity with no
+ // runner): finalize directly, but only if it is still active to avoid
+ // clobbering a concurrently-completing activity.
+ now := time.Now()
+ var finalized models.Activity
+ if err := s.db.WithContext(writeCtx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.First(&finalized, "id = ? AND environment_id = ?", activityID, environmentID).Error; err != nil {
+ return err
+ }
+ updates := completeActivityUpdatesInternal(finalized.StartedAt, models.ActivityStatusCancelled, cancelledMessageInternal, nil, nil, now)
+ result := tx.Model(&models.Activity{}).
+ Where("id = ? AND status IN ?", activityID, []models.ActivityStatus{models.ActivityStatusQueued, models.ActivityStatusRunning}).
+ Updates(updates)
+ if result.Error != nil {
+ return fmt.Errorf("failed to cancel activity: %w", result.Error)
+ }
+ if result.RowsAffected == 0 {
+ return ErrActivityNotCancelable
+ }
+ if err := tx.First(&finalized, "id = ? AND environment_id = ?", activityID, environmentID).Error; err != nil {
+ return fmt.Errorf("failed to load cancelled activity: %w", err)
+ }
+ return nil
+ }); err != nil {
+ return nil, err
+ }
+
+ dto := activityToDTOInternal(&finalized)
+ s.publishActivityInternal(dto)
+ return &dto, nil
+}
+
+const cancelledMessageInternal = "Cancelled by user"
+
func completeActivityUpdatesInternal(startedAt time.Time, status models.ActivityStatus, finalMessage string, errMessage *string, finalStep []string, now time.Time) map[string]any {
updates := map[string]any{
"status": status,
diff --git a/backend/internal/services/activity_service_test.go b/backend/internal/services/activity_service_test.go
index 9554fdef4..44922daf8 100644
--- a/backend/internal/services/activity_service_test.go
+++ b/backend/internal/services/activity_service_test.go
@@ -11,7 +11,9 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ activitylib "github.com/getarcaneapp/arcane/backend/pkg/libarcane/activity"
"github.com/getarcaneapp/arcane/backend/pkg/pagination"
+ "github.com/getarcaneapp/arcane/backend/pkg/utils"
activitytypes "github.com/getarcaneapp/arcane/types/activity"
)
@@ -289,6 +291,68 @@ func TestActivityServiceCompleteActivityRejectsUninitializedServiceInternal(t *t
require.Error(t, err)
}
+func TestActivityServiceTrackAndRequestCancelInternal(t *testing.T) {
+ db := setupActivityServiceTestDBInternal(t)
+ service := NewActivityService(db)
+
+ // Mirror the handler flow: work runs under an app-lifecycle runtime context.
+ appCtx := utils.WithAppLifecycleContext(context.Background())
+ runtimeCtx := utils.ActivityRuntimeContext(context.Background(), appCtx)
+
+ created, err := service.StartActivity(runtimeCtx, StartActivityRequest{
+ EnvironmentID: "0",
+ Type: models.ActivityTypeImagePull,
+ LatestMessage: "running",
+ })
+ require.NoError(t, err)
+
+ workCtx := service.Track(runtimeCtx, created.ID)
+ require.NoError(t, workCtx.Err())
+
+ // A tracked activity is found and cancelled with the ErrCanceled cause.
+ require.True(t, service.RequestCancel(created.ID))
+ require.ErrorIs(t, workCtx.Err(), context.Canceled)
+ require.ErrorIs(t, context.Cause(workCtx), activitylib.ErrCanceled)
+ require.True(t, activitylib.CancelledByContext(workCtx))
+
+ // Completion must land even though the work context is cancelled (this is the
+ // path CompleteHandlerActivity takes after re-wrapping the work context).
+ completed, err := service.CompleteActivity(utils.ActivityRuntimeContext(workCtx, nil), created.ID, models.ActivityStatusCancelled, "Cancelled by user", nil)
+ require.NoError(t, err)
+ require.Equal(t, "cancelled", string(completed.Status))
+ require.NotNil(t, completed.EndedAt)
+
+ // Completing the activity releases the registration.
+ require.False(t, service.RequestCancel(created.ID))
+}
+
+func TestActivityServiceCancelActivityInternal(t *testing.T) {
+ ctx := context.Background()
+ db := setupActivityServiceTestDBInternal(t)
+ service := NewActivityService(db)
+
+ // An untracked running activity (e.g. after a restart) is finalized directly.
+ created, err := service.StartActivity(ctx, StartActivityRequest{
+ EnvironmentID: "0",
+ Type: models.ActivityTypeSystemPrune,
+ LatestMessage: "running",
+ })
+ require.NoError(t, err)
+
+ cancelled, err := service.CancelActivity(ctx, "0", created.ID, "Tester")
+ require.NoError(t, err)
+ require.Equal(t, "cancelled", string(cancelled.Status))
+ require.NotNil(t, cancelled.EndedAt)
+
+ // Cancelling an already-terminal activity is rejected.
+ _, err = service.CancelActivity(ctx, "0", created.ID, "Tester")
+ require.ErrorIs(t, err, ErrActivityNotCancelable)
+
+ // Unknown activity reports not found.
+ _, err = service.CancelActivity(ctx, "0", "missing", "Tester")
+ require.ErrorIs(t, err, gorm.ErrRecordNotFound)
+}
+
func receiveActivityEventInternal(t *testing.T, events <-chan activitytypes.StreamEvent) activitytypes.StreamEvent {
t.Helper()
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index c0ac2e17c..98f20c54f 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -12,6 +12,7 @@ import (
ref "github.com/distribution/reference"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ activitylib "github.com/getarcaneapp/arcane/backend/pkg/libarcane/activity"
"github.com/getarcaneapp/arcane/backend/pkg/libarcane/crypto"
imageupdatecore "github.com/getarcaneapp/arcane/backend/pkg/libarcane/imageupdate"
"github.com/getarcaneapp/arcane/backend/pkg/libarcane/ratelimit"
@@ -115,6 +116,11 @@ func (s *ImageUpdateService) completeImageUpdateActivityInternal(ctx context.Con
if !success {
status = models.ActivityStatusFailed
errMessage = utils.StringPtrFromTrimmed(message)
+ if activitylib.CancelledByContext(ctx) {
+ status = models.ActivityStatusCancelled
+ errMessage = nil
+ message = "Image update check cancelled"
+ }
}
if message == "" {
message = "Image update check completed"
@@ -128,6 +134,7 @@ func (s *ImageUpdateService) completeImageUpdateActivityInternal(ctx context.Con
func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef string) (*imageupdate.Response, error) {
startTime := time.Now()
activityID := s.startImageUpdateActivityInternal(ctx, imageRef, 1)
+ ctx = s.activityService.Track(ctx, activityID)
s.appendImageUpdateActivityMessageInternal(ctx, activityID, models.ActivityMessageLevelInfo, fmt.Sprintf("Checking %s", imageRef), 20, "Checking remote digest")
parts := s.parseImageReference(imageRef)
@@ -987,6 +994,7 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
}
activityID := s.startImageUpdateActivityInternal(ctx, fmt.Sprintf("%d images", len(imageRefs)), len(imageRefs))
+ ctx = s.activityService.Track(ctx, activityID)
s.appendImageUpdateActivityMessageInternal(ctx, activityID, models.ActivityMessageLevelInfo, fmt.Sprintf("Checking %d image references", len(imageRefs)), 5, "Preparing image update check")
slog.DebugContext(ctx, "Starting batch image update check", "imageCount", len(imageRefs), "externalCredCount", len(externalCreds))
diff --git a/backend/internal/services/system_service.go b/backend/internal/services/system_service.go
index bbf354036..94d0efb88 100644
--- a/backend/internal/services/system_service.go
+++ b/backend/internal/services/system_service.go
@@ -10,6 +10,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ activitylib "github.com/getarcaneapp/arcane/backend/pkg/libarcane/activity"
"github.com/getarcaneapp/arcane/backend/pkg/libarcane/dockerrun"
libupdater "github.com/getarcaneapp/arcane/backend/pkg/libarcane/imageupdate"
"github.com/getarcaneapp/arcane/backend/pkg/utils"
@@ -79,6 +80,7 @@ func (s *SystemService) PruneAll(ctx context.Context, environmentID string, req
defer s.finishSystemPruneInternal(environmentID)
+ ctx = s.activityService.Track(ctx, activityID)
s.runSystemPruneInternal(ctx, req, activityID, result)
return result, true, nil
@@ -92,6 +94,7 @@ func (s *SystemService) StartPruneAll(ctx context.Context, environmentID string,
}
backgroundCtx := utils.ActivityRuntimeContext(ctx, nil)
+ backgroundCtx = s.activityService.Track(backgroundCtx, activityID)
go func() {
defer s.finishSystemPruneInternal(environmentID)
@@ -277,10 +280,15 @@ func (s *SystemService) completeSystemPruneActivityInternal(ctx context.Context,
message := "System prune completed"
var errMessage *string
if !result.Success || len(result.Errors) > 0 {
- status = models.ActivityStatusFailed
- message = "System prune completed with errors"
- joined := strings.Join(result.Errors, "; ")
- errMessage = &joined
+ if activitylib.CancelledByContext(ctx) {
+ status = models.ActivityStatusCancelled
+ message = "System prune cancelled"
+ } else {
+ status = models.ActivityStatusFailed
+ message = "System prune completed with errors"
+ joined := strings.Join(result.Errors, "; ")
+ errMessage = &joined
+ }
}
if _, err := s.activityService.CompleteActivity(utils.ActivityRuntimeContext(ctx, nil), activityID, status, message, errMessage); err != nil {
slog.DebugContext(ctx, "failed to complete system prune activity", "activityId", activityID, "error", err)
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index e66dccb83..677fc8407 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -95,6 +95,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (out *up
out = &updater.Result{Items: []updater.ResourceResult{}}
activityID := s.startAutoUpdateActivityInternal(ctx, dryRun)
out.ActivityID = utils.StringPtrFromTrimmed(activityID)
+ ctx = s.activityService.Track(ctx, activityID)
defer func() {
if out != nil {
out.ActivityID = utils.StringPtrFromTrimmed(activityID)
@@ -489,6 +490,11 @@ func (s *UpdaterService) completeAutoUpdateActivityInternal(ctx context.Context,
errMessage = &errText
message = errText
}
+ if status == models.ActivityStatusFailed && activitylib.CancelledByContext(ctx) {
+ status = models.ActivityStatusCancelled
+ message = "Auto-update cancelled"
+ errMessage = nil
+ }
if _, err := s.activityService.CompleteActivity(utils.ActivityRuntimeContext(ctx, nil), activityID, status, message, errMessage); err != nil {
slog.DebugContext(ctx, "failed to complete auto-update activity", "activityId", activityID, "error", err)
@@ -504,6 +510,7 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID
out = &updater.Result{Items: []updater.ResourceResult{}}
activityID := s.startSingleContainerUpdateActivityInternal(ctx, containerID)
out.ActivityID = utils.StringPtrFromTrimmed(activityID)
+ ctx = s.activityService.Track(ctx, activityID)
defer func() {
if out != nil {
out.ActivityID = utils.StringPtrFromTrimmed(activityID)
diff --git a/backend/internal/services/vulnerability_service.go b/backend/internal/services/vulnerability_service.go
index 408361521..f445dae2b 100644
--- a/backend/internal/services/vulnerability_service.go
+++ b/backend/internal/services/vulnerability_service.go
@@ -26,6 +26,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/models"
dockerutils "github.com/getarcaneapp/arcane/backend/pkg/dockerutil"
"github.com/getarcaneapp/arcane/backend/pkg/libarcane"
+ activitylib "github.com/getarcaneapp/arcane/backend/pkg/libarcane/activity"
libupdater "github.com/getarcaneapp/arcane/backend/pkg/libarcane/imageupdate"
"github.com/getarcaneapp/arcane/backend/pkg/libarcane/timeouts"
"github.com/getarcaneapp/arcane/backend/pkg/pagination"
@@ -275,6 +276,9 @@ func (s *VulnerabilityService) ScanImage(ctx context.Context, envID string, imag
"imageName", imageName,
)
activityID := s.startVulnerabilityScanActivityInternal(scanCtx, envID, imageID, imageName, &user)
+ // Make the scan cancelable: cancelling the activity cancels scanCtx, which
+ // unblocks the Trivy container wait and triggers its (cancel-safe) teardown.
+ scanCtx = s.activityService.Track(scanCtx, activityID)
s.setScanPhaseInternal(imageID, vulnerability.ScanPhaseCreatingContainer)
// Create pending scan record
@@ -488,11 +492,16 @@ func (s *VulnerabilityService) completeVulnerabilityScanActivityInternal(ctx con
message := "Vulnerability scan completed"
var errorPtr *string
if !success {
- status = models.ActivityStatusFailed
- message = "Vulnerability scan failed"
- if strings.TrimSpace(errMessage) != "" {
- errorPtr = &errMessage
- message = errMessage
+ if activitylib.CancelledByContext(ctx) {
+ status = models.ActivityStatusCancelled
+ message = "Vulnerability scan cancelled"
+ } else {
+ status = models.ActivityStatusFailed
+ message = "Vulnerability scan failed"
+ if strings.TrimSpace(errMessage) != "" {
+ errorPtr = &errMessage
+ message = errMessage
+ }
}
}
diff --git a/backend/pkg/authz/catalog.go b/backend/pkg/authz/catalog.go
index 2629d918a..07939cce1 100644
--- a/backend/pkg/authz/catalog.go
+++ b/backend/pkg/authz/catalog.go
@@ -193,6 +193,7 @@ var permissionCatalog = []PermissionCatalogResource{
}},
{"activities", "Activities", PermissionScopeEnv, []PermissionCatalogAction{
{"read", PermActivitiesRead, "Read", ""},
+ {"cancel", PermActivitiesCancel, "Cancel", ""},
{"delete", PermActivitiesDelete, "Clear history", ""},
}},
}
diff --git a/backend/pkg/authz/permissions.go b/backend/pkg/authz/permissions.go
index 4eb9f7682..30285539f 100644
--- a/backend/pkg/authz/permissions.go
+++ b/backend/pkg/authz/permissions.go
@@ -166,6 +166,7 @@ const (
PermBuildWorkspacesManage = "build-workspaces:manage"
PermActivitiesRead = "activities:read"
+ PermActivitiesCancel = "activities:cancel"
PermActivitiesDelete = "activities:delete"
)
@@ -276,7 +277,7 @@ func BuiltInEditorPermissions() []string {
PermImageUpdatesRead, PermImageUpdatesCheck,
PermVulnsRead, PermVulnsScan, PermVulnsManage,
PermBuildWorkspacesManage,
- PermActivitiesRead, PermActivitiesDelete,
+ PermActivitiesRead, PermActivitiesCancel, PermActivitiesDelete,
}
}
@@ -300,7 +301,7 @@ func BuiltInDeployerPermissions() []string {
PermSystemRead,
PermImageUpdatesRead, PermImageUpdatesCheck,
PermVulnsRead,
- PermActivitiesRead,
+ PermActivitiesRead, PermActivitiesCancel,
}
}
diff --git a/backend/pkg/libarcane/activity/handler.go b/backend/pkg/libarcane/activity/handler.go
index e23f72568..23da05ed5 100644
--- a/backend/pkg/libarcane/activity/handler.go
+++ b/backend/pkg/libarcane/activity/handler.go
@@ -3,6 +3,7 @@ package activity
import (
"context"
"encoding/json"
+ "errors"
"fmt"
"io"
"log/slog"
@@ -12,6 +13,22 @@ import (
"github.com/getarcaneapp/arcane/backend/pkg/utils"
)
+// ErrCanceled is the cancellation cause set on an activity's work context when a
+// user requests cancellation. Completion paths read context.Cause to record a
+// cancelled (rather than failed) terminal status.
+var ErrCanceled = errors.New("activity cancelled by user")
+
+// cancelledMessage is the latest-message recorded when work is cancelled.
+const cancelledMessage = "Cancelled by user"
+
+// CancelledByContext reports whether ctx was cancelled by a user cancellation
+// request (as opposed to app shutdown or a deadline). Callers that finalize an
+// activity from a possibly-cancelled work context use this to choose between a
+// cancelled and a failed terminal status.
+func CancelledByContext(ctx context.Context) bool {
+ return ctx != nil && errors.Is(context.Cause(ctx), ErrCanceled)
+}
+
type HandlerOptions struct {
EnvironmentID string
Type models.ActivityType
@@ -25,6 +42,12 @@ type HandlerOptions struct {
Metadata models.JSON
}
+// 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,
@@ -37,9 +60,9 @@ func StartHandlerActivityForUser(
step string,
message string,
metadata models.JSON,
-) string {
+) (string, context.Context) {
if activityService == nil {
- return ""
+ return "", ctx
}
activity, err := activityService.StartActivity(ctx, StartRequest{
@@ -55,9 +78,14 @@ func StartHandlerActivityForUser(
})
if err != nil {
slog.DebugContext(ctx, "failed to start background activity", "type", activityType, "error", err)
- return ""
+ return "", ctx
+ }
+
+ workCtx := ctx
+ if tracker, ok := activityService.(Tracker); ok {
+ workCtx = tracker.Track(ctx, activity.ID)
}
- return activity.ID
+ return activity.ID, workCtx
}
func CompleteHandlerActivity(ctx context.Context, activityService Service, activityID string, successMessage string, err error) {
@@ -69,10 +97,17 @@ func CompleteHandlerActivity(ctx context.Context, activityService Service, activ
var errMessage *string
finalMessage := successMessage
if err != nil {
- status = models.ActivityStatusFailed
- errText := err.Error()
- errMessage = &errText
- finalMessage = errText
+ // Read the cancellation cause from the (possibly-tracked) work context
+ // before it is re-wrapped for the DB write below.
+ if CancelledByContext(ctx) {
+ status = models.ActivityStatusCancelled
+ finalMessage = cancelledMessage
+ } else {
+ status = models.ActivityStatusFailed
+ errText := err.Error()
+ errMessage = &errText
+ finalMessage = errText
+ }
}
activityCtx := utils.ActivityRuntimeContext(ctx, nil)
@@ -81,8 +116,12 @@ func CompleteHandlerActivity(ctx context.Context, activityService Service, activ
}
}
-func RunHandlerActivity(ctx context.Context, activityService Service, opts HandlerOptions, action func() error) (string, error) {
- activityID := StartHandlerActivityForUser(
+// RunHandlerActivity starts an activity, runs action with the activity's work
+// context (cancelable when the service supports it), and completes the activity.
+// 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 := StartHandlerActivityForUser(
ctx,
activityService,
opts.EnvironmentID,
@@ -96,8 +135,8 @@ func RunHandlerActivity(ctx context.Context, activityService Service, opts Handl
opts.Metadata,
)
- err := action()
- CompleteHandlerActivity(ctx, activityService, activityID, opts.SuccessMessage, err)
+ err := action(workCtx)
+ CompleteHandlerActivity(workCtx, activityService, activityID, opts.SuccessMessage, err)
return activityID, err
}
diff --git a/backend/pkg/libarcane/activity/requests.go b/backend/pkg/libarcane/activity/requests.go
index a9f70e37f..cddfb7dff 100644
--- a/backend/pkg/libarcane/activity/requests.go
+++ b/backend/pkg/libarcane/activity/requests.go
@@ -16,6 +16,14 @@ type MessageAppender interface {
AppendMessage(ctx context.Context, activityID string, req AppendMessageRequest) (*activitytypes.Message, error)
}
+// Tracker is an optional interface a Service may implement to make activities
+// cancelable. Track derives a cancelable context bound to the activity ID and
+// registers it so the activity can later be cancelled via the activity service.
+// Implementers release the registration when the activity completes.
+type Tracker interface {
+ Track(ctx context.Context, activityID string) context.Context
+}
+
type StartRequest struct {
EnvironmentID string
Type models.ActivityType
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index cef1c449a..2d91be8fb 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -2028,6 +2028,13 @@
"activity_clear_history_confirm": "Clear History",
"activity_clear_history_success": "Activity history cleared",
"activity_clear_history_failed": "Failed to clear activity history",
+ "activity_cancel": "Cancel activity",
+ "activity_cancel_title": "Cancel activity?",
+ "activity_cancel_message": "This requests cancellation of the running operation. Work already completed by Docker may not be rolled back.",
+ "activity_cancel_confirm": "Cancel Activity",
+ "activity_cancel_success": "Cancellation requested",
+ "activity_cancel_failed": "Failed to cancel activity",
+ "activity_cancel_already_finished": "Activity already finished",
"activity_settings_title": "Activity",
"activity_settings_description": "Configure Activity Center history retention for each environment.",
"activity_settings_saved": "Activity settings saved",
diff --git a/frontend/src/lib/components/activity/activity-cancel.ts b/frontend/src/lib/components/activity/activity-cancel.ts
new file mode 100644
index 000000000..8fcc44be1
--- /dev/null
+++ b/frontend/src/lib/components/activity/activity-cancel.ts
@@ -0,0 +1,34 @@
+import { openConfirmDialog } from '$lib/components/confirm-dialog';
+import { toast } from 'svelte-sonner';
+import { m } from '$lib/paraglide/messages';
+import { activityStore } from '$lib/stores/activity.store.svelte';
+
+/**
+ * Opens a confirmation dialog and, on confirm, requests cancellation of the
+ * activity. Shared by the activity center row action and the detail panel so the
+ * confirm copy, toasts, and the already-finished (409) handling stay in one place.
+ */
+export function confirmCancelActivity(activityId: string) {
+ openConfirmDialog({
+ title: m.activity_cancel_title(),
+ message: m.activity_cancel_message(),
+ confirm: {
+ label: m.activity_cancel_confirm(),
+ destructive: true,
+ action: async () => {
+ try {
+ await activityStore.cancelActivity(activityId);
+ toast.success(m.activity_cancel_success());
+ } catch (error) {
+ if ((error as { response?: { status?: number } })?.response?.status === 409) {
+ toast.info(m.activity_cancel_already_finished());
+ await activityStore.refresh();
+ return;
+ }
+ console.error('Failed to cancel activity:', error);
+ toast.error(m.activity_cancel_failed());
+ }
+ }
+ }
+ });
+}
diff --git a/frontend/src/lib/components/activity/activity-center.svelte b/frontend/src/lib/components/activity/activity-center.svelte
index d7e51cc46..6f93ac67f 100644
--- a/frontend/src/lib/components/activity/activity-center.svelte
+++ b/frontend/src/lib/components/activity/activity-center.svelte
@@ -6,10 +6,11 @@
import ActivityDetailPanel from './activity-detail-panel.svelte';
import { activityStore } from '$lib/stores/activity.store.svelte';
import type { ActivityFilter } from '$lib/types/activity.type';
- import { ActivityIcon, RefreshIcon, TrashIcon } from '$lib/icons';
+ import { ActivityIcon, CloseIcon, RefreshIcon, TrashIcon } from '$lib/icons';
import { m } from '$lib/paraglide/messages';
import { cn } from '$lib/utils';
import { activityFilterLabel } from './activity-labels';
+ import { confirmCancelActivity } from './activity-cancel';
import { openConfirmDialog } from '$lib/components/confirm-dialog';
import { toast } from 'svelte-sonner';
import IfPermitted from '$lib/components/if-permitted.svelte';
@@ -122,19 +123,36 @@
<div>
{#each activityStore.filteredActivities as activity (activity.id)}
{@const expanded = activityStore.isExpanded(activity.id)}
- <Collapsible.Root open={expanded} onOpenChange={(open) => activityStore.setActivityExpanded(activity.id, open)}>
- <Collapsible.Trigger
- class="focus-visible:ring-ring block w-full cursor-pointer appearance-none border-0 bg-transparent p-0 text-left focus-visible:ring-2 focus-visible:outline-hidden focus-visible:ring-inset"
- aria-label={m.activity_center_title()}
- >
- <ActivityListItem {activity} {expanded} />
- </Collapsible.Trigger>
- <Collapsible.Content
- class="data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=closed]:slide-out-to-top-1 data-[state=open]:slide-in-from-top-1 overflow-hidden"
- >
- <ActivityDetailPanel {activity} />
- </Collapsible.Content>
- </Collapsible.Root>
+ {@const cancelable = activity.status === 'running' || activity.status === 'queued'}
+ <div class="group/activity relative">
+ <Collapsible.Root open={expanded} onOpenChange={(open) => activityStore.setActivityExpanded(activity.id, open)}>
+ <Collapsible.Trigger
+ class="focus-visible:ring-ring block w-full cursor-pointer appearance-none border-0 bg-transparent p-0 text-left focus-visible:ring-2 focus-visible:outline-hidden focus-visible:ring-inset"
+ aria-label={m.activity_center_title()}
+ >
+ <ActivityListItem {activity} {expanded} />
+ </Collapsible.Trigger>
+ <Collapsible.Content
+ class="data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=closed]:slide-out-to-top-1 data-[state=open]:slide-in-from-top-1 overflow-hidden"
+ >
+ <ActivityDetailPanel {activity} />
+ </Collapsible.Content>
+ </Collapsible.Root>
+ {#if cancelable}
+ <IfPermitted perm="activities:cancel">
+ <button
+ type="button"
+ onclick={() => confirmCancelActivity(activity.id)}
+ disabled={activityStore.isCancelling(activity.id)}
+ title={m.activity_cancel()}
+ aria-label={m.activity_cancel()}
+ class="text-muted-foreground hover:bg-destructive/10 hover:text-destructive focus-visible:ring-ring bg-background/70 absolute top-1/2 right-11 z-10 flex size-7 -translate-y-1/2 items-center justify-center rounded-md opacity-0 backdrop-blur-sm transition focus-visible:opacity-100 focus-visible:ring-2 focus-visible:outline-hidden group-hover/activity:opacity-100 disabled:pointer-events-none disabled:opacity-40"
+ >
+ <CloseIcon class="size-4" aria-hidden="true" />
+ </button>
+ </IfPermitted>
+ {/if}
+ </div>
{/each}
</div>
{/if}
diff --git a/frontend/src/lib/components/activity/activity-detail-panel.svelte b/frontend/src/lib/components/activity/activity-detail-panel.svelte
index eec062fa8..ab92cf799 100644
--- a/frontend/src/lib/components/activity/activity-detail-panel.svelte
+++ b/frontend/src/lib/components/activity/activity-detail-panel.svelte
@@ -4,9 +4,11 @@
import { CopyButton } from '$lib/components/ui/copy-button';
import { activityStore } from '$lib/stores/activity.store.svelte';
import type { Activity, ActivityMessage } from '$lib/types/activity.type';
- import { ActivityIcon, TerminalIcon } from '$lib/icons';
+ import { ActivityIcon, CloseIcon, TerminalIcon } from '$lib/icons';
import { m } from '$lib/paraglide/messages';
import { cn } from '$lib/utils';
+ import IfPermitted from '$lib/components/if-permitted.svelte';
+ import { confirmCancelActivity } from './activity-cancel';
import { activityStatusLabel, activityStatusVariant, activityTypeIcon, activityTypeLabel } from './activity-labels';
let { activity }: { activity: Activity } = $props();
@@ -30,6 +32,7 @@
liveActivity.sourceEnvironmentName || liveActivity.sourceEnvironmentId || liveActivity.environmentId
);
const startedByName = $derived(liveActivity.startedBy?.displayName || liveActivity.startedBy?.username);
+ const cancelable = $derived(liveActivity.status === 'running' || liveActivity.status === 'queued');
$effect(() => {
messages.length;
@@ -118,6 +121,19 @@
<p class="text-muted-foreground mt-1 truncate text-xs">{activityTarget}</p>
</div>
</div>
+ {#if cancelable}
+ <IfPermitted perm="activities:cancel">
+ <button
+ type="button"
+ onclick={() => confirmCancelActivity(liveActivity.id)}
+ disabled={activityStore.isCancelling(liveActivity.id)}
+ class="border-border/60 text-muted-foreground hover:bg-destructive/10 hover:text-destructive hover:border-destructive/30 focus-visible:ring-ring inline-flex shrink-0 items-center gap-1.5 rounded-md border px-2.5 py-1.5 text-xs font-medium transition focus-visible:ring-2 focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-50"
+ >
+ <CloseIcon class="size-3.5" aria-hidden="true" />
+ {m.activity_cancel()}
+ </button>
+ </IfPermitted>
+ {/if}
</div>
<div class="space-y-2">
diff --git a/frontend/src/lib/services/activity-service.ts b/frontend/src/lib/services/activity-service.ts
index 45ec59d00..1fd9bad51 100644
--- a/frontend/src/lib/services/activity-service.ts
+++ b/frontend/src/lib/services/activity-service.ts
@@ -21,6 +21,11 @@ export class ActivityService extends BaseAPIService {
return this.handleResponse(this.api.get(`/environments/${envId}/activities/${activityId}`, { params: { limit } }));
}
+ async cancelActivity(activityId: string, environmentId?: string): Promise<Activity> {
+ const envId = await this.resolveEnvironmentId(environmentId);
+ return this.handleResponse(this.api.post(`/environments/${envId}/activities/${encodeURIComponent(activityId)}/cancel`));
+ }
+
async clearHistory(environmentId?: string): Promise<ActivityClearHistoryResult> {
const envId = await this.resolveEnvironmentId(environmentId);
return this.handleResponse(this.api.delete(`/environments/${envId}/activities/history`));
diff --git a/frontend/src/lib/stores/activity.store.svelte.ts b/frontend/src/lib/stores/activity.store.svelte.ts
index a764f01c8..90ed0fe8a 100644
--- a/frontend/src/lib/stores/activity.store.svelte.ts
+++ b/frontend/src/lib/stores/activity.store.svelte.ts
@@ -50,6 +50,7 @@ function createActivityStore() {
let _expandedActivityIds = $state<Record<string, boolean>>({});
let _detailLoadingIds = $state<Record<string, boolean>>({});
let _detailErrorIds = $state<Record<string, boolean>>({});
+ let _cancellingIds = $state<Record<string, boolean>>({});
let _filter = $state<ActivityFilter>('running');
let _open = $state(false);
let _loading = $state(false);
@@ -363,6 +364,9 @@ function createActivityStore() {
isDetailError(activityId: string): boolean {
return !!_detailErrorIds[activityId];
},
+ isCancelling(activityId: string): boolean {
+ return !!_cancellingIds[activityId];
+ },
getDetail(activityId: string): ActivityDetail | null {
const activity = _details[activityId]?.activity ?? _activities.find((item) => item.id === activityId);
if (!activity) {
@@ -393,6 +397,21 @@ function createActivityStore() {
abortStreamInternal();
},
refresh: () => refreshInternal(),
+ cancelActivity: async (activityId: string) => {
+ if (!activityId || _cancellingIds[activityId]) {
+ return;
+ }
+ _cancellingIds = { ..._cancellingIds, [activityId]: true };
+ try {
+ // The cancelled status arrives via the stream (mergeActivityInternal);
+ // callers handle success/error toasts.
+ await activityService.cancelActivity(activityId, _currentEnvironmentId);
+ } finally {
+ const next = { ..._cancellingIds };
+ delete next[activityId];
+ _cancellingIds = next;
+ }
+ },
clearHistory: async () => {
await activityService.clearHistory(_currentEnvironmentId);
_details = {};
diff --git a/frontend/src/routes/(app)/images/+page.svelte b/frontend/src/routes/(app)/images/+page.svelte
index 8c8b9f775..dcb40bcd6 100644
--- a/frontend/src/routes/(app)/images/+page.svelte
+++ b/frontend/src/routes/(app)/images/+page.svelte
@@ -109,9 +109,11 @@
const imageUsageCounts = $derived(imageUsageCountsQuery.data ?? imageUsageFallback);
- const isRefreshing = $derived(
- (imagesQuery.isFetching && !imagesQuery.isPending) || (imageUsageCountsQuery.isFetching && !imageUsageCountsQuery.isPending)
- );
+ // Intentionally a manual flag, not $derived(query.isFetching): these queries use
+ // aggressive background refetching (staleTime: 0 + refetchOnMount/WindowFocus:
+ // 'always'), so deriving from isFetching leaves the manual refresh button spinning
+ // constantly. Mirrors the containers page — reflects only user-initiated refreshes.
+ let isRefreshing = $state(false);
const isUploading = $derived(uploadImagesMutation.isPending);
const isPruning = $derived(pruneImagesMutation.isPending);
const isChecking = $derived(checkUpdatesMutation.isPending);
@@ -147,7 +149,12 @@
];
async function refresh() {
- await Promise.all([imagesQuery.refetch(), imageUsageCountsQuery.refetch()]);
+ isRefreshing = true;
+ try {
+ await Promise.all([imagesQuery.refetch(), imageUsageCountsQuery.refetch()]);
+ } finally {
+ isRefreshing = false;
+ }
}
const canPullImage = $derived(hasPermission('images:pull', envId));