Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package container
import (
"context"
"fmt"
"io"
"maps"
"strings"
"github.com/danielgtaylor/huma/v2"
activitytypes "github.com/getarcaneapp/arcane/types/v2/activity"
"github.com/getarcaneapp/arcane/types/v2/base"
"github.com/getarcaneapp/arcane/types/v2/container"
usertypes "github.com/getarcaneapp/arcane/types/v2/user"
dockercontainer "github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/network"
"github.com/samber/mo"
"go.getarcane.app/docker/types"
kit "go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/internal/activity"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/container/children/stats"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
activitylib "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/activity"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
)
type ContainerHandler struct {
containerService *ContainerService
dockerService *docker.DockerClientService
settingsService *settings.SettingsService
activityService *activity.ActivityService
appCtx context.Context
}
// ContainerPaginatedResponse is the paginated list response for containers.
type ContainerPaginatedResponse struct {
Success bool `json:"success"`
Data []container.Summary `json:"data"`
Groups []container.SummaryGroup `json:"groups,omitempty"`
Counts container.StatusCounts `json:"counts"`
Pagination base.PaginationResponse `json:"pagination"`
ResourceSortSupported bool `json:"resourceSortSupported"`
FailedEnvironments []base.EnvironmentFailure `json:"failedEnvironments,omitempty" doc:"Environments whose results are missing from a multi-environment response"`
}
type ListContainersInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
Search string `query:"search" doc:"Search query"`
Sort string `query:"sort" doc:"Column to sort by"`
Order string `query:"order" default:"asc" doc:"Sort direction"`
Start int `query:"start" default:"0" doc:"Start index"`
Limit int `query:"limit" default:"20" doc:"Limit"`
GroupBy string `query:"groupBy" doc:"Optional grouping mode (for example: project)"`
IncludeInternal bool `query:"includeInternal" default:"false" doc:"Include internal containers"`
IncludeHidden bool `query:"includeHidden" default:"false" doc:"Include hidden containers"`
Updates string `query:"updates" doc:"Filter by update status (has_update, up_to_date, error, unknown)"`
Standalone string `query:"standalone" doc:"Filter standalone containers only (true/false)"`
Label string `query:"label" doc:"Filter by label key or key=value"`
}
type ListContainersOutput struct {
Body ContainerPaginatedResponse
}
type GetContainerStatusCountsInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
IncludeInternal bool `query:"includeInternal" default:"false" doc:"Include internal containers"`
IncludeHidden bool `query:"includeHidden" default:"false" doc:"Include hidden containers"`
}
type CreateContainerInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
Body container.Create
}
type GetContainerInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
}
type ContainerActionInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
}
type DeleteContainerInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
Force bool `query:"force" default:"false" doc:"Force delete running container"`
RemoveVolumes bool `query:"volumes" default:"false" doc:"Remove associated volumes"`
}
// SetAutoUpdateInput is the request input for toggling container auto-update.
type SetAutoUpdateInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
Body container.SetAutoUpdateRequest
}
// KillContainerInput carries the optional signal for a container kill.
type KillContainerInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
Signal string `query:"signal" doc:"Signal to send (for example SIGTERM, SIGKILL). Defaults to SIGKILL."`
}
type CommitContainerInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
Body container.CommitRequest
}
type GetContainerEditConfigInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
}
type EditContainerInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
ContainerID string `path:"containerId" doc:"Container ID"`
Body container.Edit
}
type GenerateComposeInput struct {
EnvironmentID string `path:"id" doc:"Environment ID"`
Body container.GenerateComposeRequest
}
type containerActionConfig struct {
ActivityType activitytypes.Type
Step string
StartMessage string
CompleteMessage string
SuccessMessage string
Action func(context.Context, string, usertypes.Actor) error
Error func(error) error
}
func (h *ContainerHandler) ListContainers(ctx context.Context, input *ListContainersInput) (*ListContainersOutput, error) {
params := handlerutil.PaginationParams(input.Start, input.Limit, input.Sort, input.Order, input.Search)
if input.Updates != "" {
params.Filters["updates"] = input.Updates
}
if input.Standalone != "" {
params.Filters["standalone"] = input.Standalone
}
if input.Label != "" {
params.Filters["label"] = input.Label
}
if _, ok := httpx.EnvironmentScopeFromContext(ctx); ok {
body, err := h.containerService.AggregateContainers(ctx, params, input.GroupBy)
if err != nil {
return nil, huma.Error500InternalServerError("Failed to list containers: " + err.Error())
}
return &ListContainersOutput{Body: body}, nil
}
if ps, _ := middleware.PermissionsFromContext(ctx); stats.ContainerResourceSortPermissionDenied(ps, input.EnvironmentID, input.Sort) {
return nil, huma.Error403Forbidden("permission denied: " + authz.PermContainersRead)
}
result, err := h.containerService.ListContainersPaginated(ctx, params, true, input.IncludeInternal, input.IncludeHidden, input.GroupBy)
if err != nil {
return nil, huma.Error500InternalServerError("Failed to list containers: " + err.Error())
}
return &ListContainersOutput{
Body: ContainerPaginatedResponse{
Success: true,
Data: result.Items,
Groups: result.Groups,
Counts: result.Counts,
Pagination: handlerutil.PaginationResponse(result.Pagination),
ResourceSortSupported: true,
},
}, nil
}
func (h *ContainerHandler) GetContainerStatusCounts(ctx context.Context, input *GetContainerStatusCountsInput) (*handlerutil.Out[container.StatusCounts], error) {
containers, _, _, _, err := h.dockerService.GetAllContainers(ctx)
if err != nil {
return nil, huma.Error500InternalServerError("Failed to get container counts: " + err.Error())
}
containers = FilterExcludedContainers(containers, input.IncludeInternal, input.IncludeHidden)
running := 0
for _, c := range containers {
if c.State == "running" {
running++
}
}
return &handlerutil.Out[container.StatusCounts]{
Body: base.ApiResponse[container.StatusCounts]{
Success: true,
Data: container.StatusCounts{
RunningContainers: running,
StoppedContainers: len(containers) - running,
TotalContainers: len(containers),
},
},
}, nil
}
func (h *ContainerHandler) CreateContainer(ctx context.Context, input *CreateContainerInput) (*handlerutil.Out[container.Created], error) {
user, err := handlerutil.RequireUser(ctx)
if err != nil {
return nil, err
}
exposedPorts := network.PortSet{}
portBindings := network.PortMap{}
for containerPort, hostPort := range input.Body.Ports {
port, parsePortErr := network.ParsePort(containerPort + "/tcp")
if parsePortErr != nil {
return nil, huma.Error400BadRequest("Invalid port format: " + parsePortErr.Error())
}
exposedPorts[port] = struct{}{}
portBindings[port] = []network.PortBinding{{HostPort: hostPort}}
}
for portSpec := range input.Body.ExposedPorts {
port, parsePortErr := network.ParsePort(kit.Ternary(strings.Contains(portSpec, "/"), portSpec, portSpec+"/tcp"))
if parsePortErr != nil {
return nil, huma.Error400BadRequest("Invalid port format: " + parsePortErr.Error())
}
exposedPorts[port] = struct{}{}
}
hostConfig := kit.FromPtr(input.Body.HostConfig)
hostBindings, err := portMapFromCreate(hostConfig.PortBindings)
if err != nil {
return nil, huma.Error400BadRequest("Invalid port format: " + err.Error())
}
for port, bindings := range hostBindings {
exposedPorts[port] = struct{}{}
if len(bindings) > 0 {
portBindings[port] = append(portBindings[port], bindings...)
}
}
endpoints := map[string]*network.EndpointSettings{}
for name, endpoint := range kit.FromPtr(input.Body.NetworkingConfig).EndpointsConfig {
ipam, ipamErr := endpointIPAMFromCreate(endpoint)
if ipamErr != nil {
return nil, huma.Error400BadRequest("Invalid network configuration: " + ipamErr.Error())
}
endpoints[name] = &network.EndpointSettings{Aliases: endpoint.Aliases, IPAMConfig: ipam}
}
if len(endpoints) == 0 {
for _, networkName := range input.Body.Networks {
endpoints[networkName] = &network.EndpointSettings{}
}
}
createLabels := map[string]string{"com.arcane.created": "true"}
maps.Copy(createLabels, input.Body.Labels)
containerJSON, err := h.containerService.CreateContainer(
ctx,
&dockercontainer.Config{
Image: input.Body.Image,
Cmd: kit.Ternary(len(input.Body.Command) > 0, input.Body.Command, input.Body.Cmd),
Entrypoint: input.Body.Entrypoint,
WorkingDir: input.Body.WorkingDir,
User: input.Body.User,
Env: kit.Ternary(len(input.Body.Environment) > 0, input.Body.Environment, input.Body.Env),
ExposedPorts: exposedPorts,
Labels: createLabels,
Healthcheck: healthConfigFromCreate(input.Body.Healthcheck),
Hostname: input.Body.Hostname,
Domainname: input.Body.Domainname,
AttachStdout: input.Body.AttachStdout,
AttachStderr: input.Body.AttachStderr,
AttachStdin: input.Body.AttachStdin,
Tty: input.Body.Tty,
OpenStdin: input.Body.OpenStdin,
StdinOnce: input.Body.StdinOnce,
NetworkDisabled: input.Body.NetworkDisabled,
},
&dockercontainer.HostConfig{
Binds: kit.Ternary(len(hostConfig.Binds) > 0, hostConfig.Binds, input.Body.Volumes),
NetworkMode: dockercontainer.NetworkMode(hostConfig.NetworkMode),
PortBindings: portBindings,
RestartPolicy: dockercontainer.RestartPolicy{
Name: dockercontainer.RestartPolicyMode(kit.Ternary(hostConfig.RestartPolicy != nil, kit.FromPtr(hostConfig.RestartPolicy).Name, input.Body.RestartPolicy)),
MaximumRetryCount: kit.FromPtr(hostConfig.RestartPolicy).MaximumRetryCount,
},
AutoRemove: mo.PointerToOption(hostConfig.AutoRemove).OrElse(input.Body.AutoRemove),
CapAdd: kit.Ternary(len(hostConfig.CapAdd) > 0, hostConfig.CapAdd, nil),
CapDrop: kit.Ternary(len(hostConfig.CapDrop) > 0, hostConfig.CapDrop, nil),
Privileged: mo.PointerToOption(hostConfig.Privileged).OrElse(input.Body.Privileged),
PublishAllPorts: kit.FromPtr(hostConfig.PublishAllPorts),
ReadonlyRootfs: kit.FromPtr(hostConfig.ReadonlyRootfs),
Memory: kit.Ternary(input.Body.Memory > 0, input.Body.Memory, max(hostConfig.Memory, 0)),
MemorySwap: max(hostConfig.MemorySwap, 0),
NanoCPUs: kit.Ternary(input.Body.CPUs > 0, int64(input.Body.CPUs*1e9), max(hostConfig.NanoCPUs, 0)),
CPUShares: max(hostConfig.CPUShares, 0),
Mounts: kit.Ternary(len(hostConfig.Mounts) > 0, mergeEditMounts(nil, hostConfig.Mounts), nil),
},
func() *network.NetworkingConfig {
if len(endpoints) == 0 {
return nil
}
return &network.NetworkingConfig{EndpointsConfig: endpoints}
}(),
input.Body.Name,
*user,
input.Body.Credentials,
)
if err != nil {
return nil, huma.Error500InternalServerError("Failed to create container: " + err.Error())
}
return &handlerutil.Out[container.Created]{
Body: base.ApiResponse[container.Created]{
Success: true,
Data: container.Created{
ID: containerJSON.ID,
Name: containerJSON.Name,
Image: containerJSON.Config.Image,
Status: string(containerJSON.State.Status),
Created: containerJSON.Created,
},
},
}, nil
}
func (h *ContainerHandler) GetContainer(ctx context.Context, input *GetContainerInput) (*handlerutil.Out[container.Details], error) {
details, err := h.containerService.GetContainerDetails(ctx, input.ContainerID)
if err != nil {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return nil, huma.NewError(apiErr.HTTPStatus(), "Failed to retrieve container: "+apiErr.Message)
}
return &handlerutil.Out[container.Details]{
Body: base.ApiResponse[container.Details]{
Success: true,
Data: details,
},
}, nil
}
func (h *ContainerHandler) GetContainerProcesses(ctx context.Context, input *GetContainerInput) (*handlerutil.Out[container.Processes], error) {
processes, err := h.containerService.GetContainerProcesses(ctx, input.ContainerID)
if err != nil {
apiErr := common.ToAPIError(err)
return nil, huma.NewError(apiErr.HTTPStatus(), "Failed to retrieve container processes: "+apiErr.Message)
}
return &handlerutil.Out[container.Processes]{
Body: base.ApiResponse[container.Processes]{
Success: true,
Data: processes,
},
}, nil
}
func (h *ContainerHandler) DownloadContainerLogs(ctx context.Context, input *GetContainerInput) (*huma.StreamResponse, error) {
reader, filename, err := h.containerService.DownloadLogs(ctx, input.ContainerID)
if err != nil {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return nil, huma.NewError(apiErr.HTTPStatus(), "Failed to download container logs: "+apiErr.Message)
}
return handlerutil.DownloadResponse(reader, -1, filename), nil
}
func (h *ContainerHandler) GenerateCompose(ctx context.Context, input *GenerateComposeInput) (*handlerutil.Out[container.GenerateComposeResponse], error) {
composeContent, err := projects.ComposeGenerate(ctx, h.dockerService.DockerHost(), "", input.Body.ContainerIDs)
if err != nil {
return nil, huma.Error500InternalServerError("Failed to generate compose file: " + err.Error())
}
return &handlerutil.Out[container.GenerateComposeResponse]{
Body: base.ApiResponse[container.GenerateComposeResponse]{
Success: true,
Data: container.GenerateComposeResponse{ComposeContent: composeContent},
},
}, nil
}
func (h *ContainerHandler) StartContainer(ctx context.Context, input *ContainerActionInput) (*handlerutil.Out[base.MessageResponse], error) {
return h.runContainerAction(ctx, input, containerActionConfig{
ActivityType: activitytypes.TypeContainerStart,
Step: "Starting container",
StartMessage: "Container start requested",
CompleteMessage: "Container started",
SuccessMessage: "Container started successfully",
Action: func(runtimeCtx context.Context, containerID string, user usertypes.Actor) error {
return h.containerService.StartContainer(runtimeCtx, containerID, user)
},
Error: func(err error) error {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return huma.NewError(apiErr.HTTPStatus(), "Failed to start container: "+apiErr.Message)
},
})
}
func (h *ContainerHandler) StopContainer(ctx context.Context, input *ContainerActionInput) (*handlerutil.Out[base.MessageResponse], error) {
return h.runContainerAction(ctx, input, containerActionConfig{
ActivityType: activitytypes.TypeContainerStop,
Step: "Stopping container",
StartMessage: "Container stop requested",
CompleteMessage: "Container stopped",
SuccessMessage: "Container stopped successfully",
Action: func(runtimeCtx context.Context, containerID string, user usertypes.Actor) error {
return h.containerService.StopContainer(runtimeCtx, containerID, user)
},
Error: func(err error) error {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return huma.NewError(apiErr.HTTPStatus(), "Failed to stop container: "+apiErr.Message)
},
})
}
func (h *ContainerHandler) RestartContainer(ctx context.Context, input *ContainerActionInput) (*handlerutil.Out[base.MessageResponse], error) {
return h.runContainerAction(ctx, input, containerActionConfig{
ActivityType: activitytypes.TypeContainerRestart,
Step: "Restarting container",
StartMessage: "Container restart requested",
CompleteMessage: "Container restarted",
SuccessMessage: "Container restarted successfully",
Action: func(runtimeCtx context.Context, containerID string, user usertypes.Actor) error {
return h.containerService.RestartContainer(runtimeCtx, containerID, user)
},
Error: func(err error) error {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return huma.NewError(apiErr.HTTPStatus(), "Failed to restart container: "+apiErr.Message)
},
})
}
func (h *ContainerHandler) KillContainer(ctx context.Context, input *KillContainerInput) (*handlerutil.Out[base.MessageResponse], error) {
return h.runContainerAction(ctx, &ContainerActionInput{EnvironmentID: input.EnvironmentID, ContainerID: input.ContainerID}, containerActionConfig{
ActivityType: activitytypes.TypeContainerKill,
Step: "Killing container",
StartMessage: "Container kill requested",
CompleteMessage: "Container killed",
SuccessMessage: "Container killed successfully",
Action: func(runtimeCtx context.Context, containerID string, user usertypes.Actor) error {
return h.containerService.KillContainer(runtimeCtx, containerID, strings.TrimSpace(input.Signal), user)
},
Error: func(err error) error {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return huma.NewError(apiErr.HTTPStatus(), "Failed to kill container: "+apiErr.Message)
},
})
}
func (h *ContainerHandler) PauseContainer(ctx context.Context, input *ContainerActionInput) (*handlerutil.Out[base.MessageResponse], error) {
return h.runContainerAction(ctx, input, containerActionConfig{
ActivityType: activitytypes.TypeContainerPause,
Step: "Pausing container",
StartMessage: "Container pause requested",
CompleteMessage: "Container paused",
SuccessMessage: "Container paused successfully",
Action: func(runtimeCtx context.Context, containerID string, user usertypes.Actor) error {
return h.containerService.PauseContainer(runtimeCtx, containerID, user)
},
Error: func(err error) error {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return huma.NewError(apiErr.HTTPStatus(), "Failed to pause container: "+apiErr.Message)
},
})
}
func (h *ContainerHandler) UnpauseContainer(ctx context.Context, input *ContainerActionInput) (*handlerutil.Out[base.MessageResponse], error) {
return h.runContainerAction(ctx, input, containerActionConfig{
ActivityType: activitytypes.TypeContainerUnpause,
Step: "Unpausing container",
StartMessage: "Container unpause requested",
CompleteMessage: "Container unpaused",
SuccessMessage: "Container unpaused successfully",
Action: func(runtimeCtx context.Context, containerID string, user usertypes.Actor) error {
return h.containerService.UnpauseContainer(runtimeCtx, containerID, user)
},
Error: func(err error) error {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return huma.NewError(apiErr.HTTPStatus(), "Failed to unpause container: "+apiErr.Message)
},
})
}
// containerActivityName returns the container's name for activity records, falling back to its ID.
func (h *ContainerHandler) containerActivityName(ctx context.Context, containerID string) string {
name, err := h.containerService.GetContainerNameByID(ctx, containerID)
if err != nil || name == "" {
return containerID
}
return name
}
func (h *ContainerHandler) runContainerAction(ctx context.Context, input *ContainerActionInput, cfg containerActionConfig) (*handlerutil.Out[base.MessageResponse], error) {
user, err := handlerutil.RequireUser(ctx)
if err != nil {
return nil, err
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
input.EnvironmentID,
cfg.ActivityType,
"container",
input.ContainerID,
h.containerActivityName(
runtimeCtx,
input.ContainerID,
),
user,
cfg.Step,
cfg.StartMessage,
database.JSON{
"containerID": input.ContainerID,
},
false,
)
if actionErr := cfg.Action(runtimeCtx, input.ContainerID, *user); actionErr != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, cfg.CompleteMessage, actionErr)
return nil, cfg.Error(actionErr)
}
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, cfg.CompleteMessage, nil)
return handlerutil.MessageOutput(cfg.SuccessMessage, activityID), nil
}
func (h *ContainerHandler) CommitContainer(ctx context.Context, input *CommitContainerInput) (*handlerutil.Out[container.CommitResult], error) {
if strings.TrimSpace(input.ContainerID) == "" {
return nil, huma.Error400BadRequest("container ID is required")
}
user, err := handlerutil.RequireUser(ctx)
if err != nil {
return nil, err
}
out, err := h.containerService.CommitContainer(ctx, input.ContainerID, input.Body, *user)
if err != nil {
return nil, huma.NewError(common.ToAPIError(common.ClassifyDockerError(err)).HTTPStatus(), fmt.Sprintf("failed to commit container: %v", err))
}
return &handlerutil.Out[container.CommitResult]{
Body: base.ApiResponse[container.CommitResult]{
Success: true,
Data: *out,
},
}, nil
}
func (h *ContainerHandler) RedeployContainer(ctx context.Context, input *ContainerActionInput) (*handlerutil.Out[container.Details], error) {
user, err := handlerutil.RequireUser(ctx)
if err != nil {
return nil, err
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
input.EnvironmentID,
activitytypes.TypeContainerRedeploy,
"container",
input.ContainerID,
h.containerActivityName(
runtimeCtx,
input.ContainerID,
),
user,
"Starting redeploy",
"Container redeploy requested",
database.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, types.ProgressWriterKey{}, activityWriter)
newContainerID, err := h.containerService.RedeployContainer(redeployCtx, input.ContainerID, *user)
if err != nil {
activitylib.FlushWriter(activityWriter)
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container redeploy failed", err)
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return nil, huma.NewError(apiErr.HTTPStatus(), "Failed to redeploy container: "+apiErr.Message)
}
activitylib.FlushWriter(activityWriter)
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container redeployed", nil)
// Fetch full container details to return (consistent with other endpoints)
details, inspectErr := h.containerService.GetContainerDetails(runtimeCtx, newContainerID)
if inspectErr != nil {
// Container was redeployed successfully, but we couldn't fetch full details.
// Return minimal response with just the ID so frontend can still navigate.
return &handlerutil.Out[container.Details]{
Body: base.ApiResponse[container.Details]{
Success: true,
Data: container.Details{
ID: newContainerID,
ActivityID: mo.EmptyableToOption(strings.TrimSpace(activityID)).ToPointer(),
},
},
}, nil
}
return &handlerutil.Out[container.Details]{
Body: base.ApiResponse[container.Details]{
Success: true,
Data: container.Details{ //exhaustruct:enforce
ID: details.ID,
Name: details.Name,
Image: details.Image,
ImageID: details.ImageID,
Created: details.Created,
State: details.State,
Config: details.Config,
HostConfig: details.HostConfig,
NetworkSettings: details.NetworkSettings,
Ports: details.Ports,
Mounts: details.Mounts,
Labels: details.Labels,
ComposeInfo: details.ComposeInfo,
IconLightURL: details.IconLightURL,
IconDarkURL: details.IconDarkURL,
RedeployDisabled: details.RedeployDisabled,
AutoUpdateEnabled: details.AutoUpdateEnabled,
UpdateInfo: details.UpdateInfo,
ActivityID: mo.EmptyableToOption(strings.TrimSpace(activityID)).ToPointer(),
},
},
}, nil
}
func (h *ContainerHandler) GetContainerEditConfig(ctx context.Context, input *GetContainerEditConfigInput) (*handlerutil.Out[container.EditConfig], error) {
editConfig, err := h.containerService.GetContainerEditConfig(ctx, input.ContainerID)
if err != nil {
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return nil, huma.NewError(apiErr.HTTPStatus(), "Failed to retrieve container: "+apiErr.Message)
}
return &handlerutil.Out[container.EditConfig]{
Body: base.ApiResponse[container.EditConfig]{
Success: true,
Data: editConfig,
},
}, nil
}
func (h *ContainerHandler) EditContainer(ctx context.Context, input *EditContainerInput) (*handlerutil.Out[container.Details], error) {
user, err := handlerutil.RequireUser(ctx)
if err != nil {
return nil, err
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
input.EnvironmentID,
activitytypes.TypeContainerEdit,
"container",
input.ContainerID,
h.containerActivityName(
runtimeCtx,
input.ContainerID,
),
user,
"Starting edit",
"Container edit requested",
database.JSON{
"containerID": input.ContainerID,
},
true,
)
activitylib.AwaitHandlerActivitySlot(runtimeCtx, h.activityService, activityID, input.EnvironmentID)
activityWriter := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, io.Discard, "Editing container")
editCtx := context.WithValue(runtimeCtx, types.ProgressWriterKey{}, activityWriter)
newContainerID, err := h.containerService.EditContainer(editCtx, input.ContainerID, input.Body, *user)
if err != nil {
activitylib.FlushWriter(activityWriter)
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container edit failed", err)
apiErr := common.ToAPIError(common.ClassifyDockerError(err))
return nil, huma.NewError(apiErr.HTTPStatus(), apiErr.Message)
}
activitylib.FlushWriter(activityWriter)
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container edited", nil)
// Fetch full container details to return (consistent with redeploy)
details, inspectErr := h.containerService.GetContainerDetails(runtimeCtx, newContainerID)
if inspectErr != nil {
// Container was recreated successfully, but we couldn't fetch full details.
// Return minimal response with just the ID so frontend can still navigate.
return &handlerutil.Out[container.Details]{
Body: base.ApiResponse[container.Details]{
Success: true,
Data: container.Details{
ID: newContainerID,
ActivityID: mo.EmptyableToOption(strings.TrimSpace(activityID)).ToPointer(),
},
},
}, nil
}
return &handlerutil.Out[container.Details]{
Body: base.ApiResponse[container.Details]{
Success: true,
Data: container.Details{ //exhaustruct:enforce
ID: details.ID,
Name: details.Name,
Image: details.Image,
ImageID: details.ImageID,
Created: details.Created,
State: details.State,
Config: details.Config,
HostConfig: details.HostConfig,
NetworkSettings: details.NetworkSettings,
Ports: details.Ports,
Mounts: details.Mounts,
Labels: details.Labels,
ComposeInfo: details.ComposeInfo,
IconLightURL: details.IconLightURL,
IconDarkURL: details.IconDarkURL,
RedeployDisabled: details.RedeployDisabled,
AutoUpdateEnabled: details.AutoUpdateEnabled,
UpdateInfo: details.UpdateInfo,
ActivityID: mo.EmptyableToOption(strings.TrimSpace(activityID)).ToPointer(),
},
},
}, nil
}
func (h *ContainerHandler) DeleteContainer(ctx context.Context, input *DeleteContainerInput) (*handlerutil.Out[base.MessageResponse], error) {
user, err := handlerutil.RequireUser(ctx)
if err != nil {
return nil, err
}
runtimeCtx := utils.ActivityRuntimeContext(ctx, h.appCtx)
activityID, runtimeCtx := activitylib.StartHandlerActivity(
runtimeCtx,
h.activityService,
input.EnvironmentID,
activitytypes.TypeContainerDelete,
"container",
input.ContainerID,
h.containerActivityName(
runtimeCtx,
input.ContainerID,
),
user,
"Deleting container",
"Container delete requested",
database.JSON{
"containerID": input.ContainerID,
"force": input.Force,
"removeVolumes": input.RemoveVolumes,
},
false,
)
if deleteContainerErr := h.containerService.DeleteContainer(runtimeCtx, input.ContainerID, input.Force, input.RemoveVolumes, *user); deleteContainerErr != nil {
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container deleted", deleteContainerErr)
apiErr := common.ToAPIError(common.ClassifyDockerError(deleteContainerErr))
return nil, huma.NewError(apiErr.HTTPStatus(), "Failed to delete container: "+apiErr.Message)
}
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Container deleted", nil)
return handlerutil.MessageOutput("Container deleted successfully", activityID), nil
}
func (h *ContainerHandler) SetAutoUpdate(ctx context.Context, input *SetAutoUpdateInput) (*handlerutil.Out[base.MessageResponse], error) {
// Resolve container name from ID
containerName, err := h.containerService.GetContainerNameByID(ctx, input.ContainerID)
if err != nil {
return nil, huma.Error404NotFound("container not found")
}
if setContainerAutoUpdateExclusionErr := h.settingsService.SetContainerAutoUpdateExclusionInternal(ctx, containerName, !input.Body.Enabled); setContainerAutoUpdateExclusionErr != nil {
return nil, huma.Error500InternalServerError("failed to update auto-update setting")
}
return handlerutil.MessageOutput(kit.Ternary(input.Body.Enabled, "Auto-update enabled", "Auto-update disabled"), ""), nil
}