Skip to content

Modern Docker Management, Designed for Everyone

feat: volume browsing and backups (#1591)

Kyle Mendell4f0ea4a6868d
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index 200fdd4b4..f1626e3f0 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -56,6 +56,14 @@ func Bootstrap(ctx context.Context) error {
if err != nil {
return fmt.Errorf("failed to initialize services: %w", err)
}
+ defer func(ctx context.Context) {
+ baseCtx := context.WithoutCancel(ctx)
+ shutdownCtx, shutdownCancel := context.WithTimeout(baseCtx, 10*time.Second)
+ defer shutdownCancel()
+ if appServices.Volume != nil {
+ appServices.Volume.CleanupHelperContainers(shutdownCtx)
+ }
+ }(appCtx)
utils.LoadAgentToken(appCtx, cfg, appServices.Settings.GetStringSetting)
utils.EnsureEncryptionKey(appCtx, cfg, appServices.Settings.EnsureEncryptionKey)
diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.go
index 821cbe65b..8cb7c6b15 100644
--- a/backend/internal/bootstrap/services_bootstrap.go
+++ b/backend/internal/bootstrap/services_bootstrap.go
@@ -67,7 +67,7 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Config
svcs.Project = services.NewProjectService(db, svcs.Settings, svcs.Event, svcs.Image, svcs.Docker)
svcs.Environment = services.NewEnvironmentService(db, httpClient, svcs.Docker, svcs.Event, svcs.Settings)
svcs.Container = services.NewContainerService(db, svcs.Event, svcs.Docker, svcs.Image, svcs.Settings)
- svcs.Volume = services.NewVolumeService(db, svcs.Docker, svcs.Event, svcs.Settings)
+ svcs.Volume = services.NewVolumeService(db, svcs.Docker, svcs.Event, svcs.Settings, svcs.Container, svcs.Image, cfg.BackupVolumeName)
svcs.Network = services.NewNetworkService(db, svcs.Docker, svcs.Event)
svcs.Template = services.NewTemplateService(ctx, db, httpClient, svcs.Settings)
svcs.Auth = services.NewAuthService(svcs.User, svcs.Settings, svcs.Event, cfg.JWTSecret, cfg)
diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go
index b66c3f7fd..86b321cec 100644
--- a/backend/internal/config/config.go
+++ b/backend/internal/config/config.go
@@ -62,12 +62,13 @@ type Config struct {
DirPerm os.FileMode `env:"DIR_PERM" default:"0755"`
GitWorkDir string `env:"GIT_WORK_DIR" default:"data/git"`
- DockerAPITimeout int `env:"DOCKER_API_TIMEOUT" default:"0"`
- DockerImagePullTimeout int `env:"DOCKER_IMAGE_PULL_TIMEOUT" default:"0"`
- GitOperationTimeout int `env:"GIT_OPERATION_TIMEOUT" default:"0"`
- HTTPClientTimeout int `env:"HTTP_CLIENT_TIMEOUT" default:"0"`
- RegistryTimeout int `env:"REGISTRY_TIMEOUT" default:"0"`
- ProxyRequestTimeout int `env:"PROXY_REQUEST_TIMEOUT" default:"0"`
+ DockerAPITimeout int `env:"DOCKER_API_TIMEOUT" default:"0"`
+ DockerImagePullTimeout int `env:"DOCKER_IMAGE_PULL_TIMEOUT" default:"0"`
+ GitOperationTimeout int `env:"GIT_OPERATION_TIMEOUT" default:"0"`
+ HTTPClientTimeout int `env:"HTTP_CLIENT_TIMEOUT" default:"0"`
+ RegistryTimeout int `env:"REGISTRY_TIMEOUT" default:"0"`
+ ProxyRequestTimeout int `env:"PROXY_REQUEST_TIMEOUT" default:"0"`
+ BackupVolumeName string `env:"ARCANE_BACKUP_VOLUME_NAME" default:"arcane-backups"`
}
func Load() *Config {
diff --git a/backend/internal/huma/handlers/containers.go b/backend/internal/huma/handlers/containers.go
index b932080fa..7139290ca 100644
--- a/backend/internal/huma/handlers/containers.go
+++ b/backend/internal/huma/handlers/containers.go
@@ -13,6 +13,7 @@ import (
humamw "github.com/getarcaneapp/arcane/backend/internal/huma/middleware"
"github.com/getarcaneapp/arcane/backend/internal/services"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
"github.com/getarcaneapp/arcane/types/base"
containertypes "github.com/getarcaneapp/arcane/types/container"
)
@@ -31,12 +32,13 @@ type ContainerPaginatedResponse struct {
}
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"`
+ 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"`
+ IncludeInternal bool `query:"includeInternal" default:"false" doc:"Include internal containers"`
}
type ListContainersOutput struct {
@@ -44,7 +46,8 @@ type ListContainersOutput struct {
}
type GetContainerStatusCountsInput struct {
- EnvironmentID string `path:"id" doc:"Environment ID"`
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ IncludeInternal bool `query:"includeInternal" default:"false" doc:"Include internal containers"`
}
// ContainerStatusCountsResponse is a dedicated response type to avoid schema name collision
@@ -211,7 +214,7 @@ func (h *ContainerHandler) ListContainers(ctx context.Context, input *ListContai
},
}
- containers, paginationResp, counts, err := h.containerService.ListContainersPaginated(ctx, params, true)
+ containers, paginationResp, counts, err := h.containerService.ListContainersPaginated(ctx, params, true, input.IncludeInternal)
if err != nil {
return nil, huma.Error500InternalServerError((&common.ContainerListError{Err: err}).Error())
}
@@ -237,11 +240,32 @@ func (h *ContainerHandler) GetContainerStatusCounts(ctx context.Context, input *
return nil, huma.Error500InternalServerError("docker service not available")
}
- _, running, stopped, total, err := h.dockerService.GetAllContainers(ctx)
+ containers, _, _, _, err := h.dockerService.GetAllContainers(ctx)
if err != nil {
return nil, huma.Error500InternalServerError((&common.ContainerStatusCountsError{Err: err}).Error())
}
+ if !input.IncludeInternal {
+ filtered := make([]dockercontainer.Summary, 0, len(containers))
+ for _, c := range containers {
+ if libarcane.IsInternalContainer(c.Labels) {
+ continue
+ }
+ filtered = append(filtered, c)
+ }
+ containers = filtered
+ }
+
+ running, stopped := 0, 0
+ for _, c := range containers {
+ if c.State == "running" {
+ running++
+ } else {
+ stopped++
+ }
+ }
+ total := len(containers)
+
return &GetContainerStatusCountsOutput{
Body: ContainerStatusCountsResponse{
Success: true,
diff --git a/backend/internal/huma/handlers/settings.go b/backend/internal/huma/handlers/settings.go
index 1cf99a368..0f26051a1 100644
--- a/backend/internal/huma/handlers/settings.go
+++ b/backend/internal/huma/handlers/settings.go
@@ -208,6 +208,15 @@ func (h *SettingsHandler) GetPublicSettings(ctx context.Context, input *GetPubli
Value: strconv.FormatBool(uiConfigDisabled),
Type: "boolean",
})
+ backupVolumeName := "arcane-backups"
+ if h.cfg != nil && strings.TrimSpace(h.cfg.BackupVolumeName) != "" {
+ backupVolumeName = h.cfg.BackupVolumeName
+ }
+ settingsDto = append(settingsDto, settings.PublicSetting{
+ Key: "backupVolumeName",
+ Value: backupVolumeName,
+ Type: "string",
+ })
return &GetPublicSettingsOutput{Body: settingsDto}, nil
}
@@ -256,6 +265,15 @@ func (h *SettingsHandler) GetSettings(ctx context.Context, input *GetSettingsInp
Value: strconv.FormatBool(uiConfigDisabled),
Type: "boolean",
})
+ backupVolumeName := "arcane-backups"
+ if h.cfg != nil && strings.TrimSpace(h.cfg.BackupVolumeName) != "" {
+ backupVolumeName = h.cfg.BackupVolumeName
+ }
+ settingsDto = append(settingsDto, settings.PublicSetting{
+ Key: "backupVolumeName",
+ Value: backupVolumeName,
+ Type: "string",
+ })
return &GetSettingsOutput{Body: settingsDto}, nil
}
diff --git a/backend/internal/huma/handlers/volumes.go b/backend/internal/huma/handlers/volumes.go
index a80f1a3fb..3eac3dbfc 100644
--- a/backend/internal/huma/handlers/volumes.go
+++ b/backend/internal/huma/handlers/volumes.go
@@ -2,12 +2,15 @@ package handlers
import (
"context"
+ "io"
"net/http"
+ "path"
"github.com/danielgtaylor/huma/v2"
"github.com/docker/docker/api/types/volume"
"github.com/getarcaneapp/arcane/backend/internal/common"
humamw "github.com/getarcaneapp/arcane/backend/internal/huma/middleware"
+ "github.com/getarcaneapp/arcane/backend/internal/models"
"github.com/getarcaneapp/arcane/backend/internal/services"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
"github.com/getarcaneapp/arcane/types/base"
@@ -133,6 +136,173 @@ type GetVolumeSizesOutput struct {
Body base.ApiResponse[[]VolumeSizeInfo]
}
+// --- Volume Browser & Backup ---
+
+type BrowseDirectoryInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ Path string `query:"path" default:"/" doc:"Directory path to browse"`
+}
+
+type BrowseDirectoryOutput struct {
+ Body base.ApiResponse[[]volumetypes.FileEntry]
+}
+
+type GetFileContentInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ Path string `query:"path" doc:"File path"`
+ MaxBytes int64 `query:"maxBytes" default:"1048576" doc:"Maximum bytes to read (default 1MB)"`
+}
+
+type FileContentResponse struct {
+ Content []byte `json:"content"`
+ MimeType string `json:"mimeType"`
+}
+
+type GetFileContentOutput struct {
+ Body base.ApiResponse[FileContentResponse]
+}
+
+type DownloadFileInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ Path string `query:"path" doc:"File path"`
+}
+
+type DownloadFileOutput struct {
+ ContentType string `header:"Content-Type"`
+ ContentDisposition string `header:"Content-Disposition"`
+ ContentLength int64 `header:"Content-Length"`
+ Body io.ReadCloser
+}
+
+type UploadFileInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ Path string `query:"path" default:"/" doc:"Destination path"`
+ File huma.FormFile `form:"file" doc:"File to upload"`
+}
+
+type CreateDirectoryInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ Path string `query:"path" doc:"Directory path to create"`
+}
+
+type DeleteFileInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ Path string `query:"path" doc:"File or directory path to delete"`
+}
+
+type ListBackupsInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ 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"`
+}
+
+type VolumeBackupPaginatedResponse struct {
+ Success bool `json:"success"`
+ Data []models.VolumeBackup `json:"data"`
+ Pagination base.PaginationResponse `json:"pagination"`
+ Warnings []string `json:"warnings,omitempty"`
+}
+
+type ListBackupsOutput struct {
+ Body VolumeBackupPaginatedResponse
+}
+
+type CreateBackupInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+}
+
+type CreateBackupOutput struct {
+ Body base.ApiResponse[*models.VolumeBackup]
+}
+
+type RestoreBackupInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ BackupID string `path:"backupId" doc:"Backup ID"`
+}
+
+type RestoreBackupOutput struct {
+ Body base.ApiResponse[base.MessageResponse]
+}
+
+type RestoreBackupFilesInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ BackupID string `path:"backupId" doc:"Backup ID"`
+ Body struct {
+ Paths []string `json:"paths" doc:"Paths to restore from backup"`
+ }
+}
+
+type RestoreBackupFilesOutput struct {
+ Body base.ApiResponse[base.MessageResponse]
+}
+
+type BackupHasPathInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ BackupID string `path:"backupId" doc:"Backup ID"`
+ Path string `query:"path" doc:"Path to check"`
+}
+
+type BackupHasPathResponse struct {
+ Exists bool `json:"exists"`
+}
+
+type BackupHasPathOutput struct {
+ Body base.ApiResponse[BackupHasPathResponse]
+}
+
+type ListBackupFilesInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ BackupID string `path:"backupId" doc:"Backup ID"`
+}
+
+type ListBackupFilesOutput struct {
+ Body base.ApiResponse[[]string]
+}
+
+type DeleteBackupInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ BackupID string `path:"backupId" doc:"Backup ID"`
+}
+
+type DeleteBackupOutput struct {
+ Body base.ApiResponse[base.MessageResponse]
+}
+
+type DownloadBackupInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ BackupID string `path:"backupId" doc:"Backup ID"`
+}
+
+type DownloadBackupOutput struct {
+ ContentType string `header:"Content-Type"`
+ ContentDisposition string `header:"Content-Disposition"`
+ ContentLength int64 `header:"Content-Length"`
+ Body io.ReadCloser
+}
+
+type UploadAndRestoreInput struct {
+ EnvironmentID string `path:"id" doc:"Environment ID"`
+ VolumeName string `path:"volumeName" doc:"Volume name"`
+ File huma.FormFile `form:"file" doc:"Backup archive (tar.gz)"`
+}
+
+type UploadAndRestoreOutput struct {
+ Body base.ApiResponse[base.MessageResponse]
+}
+
// RegisterVolumes registers volume management routes using Huma.
func RegisterVolumes(api huma.API, dockerService *services.DockerClientService, volumeService *services.VolumeService) {
h := &VolumeHandler{
@@ -243,6 +413,190 @@ func RegisterVolumes(api huma.API, dockerService *services.DockerClientService,
{"ApiKeyAuth": {}},
},
}, h.GetVolumeSizes)
+
+ // --- Volume Browsing Endpoints ---
+
+ huma.Register(api, huma.Operation{
+ OperationID: "browse-volume-directory",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/{volumeName}/browse",
+ Summary: "List volume directory",
+ Tags: []string{"Volume Browser"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.BrowseDirectory)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "get-volume-file-content",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/{volumeName}/browse/content",
+ Summary: "Get file content preview",
+ Tags: []string{"Volume Browser"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.GetFileContent)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "download-volume-file",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/{volumeName}/browse/download",
+ Summary: "Download file from volume",
+ Tags: []string{"Volume Browser"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.DownloadFile)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "upload-volume-file",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/volumes/{volumeName}/browse/upload",
+ Summary: "Upload file to volume",
+ Tags: []string{"Volume Browser"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.UploadFile)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "create-volume-directory",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/volumes/{volumeName}/browse/mkdir",
+ Summary: "Create directory in volume",
+ Tags: []string{"Volume Browser"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.CreateDirectory)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "delete-volume-file",
+ Method: http.MethodDelete,
+ Path: "/environments/{id}/volumes/{volumeName}/browse",
+ Summary: "Delete file or directory in volume",
+ Tags: []string{"Volume Browser"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.DeleteFile)
+
+ // --- Volume Backup Endpoints ---
+
+ huma.Register(api, huma.Operation{
+ OperationID: "list-volume-backups",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/{volumeName}/backups",
+ Summary: "List volume backups",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.ListBackups)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "create-volume-backup",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/volumes/{volumeName}/backups",
+ Summary: "Create volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.CreateBackup)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "restore-volume-backup",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/volumes/{volumeName}/backups/{backupId}/restore",
+ Summary: "Restore volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.RestoreBackup)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "restore-volume-backup-files",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/volumes/{volumeName}/backups/{backupId}/restore-files",
+ Summary: "Restore specific files from a volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.RestoreBackupFiles)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "delete-volume-backup",
+ Method: http.MethodDelete,
+ Path: "/environments/{id}/volumes/backups/{backupId}",
+ Summary: "Delete volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.DeleteBackup)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "download-volume-backup",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/backups/{backupId}/download",
+ Summary: "Download volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.DownloadBackup)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "backup-has-path",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/backups/{backupId}/has-path",
+ Summary: "Check if backup contains path",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.BackupHasPath)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "list-backup-files",
+ Method: http.MethodGet,
+ Path: "/environments/{id}/volumes/backups/{backupId}/files",
+ Summary: "List files in a volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.ListBackupFiles)
+
+ huma.Register(api, huma.Operation{
+ OperationID: "upload-volume-backup",
+ Method: http.MethodPost,
+ Path: "/environments/{id}/volumes/{volumeName}/backups/upload",
+ Summary: "Upload and restore volume backup",
+ Tags: []string{"Volume Backup"},
+ Security: []map[string][]string{
+ {"BearerAuth": {}},
+ {"ApiKeyAuth": {}},
+ },
+ }, h.UploadAndRestore)
}
// ListVolumes returns a paginated list of volumes.
@@ -474,3 +828,317 @@ func (h *VolumeHandler) GetVolumeSizes(ctx context.Context, input *GetVolumeSize
},
}, nil
}
+
+// --- Volume Browser Handler Methods ---
+
+func (h *VolumeHandler) BrowseDirectory(ctx context.Context, input *BrowseDirectoryInput) (*BrowseDirectoryOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ entries, err := h.volumeService.ListDirectory(ctx, input.VolumeName, input.Path)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &BrowseDirectoryOutput{
+ Body: base.ApiResponse[[]volumetypes.FileEntry]{
+ Success: true,
+ Data: entries,
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) GetFileContent(ctx context.Context, input *GetFileContentInput) (*GetFileContentOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ content, mimeType, err := h.volumeService.GetFileContent(ctx, input.VolumeName, input.Path, input.MaxBytes)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &GetFileContentOutput{
+ Body: base.ApiResponse[FileContentResponse]{
+ Success: true,
+ Data: FileContentResponse{
+ Content: content,
+ MimeType: mimeType,
+ },
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) DownloadFile(ctx context.Context, input *DownloadFileInput) (*DownloadFileOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ reader, size, err := h.volumeService.DownloadFile(ctx, input.VolumeName, input.Path)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &DownloadFileOutput{
+ ContentType: "application/octet-stream",
+ ContentDisposition: "attachment; filename=" + path.Base(input.Path),
+ ContentLength: size,
+ Body: reader,
+ }, nil
+}
+
+func (h *VolumeHandler) UploadFile(ctx context.Context, input *UploadFileInput) (*base.ApiResponse[base.MessageResponse], error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, _ := humamw.GetCurrentUserFromContext(ctx)
+ err := h.volumeService.UploadFile(ctx, input.VolumeName, input.Path, input.File, input.File.Filename, user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "File uploaded successfully"},
+ }, nil
+}
+
+func (h *VolumeHandler) CreateDirectory(ctx context.Context, input *CreateDirectoryInput) (*base.ApiResponse[base.MessageResponse], error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, _ := humamw.GetCurrentUserFromContext(ctx)
+ err := h.volumeService.CreateDirectory(ctx, input.VolumeName, input.Path, user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "Directory created successfully"},
+ }, nil
+}
+
+func (h *VolumeHandler) DeleteFile(ctx context.Context, input *DeleteFileInput) (*base.ApiResponse[base.MessageResponse], error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, _ := humamw.GetCurrentUserFromContext(ctx)
+ err := h.volumeService.DeleteFile(ctx, input.VolumeName, input.Path, user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "Deleted successfully"},
+ }, nil
+}
+
+// --- Volume Backup Handler Methods ---
+
+func (h *VolumeHandler) ListBackups(ctx context.Context, input *ListBackupsInput) (*ListBackupsOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+
+ params := pagination.QueryParams{
+ SearchQuery: pagination.SearchQuery{
+ Search: input.Search,
+ },
+ SortParams: pagination.SortParams{
+ Sort: input.Sort,
+ Order: pagination.SortOrder(input.Order),
+ },
+ PaginationParams: pagination.PaginationParams{
+ Start: input.Start,
+ Limit: input.Limit,
+ },
+ }
+
+ if params.Limit == 0 {
+ params.Limit = 20
+ }
+
+ backups, paginationResp, err := h.volumeService.ListBackupsPaginated(ctx, input.VolumeName, params)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+
+ warning := h.volumeService.BackupMountWarning(ctx)
+
+ return &ListBackupsOutput{
+ Body: VolumeBackupPaginatedResponse{
+ Success: true,
+ Data: backups,
+ Pagination: base.PaginationResponse{
+ TotalPages: paginationResp.TotalPages,
+ TotalItems: paginationResp.TotalItems,
+ CurrentPage: paginationResp.CurrentPage,
+ ItemsPerPage: paginationResp.ItemsPerPage,
+ GrandTotalItems: paginationResp.GrandTotalItems,
+ },
+ Warnings: func() []string {
+ if warning == "" {
+ return nil
+ }
+ return []string{warning}
+ }(),
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) CreateBackup(ctx context.Context, input *CreateBackupInput) (*CreateBackupOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, exists := humamw.GetCurrentUserFromContext(ctx)
+ if !exists {
+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())
+ }
+
+ backup, err := h.volumeService.CreateBackup(ctx, input.VolumeName, *user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &CreateBackupOutput{
+ Body: base.ApiResponse[*models.VolumeBackup]{
+ Success: true,
+ Data: backup,
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) RestoreBackup(ctx context.Context, input *RestoreBackupInput) (*RestoreBackupOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, exists := humamw.GetCurrentUserFromContext(ctx)
+ if !exists {
+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())
+ }
+
+ err := h.volumeService.RestoreBackup(ctx, input.VolumeName, input.BackupID, *user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &RestoreBackupOutput{
+ Body: base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "Restore initiated successfully"},
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) RestoreBackupFiles(ctx context.Context, input *RestoreBackupFilesInput) (*RestoreBackupFilesOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+
+ user, exists := humamw.GetCurrentUserFromContext(ctx)
+ if !exists {
+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())
+ }
+
+ if len(input.Body.Paths) == 0 {
+ return nil, huma.Error400BadRequest("paths are required")
+ }
+
+ if err := h.volumeService.RestoreBackupFiles(ctx, input.VolumeName, input.BackupID, input.Body.Paths, *user); err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+
+ return &RestoreBackupFilesOutput{
+ Body: base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "Restore initiated successfully"},
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) BackupHasPath(ctx context.Context, input *BackupHasPathInput) (*BackupHasPathOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+
+ if input.Path == "" {
+ return nil, huma.Error400BadRequest("path is required")
+ }
+
+ exists, err := h.volumeService.BackupHasPath(ctx, input.BackupID, input.Path)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+
+ return &BackupHasPathOutput{
+ Body: base.ApiResponse[BackupHasPathResponse]{
+ Success: true,
+ Data: BackupHasPathResponse{Exists: exists},
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) ListBackupFiles(ctx context.Context, input *ListBackupFilesInput) (*ListBackupFilesOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+
+ files, err := h.volumeService.ListBackupFiles(ctx, input.BackupID)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+
+ return &ListBackupFilesOutput{
+ Body: base.ApiResponse[[]string]{
+ Success: true,
+ Data: files,
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) DeleteBackup(ctx context.Context, input *DeleteBackupInput) (*DeleteBackupOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, _ := humamw.GetCurrentUserFromContext(ctx)
+ err := h.volumeService.DeleteBackup(ctx, input.BackupID, user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &DeleteBackupOutput{
+ Body: base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "Backup deleted successfully"},
+ },
+ }, nil
+}
+
+func (h *VolumeHandler) DownloadBackup(ctx context.Context, input *DownloadBackupInput) (*DownloadBackupOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, _ := humamw.GetCurrentUserFromContext(ctx)
+ reader, size, err := h.volumeService.DownloadBackup(ctx, input.BackupID, user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &DownloadBackupOutput{
+ ContentType: "application/x-gzip",
+ ContentDisposition: "attachment; filename=" + input.BackupID + ".tar.gz",
+ ContentLength: size,
+ Body: reader,
+ }, nil
+}
+
+func (h *VolumeHandler) UploadAndRestore(ctx context.Context, input *UploadAndRestoreInput) (*UploadAndRestoreOutput, error) {
+ if h.volumeService == nil {
+ return nil, huma.Error500InternalServerError("service not available")
+ }
+ user, exists := humamw.GetCurrentUserFromContext(ctx)
+ if !exists {
+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())
+ }
+
+ err := h.volumeService.UploadAndRestore(ctx, input.VolumeName, input.File, input.File.Filename, *user)
+ if err != nil {
+ return nil, huma.Error500InternalServerError(err.Error())
+ }
+ return &UploadAndRestoreOutput{
+ Body: base.ApiResponse[base.MessageResponse]{
+ Success: true,
+ Data: base.MessageResponse{Message: "Backup uploaded and restored successfully"},
+ },
+ }, nil
+}
diff --git a/backend/internal/models/event.go b/backend/internal/models/event.go
index d2addbae2..a57574757 100644
--- a/backend/internal/models/event.go
+++ b/backend/internal/models/event.go
@@ -48,6 +48,16 @@ const (
EventTypeVolumeDelete EventType = "volume.delete"
EventTypeVolumeError EventType = "volume.error"
+ EventTypeVolumeFileCreate EventType = "volume.file.create"
+ EventTypeVolumeFileDelete EventType = "volume.file.delete"
+ EventTypeVolumeFileUpload EventType = "volume.file.upload"
+
+ EventTypeVolumeBackupCreate EventType = "volume.backup.create"
+ EventTypeVolumeBackupDelete EventType = "volume.backup.delete"
+ EventTypeVolumeBackupRestore EventType = "volume.backup.restore"
+ EventTypeVolumeBackupRestoreFiles EventType = "volume.backup.restore_files"
+ EventTypeVolumeBackupDownload EventType = "volume.backup.download"
+
EventTypeNetworkCreate EventType = "network.create"
EventTypeNetworkDelete EventType = "network.delete"
EventTypeNetworkError EventType = "network.error"
diff --git a/backend/internal/models/volume_backup.go b/backend/internal/models/volume_backup.go
new file mode 100644
index 000000000..a4df4768a
--- /dev/null
+++ b/backend/internal/models/volume_backup.go
@@ -0,0 +1,27 @@
+package models
+
+import (
+ "time"
+
+ "github.com/getarcaneapp/arcane/types/volume"
+)
+
+type VolumeBackup struct {
+ BaseModel
+ VolumeName string `json:"volumeName" gorm:"column:volume_name;index"`
+ Size int64 `json:"size" gorm:"column:size"`
+ CreatedAt time.Time `json:"createdAt" gorm:"column:created_at"`
+}
+
+func (*VolumeBackup) TableName() string {
+ return "volume_backups"
+}
+
+func (b *VolumeBackup) ToDTO() volume.BackupEntry {
+ return volume.BackupEntry{
+ ID: b.ID,
+ VolumeName: b.VolumeName,
+ Size: b.Size,
+ CreatedAt: b.CreatedAt.Format(time.RFC3339),
+ }
+}
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index 67ced79b1..2d9332c1a 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -18,6 +18,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/models"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
"github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
containertypes "github.com/getarcaneapp/arcane/types/container"
"github.com/getarcaneapp/arcane/types/containerregistry"
imagetypes "github.com/getarcaneapp/arcane/types/image"
@@ -424,7 +425,7 @@ func (s *ContainerService) readAllLogs(logs io.ReadCloser, logsChan chan<- strin
return nil
}
-func (s *ContainerService) ListContainersPaginated(ctx context.Context, params pagination.QueryParams, includeAll bool) ([]containertypes.Summary, pagination.Response, containertypes.StatusCounts, error) {
+func (s *ContainerService) ListContainersPaginated(ctx context.Context, params pagination.QueryParams, includeAll bool, includeInternal bool) ([]containertypes.Summary, pagination.Response, containertypes.StatusCounts, error) {
dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, pagination.Response{}, containertypes.StatusCounts{}, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -435,42 +436,77 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params p
return nil, pagination.Response{}, containertypes.StatusCounts{}, fmt.Errorf("failed to list Docker containers: %w", err)
}
- // Collect unique image IDs for update info lookup
- imageIDSet := make(map[string]struct{}, len(dockerContainers))
- for _, dc := range dockerContainers {
+ dockerContainers = filterInternalContainers(dockerContainers, includeInternal)
+ imageIDs := collectImageIDs(dockerContainers)
+ updateInfoMap := s.getUpdateInfoMap(ctx, imageIDs)
+ items := buildContainerSummaries(dockerContainers, updateInfoMap)
+
+ result := pagination.SearchOrderAndPaginate(items, params, containerPaginationConfig())
+ counts := computeContainerCounts(items)
+ paginationResp := buildPaginationResponse(result, params)
+
+ return result.Items, paginationResp, counts, nil
+}
+
+func filterInternalContainers(containers []container.Summary, includeInternal bool) []container.Summary {
+ if includeInternal {
+ return containers
+ }
+
+ filtered := make([]container.Summary, 0, len(containers))
+ for _, dc := range containers {
+ if libarcane.IsInternalContainer(dc.Labels) {
+ continue
+ }
+ filtered = append(filtered, dc)
+ }
+ return filtered
+}
+
+func collectImageIDs(containers []container.Summary) []string {
+ imageIDSet := make(map[string]struct{}, len(containers))
+ for _, dc := range containers {
if dc.ImageID != "" {
imageIDSet[dc.ImageID] = struct{}{}
}
}
+
imageIDs := make([]string, 0, len(imageIDSet))
for id := range imageIDSet {
imageIDs = append(imageIDs, id)
}
+ return imageIDs
+}
- // Fetch update info for all images used by containers
- var updateInfoMap map[string]*imagetypes.UpdateInfo
- if s.imageService != nil && len(imageIDs) > 0 {
- updateInfoMap, err = s.imageService.GetUpdateInfoByImageIDs(ctx, imageIDs)
- if err != nil {
- // Log error but continue - update info is optional
- slog.WarnContext(ctx, "Failed to fetch image update info for containers", "error", err)
- updateInfoMap = make(map[string]*imagetypes.UpdateInfo)
- }
- } else {
- updateInfoMap = make(map[string]*imagetypes.UpdateInfo)
+func (s *ContainerService) getUpdateInfoMap(ctx context.Context, imageIDs []string) map[string]*imagetypes.UpdateInfo {
+ if s.imageService == nil || len(imageIDs) == 0 {
+ return make(map[string]*imagetypes.UpdateInfo)
+ }
+
+ updateInfoMap, err := s.imageService.GetUpdateInfoByImageIDs(ctx, imageIDs)
+ if err != nil {
+ // Log error but continue - update info is optional
+ slog.WarnContext(ctx, "Failed to fetch image update info for containers", "error", err)
+ return make(map[string]*imagetypes.UpdateInfo)
}
- items := make([]containertypes.Summary, 0, len(dockerContainers))
- for _, dc := range dockerContainers {
+ return updateInfoMap
+}
+
+func buildContainerSummaries(containers []container.Summary, updateInfoMap map[string]*imagetypes.UpdateInfo) []containertypes.Summary {
+ items := make([]containertypes.Summary, 0, len(containers))
+ for _, dc := range containers {
summary := containertypes.NewSummary(dc)
- // Attach update info if available
if info, exists := updateInfoMap[dc.ImageID]; exists {
summary.UpdateInfo = info
}
items = append(items, summary)
}
+ return items
+}
- config := pagination.Config[containertypes.Summary]{
+func containerPaginationConfig() pagination.Config[containertypes.Summary] {
+ return pagination.Config[containertypes.Summary]{
SearchAccessors: []pagination.SearchAccessor[containertypes.Summary]{
func(c containertypes.Summary) (string, error) {
if len(c.Names) > 0 {
@@ -529,10 +565,9 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params p
},
},
}
+}
- result := pagination.SearchOrderAndPaginate(items, params, config)
-
- // Calculate status counts from items (before pagination)
+func computeContainerCounts(items []containertypes.Summary) containertypes.StatusCounts {
counts := containertypes.StatusCounts{
TotalContainers: len(items),
}
@@ -543,10 +578,13 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params p
counts.StoppedContainers++
}
}
+ return counts
+}
+func buildPaginationResponse(result pagination.FilterResult[containertypes.Summary], params pagination.QueryParams) pagination.Response {
totalPages := int64(0)
if params.Limit > 0 {
- totalPages = (int64(result.TotalCount) + int64(params.Limit) - 1) / int64(params.Limit)
+ totalPages = (result.TotalCount + int64(params.Limit) - 1) / int64(params.Limit)
}
page := 1
@@ -554,15 +592,13 @@ func (s *ContainerService) ListContainersPaginated(ctx context.Context, params p
page = (params.Start / params.Limit) + 1
}
- paginationResp := pagination.Response{
+ return pagination.Response{
TotalPages: totalPages,
- TotalItems: int64(result.TotalCount),
+ TotalItems: result.TotalCount,
CurrentPage: page,
ItemsPerPage: params.Limit,
- GrandTotalItems: int64(result.TotalAvailable),
+ GrandTotalItems: result.TotalAvailable,
}
-
- return result.Items, paginationResp, counts, nil
}
// CreateExec creates an exec instance in the container
diff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.go
index 22a7cbd6b..be2c680b6 100644
--- a/backend/internal/services/event_service.go
+++ b/backend/internal/services/event_service.go
@@ -395,9 +395,17 @@ var eventDefinitions = map[models.EventType]struct {
models.EventTypeProjectUpdate: {"Project updated: %s", "Project '%s' has been updated", models.EventSeverityInfo},
models.EventTypeProjectError: {"Project error: %s", "An error occurred with project '%s'", models.EventSeverityError},
- models.EventTypeVolumeCreate: {"Volume created: %s", "Volume '%s' has been created", models.EventSeveritySuccess},
- models.EventTypeVolumeDelete: {"Volume deleted: %s", "Volume '%s' has been deleted", models.EventSeverityWarning},
- models.EventTypeVolumeError: {"Volume error: %s", "An error occurred with volume '%s'", models.EventSeverityError},
+ models.EventTypeVolumeCreate: {"Volume created: %s", "Volume '%s' has been created", models.EventSeveritySuccess},
+ models.EventTypeVolumeDelete: {"Volume deleted: %s", "Volume '%s' has been deleted", models.EventSeverityWarning},
+ models.EventTypeVolumeError: {"Volume error: %s", "An error occurred with volume '%s'", models.EventSeverityError},
+ models.EventTypeVolumeFileCreate: {"Volume file created: %s", "A file or directory was created in volume '%s'", models.EventSeveritySuccess},
+ models.EventTypeVolumeFileDelete: {"Volume file deleted: %s", "A file or directory was deleted in volume '%s'", models.EventSeverityWarning},
+ models.EventTypeVolumeFileUpload: {"Volume file uploaded: %s", "A file was uploaded to volume '%s'", models.EventSeveritySuccess},
+ models.EventTypeVolumeBackupCreate: {"Volume backup created: %s", "A backup was created for volume '%s'", models.EventSeveritySuccess},
+ models.EventTypeVolumeBackupDelete: {"Volume backup deleted: %s", "A backup was deleted for volume '%s'", models.EventSeverityWarning},
+ models.EventTypeVolumeBackupRestore: {"Volume backup restored: %s", "A backup was restored for volume '%s'", models.EventSeverityWarning},
+ models.EventTypeVolumeBackupRestoreFiles: {"Volume backup files restored: %s", "Selected files were restored for volume '%s'", models.EventSeverityWarning},
+ models.EventTypeVolumeBackupDownload: {"Volume backup downloaded: %s", "A backup was downloaded for volume '%s'", models.EventSeverityInfo},
models.EventTypeNetworkCreate: {"Network created: %s", "Network '%s' has been created", models.EventSeveritySuccess},
models.EventTypeNetworkDelete: {"Network deleted: %s", "Network '%s' has been deleted", models.EventSeverityWarning},
diff --git a/backend/internal/services/job_service.go b/backend/internal/services/job_service.go
index 9bd155cfc..dc3e93feb 100644
--- a/backend/internal/services/job_service.go
+++ b/backend/internal/services/job_service.go
@@ -68,37 +68,29 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedule
current := s.GetJobSchedules(ctx)
+ fields := []struct {
+ key string
+ current string
+ update *string
+ }{
+ {key: "environmentHealthInterval", current: current.EnvironmentHealthInterval, update: updates.EnvironmentHealthInterval},
+ {key: "eventCleanupInterval", current: current.EventCleanupInterval, update: updates.EventCleanupInterval},
+ {key: "analyticsHeartbeatInterval", current: current.AnalyticsHeartbeatInterval, update: updates.AnalyticsHeartbeatInterval},
+ {key: "autoUpdateInterval", current: current.AutoUpdateInterval, update: updates.AutoUpdateInterval},
+ {key: "pollingInterval", current: current.PollingInterval, update: updates.PollingInterval},
+ {key: "scheduledPruneInterval", current: current.ScheduledPruneInterval, update: updates.ScheduledPruneInterval},
+ {key: "gitopsSyncInterval", current: current.GitopsSyncInterval, update: updates.GitopsSyncInterval},
+ }
+
// Validate inputs (cron expressions)
- validate := func(name string, v *string) error {
- if v == nil || *v == "" {
- return nil
+ parser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow)
+ for _, field := range fields {
+ if field.update == nil || *field.update == "" {
+ continue
}
- if _, err := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow).Parse(*v); err != nil {
- return fmt.Errorf("invalid cron expression for %s: %w", name, err)
+ if _, err := parser.Parse(*field.update); err != nil {
+ return jobschedule.Config{}, fmt.Errorf("invalid cron expression for %s: %w", field.key, err)
}
- return nil
- }
-
- if err := validate("environmentHealthInterval", updates.EnvironmentHealthInterval); err != nil {
- return jobschedule.Config{}, err
- }
- if err := validate("eventCleanupInterval", updates.EventCleanupInterval); err != nil {
- return jobschedule.Config{}, err
- }
- if err := validate("analyticsHeartbeatInterval", updates.AnalyticsHeartbeatInterval); err != nil {
- return jobschedule.Config{}, err
- }
- if err := validate("autoUpdateInterval", updates.AutoUpdateInterval); err != nil {
- return jobschedule.Config{}, err
- }
- if err := validate("pollingInterval", updates.PollingInterval); err != nil {
- return jobschedule.Config{}, err
- }
- if err := validate("scheduledPruneInterval", updates.ScheduledPruneInterval); err != nil {
- return jobschedule.Config{}, err
- }
- if err := validate("gitopsSyncInterval", updates.GitopsSyncInterval); err != nil {
- return jobschedule.Config{}, err
}
changed := false
@@ -116,26 +108,10 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedule
}
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- if err := upsert(tx, "environmentHealthInterval", updates.EnvironmentHealthInterval, current.EnvironmentHealthInterval); err != nil {
- return err
- }
- if err := upsert(tx, "eventCleanupInterval", updates.EventCleanupInterval, current.EventCleanupInterval); err != nil {
- return err
- }
- if err := upsert(tx, "analyticsHeartbeatInterval", updates.AnalyticsHeartbeatInterval, current.AnalyticsHeartbeatInterval); err != nil {
- return err
- }
- if err := upsert(tx, "autoUpdateInterval", updates.AutoUpdateInterval, current.AutoUpdateInterval); err != nil {
- return err
- }
- if err := upsert(tx, "pollingInterval", updates.PollingInterval, current.PollingInterval); err != nil {
- return err
- }
- if err := upsert(tx, "scheduledPruneInterval", updates.ScheduledPruneInterval, current.ScheduledPruneInterval); err != nil {
- return err
- }
- if err := upsert(tx, "gitopsSyncInterval", updates.GitopsSyncInterval, current.GitopsSyncInterval); err != nil {
- return err
+ for _, field := range fields {
+ if err := upsert(tx, field.key, field.update, field.current); err != nil {
+ return err
+ }
}
return nil
})
diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.go
index 085b0f084..e9b33a12e 100644
--- a/backend/internal/services/volume_service.go
+++ b/backend/internal/services/volume_service.go
@@ -1,183 +1,1470 @@
package services
import (
+ "archive/tar"
+ "bytes"
+ "compress/gzip"
"context"
"fmt"
+ "io"
"log/slog"
+ "net/http"
+ "os"
+ "path"
+ "strconv"
"strings"
+ "sync"
+ "time"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/mount"
"github.com/docker/docker/api/types/volume"
"github.com/docker/docker/client"
+ "github.com/docker/docker/pkg/stdcopy"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
"github.com/getarcaneapp/arcane/backend/internal/utils/docker"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
"github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
volumetypes "github.com/getarcaneapp/arcane/types/volume"
+ "github.com/google/uuid"
)
type VolumeService struct {
- db *database.DB
- dockerService *DockerClientService
- eventService *EventService
- settingsService *SettingsService
+ db *database.DB
+ dockerService *DockerClientService
+ eventService *EventService
+ settingsService *SettingsService
+ containerService *ContainerService
+ imageService *ImageService
+ backupVolumeName string
+ helperMu sync.Mutex
+ helperByVolume map[string]string
}
-func NewVolumeService(db *database.DB, dockerService *DockerClientService, eventService *EventService, settingsService *SettingsService) *VolumeService {
+func NewVolumeService(db *database.DB, dockerService *DockerClientService, eventService *EventService, settingsService *SettingsService, containerService *ContainerService, imageService *ImageService, backupVolumeName string) *VolumeService {
+ slog.Debug("volume service: new")
+ if strings.TrimSpace(backupVolumeName) == "" {
+ backupVolumeName = "arcane-backups"
+ }
return &VolumeService{
- db: db,
- dockerService: dockerService,
- eventService: eventService,
- settingsService: settingsService,
+ db: db,
+ dockerService: dockerService,
+ eventService: eventService,
+ settingsService: settingsService,
+ containerService: containerService,
+ imageService: imageService,
+ backupVolumeName: backupVolumeName,
+ helperByVolume: make(map[string]string),
+ }
+}
+
+func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*volumetypes.Volume, error) {
+ slog.DebugContext(ctx, "volume service: get volume", "volume", name)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ vol, err := dockerClient.VolumeInspect(ctx, name)
+ if err != nil {
+ return nil, fmt.Errorf("volume not found: %w", err)
+ }
+
+ if usageVolumes, duErr := docker.GetVolumeUsageData(ctx, dockerClient); duErr == nil {
+ for _, uv := range usageVolumes {
+ if uv.Name == vol.Name && uv.UsageData != nil {
+ vol.UsageData = uv.UsageData
+ slog.DebugContext(ctx, "attached volume usage data", "volume", vol.Name, "size_bytes", uv.UsageData.Size, "ref_count", uv.UsageData.RefCount)
+ break
+ }
+ }
+ } else {
+ slog.WarnContext(ctx, "failed to load volume usage data", "volume", vol.Name, "error", duErr.Error())
+ }
+
+ v := volumetypes.NewSummary(vol)
+
+ containerIDs, err := docker.GetContainersUsingVolume(ctx, dockerClient, name)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to get containers using volume", "volume", name, "error", err.Error())
+ } else {
+ v.Containers = containerIDs
+ if len(containerIDs) > 0 {
+ v.InUse = true
+ }
+ }
+
+ return &v, nil
+}
+
+func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions, user models.User) (*volumetypes.Volume, error) {
+ slog.DebugContext(ctx, "volume service: create volume", "volume", options.Name, "driver", options.Driver, "user", user.ID)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})
+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ created, err := dockerClient.VolumeCreate(ctx, options)
+ if err != nil {
+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})
+ return nil, fmt.Errorf("failed to create volume: %w", err)
+ }
+
+ vol, err := dockerClient.VolumeInspect(ctx, created.Name)
+ if err != nil {
+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", created.Name, created.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver, "step": "inspect"})
+ return nil, fmt.Errorf("failed to inspect created volume: %w", err)
+ }
+
+ metadata := models.JSON{
+ "action": "create",
+ "driver": vol.Driver,
+ "name": vol.Name,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeCreate, vol.Name, vol.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume creation action", "volume", vol.Name, "error", logErr.Error())
+ }
+
+ docker.InvalidateVolumeUsageCache()
+
+ dtoVol := volumetypes.NewSummary(vol)
+ return &dtoVol, nil
+}
+
+func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool, user models.User) error {
+ slog.DebugContext(ctx, "volume service: delete volume", "volume", name, "force", force, "user", user.ID)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
+ return fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ if err := dockerClient.VolumeRemove(ctx, name, force); err != nil {
+ s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
+ return fmt.Errorf("failed to remove volume: %w", err)
+ }
+
+ metadata := models.JSON{
+ "action": "delete",
+ "name": name,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, name, name, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume deletion action", "volume", name, "error", logErr.Error())
+ }
+
+ s.removeHelperEntry(name)
+ return nil
+}
+
+func (s *VolumeService) PruneVolumes(ctx context.Context) (*volumetypes.PruneReport, error) {
+ slog.DebugContext(ctx, "volume service: prune volumes")
+ return s.PruneVolumesWithOptions(ctx, false)
+}
+
+func (s *VolumeService) PruneVolumesWithOptions(ctx context.Context, all bool) (*volumetypes.PruneReport, error) {
+ slog.DebugContext(ctx, "volume service: prune volumes with options", "all", all)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ // Docker's VolumesPrune behavior (API v1.42+):
+ // - Without 'all' flag: Only removes anonymous (unnamed) volumes that are not in use
+ // - With 'all=true' flag: Removes ALL unused volumes (both named and anonymous)
+ // Note: Volumes are considered "in use" if referenced by any container (running or stopped)
+ filterArgs := filters.NewArgs()
+ if all {
+ // The 'all' filter was added in Docker API v1.42
+ // This tells Docker to prune ALL unused volumes, not just anonymous ones
+ filterArgs.Add("all", "true")
+ }
+ // Other valid filters for volume prune:
+ // - label=<key> or label=<key>=<value>
+ // - label!=<key> or label!=<key>=<value>
+
+ report, err := dockerClient.VolumesPrune(ctx, filterArgs)
+ if err != nil {
+ return nil, fmt.Errorf("failed to prune volumes: %w", err)
+ }
+
+ metadata := models.JSON{
+ "action": "prune",
+ "all": all,
+ "volumesDeleted": len(report.VolumesDeleted),
+ "spaceReclaimed": report.SpaceReclaimed,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume prune action", "error", logErr.Error())
+ }
+
+ for _, volumeName := range report.VolumesDeleted {
+ s.removeHelperEntry(volumeName)
+ }
+
+ docker.InvalidateVolumeUsageCache()
+
+ return &volumetypes.PruneReport{
+ VolumesDeleted: report.VolumesDeleted,
+ SpaceReclaimed: report.SpaceReclaimed,
+ }, nil
+}
+
+// --- Volume Browsing & Backup ---
+
+func (s *VolumeService) ListDirectory(ctx context.Context, volumeName, dirPath string) ([]volumetypes.FileEntry, error) {
+ slog.DebugContext(ctx, "volume service: list directory", "volume", volumeName, "path", dirPath)
+
+ sanitizedPath, err := s.sanitizeBrowsePathInternal(dirPath)
+ if err != nil {
+ return nil, fmt.Errorf("invalid path: %w", err)
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, true)
+ if err != nil {
+ return nil, err
+ }
+ defer cleanup()
+
+ targetPath := path.Join("/volume", sanitizedPath)
+ quotedPath := strconv.Quote(targetPath)
+ cmd := []string{"sh", "-c", fmt.Sprintf("find %s -mindepth 1 -maxdepth 1 -exec sh -c 'for f; do out=$(stat -c \"%%s %%Y %%f %%A\" -- \"$f\" 2>/dev/null) || continue; printf \"%%s\\0%%s\\0\" \"$f\" \"$out\"; done' sh {} + || true", quotedPath)}
+ stdout, _, err := s.execInContainerInternal(ctx, containerID, cmd)
+ if err != nil {
+ return nil, fmt.Errorf("failed to list directory: %w", err)
+ }
+
+ lines := strings.Split(stdout, "\x00")
+ entries := make([]volumetypes.FileEntry, 0)
+ for i := 0; i+1 < len(lines); i += 2 {
+ fullPath := lines[i]
+ meta := strings.Fields(strings.TrimSpace(lines[i+1]))
+ if fullPath == "" || len(meta) < 4 {
+ continue
+ }
+ name := path.Base(fullPath)
+ size, _ := strconv.ParseInt(meta[0], 10, 64)
+ modTimeSec, _ := strconv.ParseInt(meta[1], 10, 64)
+ mode := meta[3]
+
+ isDir := strings.HasPrefix(mode, "d")
+ isSymlink := strings.HasPrefix(mode, "l")
+
+ relPath := strings.TrimPrefix(fullPath, "/volume")
+ if relPath == "" {
+ relPath = "/"
+ }
+
+ entry := volumetypes.FileEntry{
+ Name: name,
+ Path: relPath,
+ IsDirectory: isDir,
+ Size: size,
+ ModTime: time.Unix(modTimeSec, 0),
+ Mode: mode,
+ IsSymlink: isSymlink,
+ }
+
+ if isSymlink {
+ // Use readlink without -f to get the raw symlink target (not resolved)
+ // This prevents exposing paths outside the volume
+ target, _, _ := s.execInContainerInternal(ctx, containerID, []string{"readlink", fullPath})
+ target = strings.TrimSpace(target)
+ if target != "" {
+ // If target is relative, it's safe to show
+ // If target is absolute and within /volume, strip the /volume prefix
+ // If target points outside /volume, indicate it's external
+ switch {
+ case strings.HasPrefix(target, "/volume/"):
+ entry.LinkTarget = strings.TrimPrefix(target, "/volume")
+ case strings.HasPrefix(target, "/volume"):
+ entry.LinkTarget = "/"
+ case !strings.HasPrefix(target, "/"):
+ // Relative path - safe to show as-is
+ entry.LinkTarget = target
+ default:
+ // Absolute path outside /volume - indicate it's external
+ entry.LinkTarget = "(external)"
+ }
+ }
+ }
+
+ entries = append(entries, entry)
+ }
+
+ return entries, nil
+}
+
+func (s *VolumeService) GetFileContent(ctx context.Context, volumeName, filePath string, maxBytes int64) ([]byte, string, error) {
+ slog.DebugContext(ctx, "volume service: get file content", "volume", volumeName, "path", filePath, "max_bytes", maxBytes)
+
+ sanitizedPath, err := s.sanitizeBrowsePathInternal(filePath)
+ if err != nil {
+ return nil, "", fmt.Errorf("invalid path: %w", err)
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, true)
+ if err != nil {
+ return nil, "", err
+ }
+ defer cleanup()
+
+ targetPath := path.Join("/volume", sanitizedPath)
+ cmd := []string{"head", "-c", strconv.FormatInt(maxBytes, 10), targetPath}
+ stdout, _, err := s.execInContainerInternal(ctx, containerID, cmd)
+ if err != nil {
+ return nil, "", fmt.Errorf("failed to read file: %w", err)
+ }
+
+ content := []byte(stdout)
+ mimeType := http.DetectContentType(content)
+
+ return content, mimeType, nil
+}
+
+func (s *VolumeService) DownloadFile(ctx context.Context, volumeName, filePath string) (io.ReadCloser, int64, error) {
+ slog.DebugContext(ctx, "volume service: download file", "volume", volumeName, "path", filePath)
+
+ sanitizedPath, err := s.sanitizeBrowsePathInternal(filePath)
+ if err != nil {
+ return nil, 0, fmt.Errorf("invalid path: %w", err)
+ }
+
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return nil, 0, err
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, true)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ targetPath := path.Join("/volume", sanitizedPath)
+ reader, _, err := dockerClient.CopyFromContainer(ctx, containerID, targetPath)
+ if err != nil {
+ cleanup()
+ return nil, 0, fmt.Errorf("failed to download: %w", err)
+ }
+
+ tr := tar.NewReader(reader)
+ hdr, err := tr.Next()
+ if err != nil {
+ reader.Close()
+ cleanup()
+ return nil, 0, fmt.Errorf("failed to read tar stream: %w", err)
+ }
+ if hdr.FileInfo().IsDir() {
+ reader.Close()
+ cleanup()
+ return nil, 0, fmt.Errorf("path is a directory")
+ }
+ size := hdr.Size
+
+ return &cleanupReadCloser{
+ Reader: tr,
+ Closer: reader,
+ cleanup: cleanup,
+ }, size, nil
+}
+
+func (s *VolumeService) getHelperImageInternal(ctx context.Context) (string, error) {
+ slog.DebugContext(ctx, "volume service: resolve helper image")
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return "", fmt.Errorf("failed to get docker client: %w", err)
+ }
+
+ // 1. Try to find Arcane container's image (the most prune-proof)
+ // Check hostname first (ID of container if in Docker)
+ hostname, _ := os.Hostname()
+ if hostname != "" {
+ if inspect, err := dockerClient.ContainerInspect(ctx, hostname); err == nil {
+ return inspect.Config.Image, nil
+ }
+ }
+
+ // 2. Search for any container with Arcane label
+ filter := filters.NewArgs()
+ filter.Add("label", "com.getarcaneapp.arcane=true")
+ if containers, err := dockerClient.ContainerList(ctx, container.ListOptions{Filters: filter, All: true}); err == nil && len(containers) > 0 {
+ return containers[0].Image, nil
+ }
+
+ // 3. Try busybox:stable-musl
+ const helperImage = "busybox:stable-musl"
+ if _, err := dockerClient.ImageInspect(ctx, helperImage); err == nil {
+ return helperImage, nil
+ }
+
+ // 4. Default to pulling busybox
+ slog.InfoContext(ctx, "no suitable internal image found, pulling busybox:stable-musl")
+ if s.imageService == nil {
+ return "", fmt.Errorf("helper image %s missing and image service unavailable", helperImage)
+ }
+ if err := s.imageService.PullImage(ctx, helperImage, io.Discard, systemUser, nil); err != nil {
+ return "", fmt.Errorf("failed to pull helper image %s: %w", helperImage, err)
+ }
+
+ return helperImage, nil
+}
+
+func (s *VolumeService) BackupMountWarning(ctx context.Context) string {
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return ""
+ }
+
+ containerID := s.getArcaneContainerIDInternal(ctx, dockerClient)
+ if containerID == "" {
+ return ""
+ }
+
+ inspect, err := dockerClient.ContainerInspect(ctx, containerID)
+ if err != nil {
+ return ""
+ }
+
+ hasBackups := false
+ hasRestores := false
+ for _, mount := range inspect.Mounts {
+ if mount.Destination == "/backups" {
+ hasBackups = true
+ }
+ if mount.Destination == "/restores" {
+ hasRestores = true
+ }
+ }
+
+ if hasBackups || hasRestores {
+ return ""
+ }
+
+ return "No volume is mounted at /backups or /restores in the Arcane container. Backups/restores will only live inside Docker unless you mount a host path."
+}
+
+func (s *VolumeService) getArcaneContainerIDInternal(ctx context.Context, dockerClient *client.Client) string {
+ hostname, _ := os.Hostname()
+ if hostname != "" {
+ if inspect, err := dockerClient.ContainerInspect(ctx, hostname); err == nil {
+ return inspect.ID
+ }
+ }
+
+ filter := filters.NewArgs()
+ filter.Add("label", "com.getarcaneapp.arcane=true")
+ containers, err := dockerClient.ContainerList(ctx, container.ListOptions{Filters: filter, All: true})
+ if err != nil || len(containers) == 0 {
+ return ""
+ }
+
+ for _, c := range containers {
+ if strings.EqualFold(strings.TrimSpace(c.State), "running") {
+ return c.ID
+ }
+ }
+
+ return containers[0].ID
+}
+
+type cleanupReadCloser struct {
+ io.Reader
+ io.Closer
+ cleanup func()
+}
+
+func (c *cleanupReadCloser) Close() error {
+ err := c.Closer.Close()
+ c.cleanup()
+ return err
+}
+
+func (s *VolumeService) createTempContainerInternal(ctx context.Context, volumeName string, readOnly bool) (string, func(), error) {
+ slog.DebugContext(ctx, "volume service: create temp container", "volume", volumeName, "read_only", readOnly)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return "", nil, err
+ }
+
+ if readOnly {
+ if containerID, ok := s.getReusableReadOnlyContainerInternal(ctx, dockerClient, volumeName); ok {
+ return containerID, func() {}, nil
+ }
+ }
+
+ helperImage, err := s.getHelperImageInternal(ctx)
+ if err != nil {
+ return "", nil, err
+ }
+
+ config := &container.Config{
+ Image: helperImage,
+ Cmd: []string{"sleep", "infinity"},
+ NetworkDisabled: true,
+ Labels: map[string]string{
+ libarcane.InternalContainerLabel: "true",
+ },
+ }
+
+ hostConfig := &container.HostConfig{
+ Binds: []string{
+ fmt.Sprintf("%s:/volume%s", volumeName, func() string {
+ if readOnly {
+ return ":ro"
+ }
+ return ""
+ }()),
+ },
+ AutoRemove: true,
+ }
+
+ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")
+ if err != nil {
+ return "", nil, fmt.Errorf("failed to create temp container: %w", err)
+ }
+
+ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
+ return "", nil, fmt.Errorf("failed to start temp container: %w", err)
+ }
+
+ cleanup := func() {
+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
+ }
+
+ if readOnly {
+ s.helperMu.Lock()
+ s.helperByVolume[volumeName] = resp.ID
+ s.helperMu.Unlock()
+ return resp.ID, func() {}, nil
+ }
+
+ return resp.ID, cleanup, nil
+}
+
+func (s *VolumeService) getReusableReadOnlyContainerInternal(ctx context.Context, dockerClient *client.Client, volumeName string) (string, bool) {
+ s.helperMu.Lock()
+ containerID := s.helperByVolume[volumeName]
+ s.helperMu.Unlock()
+ if containerID == "" {
+ return "", false
+ }
+
+ inspect, err := dockerClient.ContainerInspect(ctx, containerID)
+ if err != nil || inspect.State == nil || !inspect.State.Running {
+ s.helperMu.Lock()
+ delete(s.helperByVolume, volumeName)
+ s.helperMu.Unlock()
+ return "", false
+ }
+
+ return containerID, true
+}
+
+func (s *VolumeService) CleanupHelperContainers(ctx context.Context) {
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ slog.WarnContext(ctx, "failed to get docker client for helper cleanup", "error", err)
+ return
+ }
+
+ s.helperMu.Lock()
+ helperIDs := make([]string, 0, len(s.helperByVolume))
+ for _, containerID := range s.helperByVolume {
+ if containerID != "" {
+ helperIDs = append(helperIDs, containerID)
+ }
+ }
+ s.helperByVolume = make(map[string]string)
+ s.helperMu.Unlock()
+
+ for _, containerID := range helperIDs {
+ if err := dockerClient.ContainerRemove(ctx, containerID, container.RemoveOptions{Force: true}); err != nil {
+ slog.WarnContext(ctx, "failed to remove helper container", "container_id", containerID, "error", err.Error())
+ }
+ }
+}
+
+func (s *VolumeService) removeHelperEntry(volumeName string) {
+ if strings.TrimSpace(volumeName) == "" {
+ return
+ }
+ s.helperMu.Lock()
+ delete(s.helperByVolume, volumeName)
+ s.helperMu.Unlock()
+}
+
+func (s *VolumeService) execInContainerInternal(ctx context.Context, containerID string, cmd []string) (string, string, error) {
+ slog.DebugContext(ctx, "volume service: exec in container", "container_id", containerID, "cmd", cmd)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return "", "", err
+ }
+
+ execConfig := container.ExecOptions{
+ AttachStdout: true,
+ AttachStderr: true,
+ Cmd: cmd,
+ }
+
+ execResp, err := dockerClient.ContainerExecCreate(ctx, containerID, execConfig)
+ if err != nil {
+ return "", "", err
+ }
+
+ resp, err := dockerClient.ContainerExecAttach(ctx, execResp.ID, container.ExecAttachOptions{})
+ if err != nil {
+ return "", "", err
+ }
+ defer resp.Close()
+
+ var stdout, stderr bytes.Buffer
+ _, err = stdcopy.StdCopy(&stdout, &stderr, resp.Reader)
+ if err != nil {
+ return "", "", err
+ }
+
+ return stdout.String(), stderr.String(), nil
+}
+
+func (s *VolumeService) DeleteFile(ctx context.Context, volumeName, filePath string, user *models.User) error {
+ slog.DebugContext(ctx, "volume service: delete file", "volume", volumeName, "path", filePath)
+
+ sanitizedPath, err := s.sanitizeBrowsePathInternal(filePath)
+ if err != nil {
+ return fmt.Errorf("invalid path: %w", err)
+ }
+ // Prevent deleting root
+ if sanitizedPath == "/" {
+ return fmt.Errorf("cannot delete root directory")
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)
+ if err != nil {
+ return err
+ }
+ defer cleanup()
+
+ targetPath := path.Join("/volume", sanitizedPath)
+ _, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"rm", "-rf", targetPath})
+ if err != nil {
+ return err
+ }
+ if stderr != "" {
+ return fmt.Errorf("delete failed: %s", stderr)
+ }
+
+ actingUser := user
+ if actingUser == nil {
+ actingUser = &systemUser
+ }
+ metadata := models.JSON{
+ "action": "file_delete",
+ "path": filePath,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeFileDelete, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume file delete event", "volume", volumeName, "error", logErr.Error())
+ }
+ return nil
+}
+
+func (s *VolumeService) CreateDirectory(ctx context.Context, volumeName, dirPath string, user *models.User) error {
+ slog.DebugContext(ctx, "volume service: create directory", "volume", volumeName, "path", dirPath)
+
+ sanitizedPath, err := s.sanitizeBrowsePathInternal(dirPath)
+ if err != nil {
+ return fmt.Errorf("invalid path: %w", err)
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)
+ if err != nil {
+ return err
+ }
+ defer cleanup()
+
+ targetPath := path.Join("/volume", sanitizedPath)
+ _, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"mkdir", "-p", targetPath})
+ if err != nil {
+ return err
+ }
+ if stderr != "" {
+ return fmt.Errorf("mkdir failed: %s", stderr)
+ }
+
+ actingUser := user
+ if actingUser == nil {
+ actingUser = &systemUser
+ }
+ metadata := models.JSON{
+ "action": "file_create",
+ "path": dirPath,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeFileCreate, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume file create event", "volume", volumeName, "error", logErr.Error())
+ }
+ return nil
+}
+
+func (s *VolumeService) UploadFile(ctx context.Context, volumeName, destPath string, content io.Reader, filename string, user *models.User) error {
+ slog.DebugContext(ctx, "volume service: upload file", "volume", volumeName, "dest_path", destPath, "filename", filename)
+
+ sanitizedPath, err := s.sanitizeBrowsePathInternal(destPath)
+ if err != nil {
+ return fmt.Errorf("invalid path: %w", err)
+ }
+
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return err
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)
+ if err != nil {
+ return err
+ }
+ defer cleanup()
+
+ var buf bytes.Buffer
+ tw := tar.NewWriter(&buf)
+
+ contentBytes, err := io.ReadAll(content)
+ if err != nil {
+ return err
+ }
+
+ hdr := &tar.Header{
+ Name: filename,
+ Mode: 0644,
+ Size: int64(len(contentBytes)),
+ }
+ if err := tw.WriteHeader(hdr); err != nil {
+ return err
+ }
+ if _, err := tw.Write(contentBytes); err != nil {
+ tw.Close()
+ return err
+ }
+ tw.Close()
+
+ targetDir := path.Join("/volume", sanitizedPath)
+ err = dockerClient.CopyToContainer(ctx, containerID, targetDir, &buf, container.CopyToContainerOptions{})
+ if err != nil {
+ return fmt.Errorf("failed to upload: %w", err)
+ }
+
+ actingUser := user
+ if actingUser == nil {
+ actingUser = &systemUser
+ }
+ metadata := models.JSON{
+ "action": "file_upload",
+ "path": destPath,
+ "filename": filename,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeFileUpload, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume file upload event", "volume", volumeName, "error", logErr.Error())
+ }
+
+ return nil
+}
+
+func (s *VolumeService) ensureBackupVolumeInternal(ctx context.Context) error {
+ slog.DebugContext(ctx, "volume service: ensure backup volume", "backup_volume", s.backupVolumeName)
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return err
+ }
+
+ _, err = dockerClient.VolumeInspect(ctx, s.backupVolumeName)
+ if err != nil {
+ _, err = dockerClient.VolumeCreate(ctx, volume.CreateOptions{
+ Name: s.backupVolumeName,
+ })
+ if err != nil {
+ return fmt.Errorf("failed to create backup volume: %w", err)
+ }
+ }
+ return nil
+}
+
+func (s *VolumeService) CreateBackup(ctx context.Context, volumeName string, user models.User) (*models.VolumeBackup, error) {
+ slog.DebugContext(ctx, "volume service: create backup", "volume", volumeName, "user", user.ID)
+ if err := s.ensureBackupVolumeInternal(ctx); err != nil {
+ return nil, err
+ }
+
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return nil, err
+ }
+
+ backupID := fmt.Sprintf("%s-%d-%s", volumeName, time.Now().UnixNano(), uuid.NewString()[:8])
+ filename := fmt.Sprintf("%s.tar.gz", backupID)
+
+ helperImage, err := s.getHelperImageInternal(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ config := &container.Config{
+ Image: helperImage,
+ Cmd: []string{"sh", "-c", fmt.Sprintf("tar -czf /backups/%s -C /volume .", filename)},
+ Labels: map[string]string{
+ libarcane.InternalContainerLabel: "true",
+ },
+ }
+
+ hostConfig := &container.HostConfig{
+ Binds: []string{
+ fmt.Sprintf("%s:/volume:ro", volumeName),
+ fmt.Sprintf("%s:/backups", s.backupVolumeName),
+ },
+ AutoRemove: true,
+ }
+
+ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")
+ if err != nil {
+ return nil, fmt.Errorf("failed to create backup container: %w", err)
+ }
+
+ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
+ return nil, fmt.Errorf("failed to start backup container: %w", err)
+ }
+
+ statusCh, errCh := dockerClient.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
+ select {
+ case err := <-errCh:
+ if err != nil {
+ return nil, err
+ }
+ case status := <-statusCh:
+ if status.StatusCode != 0 {
+ return nil, fmt.Errorf("backup container exited with status %d", status.StatusCode)
+ }
+ }
+
+ tempContainerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, true)
+ if err != nil {
+ return nil, err
+ }
+ defer cleanup()
+
+ sizeStr, _, err := s.execInContainerInternal(ctx, tempContainerID, []string{"stat", "-c", "%s", path.Join("/volume", filename)})
+ if err != nil {
+ return nil, err
+ }
+ size, err := strconv.ParseInt(strings.TrimSpace(sizeStr), 10, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ backup := &models.VolumeBackup{
+ VolumeName: volumeName,
+ Size: size,
+ CreatedAt: time.Now(),
+ }
+ backup.ID = backupID
+
+ if err := s.db.WithContext(ctx).Create(backup).Error; err != nil {
+ return nil, err
+ }
+
+ metadata := models.JSON{
+ "action": "backup_create",
+ "backup_id": backup.ID,
+ "filename": filename,
+ "size": size,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupCreate, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume backup create event", "volume", volumeName, "error", logErr.Error())
+ }
+
+ return backup, nil
+}
+
+func (s *VolumeService) ListBackupsPaginated(ctx context.Context, volumeName string, params pagination.QueryParams) ([]models.VolumeBackup, pagination.Response, error) {
+ slog.DebugContext(ctx, "volume service: list backups paginated", "volume", volumeName, "search", params.Search, "sort", params.Sort, "order", params.Order, "start", params.Start, "limit", params.Limit)
+ var backups []models.VolumeBackup
+ query := s.db.WithContext(ctx).Model(&models.VolumeBackup{}).Where("volume_name = ?", volumeName)
+
+ if params.Search != "" {
+ query = query.Where("id LIKE ?", "%"+params.Search+"%")
+ }
+
+ var totalItems int64
+ if err := query.Count(&totalItems).Error; err != nil {
+ return nil, pagination.Response{}, err
+ }
+
+ sortCol := "created_at"
+ sortOrder := "DESC"
+ if params.Sort != "" {
+ switch params.Sort {
+ case "createdAt", "created_at":
+ sortCol = "created_at"
+ case "id":
+ sortCol = "id"
+ case "size":
+ sortCol = "size"
+ default:
+ sortCol = "created_at"
+ }
+
+ if params.Order == pagination.SortDesc {
+ sortOrder = "DESC"
+ } else {
+ sortOrder = "ASC"
+ }
+ }
+ query = query.Order(fmt.Sprintf("%s %s", sortCol, sortOrder))
+
+ if params.Limit > 0 {
+ query = query.Offset(params.Start).Limit(params.Limit)
+ }
+
+ if err := query.Find(&backups).Error; err != nil {
+ return nil, pagination.Response{}, err
+ }
+
+ paginationResp := s.buildPaginationResponseFromCountsInternal(totalItems, totalItems, params)
+ return backups, paginationResp, nil
+}
+
+func (s *VolumeService) buildPaginationResponseFromCountsInternal(totalCount int64, totalAvailable int64, params pagination.QueryParams) pagination.Response {
+ slog.Debug("volume service: build pagination response", "total_count", totalCount, "total_available", totalAvailable, "start", params.Start, "limit", params.Limit)
+ totalPages := int64(0)
+ if params.Limit > 0 {
+ totalPages = (totalCount + int64(params.Limit) - 1) / int64(params.Limit)
+ }
+
+ page := 1
+ if params.Limit > 0 {
+ page = (params.Start / params.Limit) + 1
+ }
+
+ return pagination.Response{
+ TotalPages: totalPages,
+ TotalItems: totalCount,
+ CurrentPage: page,
+ ItemsPerPage: params.Limit,
+ GrandTotalItems: totalAvailable,
+ }
+}
+
+func (s *VolumeService) ListBackups(ctx context.Context, volumeName string) ([]models.VolumeBackup, error) {
+ slog.DebugContext(ctx, "volume service: list backups", "volume", volumeName)
+ var backups []models.VolumeBackup
+ err := s.db.WithContext(ctx).Where("volume_name = ?", volumeName).Order("created_at DESC").Find(&backups).Error
+ return backups, err
+}
+
+func (s *VolumeService) DeleteBackup(ctx context.Context, backupID string, user *models.User) error {
+ slog.DebugContext(ctx, "volume service: delete backup", "backup_id", backupID)
+ var backup models.VolumeBackup
+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {
+ return err
+ }
+
+ // Delete from DB first - if this fails, no changes are made.
+ // If file deletion fails afterward, we just have an orphan file (easier to clean up)
+ // rather than an orphan DB record pointing to a non-existent file.
+ volumeName := backup.VolumeName // Save before deletion
+ if err := s.db.WithContext(ctx).Delete(&backup).Error; err != nil {
+ return err
+ }
+
+ // Now delete the actual file - best effort since DB record is already gone
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, false)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to create container for backup file cleanup", "backup_id", backupID, "error", err.Error())
+ } else {
+ defer cleanup()
+ filename := fmt.Sprintf("%s.tar.gz", backupID)
+ if _, _, err = s.execInContainerInternal(ctx, containerID, []string{"rm", "-f", path.Join("/volume", filename)}); err != nil {
+ slog.WarnContext(ctx, "failed to delete backup file (orphan file may remain)", "backup_id", backupID, "error", err.Error())
+ }
+ }
+
+ actingUser := user
+ if actingUser == nil {
+ actingUser = &systemUser
}
+ metadata := models.JSON{
+ "action": "backup_delete",
+ "backup_id": backupID,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupDelete, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume backup delete event", "volume", volumeName, "error", logErr.Error())
+ }
+
+ return nil
}
-func (s *VolumeService) GetVolumeByName(ctx context.Context, name string) (*volumetypes.Volume, error) {
+func (s *VolumeService) RestoreBackup(ctx context.Context, volumeName, backupID string, user models.User) error {
+ slog.DebugContext(ctx, "volume service: restore backup", "volume", volumeName, "backup_id", backupID, "user", user.ID)
+ var backup models.VolumeBackup
+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {
+ return err
+ }
+
+ // Validate backup belongs to volume
+ if backup.VolumeName != volumeName {
+ return fmt.Errorf("backup does not belong to volume %s", volumeName)
+ }
+
+ // Check if volume is in use by running containers
+ inUse, containerIDs, err := s.GetVolumeUsage(ctx, volumeName)
+ if err != nil {
+ slog.WarnContext(ctx, "could not check volume usage", "volume", volumeName, "error", err.Error())
+ } else if inUse {
+ return fmt.Errorf("volume is in use by %d container(s): restoring while containers are running may cause data corruption. Stop the containers first or use selective file restore", len(containerIDs))
+ }
+
+ preBackup, err := s.CreateBackup(ctx, volumeName, user)
+ if err != nil {
+ return fmt.Errorf("failed to create pre-restore backup: %w", err)
+ }
+
dockerClient, err := s.dockerService.GetClient()
if err != nil {
- return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ return err
}
- vol, err := dockerClient.VolumeInspect(ctx, name)
+ filename := fmt.Sprintf("%s.tar.gz", backupID)
+
+ helperImage, err := s.getHelperImageInternal(ctx)
if err != nil {
- return nil, fmt.Errorf("volume not found: %w", err)
+ return err
}
- if usageVolumes, duErr := docker.GetVolumeUsageData(ctx, dockerClient); duErr == nil {
- for _, uv := range usageVolumes {
- if uv.Name == vol.Name && uv.UsageData != nil {
- vol.UsageData = uv.UsageData
- slog.DebugContext(ctx, "attached volume usage data", "volume", vol.Name, "size_bytes", uv.UsageData.Size, "ref_count", uv.UsageData.RefCount)
- break
- }
- }
- } else {
- slog.WarnContext(ctx, "failed to load volume usage data", "volume", vol.Name, "error", duErr.Error())
+ config := &container.Config{
+ Image: helperImage,
+ Cmd: []string{
+ "sh",
+ "-c",
+ fmt.Sprintf("set -e; tmp=$(mktemp -d /volume/.restore_tmp.XXXXXX); tar -tzf /backups/%s >/dev/null; tar -xzf /backups/%s -C \"$tmp\"; find /volume -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +; find \"$tmp\" -mindepth 1 -maxdepth 1 -exec mv -- {} /volume/ \\;; rmdir \"$tmp\"", filename, filename),
+ },
+ Labels: map[string]string{
+ libarcane.InternalContainerLabel: "true",
+ },
}
- v := volumetypes.NewSummary(vol)
+ hostConfig := &container.HostConfig{
+ Binds: []string{
+ fmt.Sprintf("%s:/volume", volumeName),
+ fmt.Sprintf("%s:/backups:ro", s.backupVolumeName),
+ },
+ AutoRemove: true,
+ }
- containerIDs, err := docker.GetContainersUsingVolume(ctx, dockerClient, name)
+ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")
if err != nil {
- slog.WarnContext(ctx, "failed to get containers using volume", "volume", name, "error", err.Error())
- } else {
- v.Containers = containerIDs
- if len(containerIDs) > 0 {
- v.InUse = true
+ return fmt.Errorf("failed to create restore container: %w", err)
+ }
+
+ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
+ return fmt.Errorf("failed to start restore container: %w", err)
+ }
+
+ statusCh, errCh := dockerClient.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
+ var waitBody container.WaitResponse
+ select {
+ case err := <-errCh:
+ if err != nil {
+ return err
}
+ case waitBody = <-statusCh:
}
- return &v, nil
+ if waitBody.StatusCode != 0 {
+ return fmt.Errorf("restore container exited with code %d (volume may be partially wiped)", waitBody.StatusCode)
+ }
+
+ metadata := models.JSON{
+ "action": "backup_restore",
+ "backup_id": backupID,
+ "pre_restore_backupId": preBackup.ID,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupRestore, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume backup restore event", "volume", volumeName, "error", logErr.Error())
+ }
+
+ return nil
}
-func (s *VolumeService) CreateVolume(ctx context.Context, options volume.CreateOptions, user models.User) (*volumetypes.Volume, error) {
- dockerClient, err := s.dockerService.GetClient()
+func (s *VolumeService) sanitizeBackupPathInternal(input string) (string, error) {
+ trimmed := strings.TrimSpace(input)
+ if trimmed == "" {
+ return "", fmt.Errorf("invalid path: empty")
+ }
+ cleaned := path.Clean(trimmed)
+ if cleaned == "." || cleaned == "/" {
+ return "", fmt.Errorf("invalid path: %s", input)
+ }
+ if path.IsAbs(cleaned) {
+ cleaned = strings.TrimPrefix(cleaned, "/")
+ }
+ if cleaned == "" || cleaned == "." || cleaned == "/" || strings.HasPrefix(cleaned, "..") || strings.Contains(cleaned, "/../") {
+ return "", fmt.Errorf("invalid path: %s", input)
+ }
+ return cleaned, nil
+}
+
+// sanitizeBrowsePath validates and cleans a path for file browser operations.
+// It ensures the path stays within the volume boundary.
+func (s *VolumeService) sanitizeBrowsePathInternal(input string) (string, error) {
+ trimmed := strings.TrimSpace(input)
+ if trimmed == "" || trimmed == "/" {
+ return "/", nil // Root is valid for browse
+ }
+ cleaned := path.Clean(trimmed)
+ // Ensure path starts with /
+ if !path.IsAbs(cleaned) {
+ cleaned = "/" + cleaned
+ }
+ // Check for path traversal attempts
+ if strings.Contains(cleaned, "/../") || strings.HasSuffix(cleaned, "/..") || cleaned == "/.." {
+ return "", fmt.Errorf("invalid path: path traversal not allowed")
+ }
+ // After cleaning, the path should not escape root
+ if !strings.HasPrefix(cleaned, "/") {
+ return "", fmt.Errorf("invalid path: must be absolute")
+ }
+ return cleaned, nil
+}
+
+func (s *VolumeService) BackupHasPath(ctx context.Context, backupID string, filePath string) (bool, error) {
+ slog.DebugContext(ctx, "volume service: backup has path", "backup_id", backupID, "path", filePath)
+ if err := s.ensureBackupVolumeInternal(ctx); err != nil {
+ return false, err
+ }
+
+ cleaned, err := s.sanitizeBackupPathInternal(filePath)
if err != nil {
- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})
- return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ return false, err
}
- created, err := dockerClient.VolumeCreate(ctx, options)
+ var backup models.VolumeBackup
+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {
+ return false, err
+ }
+
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, true)
if err != nil {
- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver})
- return nil, fmt.Errorf("failed to create volume: %w", err)
+ return false, err
}
+ defer cleanup()
- vol, err := dockerClient.VolumeInspect(ctx, created.Name)
+ archivePath := path.Join("/volume", fmt.Sprintf("%s.tar.gz", backupID))
+ cmd := []string{"tar", "-tzf", archivePath}
+ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, cmd)
if err != nil {
- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", created.Name, created.Name, user.ID, user.Username, "0", err, models.JSON{"action": "create", "driver": options.Driver, "step": "inspect"})
- return nil, fmt.Errorf("failed to inspect created volume: %w", err)
+ return false, err
+ }
+ if strings.TrimSpace(stderr) != "" {
+ return false, fmt.Errorf("failed to list backup contents: %s", strings.TrimSpace(stderr))
}
- metadata := models.JSON{
- "action": "create",
- "driver": vol.Driver,
- "name": vol.Name,
+ for _, line := range strings.Split(stdout, "\n") {
+ entry := strings.TrimSpace(line)
+ if entry == "" {
+ continue
+ }
+ entry = strings.TrimPrefix(entry, "./")
+ if entry == cleaned || strings.TrimSuffix(entry, "/") == cleaned {
+ return true, nil
+ }
}
- if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeCreate, vol.Name, vol.Name, user.ID, user.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "could not log volume creation action", "volume", vol.Name, "error", logErr.Error())
+
+ return false, nil
+}
+
+func (s *VolumeService) ListBackupFiles(ctx context.Context, backupID string) ([]string, error) {
+ slog.DebugContext(ctx, "volume service: list backup files", "backup_id", backupID)
+ if err := s.ensureBackupVolumeInternal(ctx); err != nil {
+ return nil, err
}
- docker.InvalidateVolumeUsageCache()
+ var backup models.VolumeBackup
+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {
+ return nil, err
+ }
- dtoVol := volumetypes.NewSummary(vol)
- return &dtoVol, nil
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, s.backupVolumeName, true)
+ if err != nil {
+ return nil, err
+ }
+ defer cleanup()
+
+ archivePath := path.Join("/volume", fmt.Sprintf("%s.tar.gz", backupID))
+ cmd := []string{"tar", "-tzf", archivePath}
+ stdout, _, err := s.execInContainerInternal(ctx, containerID, cmd)
+ if err != nil {
+ return nil, err
+ }
+
+ lines := strings.Split(strings.TrimSpace(stdout), "\n")
+ files := make([]string, 0, len(lines))
+ seen := make(map[string]struct{})
+ for _, line := range lines {
+ clean := strings.TrimSpace(line)
+ if clean == "" {
+ continue
+ }
+ clean = strings.TrimPrefix(clean, "./")
+ if strings.HasSuffix(clean, "/") {
+ continue
+ }
+ if _, ok := seen[clean]; ok {
+ continue
+ }
+ seen[clean] = struct{}{}
+ files = append(files, clean)
+ }
+
+ return files, nil
}
-func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force bool, user models.User) error {
+func (s *VolumeService) RestoreBackupFiles(ctx context.Context, volumeName, backupID string, paths []string, user models.User) error {
+ slog.DebugContext(ctx, "volume service: restore backup files", "volume", volumeName, "backup_id", backupID, "paths_count", len(paths), "user", user.ID)
+ if len(paths) == 0 {
+ return fmt.Errorf("no paths provided")
+ }
+
+ var backup models.VolumeBackup
+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err != nil {
+ return err
+ }
+ if backup.VolumeName != volumeName {
+ return fmt.Errorf("backup does not belong to volume")
+ }
+
+ // Create pre-restore backup for safety (consistent with RestoreBackup behavior)
+ preBackup, err := s.CreateBackup(ctx, volumeName, user)
+ if err != nil {
+ return fmt.Errorf("failed to create pre-restore backup: %w", err)
+ }
+ slog.DebugContext(ctx, "created pre-restore backup", "volume", volumeName, "pre_backup_id", preBackup.ID)
+
+ cleanedPaths := make([]string, 0, len(paths))
+ for _, p := range paths {
+ cleaned, err := s.sanitizeBackupPathInternal(p)
+ if err != nil {
+ return err
+ }
+ cleanedPaths = append(cleanedPaths, cleaned)
+ }
+ if len(cleanedPaths) == 0 {
+ return fmt.Errorf("no valid paths provided")
+ }
+
+ tarPaths := make([]string, 0, len(cleanedPaths))
+ for _, p := range cleanedPaths {
+ tarPaths = append(tarPaths, "./"+p)
+ }
+
dockerClient, err := s.dockerService.GetClient()
if err != nil {
- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
- return fmt.Errorf("failed to connect to Docker: %w", err)
+ return err
}
- if err := dockerClient.VolumeRemove(ctx, name, force); err != nil {
- s.eventService.LogErrorEvent(ctx, models.EventTypeVolumeError, "volume", name, name, user.ID, user.Username, "0", err, models.JSON{"action": "delete", "force": force})
- return fmt.Errorf("failed to remove volume: %w", err)
+ helperImage, err := s.getHelperImageInternal(ctx)
+ if err != nil {
+ return err
+ }
+
+ config := &container.Config{
+ Image: helperImage,
+ Cmd: []string{"sleep", "infinity"},
+ NetworkDisabled: true,
+ Labels: map[string]string{
+ libarcane.InternalContainerLabel: "true",
+ },
+ }
+
+ hostConfig := &container.HostConfig{
+ Binds: []string{
+ fmt.Sprintf("%s:/volume", volumeName),
+ fmt.Sprintf("%s:/backups:ro", s.backupVolumeName),
+ },
+ AutoRemove: true,
+ }
+
+ resp, err := dockerClient.ContainerCreate(ctx, config, hostConfig, nil, nil, "")
+ if err != nil {
+ return fmt.Errorf("failed to create restore container: %w", err)
+ }
+
+ if err := dockerClient.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
+ return fmt.Errorf("failed to start restore container: %w", err)
+ }
+
+ cleanup := func() {
+ _ = dockerClient.ContainerRemove(ctx, resp.ID, container.RemoveOptions{Force: true})
+ }
+ defer cleanup()
+
+ filename := fmt.Sprintf("%s.tar.gz", backupID)
+ cmd := append([]string{"tar", "-xzf", path.Join("/backups", filename), "-C", "/volume", "--"}, tarPaths...)
+ _, stderr, err := s.execInContainerInternal(ctx, resp.ID, cmd)
+ if err != nil {
+ return fmt.Errorf("failed to restore files: %w", err)
+ }
+ if strings.TrimSpace(stderr) != "" {
+ slog.DebugContext(ctx, "volume service: restore files stderr", "backup_id", backupID, "stderr", strings.TrimSpace(stderr))
}
metadata := models.JSON{
- "action": "delete",
- "name": name,
+ "action": "backup_restore_files",
+ "backup_id": backupID,
+ "pre_restore_backupId": preBackup.ID,
+ "paths_count": len(cleanedPaths),
}
- if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, name, name, user.ID, user.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "could not log volume deletion action", "volume", name, "error", logErr.Error())
+ if len(cleanedPaths) > 0 {
+ limit := min(len(cleanedPaths), 5)
+ metadata["paths_sample"] = cleanedPaths[:limit]
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupRestoreFiles, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume backup restore files event", "volume", volumeName, "error", logErr.Error())
}
return nil
}
-func (s *VolumeService) PruneVolumes(ctx context.Context) (*volumetypes.PruneReport, error) {
- return s.PruneVolumesWithOptions(ctx, false)
+func (s *VolumeService) DownloadBackup(ctx context.Context, backupID string, user *models.User) (io.ReadCloser, int64, error) {
+ slog.DebugContext(ctx, "volume service: download backup", "backup_id", backupID)
+ filename := fmt.Sprintf("%s.tar.gz", backupID)
+ reader, size, err := s.DownloadFile(ctx, s.backupVolumeName, filename)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ actingUser := user
+ if actingUser == nil {
+ actingUser = &systemUser
+ }
+ volumeName := ""
+ var backup models.VolumeBackup
+ if err := s.db.WithContext(ctx).Where("id = ?", backupID).First(&backup).Error; err == nil {
+ volumeName = backup.VolumeName
+ }
+ if volumeName != "" {
+ metadata := models.JSON{
+ "action": "backup_download",
+ "backup_id": backupID,
+ "size": size,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupDownload, volumeName, volumeName, actingUser.ID, actingUser.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume backup download event", "volume", volumeName, "error", logErr.Error())
+ }
+ }
+
+ return reader, size, nil
}
-func (s *VolumeService) PruneVolumesWithOptions(ctx context.Context, all bool) (*volumetypes.PruneReport, error) {
+func (s *VolumeService) UploadAndRestore(ctx context.Context, volumeName string, archive io.Reader, filename string, user models.User) error {
+ slog.DebugContext(ctx, "volume service: upload and restore", "volume", volumeName, "filename", filename, "user", user.ID)
+
+ tmpFile, err := os.CreateTemp("", "arcane-restore-*.tar.gz")
+ if err != nil {
+ return fmt.Errorf("failed to buffer upload: %w", err)
+ }
+ defer func() {
+ _ = tmpFile.Close()
+ _ = os.Remove(tmpFile.Name())
+ }()
+ if _, err := io.Copy(tmpFile, archive); err != nil {
+ return fmt.Errorf("failed to buffer upload: %w", err)
+ }
+ if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {
+ return fmt.Errorf("failed to read buffered upload: %w", err)
+ }
+ gzr, err := gzip.NewReader(tmpFile)
+ if err != nil {
+ return fmt.Errorf("invalid archive: %w", err)
+ }
+ if _, err := tar.NewReader(gzr).Next(); err != nil {
+ _ = gzr.Close()
+ return fmt.Errorf("invalid archive: %w", err)
+ }
+ _ = gzr.Close()
+
+ preBackup, err := s.CreateBackup(ctx, volumeName, user)
+ if err != nil {
+ return fmt.Errorf("failed to create pre-restore backup: %w", err)
+ }
+
dockerClient, err := s.dockerService.GetClient()
if err != nil {
- return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ return err
}
- // Docker's VolumesPrune behavior (API v1.42+):
- // - Without 'all' flag: Only removes anonymous (unnamed) volumes that are not in use
- // - With 'all=true' flag: Removes ALL unused volumes (both named and anonymous)
- // Note: Volumes are considered "in use" if referenced by any container (running or stopped)
- filterArgs := filters.NewArgs()
- if all {
- // The 'all' filter was added in Docker API v1.42
- // This tells Docker to prune ALL unused volumes, not just anonymous ones
- filterArgs.Add("all", "true")
+ containerID, cleanup, err := s.createTempContainerInternal(ctx, volumeName, false)
+ if err != nil {
+ return err
}
- // Other valid filters for volume prune:
- // - label=<key> or label=<key>=<value>
- // - label!=<key> or label!=<key>=<value>
+ defer cleanup()
- report, err := dockerClient.VolumesPrune(ctx, filterArgs)
+ tmpDir := fmt.Sprintf("/volume/.restore_tmp_%d", time.Now().UnixNano())
+ _, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"mkdir", "-p", tmpDir})
if err != nil {
- return nil, fmt.Errorf("failed to prune volumes: %w", err)
+ return fmt.Errorf("failed to create temp restore dir: %w", err)
+ }
+ if strings.TrimSpace(stderr) != "" {
+ slog.DebugContext(ctx, "volume service: restore temp dir stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))
}
- metadata := models.JSON{
- "action": "prune",
- "all": all,
- "volumesDeleted": len(report.VolumesDeleted),
- "spaceReclaimed": report.SpaceReclaimed,
+ if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {
+ return fmt.Errorf("failed to read buffered upload: %w", err)
}
- if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeDelete, "", "bulk_prune", systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "could not log volume prune action", "error", logErr.Error())
+ err = dockerClient.CopyToContainer(ctx, containerID, tmpDir, tmpFile, container.CopyToContainerOptions{})
+ if err != nil {
+ return fmt.Errorf("failed to restore from uploaded archive: %w", err)
}
- docker.InvalidateVolumeUsageCache()
+ _, stderr, err = s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", fmt.Sprintf("test -n \"$(find %s -mindepth 1 -maxdepth 1 -print -quit)\"", tmpDir)})
+ if err != nil {
+ return fmt.Errorf("uploaded archive appears empty or invalid: %w", err)
+ }
+ if strings.TrimSpace(stderr) != "" {
+ slog.DebugContext(ctx, "volume service: restore validate stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))
+ }
- return &volumetypes.PruneReport{
- VolumesDeleted: report.VolumesDeleted,
- SpaceReclaimed: report.SpaceReclaimed,
- }, nil
+ _, stderr, err = s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", "rm -rf /volume/* /volume/.[!.]* /volume/..?* 2>/dev/null || true"})
+ if err != nil {
+ return fmt.Errorf("failed to clear volume before restore: %w", err)
+ }
+ if strings.TrimSpace(stderr) != "" {
+ slog.DebugContext(ctx, "volume service: restore clear stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))
+ }
+
+ moveCmd := fmt.Sprintf("find %s -mindepth 1 -maxdepth 1 -exec mv -- {} /volume/ \\; && rmdir %s", tmpDir, tmpDir)
+ _, stderr, err = s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", moveCmd})
+ if err != nil {
+ return fmt.Errorf("failed to move restored files into place: %w", err)
+ }
+ if strings.TrimSpace(stderr) != "" {
+ slog.DebugContext(ctx, "volume service: restore move stderr", "volume", volumeName, "stderr", strings.TrimSpace(stderr))
+ }
+
+ metadata := models.JSON{
+ "action": "backup_upload_restore",
+ "filename": filename,
+ "pre_restore_backupId": preBackup.ID,
+ }
+ if logErr := s.eventService.LogVolumeEvent(ctx, models.EventTypeVolumeBackupRestore, volumeName, volumeName, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.WarnContext(ctx, "could not log volume backup upload restore event", "volume", volumeName, "error", logErr.Error())
+ }
+
+ return nil
}
func (s *VolumeService) GetVolumeUsage(ctx context.Context, name string) (bool, []string, error) {
+ slog.DebugContext(ctx, "volume service: get volume usage", "volume", name)
dockerClient, err := s.dockerService.GetClient()
if err != nil {
return false, nil, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -206,6 +1493,7 @@ type VolumeSizeData struct {
// GetVolumeSizes returns disk usage data for all volumes.
// This is a slow operation as it calls Docker's DiskUsage API.
func (s *VolumeService) GetVolumeSizes(ctx context.Context) (map[string]VolumeSizeData, error) {
+ slog.DebugContext(ctx, "volume service: get volume sizes")
dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -229,7 +1517,8 @@ func (s *VolumeService) GetVolumeSizes(ctx context.Context) (map[string]VolumeSi
return result, nil
}
-func (s *VolumeService) enrichVolumesWithUsageData(volumes []*volume.Volume, usageVolumes []volume.Volume) []volume.Volume {
+func (s *VolumeService) enrichVolumesWithUsageDataInternal(volumes []*volume.Volume, usageVolumes []volume.Volume) []volume.Volume {
+ slog.Debug("volume service: enrich volumes with usage data", "volumes", len(volumes), "usage_volumes", len(usageVolumes))
result := make([]volume.Volume, 0, len(volumes))
for _, v := range volumes {
if v != nil {
@@ -246,7 +1535,8 @@ func (s *VolumeService) enrichVolumesWithUsageData(volumes []*volume.Volume, usa
return result
}
-func (s *VolumeService) buildVolumeContainerMap(ctx context.Context, dockerClient *client.Client) (map[string][]string, error) {
+func (s *VolumeService) buildVolumeContainerMapInternal(ctx context.Context, dockerClient *client.Client) (map[string][]string, error) {
+ slog.DebugContext(ctx, "volume service: build volume container map")
containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
if err != nil {
return nil, fmt.Errorf("failed to list containers: %w", err)
@@ -264,7 +1554,8 @@ func (s *VolumeService) buildVolumeContainerMap(ctx context.Context, dockerClien
return volumeContainerMap, nil
}
-func (s *VolumeService) buildVolumePaginationConfig() pagination.Config[volumetypes.Volume] {
+func (s *VolumeService) buildVolumePaginationConfigInternal() pagination.Config[volumetypes.Volume] {
+ slog.Debug("volume service: build volume pagination config")
return pagination.Config[volumetypes.Volume]{
SearchAccessors: []pagination.SearchAccessor[volumetypes.Volume]{
func(v volumetypes.Volume) (string, error) { return v.Name, nil },
@@ -272,13 +1563,14 @@ func (s *VolumeService) buildVolumePaginationConfig() pagination.Config[volumety
func(v volumetypes.Volume) (string, error) { return v.Mountpoint, nil },
func(v volumetypes.Volume) (string, error) { return v.Scope, nil },
},
- SortBindings: s.buildVolumeSortBindings(),
- FilterAccessors: s.buildVolumeFilterAccessors(),
+ SortBindings: s.buildVolumeSortBindingsInternal(),
+ FilterAccessors: s.buildVolumeFilterAccessorsInternal(),
}
}
-func (s *VolumeService) buildVolumeSortBindings() []pagination.SortBinding[volumetypes.Volume] {
- createdSortFn := func(a, b volumetypes.Volume) int { return strings.Compare(a.CreatedAt, b.CreatedAt) }
+func (s *VolumeService) buildVolumeSortBindingsInternal() []pagination.SortBinding[volumetypes.Volume] {
+ slog.Debug("volume service: build volume sort bindings")
+ createdSortFn := s.compareVolumeCreatedInternal
return []pagination.SortBinding[volumetypes.Volume]{
{
@@ -319,12 +1611,13 @@ func (s *VolumeService) buildVolumeSortBindings() []pagination.SortBinding[volum
},
{
Key: "size",
- Fn: s.compareVolumeSizes,
+ Fn: s.compareVolumeSizesInternal,
},
}
}
-func (s *VolumeService) compareVolumeSizes(a, b volumetypes.Volume) int {
+func (s *VolumeService) compareVolumeSizesInternal(a, b volumetypes.Volume) int {
+ slog.Debug("volume service: compare volume sizes")
aSize := a.Size
bSize := b.Size
@@ -344,7 +1637,37 @@ func (s *VolumeService) compareVolumeSizes(a, b volumetypes.Volume) int {
return 1
}
-func (s *VolumeService) buildVolumeFilterAccessors() []pagination.FilterAccessor[volumetypes.Volume] {
+func (s *VolumeService) compareVolumeCreatedInternal(a, b volumetypes.Volume) int {
+ slog.Debug("volume service: compare volume created time")
+ aTime, aOk := s.parseVolumeCreatedAtInternal(a.CreatedAt)
+ bTime, bOk := s.parseVolumeCreatedAtInternal(b.CreatedAt)
+ if aOk && bOk {
+ if aTime.Before(bTime) {
+ return -1
+ }
+ if aTime.After(bTime) {
+ return 1
+ }
+ return 0
+ }
+ return strings.Compare(a.CreatedAt, b.CreatedAt)
+}
+
+func (s *VolumeService) parseVolumeCreatedAtInternal(createdAt string) (time.Time, bool) {
+ if createdAt == "" {
+ return time.Time{}, false
+ }
+ if parsed, err := time.Parse(time.RFC3339Nano, createdAt); err == nil {
+ return parsed, true
+ }
+ if parsed, err := time.Parse(time.RFC3339, createdAt); err == nil {
+ return parsed, true
+ }
+ return time.Time{}, false
+}
+
+func (s *VolumeService) buildVolumeFilterAccessorsInternal() []pagination.FilterAccessor[volumetypes.Volume] {
+ slog.Debug("volume service: build volume filter accessors")
return []pagination.FilterAccessor[volumetypes.Volume]{
{
Key: "inUse",
@@ -361,7 +1684,8 @@ func (s *VolumeService) buildVolumeFilterAccessors() []pagination.FilterAccessor
}
}
-func (s *VolumeService) calculateVolumeUsageCounts(items []volumetypes.Volume) volumetypes.UsageCounts {
+func (s *VolumeService) calculateVolumeUsageCountsInternal(items []volumetypes.Volume) volumetypes.UsageCounts {
+ slog.Debug("volume service: calculate volume usage counts", "items", len(items))
counts := volumetypes.UsageCounts{
Total: len(items),
}
@@ -375,27 +1699,12 @@ func (s *VolumeService) calculateVolumeUsageCounts(items []volumetypes.Volume) v
return counts
}
-func (s *VolumeService) buildPaginationResponse(result pagination.FilterResult[volumetypes.Volume], params pagination.QueryParams) pagination.Response {
- totalPages := int64(0)
- if params.Limit > 0 {
- totalPages = (int64(result.TotalCount) + int64(params.Limit) - 1) / int64(params.Limit)
- }
-
- page := 1
- if params.Limit > 0 {
- page = (params.Start / params.Limit) + 1
- }
-
- return pagination.Response{
- TotalPages: totalPages,
- TotalItems: int64(result.TotalCount),
- CurrentPage: page,
- ItemsPerPage: params.Limit,
- GrandTotalItems: int64(result.TotalAvailable),
- }
+func (s *VolumeService) buildPaginationResponseInternal(result pagination.FilterResult[volumetypes.Volume], params pagination.QueryParams) pagination.Response {
+ return s.buildPaginationResponseFromCountsInternal(result.TotalCount, result.TotalAvailable, params)
}
func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params pagination.QueryParams) ([]volumetypes.Volume, pagination.Response, volumetypes.UsageCounts, error) {
+ slog.DebugContext(ctx, "volume service: list volumes paginated", "search", params.Search, "sort", params.Sort, "order", params.Order, "start", params.Start, "limit", params.Limit)
dockerClient, err := s.dockerService.GetClient()
if err != nil {
return nil, pagination.Response{}, volumetypes.UsageCounts{}, fmt.Errorf("failed to connect to Docker: %w", err)
@@ -424,7 +1733,7 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginat
}(apiCtx)
go func(ctx context.Context) {
- containerMap, err := s.buildVolumeContainerMap(ctx, dockerClient)
+ containerMap, err := s.buildVolumeContainerMapInternal(ctx, dockerClient)
containerChan <- containerMapResult{containerMap: containerMap, err: err}
}(apiCtx)
@@ -451,7 +1760,7 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginat
}
}
- volumes := s.enrichVolumesWithUsageData(volResult.volumes, usageVolumes)
+ volumes := s.enrichVolumesWithUsageDataInternal(volResult.volumes, usageVolumes)
items := make([]volumetypes.Volume, 0, len(volumes))
for _, v := range volumes {
@@ -465,10 +1774,10 @@ func (s *VolumeService) ListVolumesPaginated(ctx context.Context, params paginat
items = append(items, volDto)
}
- config := s.buildVolumePaginationConfig()
+ config := s.buildVolumePaginationConfigInternal()
result := pagination.SearchOrderAndPaginate(items, params, config)
- counts := s.calculateVolumeUsageCounts(items)
- paginationResp := s.buildPaginationResponse(result, params)
+ counts := s.calculateVolumeUsageCountsInternal(items)
+ paginationResp := s.buildPaginationResponseInternal(result, params)
return result.Items, paginationResp, counts, nil
}
diff --git a/backend/pkg/libarcane/internal_container.go b/backend/pkg/libarcane/internal_container.go
new file mode 100644
index 000000000..673200fa3
--- /dev/null
+++ b/backend/pkg/libarcane/internal_container.go
@@ -0,0 +1,21 @@
+package libarcane
+
+import "strings"
+
+// Internal containers indicate containers used for arcanes utilties, ie: temp containers used for viewing files for volumes etc
+const InternalContainerLabel = "com.getarcaneapp.internal.container"
+
+func IsInternalContainer(labels map[string]string) bool {
+ if labels == nil {
+ return false
+ }
+ for k, v := range labels {
+ if strings.EqualFold(k, InternalContainerLabel) {
+ switch strings.TrimSpace(strings.ToLower(v)) {
+ case "true", "1", "yes", "on":
+ return true
+ }
+ }
+ }
+ return false
+}
diff --git a/backend/resources/migrations/postgres/032_add_volume_backups.down.sql b/backend/resources/migrations/postgres/032_add_volume_backups.down.sql
new file mode 100644
index 000000000..dc16e31ec
--- /dev/null
+++ b/backend/resources/migrations/postgres/032_add_volume_backups.down.sql
@@ -0,0 +1 @@
+DROP TABLE volume_backups;
diff --git a/backend/resources/migrations/postgres/032_add_volume_backups.up.sql b/backend/resources/migrations/postgres/032_add_volume_backups.up.sql
new file mode 100644
index 000000000..b9c095beb
--- /dev/null
+++ b/backend/resources/migrations/postgres/032_add_volume_backups.up.sql
@@ -0,0 +1,8 @@
+CREATE TABLE volume_backups (
+ id TEXT PRIMARY KEY,
+ volume_name TEXT NOT NULL,
+ size BIGINT NOT NULL,
+ created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+ updated_at TIMESTAMP WITH TIME ZONE
+);
+CREATE INDEX idx_volume_backups_volume_name ON volume_backups(volume_name);
diff --git a/backend/resources/migrations/sqlite/032_add_volume_backups.down.sql b/backend/resources/migrations/sqlite/032_add_volume_backups.down.sql
new file mode 100644
index 000000000..dc16e31ec
--- /dev/null
+++ b/backend/resources/migrations/sqlite/032_add_volume_backups.down.sql
@@ -0,0 +1 @@
+DROP TABLE volume_backups;
diff --git a/backend/resources/migrations/sqlite/032_add_volume_backups.up.sql b/backend/resources/migrations/sqlite/032_add_volume_backups.up.sql
new file mode 100644
index 000000000..9645bf005
--- /dev/null
+++ b/backend/resources/migrations/sqlite/032_add_volume_backups.up.sql
@@ -0,0 +1,8 @@
+CREATE TABLE volume_backups (
+ id TEXT PRIMARY KEY,
+ volume_name TEXT NOT NULL,
+ size INTEGER NOT NULL,
+ created_at TIMESTAMP NOT NULL,
+ updated_at TIMESTAMP
+);
+CREATE INDEX idx_volume_backups_volume_name ON volume_backups(volume_name);
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 0ceb02de9..0e6ef93c8 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -61,7 +61,7 @@ ARG VERSION="dev"
ARG REVISION="unknown"
RUN apt-get update && apt-get upgrade -y \
- && apt-get install -y --no-install-recommends ca-certificates curl tzdata \
+ && apt-get install -y --no-install-recommends ca-certificates curl tzdata tar gzip \
vainfo clinfo libdrm2 libsystemd0 \
&& if [ "$TARGETARCH" = "amd64" ]; then \
apt-get install -y --no-install-recommends intel-gpu-tools; \
diff --git a/docker/Dockerfile-agent b/docker/Dockerfile-agent
index 83612e9a9..392abdd70 100644
--- a/docker/Dockerfile-agent
+++ b/docker/Dockerfile-agent
@@ -35,7 +35,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build \
FROM debian:trixie-slim AS agent
ARG TARGETARCH
RUN apt-get update && apt-get upgrade -y \
- && apt-get install -y --no-install-recommends ca-certificates curl tzdata \
+ && apt-get install -y --no-install-recommends ca-certificates curl tzdata tar gzip \
vainfo clinfo libdrm2 libsystemd0 \
&& if [ "$TARGETARCH" = "amd64" ]; then \
apt-get install -y --no-install-recommends intel-gpu-tools; \
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index e398eb9c2..2d3632f2d 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -595,6 +595,13 @@
"volumes_subtitle": "Manage your Docker volumes",
"volumes_stat_total": "Total Volumes",
"volumes_stat_unused": "Unused Volumes",
+ "volumes_nav_browser": "Browser",
+ "volumes_nav_backups": "Backups",
+ "volumes_browser_title": "Volume Browser",
+ "volumes_browser_description": "Browse and manage files inside the volume",
+ "volumes_backups_title": "Volume Backups",
+ "volumes_backups_description": "Create and manage backups of this volume",
+ "volumes_backups_restore": "Restore",
"volumes_remove_in_use_warning": "Warning: This volume is currently in use by containers. Forcing removal may cause data loss or container issues.",
"volumes_containers_using_title": "Containers Using This Volume",
"volumes_containers_using_description": "List of containers currently referencing this volume",
@@ -608,6 +615,23 @@
"volumes_remove_selected_message": "Are you sure you want to remove the selected volume(s)? This action cannot be undone.",
"volumes_remove_failed": "Failed to remove volume {name}",
"volumes_remove_success": "Volume {name} removed successfully",
+ "volumes_browser_new_folder": "New Folder",
+ "volumes_browser_upload_files": "Upload Files",
+ "volumes_browser_delete_confirm": "Are you sure you want to delete {name}?",
+ "volumes_backup_create": "Create Backup",
+ "volumes_backup_restore_confirm": "Are you sure you want to restore this backup? This will overwrite the current volume contents!",
+ "volumes_backup_delete_confirm": "Are you sure you want to delete this backup?",
+ "volumes_backup_restore_title": "Restore Volume",
+ "volumes_backup_restore_message": "This will replace ALL data in the volume \"{volumeName}\" with the contents of this backup.\n\nA safety backup will be created automatically before restoring, so you can undo this operation if needed.",
+ "volumes_backup_restore_in_use_warning": "\n\n⚠️ Warning: This volume is currently in use by {count} container(s). Restoring while containers are running may cause data corruption. Stop the containers first or use \"Restore files\" to restore specific files.",
+ "volumes_backup_restore_success": "Volume restored successfully. A safety backup was created before restoring.",
+ "volumes_backup_restore_files_success": "{count} file(s) restored successfully. A safety backup was created before restoring.",
+ "volumes_backup_safety_info": "A safety backup will be created automatically before restoring, so you can undo this operation if needed.",
+ "volumes_backup_overwrite_warning": "Selected files will overwrite existing files at those paths.",
+ "volumes_backup_file_restore_success": "File restored successfully. A safety backup was created before restoring.",
+ "volumes_symlink_external_tooltip": "This symlink points to a location outside the volume",
+ "volumes_symlink_target_tooltip": "Symlink → {target}",
+ "volumes_symlink_tooltip": "Symbolic link",
"_comment_networks": "=== NETWORKS ===",
"networks_title": "Networks",
"networks_subtitle": "Manage your Docker networks",
diff --git a/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte b/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte
index 7dd98f3f4..1f2524f58 100644
--- a/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte
+++ b/frontend/src/lib/components/arcane-table/arcane-table-toolbar.svelte
@@ -19,6 +19,7 @@
mobileFields = [],
onToggleMobileField,
customViewOptions,
+ customToolbarActions,
class: className
}: {
table: Table<TData>;
@@ -28,6 +29,7 @@
mobileFields?: { id: string; label: string; visible: boolean }[];
onToggleMobileField?: (fieldId: string) => void;
customViewOptions?: Snippet;
+ customToolbarActions?: Snippet;
class?: string;
} = $props();
@@ -129,6 +131,10 @@
{/if}
{/if}
+ {#if customToolbarActions}
+ {@render customToolbarActions()}
+ {/if}
+
<!-- View options - desktop only, always on the right -->
<div class="hidden md:block">
<DataTableViewOptions {table} {customViewOptions} />
diff --git a/frontend/src/lib/components/arcane-table/arcane-table.svelte b/frontend/src/lib/components/arcane-table/arcane-table.svelte
index 4044d4d0e..061e3da61 100644
--- a/frontend/src/lib/components/arcane-table/arcane-table.svelte
+++ b/frontend/src/lib/components/arcane-table/arcane-table.svelte
@@ -56,6 +56,7 @@
bulkActions = [],
persistKey,
customViewOptions,
+ customToolbarActions,
customTableView,
customSettings = $bindable<Record<string, unknown>>({}),
columnVisibility = $bindable<VisibilityState>({})
@@ -76,6 +77,7 @@
bulkActions?: BulkAction[];
persistKey?: string;
customViewOptions?: Snippet;
+ customToolbarActions?: Snippet;
customTableView?: Snippet<
[
{
@@ -527,6 +529,7 @@
mobileFields={mobileFieldsForOptions}
{onToggleMobileField}
{customViewOptions}
+ {customToolbarActions}
/>
</div>
{/if}
@@ -561,6 +564,7 @@
mobileFields={mobileFieldsForOptions}
{onToggleMobileField}
{customViewOptions}
+ {customToolbarActions}
/>
</Card.Header>
{/if}
diff --git a/frontend/src/lib/components/file-browser/CreateFolderDialog.svelte b/frontend/src/lib/components/file-browser/CreateFolderDialog.svelte
new file mode 100644
index 000000000..6f8b14906
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/CreateFolderDialog.svelte
@@ -0,0 +1,61 @@
+<script lang="ts">
+ import * as Dialog from '$lib/components/ui/dialog';
+ import { Button } from '$lib/components/ui/button';
+ import { Input } from '$lib/components/ui/input';
+ import { Label } from '$lib/components/ui/label';
+ import { toast } from 'svelte-sonner';
+ import * as m from '$lib/paraglide/messages.js';
+
+ let {
+ open = $bindable(false),
+ currentPath,
+ onCreate
+ }: {
+ open: boolean;
+ currentPath: string;
+ onCreate: (folderName: string) => Promise<void>;
+ } = $props();
+
+ let folderName = $state('');
+ let loading = $state(false);
+
+ async function handleSubmit(e: SubmitEvent) {
+ e.preventDefault();
+ if (!folderName) return;
+
+ loading = true;
+ try {
+ await onCreate(folderName);
+ toast.success(m.common_create_success({ resource: folderName }));
+ open = false;
+ folderName = '';
+ } catch (e: any) {
+ toast.error(e.message || m.common_create_failed({ resource: folderName }));
+ } finally {
+ loading = false;
+ }
+ }
+</script>
+
+<Dialog.Root bind:open>
+ <Dialog.Content class="sm:max-w-[425px]">
+ <Dialog.Header>
+ <Dialog.Title>{m.volumes_browser_new_folder()}</Dialog.Title>
+ <Dialog.Description>
+ Enter a name for the new folder in {currentPath}
+ </Dialog.Description>
+ </Dialog.Header>
+ <form onsubmit={handleSubmit} class="grid gap-4 py-4">
+ <div class="grid grid-cols-4 items-center gap-4">
+ <Label for="name" class="text-right">{m.common_name()}</Label>
+ <Input id="name" bind:value={folderName} class="col-span-3" autofocus />
+ </div>
+ <Dialog.Footer>
+ <Button type="button" variant="outline" onclick={() => (open = false)}>{m.common_cancel()}</Button>
+ <Button type="submit" disabled={loading || !folderName}>
+ {loading ? m.common_action_creating() : m.common_create()}
+ </Button>
+ </Dialog.Footer>
+ </form>
+ </Dialog.Content>
+</Dialog.Root>
diff --git a/frontend/src/lib/components/file-browser/FileBreadcrumb.svelte b/frontend/src/lib/components/file-browser/FileBreadcrumb.svelte
new file mode 100644
index 000000000..5cfa6e736
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/FileBreadcrumb.svelte
@@ -0,0 +1,62 @@
+<script lang="ts">
+ import * as Breadcrumb from '$lib/components/ui/breadcrumb';
+ import { ArrowRightIcon, DashboardIcon } from '$lib/icons';
+
+ let {
+ path,
+ rootLabel,
+ onNavigate
+ }: {
+ path: string;
+ rootLabel?: string;
+ onNavigate: (path: string) => void;
+ } = $props();
+
+ let segments = $derived.by(() => {
+ const parts = path.split('/').filter((p) => p);
+ return parts.map((name, index) => ({
+ name,
+ path: '/' + parts.slice(0, index + 1).join('/')
+ }));
+ });
+</script>
+
+<Breadcrumb.Root>
+ <Breadcrumb.List>
+ <Breadcrumb.Item>
+ <Breadcrumb.Link onclick={() => onNavigate('/')} class="cursor-pointer">
+ <DashboardIcon class="h-4 w-4" />
+ </Breadcrumb.Link>
+ </Breadcrumb.Item>
+
+ {#if rootLabel}
+ <Breadcrumb.Separator>
+ <ArrowRightIcon class="h-4 w-4" />
+ </Breadcrumb.Separator>
+ <Breadcrumb.Item>
+ {#if segments.length === 0}
+ <Breadcrumb.Page>{rootLabel}</Breadcrumb.Page>
+ {:else}
+ <Breadcrumb.Link onclick={() => onNavigate('/')} class="cursor-pointer">
+ {rootLabel}
+ </Breadcrumb.Link>
+ {/if}
+ </Breadcrumb.Item>
+ {/if}
+
+ {#each segments as segment, i}
+ <Breadcrumb.Separator>
+ <ArrowRightIcon class="h-4 w-4" />
+ </Breadcrumb.Separator>
+ <Breadcrumb.Item>
+ {#if i === segments.length - 1}
+ <Breadcrumb.Page>{segment.name}</Breadcrumb.Page>
+ {:else}
+ <Breadcrumb.Link onclick={() => onNavigate(segment.path)} class="cursor-pointer">
+ {segment.name}
+ </Breadcrumb.Link>
+ {/if}
+ </Breadcrumb.Item>
+ {/each}
+ </Breadcrumb.List>
+</Breadcrumb.Root>
diff --git a/frontend/src/lib/components/file-browser/FileList.svelte b/frontend/src/lib/components/file-browser/FileList.svelte
new file mode 100644
index 000000000..1c5770657
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/FileList.svelte
@@ -0,0 +1,290 @@
+<script lang="ts">
+ import type { FileEntry } from '$lib/types/file-browser.type';
+ import {
+ FolderOpenIcon,
+ FileTextIcon,
+ DownloadIcon,
+ TrashIcon,
+ EllipsisIcon,
+ EyeOnIcon,
+ ClockIcon,
+ RestartIcon,
+ ExternalLinkIcon
+ } from '$lib/icons';
+ import { toast } from 'svelte-sonner';
+ import * as m from '$lib/paraglide/messages.js';
+ import ArcaneTable from '$lib/components/arcane-table/arcane-table.svelte';
+ import type { Paginated, SearchPaginationSortRequest } from '$lib/types/pagination.type';
+ import { UniversalMobileCard, type ColumnSpec, type MobileFieldVisibility } from '$lib/components/arcane-table';
+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu';
+ import * as Tooltip from '$lib/components/ui/tooltip';
+ import { openConfirmDialog } from '$lib/components/confirm-dialog';
+ import { ArcaneButton } from '$lib/components/arcane-button';
+ import bytes from 'bytes';
+ import { format } from 'date-fns';
+
+ let {
+ files,
+ currentPath,
+ persistKey = 'arcane-file-browser-table',
+ onNavigate,
+ onRefresh,
+ onDelete,
+ onDownload,
+ onPreview,
+ onRestoreFromBackup
+ }: {
+ files: FileEntry[];
+ currentPath: string;
+ persistKey?: string;
+ onNavigate: (path: string) => void;
+ onRefresh: () => void;
+ onDelete: (file: FileEntry) => Promise<void>;
+ onDownload: (file: FileEntry) => Promise<void>;
+ onPreview: (file: FileEntry) => void;
+ onRestoreFromBackup?: (file: FileEntry) => void;
+ } = $props();
+
+ let requestOptions = $state<SearchPaginationSortRequest>({
+ pagination: { page: 1, limit: 100 },
+ sort: { column: 'name', direction: 'asc' }
+ });
+
+ let mobileFieldVisibility = $state<Record<string, boolean>>({});
+
+ function compareByColumn(a: FileEntry, b: FileEntry, column: string): number {
+ switch (column) {
+ case 'size':
+ return Number(a.size) - Number(b.size);
+ case 'modTime':
+ return new Date(a.modTime).getTime() - new Date(b.modTime).getTime();
+ case 'name':
+ default:
+ return a.name.localeCompare(b.name);
+ }
+ }
+
+ const sortedFiles = $derived.by(() => {
+ const sortColumn = requestOptions?.sort?.column ?? 'name';
+ const direction = requestOptions?.sort?.direction === 'desc' ? -1 : 1;
+ const items = files.slice();
+ return items.sort((a, b) => {
+ if (a.isDirectory !== b.isDirectory) {
+ return a.isDirectory ? -1 : 1;
+ }
+ const diff = compareByColumn(a, b, sortColumn);
+ if (diff !== 0) return diff * direction;
+ return a.name.localeCompare(b.name);
+ });
+ });
+
+ const itemsPaginated = $derived<Paginated<FileEntry & { id: string }>>({
+ data: sortedFiles.map((f) => ({ ...f, id: f.path })),
+ pagination: {
+ currentPage: 1,
+ totalPages: 1,
+ totalItems: sortedFiles.length,
+ itemsPerPage: sortedFiles.length
+ }
+ });
+
+ function formatBytes(value: number) {
+ return bytes.format(value, { unitSeparator: ' ' }) ?? '-';
+ }
+
+ async function handleDelete(file: FileEntry) {
+ openConfirmDialog({
+ title: m.common_remove_title({ resource: file.name }),
+ message: m.volumes_browser_delete_confirm({ name: file.name }),
+ confirm: {
+ label: m.common_delete(),
+ destructive: true,
+ action: async () => {
+ try {
+ await onDelete(file);
+ toast.success(m.common_delete_success({ resource: file.name }));
+ onRefresh();
+ } catch (e: any) {
+ toast.error(e.message || m.common_delete_failed({ resource: file.name }));
+ }
+ }
+ }
+ });
+ }
+
+ async function handleDownload(file: FileEntry) {
+ try {
+ await onDownload(file);
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ }
+ }
+
+ const columns = [
+ { accessorKey: 'name', title: m.common_name(), sortable: true, cell: NameCell },
+ { accessorKey: 'size', title: m.common_size(), sortable: true, cell: SizeCell },
+ { accessorKey: 'modTime', title: m.common_created(), sortable: true, cell: CreatedCell }
+ ] satisfies ColumnSpec<FileEntry & { id: string }>[];
+
+ const mobileFields = [
+ { id: 'size', label: m.common_size(), defaultVisible: true },
+ { id: 'modTime', label: m.common_created(), defaultVisible: false }
+ ];
+</script>
+
+{#snippet NameCell({ item }: { item: FileEntry })}
+ <div class="flex items-center gap-2">
+ {#if item.isDirectory}
+ <FolderOpenIcon class="size-4 text-blue-500" />
+ <button class="text-left font-medium hover:underline" onclick={() => onNavigate(item.path)}>
+ {item.name}
+ </button>
+ {:else}
+ <FileTextIcon class="text-muted-foreground size-4" />
+ <span class="font-medium">{item.name}</span>
+ {/if}
+ {#if item.isSymlink}
+ <Tooltip.Provider>
+ <Tooltip.Root>
+ <Tooltip.Trigger>
+ <span class="inline-flex items-center gap-1 text-xs">
+ <ExternalLinkIcon class="size-3 text-purple-500" />
+ {#if item.linkTarget === '(external)'}
+ <span class="text-amber-500">(external)</span>
+ {/if}
+ </span>
+ </Tooltip.Trigger>
+ <Tooltip.Content>
+ {#if item.linkTarget === '(external)'}
+ <p>{m.volumes_symlink_external_tooltip()}</p>
+ {:else if item.linkTarget}
+ <p>{m.volumes_symlink_target_tooltip({ target: item.linkTarget })}</p>
+ {:else}
+ <p>{m.volumes_symlink_tooltip()}</p>
+ {/if}
+ </Tooltip.Content>
+ </Tooltip.Root>
+ </Tooltip.Provider>
+ {/if}
+ </div>
+{/snippet}
+
+{#snippet SizeCell({ item, value }: { item: FileEntry; value: any })}
+ <span class="text-muted-foreground text-sm">
+ {item.isDirectory ? '--' : formatBytes(Number(value))}
+ </span>
+{/snippet}
+
+{#snippet CreatedCell({ value }: { value: any })}
+ <span class="text-muted-foreground text-sm">
+ {format(new Date(String(value)), 'PP p')}
+ </span>
+{/snippet}
+
+{#snippet RowActions({ item }: { item: FileEntry })}
+ <DropdownMenu.Root>
+ <DropdownMenu.Trigger>
+ {#snippet child({ props })}
+ <ArcaneButton
+ {...props}
+ action="base"
+ tone="ghost"
+ size="icon"
+ class="relative size-8 p-0"
+ icon={EllipsisIcon}
+ showLabel={false}
+ customLabel={m.common_open_menu()}
+ />
+ {/snippet}
+ </DropdownMenu.Trigger>
+ <DropdownMenu.Content align="end">
+ <DropdownMenu.Group>
+ {#if !item.isDirectory}
+ <DropdownMenu.Item onclick={() => onPreview(item)}>
+ <EyeOnIcon class="size-4" />
+ {m.common_view()}
+ </DropdownMenu.Item>
+ <DropdownMenu.Item onclick={() => handleDownload(item)}>
+ <DownloadIcon class="size-4" />
+ {m.templates_download()}
+ </DropdownMenu.Item>
+ {#if onRestoreFromBackup && !item.isSymlink}
+ <DropdownMenu.Item onclick={() => onRestoreFromBackup(item)}>
+ <RestartIcon class="size-4" />
+ Restore from backup
+ </DropdownMenu.Item>
+ {/if}
+ <DropdownMenu.Separator />
+ {/if}
+ <DropdownMenu.Item variant="destructive" onclick={() => handleDelete(item)}>
+ <TrashIcon class="size-4" />
+ {m.common_delete()}
+ </DropdownMenu.Item>
+ </DropdownMenu.Group>
+ </DropdownMenu.Content>
+ </DropdownMenu.Root>
+{/snippet}
+
+{#snippet FileMobileCardSnippet({
+ item,
+ mobileFieldVisibility
+}: {
+ item: FileEntry;
+ mobileFieldVisibility: MobileFieldVisibility;
+})}
+ <UniversalMobileCard
+ {item}
+ icon={{ component: item.isDirectory ? FolderOpenIcon : FileTextIcon, variant: item.isDirectory ? 'blue' : 'gray' }}
+ title={(item) => item.name}
+ fields={[
+ {
+ label: m.common_size(),
+ getValue: (item) => (item.isDirectory ? '--' : formatBytes(item.size)),
+ icon: EyeOnIcon,
+ iconVariant: 'gray',
+ show: mobileFieldVisibility.size ?? true
+ }
+ ]}
+ footer={{
+ label: m.common_created(),
+ getValue: (item) => format(new Date(item.modTime), 'PP p'),
+ icon: ClockIcon || 'div'
+ }}
+ rowActions={RowActions}
+ onclick={() => item.isDirectory && onNavigate(item.path)}
+ />
+{/snippet}
+
+<div class="file-browser-table bg-card overflow-hidden rounded-lg border shadow-sm">
+ <ArcaneTable
+ {persistKey}
+ items={itemsPaginated}
+ bind:requestOptions
+ bind:mobileFieldVisibility
+ onRefresh={async () => itemsPaginated}
+ {columns}
+ {mobileFields}
+ rowActions={RowActions}
+ mobileCard={FileMobileCardSnippet}
+ unstyled
+ withoutPagination
+ withoutSearch
+ selectionDisabled
+ />
+</div>
+
+<style>
+ @reference "../../../app.css";
+
+ :global(.file-browser-table thead tr) {
+ @apply bg-muted/30 hover:bg-muted/30;
+ }
+
+ :global(.file-browser-table tbody tr) {
+ @apply hover:bg-muted/50 cursor-default border-none transition-colors;
+ }
+
+ :global(.file-browser-table td) {
+ @apply py-2;
+ }
+</style>
diff --git a/frontend/src/lib/components/file-browser/FilePreview.svelte b/frontend/src/lib/components/file-browser/FilePreview.svelte
new file mode 100644
index 000000000..8b7af4c78
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/FilePreview.svelte
@@ -0,0 +1,64 @@
+<script lang="ts">
+ import type { FileEntry } from '$lib/types/file-browser.type';
+ import { onMount } from 'svelte';
+ import * as Sheet from '$lib/components/ui/sheet';
+ import { LoadingSpinnerIcon } from '$lib/icons';
+
+ let { file, fetchContent, onClose }: { file: FileEntry; fetchContent: (path: string) => Promise<string>; onClose: () => void } =
+ $props();
+
+ let content = $state<string | null>(null);
+ let loading = $state(true);
+ let error = $state<string | null>(null);
+
+ function b64DecodeUnicode(str: string) {
+ try {
+ // Try to decode UTF-8 safely
+ return decodeURIComponent(
+ atob(str)
+ .split('')
+ .map(function (c) {
+ return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+ })
+ .join('')
+ );
+ } catch (e) {
+ // Fallback to plain atob if it's not proper UTF-8
+ return atob(str);
+ }
+ }
+
+ onMount(async () => {
+ try {
+ const res = await fetchContent(file.path);
+ content = b64DecodeUnicode(res);
+ } catch (e: any) {
+ error = e.message || 'Failed to load preview';
+ } finally {
+ loading = false;
+ }
+ });
+</script>
+
+<Sheet.Root open={!!file} onOpenChange={(open) => !open && onClose()}>
+ <Sheet.Content class="flex h-full flex-col sm:max-w-2xl">
+ <Sheet.Header>
+ <Sheet.Title class="truncate">{file.name}</Sheet.Title>
+ <Sheet.Description class="break-all">{file.path}</Sheet.Description>
+ </Sheet.Header>
+
+ <div class="mt-6 min-h-0 flex-grow overflow-y-auto">
+ {#if loading}
+ <div class="flex h-full items-center justify-center p-12">
+ <LoadingSpinnerIcon class="text-muted-foreground h-8 w-8" />
+ </div>
+ {:else if error}
+ <div class="border-destructive/20 bg-destructive/10 text-destructive rounded border p-4">
+ {error}
+ </div>
+ {:else}
+ <pre class="bg-muted w-full rounded p-4 font-mono text-xs break-all whitespace-pre-wrap">{content}</pre>
+ {/if}
+ </div>
+ </Sheet.Content>
+</Sheet.Root>
diff --git a/frontend/src/lib/components/file-browser/FileUploadDialog.svelte b/frontend/src/lib/components/file-browser/FileUploadDialog.svelte
new file mode 100644
index 000000000..c59ab5310
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/FileUploadDialog.svelte
@@ -0,0 +1,108 @@
+<script lang="ts">
+ import * as Dialog from '$lib/components/ui/dialog';
+ import { ArcaneButton } from '$lib/components/arcane-button';
+ import { FileDropZone, displaySize, MEGABYTE, type FileDropZoneProps } from '$lib/components/ui/file-drop-zone';
+ import { toast } from 'svelte-sonner';
+ import * as m from '$lib/paraglide/messages.js';
+ import { CloseIcon } from '$lib/icons';
+
+ let {
+ open = $bindable(false),
+ currentPath,
+ onUpload: onUploadAction
+ }: {
+ open: boolean;
+ currentPath: string;
+ onUpload: (file: File) => Promise<void>;
+ } = $props();
+
+ let files = $state<File[]>([]);
+ let uploading = $state(false);
+
+ const onUpload: FileDropZoneProps['onUpload'] = async (newFiles) => {
+ files = [...files, ...newFiles];
+ };
+
+ const onFileRejected: FileDropZoneProps['onFileRejected'] = ({ reason, file }) => {
+ toast.error(`${file.name} failed to upload!`, { description: reason });
+ };
+
+ function removeFile(index: number) {
+ files = files.filter((_, i) => i !== index);
+ }
+
+ async function handleUpload() {
+ if (files.length === 0) return;
+ uploading = true;
+ try {
+ for (const file of files) {
+ await onUploadAction(file);
+ }
+ toast.success(m.common_success());
+ open = false;
+ files = [];
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ } finally {
+ uploading = false;
+ }
+ }
+</script>
+
+<Dialog.Root
+ bind:open
+ onOpenChange={(isOpen) => {
+ if (!isOpen) files = [];
+ }}
+>
+ <Dialog.Content class="sm:max-w-[500px]">
+ <Dialog.Header>
+ <Dialog.Title>{m.volumes_browser_upload_files()}</Dialog.Title>
+ <Dialog.Description>
+ Upload files to {currentPath}
+ </Dialog.Description>
+ </Dialog.Header>
+ <div class="space-y-4 py-4">
+ <FileDropZone {onUpload} {onFileRejected} multiple fileCount={files.length} disabled={uploading} />
+
+ {#if files.length > 0}
+ <div class="flex max-h-[200px] flex-col gap-2 overflow-y-auto pr-1">
+ {#each files as file, i (file.name + i)}
+ <div class="border-border bg-muted/50 flex items-center justify-between gap-2 rounded-lg border p-2">
+ <div class="flex flex-col overflow-hidden">
+ <span class="truncate text-xs font-medium">{file.name}</span>
+ <span class="text-muted-foreground text-[10px]">{displaySize(file.size)}</span>
+ </div>
+ <ArcaneButton
+ action="base"
+ tone="ghost"
+ size="icon"
+ class="h-6 w-6"
+ onclick={() => removeFile(i)}
+ icon={CloseIcon}
+ disabled={uploading}
+ />
+ </div>
+ {/each}
+ </div>
+ {/if}
+ </div>
+ <Dialog.Footer>
+ <ArcaneButton
+ action="cancel"
+ onclick={() => {
+ open = false;
+ files = [];
+ }}
+ disabled={uploading}
+ />
+ <ArcaneButton
+ action="create"
+ onclick={handleUpload}
+ disabled={uploading || files.length === 0}
+ loading={uploading}
+ customLabel={uploading ? m.common_action_updating() : m.common_update()}
+ />
+ </Dialog.Footer>
+ </Dialog.Content>
+</Dialog.Root>
diff --git a/frontend/src/lib/components/file-browser/GenericFileBrowser.svelte b/frontend/src/lib/components/file-browser/GenericFileBrowser.svelte
new file mode 100644
index 000000000..bb74c5e97
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/GenericFileBrowser.svelte
@@ -0,0 +1,327 @@
+<script lang="ts" module>
+ import type { BackupEntry, FileEntry } from '$lib/types/file-browser.type';
+
+ export interface FileProvider {
+ list: (path: string) => Promise<FileEntry[]>;
+ mkdir: (path: string) => Promise<void>;
+ upload: (path: string, file: File) => Promise<void>;
+ delete: (path: string) => Promise<void>;
+ download: (path: string) => Promise<void>;
+ getContent: (path: string) => Promise<{ content: string }>;
+ listBackups?: () => Promise<BackupEntry[]>;
+ restoreFromBackup?: (backupId: string, path: string) => Promise<void>;
+ backupHasPath?: (backupId: string, path: string) => Promise<boolean>;
+ }
+</script>
+
+<script lang="ts">
+ import { onMount } from 'svelte';
+ import FileList from './FileList.svelte';
+ import FileBreadcrumb from './FileBreadcrumb.svelte';
+ import { UploadIcon, MoveToFolderIcon, InfoIcon } from '$lib/icons';
+ import { ArcaneButton } from '$lib/components/arcane-button';
+ import CreateFolderDialog from './CreateFolderDialog.svelte';
+ import FileUploadDialog from './FileUploadDialog.svelte';
+ import FilePreview from './FilePreview.svelte';
+ import * as m from '$lib/paraglide/messages.js';
+ import { Spinner } from '$lib/components/ui/spinner/index.js';
+ import { ResponsiveDialog } from '$lib/components/ui/responsive-dialog';
+ import * as Select from '$lib/components/ui/select';
+ import * as Alert from '$lib/components/ui/alert';
+ import { Label } from '$lib/components/ui/label';
+ import { toast } from 'svelte-sonner';
+ import bytes from 'bytes';
+ import { format } from 'date-fns';
+
+ let { provider, rootLabel, persistKey }: { provider: FileProvider; rootLabel?: string; persistKey?: string } = $props();
+
+ let currentPath = $state('/');
+ let files = $state<FileEntry[]>([]);
+ let loading = $state(true);
+ let error = $state<string | null>(null);
+
+ let showCreateFolder = $state(false);
+ let showUpload = $state(false);
+ let previewFile = $state<FileEntry | null>(null);
+ let showRestoreFile = $state(false);
+ let restoreTarget = $state<FileEntry | null>(null);
+ let backups = $state<BackupEntry[]>([]);
+ let loadingBackups = $state(false);
+ let restoringFile = $state(false);
+ let selectedBackupId = $state('');
+ let backupHasFile = $state<boolean | null>(null);
+ let checkingBackup = $state(false);
+ let lastCheckedKey = $state('');
+ const selectedBackup = $derived(backups.find((b) => b.id === selectedBackupId));
+
+ const canRestoreFromBackup = $derived(!!provider.listBackups && !!provider.restoreFromBackup);
+ const requiresBackupCheck = $derived(!!provider.backupHasPath);
+
+ async function loadFiles(path: string) {
+ loading = true;
+ error = null;
+ try {
+ const result = await provider.list(path);
+ // Sort: directories first, then alphabetically
+ files = result.sort((a, b) => {
+ if (a.isDirectory && !b.isDirectory) return -1;
+ if (!a.isDirectory && b.isDirectory) return 1;
+ return a.name.localeCompare(b.name);
+ });
+ currentPath = path;
+ } catch (e: any) {
+ error = e.message || m.common_failed();
+ } finally {
+ loading = false;
+ }
+ }
+
+ function handleNavigate(path: string) {
+ loadFiles(path);
+ }
+
+ async function loadBackups() {
+ if (!provider.listBackups) return;
+ loadingBackups = true;
+ try {
+ backups = await provider.listBackups();
+ if (backups.length > 0) {
+ selectedBackupId = backups[0].id;
+ }
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ } finally {
+ loadingBackups = false;
+ }
+ }
+
+ function openRestoreFileDialog(file: FileEntry) {
+ if (file.isDirectory || file.isSymlink) return;
+ restoreTarget = file;
+ selectedBackupId = '';
+ backups = [];
+ backupHasFile = null;
+ lastCheckedKey = '';
+ showRestoreFile = true;
+ loadBackups();
+ }
+
+ async function handleRestoreFile() {
+ if (!restoreTarget || !provider.restoreFromBackup || !selectedBackupId) return;
+ restoringFile = true;
+ try {
+ await provider.restoreFromBackup(selectedBackupId, restoreTarget.path);
+ toast.success(m.volumes_backup_file_restore_success());
+ showRestoreFile = false;
+ // Refresh the file list to show the restored file
+ await loadFiles(currentPath);
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ } finally {
+ restoringFile = false;
+ }
+ }
+
+ async function checkBackupHasFile(backupId: string, filePath: string) {
+ if (!provider.backupHasPath) return;
+ const key = `${backupId}:${filePath}`;
+ if (key === lastCheckedKey) return;
+ lastCheckedKey = key;
+ checkingBackup = true;
+ backupHasFile = null;
+ try {
+ backupHasFile = await provider.backupHasPath(backupId, filePath);
+ } catch (e: any) {
+ backupHasFile = null;
+ toast.error(e.message || m.common_failed());
+ } finally {
+ checkingBackup = false;
+ }
+ }
+
+ function formatBackupLabel(backup: BackupEntry): string {
+ const sizeLabel = bytes.format(backup.size, { unitSeparator: ' ' }) ?? '-';
+ const createdLabel = backup.createdAt ? format(new Date(backup.createdAt), 'PP p') : '-';
+ return `${backup.id} • ${createdLabel} • ${sizeLabel}`;
+ }
+
+ onMount(() => {
+ loadFiles('/');
+ });
+
+ $effect(() => {
+ if (!showRestoreFile) return;
+ if (!requiresBackupCheck) return;
+ if (!restoreTarget || !selectedBackupId) {
+ backupHasFile = null;
+ return;
+ }
+ checkBackupHasFile(selectedBackupId, restoreTarget.path);
+ });
+</script>
+
+<div class="flex flex-col gap-4">
+ <div class="flex items-center justify-between">
+ <FileBreadcrumb path={currentPath} {rootLabel} onNavigate={handleNavigate} />
+ <div class="flex gap-2">
+ <ArcaneButton
+ action="base"
+ tone="outline"
+ size="sm"
+ onclick={() => (showCreateFolder = true)}
+ icon={MoveToFolderIcon}
+ customLabel={m.volumes_browser_new_folder()}
+ />
+ <ArcaneButton
+ action="base"
+ tone="outline"
+ size="sm"
+ onclick={() => (showUpload = true)}
+ icon={UploadIcon}
+ customLabel={m.volumes_browser_upload_files()}
+ />
+ </div>
+ </div>
+
+ {#if loading}
+ <div class="flex justify-center p-12">
+ <Spinner class="text-muted-foreground size-8" />
+ </div>
+ {:else if error}
+ <div class="border-destructive/20 bg-destructive/10 text-destructive rounded-lg border p-8 text-center">
+ {error}
+ </div>
+ {:else}
+ <FileList
+ {files}
+ {currentPath}
+ {persistKey}
+ onNavigate={handleNavigate}
+ onRefresh={() => loadFiles(currentPath)}
+ onDelete={(file) => provider.delete(file.path)}
+ onDownload={(file) => provider.download(file.path)}
+ onPreview={(file) => (previewFile = file)}
+ onRestoreFromBackup={canRestoreFromBackup ? openRestoreFileDialog : undefined}
+ />
+ {/if}
+</div>
+
+<CreateFolderDialog
+ bind:open={showCreateFolder}
+ {currentPath}
+ onCreate={async (name) => {
+ const fullPath = currentPath === '/' ? `/${name}` : `${currentPath}/${name}`;
+ await provider.mkdir(fullPath);
+ await loadFiles(currentPath);
+ }}
+/>
+
+<FileUploadDialog
+ bind:open={showUpload}
+ {currentPath}
+ onUpload={async (file) => {
+ await provider.upload(currentPath, file);
+ await loadFiles(currentPath);
+ }}
+/>
+
+{#if previewFile}
+ <FilePreview
+ file={previewFile}
+ fetchContent={async (path) => {
+ const res = await provider.getContent(path);
+ return res.content;
+ }}
+ onClose={() => (previewFile = null)}
+ />
+{/if}
+
+<ResponsiveDialog
+ bind:open={showRestoreFile}
+ title="Restore file from backup"
+ description="Select a backup to restore the chosen file."
+ contentClass="sm:max-w-[520px]"
+>
+ {#snippet children()}
+ <div class="space-y-4 py-2">
+ <Alert.Root class="py-2 [&>svg]:top-2">
+ <InfoIcon class="size-4" />
+ <Alert.Description class="text-xs">
+ {m.volumes_backup_safety_info()}
+ </Alert.Description>
+ </Alert.Root>
+
+ {#if restoreTarget}
+ <div class="text-muted-foreground text-xs">
+ File: <code class="bg-muted/40 rounded px-1.5 py-0.5 font-mono">{restoreTarget.path}</code>
+ </div>
+ {/if}
+
+ {#if loadingBackups}
+ <div class="text-muted-foreground flex items-center gap-2 text-sm">
+ <Spinner class="size-4" />
+ Loading backups...
+ </div>
+ {:else if backups.length === 0}
+ <div class="text-muted-foreground text-sm">No backups available.</div>
+ {:else}
+ <div class="space-y-2">
+ <Label for="restore-backup-select">Backup</Label>
+ <div class="w-full overflow-hidden">
+ <Select.Root
+ type="single"
+ value={selectedBackupId}
+ onValueChange={(value) => {
+ selectedBackupId = value;
+ }}
+ >
+ <Select.Trigger id="restore-backup-select" class="h-10 w-full overflow-hidden">
+ <span class="min-w-0 flex-1 truncate">
+ {selectedBackup ? formatBackupLabel(selectedBackup) : 'Select backup'}
+ </span>
+ </Select.Trigger>
+ <Select.Content>
+ {#each backups as backup (backup.id)}
+ <Select.Item value={backup.id}>{formatBackupLabel(backup)}</Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+ </div>
+ </div>
+ {#if requiresBackupCheck}
+ {#if checkingBackup}
+ <div class="text-muted-foreground flex items-center gap-2 text-xs">
+ <Spinner class="size-3" />
+ Checking backup contents...
+ </div>
+ {:else if backupHasFile === false}
+ <div class="text-destructive text-xs">This backup does not contain the selected file.</div>
+ {/if}
+ {/if}
+ {/if}
+ </div>
+ {/snippet}
+
+ {#snippet footer()}
+ <ArcaneButton
+ action="cancel"
+ onclick={() => {
+ showRestoreFile = false;
+ restoreTarget = null;
+ selectedBackupId = '';
+ }}
+ />
+ <ArcaneButton
+ action="create"
+ customLabel="Restore file"
+ onclick={handleRestoreFile}
+ loading={restoringFile}
+ disabled={restoringFile ||
+ loadingBackups ||
+ checkingBackup ||
+ !selectedBackupId ||
+ !restoreTarget ||
+ (requiresBackupCheck && backupHasFile !== true)}
+ />
+ {/snippet}
+</ResponsiveDialog>
diff --git a/frontend/src/lib/components/file-browser/VolumeBrowser.svelte b/frontend/src/lib/components/file-browser/VolumeBrowser.svelte
new file mode 100644
index 000000000..379aae53f
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/VolumeBrowser.svelte
@@ -0,0 +1,27 @@
+<script lang="ts">
+ import { volumeBrowserService } from '$lib/services/volume-browser-service';
+ import { volumeBackupService } from '$lib/services/volume-backup-service';
+ import GenericFileBrowser, { type FileProvider } from './GenericFileBrowser.svelte';
+
+ let { volumeName }: { volumeName: string } = $props();
+
+ const provider: FileProvider = {
+ list: (path) => volumeBrowserService.listDirectory(volumeName, path),
+ mkdir: (path) => volumeBrowserService.createDirectory(volumeName, path),
+ upload: (path, file) => volumeBrowserService.uploadFile(volumeName, path, file),
+ delete: (path) => volumeBrowserService.deleteFile(volumeName, path),
+ download: (path) => volumeBrowserService.downloadFile(volumeName, path),
+ getContent: (path) => volumeBrowserService.getFileContent(volumeName, path),
+ listBackups: async () => {
+ const res = await volumeBackupService.listBackups(volumeName, {
+ pagination: { page: 1, limit: 200 },
+ sort: { column: 'createdAt', direction: 'desc' }
+ });
+ return res.data;
+ },
+ restoreFromBackup: (backupId, path) => volumeBackupService.restoreBackupFiles(volumeName, backupId, [path]),
+ backupHasPath: (backupId, path) => volumeBackupService.backupHasPath(backupId, path)
+ };
+</script>
+
+<GenericFileBrowser {provider} rootLabel={volumeName} persistKey="volume-file-browser" />
diff --git a/frontend/src/lib/components/file-browser/index.ts b/frontend/src/lib/components/file-browser/index.ts
new file mode 100644
index 000000000..f676e369d
--- /dev/null
+++ b/frontend/src/lib/components/file-browser/index.ts
@@ -0,0 +1,26 @@
+import Root from './GenericFileBrowser.svelte';
+import Breadcrumb from './FileBreadcrumb.svelte';
+import List from './FileList.svelte';
+import Preview from './FilePreview.svelte';
+import UploadDialog from './FileUploadDialog.svelte';
+import CreateFolderDialog from './CreateFolderDialog.svelte';
+import VolumeBrowser from './VolumeBrowser.svelte';
+
+export type { FileProvider } from './GenericFileBrowser.svelte';
+
+export {
+ Root,
+ Breadcrumb,
+ List,
+ Preview,
+ UploadDialog,
+ CreateFolderDialog,
+ VolumeBrowser,
+ // aliases
+ Root as FileBrowser,
+ Breadcrumb as FileBreadcrumb,
+ List as FileList,
+ Preview as FilePreview,
+ UploadDialog as FileUploadDialog,
+ CreateFolderDialog as FileCreateFolderDialog
+};
diff --git a/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte b/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte
index b37929f96..a54d8203d 100644
--- a/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte
+++ b/frontend/src/lib/components/ui/file-drop-zone/file-drop-zone.svelte
@@ -13,6 +13,7 @@
maxFileSize,
fileCount,
disabled = false,
+ multiple,
onUpload,
onFileRejected,
accept,
@@ -161,7 +162,7 @@
disabled={!canUploadFiles}
{id}
{accept}
- multiple={maxFiles === undefined || maxFiles - (fileCount ?? 0) > 1}
+ multiple={multiple ?? (maxFiles === undefined || maxFiles - (fileCount ?? 0) > 1)}
type="file"
onchange={change}
class="hidden"
diff --git a/frontend/src/lib/components/ui/file-drop-zone/types.ts b/frontend/src/lib/components/ui/file-drop-zone/types.ts
index 00531b4a9..e659f8cca 100644
--- a/frontend/src/lib/components/ui/file-drop-zone/types.ts
+++ b/frontend/src/lib/components/ui/file-drop-zone/types.ts
@@ -18,6 +18,9 @@ export type FileDropZonePropsWithoutHTML = WithChildren<{
/** Called when a file does not meet the upload criteria (size, or type) */
onFileRejected?: (opts: { reason: FileRejectedReason; file: File }) => void;
+ /** Whether to allow multiple files. If undefined, it will be true if maxFiles is not 1. */
+ multiple?: boolean;
+
// just for extra documentation
/** Takes a comma separated list of one or more file types.
*
@@ -40,4 +43,4 @@ export type FileDropZonePropsWithoutHTML = WithChildren<{
accept?: string;
}>;
-export type FileDropZoneProps = FileDropZonePropsWithoutHTML & Omit<HTMLInputAttributes, 'multiple' | 'files'>;
+export type FileDropZoneProps = FileDropZonePropsWithoutHTML & Omit<HTMLInputAttributes, 'files'>;
diff --git a/frontend/src/lib/services/volume-backup-service.ts b/frontend/src/lib/services/volume-backup-service.ts
new file mode 100644
index 000000000..a431c351a
--- /dev/null
+++ b/frontend/src/lib/services/volume-backup-service.ts
@@ -0,0 +1,87 @@
+import BaseAPIService from './api-service';
+import { environmentStore } from '$lib/stores/environment.store.svelte';
+import type { BackupEntry } from '$lib/types/file-browser.type';
+import type { SearchPaginationSortRequest, Paginated } from '$lib/types/pagination.type';
+import { transformPaginationParams } from '$lib/utils/params.util';
+
+export type VolumeBackupListResponse = Paginated<BackupEntry> & { warnings?: string[] };
+
+export class VolumeBackupService extends BaseAPIService {
+ async createBackup(volumeName: string): Promise<BackupEntry> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.post(`/environments/${envId}/volumes/${volumeName}/backups`);
+ return res.data.data;
+ }
+
+ async listBackups(volumeName: string, options?: SearchPaginationSortRequest): Promise<VolumeBackupListResponse> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const params = transformPaginationParams(options);
+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/backups`, { params });
+ return res.data;
+ }
+
+ async restoreBackup(volumeName: string, backupId: string): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ return this.handleResponse(
+ this.api.post(`/environments/${envId}/volumes/${volumeName}/backups/${backupId}/restore`)
+ );
+ }
+
+ async restoreBackupFiles(volumeName: string, backupId: string, paths: string[]): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ return this.handleResponse(
+ this.api.post(`/environments/${envId}/volumes/${volumeName}/backups/${backupId}/restore-files`, {
+ paths
+ })
+ );
+ }
+
+ async backupHasPath(backupId: string, filePath: string): Promise<boolean> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.get(`/environments/${envId}/volumes/backups/${backupId}/has-path`, {
+ params: { path: filePath }
+ });
+ return !!res.data.data?.exists;
+ }
+
+ async listBackupFiles(backupId: string): Promise<string[]> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.get(`/environments/${envId}/volumes/backups/${backupId}/files`);
+ return res.data.data ?? [];
+ }
+
+ async deleteBackup(backupId: string): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ return this.handleResponse(this.api.delete(`/environments/${envId}/volumes/backups/${backupId}`));
+ }
+
+ async downloadBackup(backupId: string): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.get(`/environments/${envId}/volumes/backups/${backupId}/download`, {
+ responseType: 'blob'
+ });
+
+ const url = window.URL.createObjectURL(new Blob([res.data]));
+ const link = document.createElement('a');
+ link.href = url;
+ link.setAttribute('download', `${backupId}.tar.gz`);
+ document.body.appendChild(link);
+ link.click();
+ link.remove();
+ }
+
+ async uploadAndRestore(volumeName: string, file: File): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const formData = new FormData();
+ formData.append('file', file);
+ return this.handleResponse(
+ this.api.post(`/environments/${envId}/volumes/${volumeName}/backups/upload`, formData, {
+ headers: {
+ 'Content-Type': 'multipart/form-data'
+ }
+ })
+ );
+ }
+}
+
+export const volumeBackupService = new VolumeBackupService();
diff --git a/frontend/src/lib/services/volume-browser-service.ts b/frontend/src/lib/services/volume-browser-service.ts
new file mode 100644
index 000000000..cec070a77
--- /dev/null
+++ b/frontend/src/lib/services/volume-browser-service.ts
@@ -0,0 +1,73 @@
+import BaseAPIService from './api-service';
+import { environmentStore } from '$lib/stores/environment.store.svelte';
+import type { FileEntry, FileContentResponse } from '$lib/types/file-browser.type';
+
+export class VolumeBrowserService extends BaseAPIService {
+ async listDirectory(volumeName: string, path: string = '/'): Promise<FileEntry[]> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/browse`, {
+ params: { path }
+ });
+ return res.data.data;
+ }
+
+ async getFileContent(volumeName: string, path: string): Promise<FileContentResponse> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/browse/content`, {
+ params: { path }
+ });
+ return res.data.data;
+ }
+
+ async downloadFile(volumeName: string, path: string): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const res = await this.api.get(`/environments/${envId}/volumes/${volumeName}/browse/download`, {
+ params: { path },
+ responseType: 'blob'
+ });
+
+ const url = window.URL.createObjectURL(new Blob([res.data]));
+ const link = document.createElement('a');
+ link.href = url;
+ // Extract filename from path
+ const fileName = path.split('/').pop() || 'download';
+ link.setAttribute('download', fileName);
+ document.body.appendChild(link);
+ link.click();
+ link.remove();
+ }
+
+ async uploadFile(volumeName: string, path: string, file: File): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ const formData = new FormData();
+ formData.append('file', file);
+ return this.handleResponse(
+ this.api.post(`/environments/${envId}/volumes/${volumeName}/browse/upload`, formData, {
+ params: { path },
+ headers: {
+ 'Content-Type': 'multipart/form-data'
+ }
+ })
+ );
+ }
+
+ async createDirectory(volumeName: string, path: string): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ return this.handleResponse(
+ this.api.post(`/environments/${envId}/volumes/${volumeName}/browse/mkdir`, null, {
+ params: { path }
+ })
+ );
+ }
+
+ async deleteFile(volumeName: string, path: string): Promise<void> {
+ const envId = await environmentStore.getCurrentEnvironmentId();
+ return this.handleResponse(
+ this.api.delete(`/environments/${envId}/volumes/${volumeName}/browse`, {
+ params: { path }
+ })
+ );
+ }
+}
+
+export const volumeBrowserService = new VolumeBrowserService();
diff --git a/frontend/src/lib/types/file-browser.type.ts b/frontend/src/lib/types/file-browser.type.ts
new file mode 100644
index 000000000..74d73d5d3
--- /dev/null
+++ b/frontend/src/lib/types/file-browser.type.ts
@@ -0,0 +1,22 @@
+export interface FileEntry {
+ name: string;
+ path: string;
+ isDirectory: boolean;
+ size: number;
+ modTime: string;
+ mode: string;
+ isSymlink: boolean;
+ linkTarget?: string;
+}
+
+export interface FileContentResponse {
+ content: string; // Base64 encoded bytes from Go
+ mimeType: string;
+}
+
+export interface BackupEntry {
+ id: string;
+ volumeName: string;
+ size: number;
+ createdAt: string;
+}
diff --git a/frontend/src/lib/types/pagination.type.ts b/frontend/src/lib/types/pagination.type.ts
index 9d8067883..239560eee 100644
--- a/frontend/src/lib/types/pagination.type.ts
+++ b/frontend/src/lib/types/pagination.type.ts
@@ -16,6 +16,7 @@ export type SearchPaginationSortRequest = {
pagination?: PaginationRequest;
sort?: SortRequest;
filters?: FilterMap;
+ includeInternal?: boolean;
};
export type PaginationResponse = {
diff --git a/frontend/src/lib/types/settings.type.ts b/frontend/src/lib/types/settings.type.ts
index 8ac76b451..9829f9f1e 100644
--- a/frontend/src/lib/types/settings.type.ts
+++ b/frontend/src/lib/types/settings.type.ts
@@ -24,6 +24,7 @@ export type Settings = {
dockerHost: string;
accentColor: string;
autoInjectEnv: boolean;
+ backupVolumeName?: string;
authLocalEnabled: boolean;
authSessionTimeout: number;
diff --git a/frontend/src/lib/utils/params.util.ts b/frontend/src/lib/utils/params.util.ts
index 3d67be0c4..3fa2b57cf 100644
--- a/frontend/src/lib/utils/params.util.ts
+++ b/frontend/src/lib/utils/params.util.ts
@@ -30,5 +30,9 @@ export function transformPaginationParams(options?: SearchPaginationSortRequest)
});
}
+ if (typeof options.includeInternal === 'boolean') {
+ params.includeInternal = String(options.includeInternal);
+ }
+
return params;
}
diff --git a/frontend/src/lib/utils/table-persistence.util.ts b/frontend/src/lib/utils/table-persistence.util.ts
index 46bba4acd..26e9dfa15 100644
--- a/frontend/src/lib/utils/table-persistence.util.ts
+++ b/frontend/src/lib/utils/table-persistence.util.ts
@@ -10,7 +10,8 @@ function cloneRequest(options: SearchPaginationSortRequest): SearchPaginationSor
search: options.search,
filters: options.filters ? { ...options.filters } : undefined,
pagination: options.pagination ? { ...options.pagination } : undefined,
- sort: options.sort ? { ...options.sort } : undefined
+ sort: options.sort ? { ...options.sort } : undefined,
+ includeInternal: options.includeInternal
};
}
diff --git a/frontend/src/routes/(app)/containers/container-table.svelte b/frontend/src/routes/(app)/containers/container-table.svelte
index 99d1d3f7c..e207b8a66 100644
--- a/frontend/src/routes/(app)/containers/container-table.svelte
+++ b/frontend/src/routes/(app)/containers/container-table.svelte
@@ -115,6 +115,27 @@
return 'amber';
}
+ async function refreshContainers(options: SearchPaginationSortRequest) {
+ const result = await containerService.getContainers(options);
+ containers = result;
+ return result;
+ }
+
+ function getCurrentLimit() {
+ return requestOptions?.pagination?.limit ?? containers?.pagination?.itemsPerPage ?? 20;
+ }
+
+ function setShowInternal(value: boolean) {
+ customSettings = { ...customSettings, showInternalContainers: value };
+ const nextOptions: SearchPaginationSortRequest = {
+ ...requestOptions,
+ includeInternal: value,
+ pagination: { page: 1, limit: getCurrentLimit() }
+ };
+ requestOptions = nextOptions;
+ refreshContainers(nextOptions);
+ }
+
async function performContainerAction(action: 'start' | 'stop' | 'restart', id: string) {
// Set action status for this specific container
if (action === 'start') {
@@ -406,6 +427,9 @@
let mobileFieldVisibility = $state<Record<string, boolean>>({});
let customSettings = $state<Record<string, unknown>>({});
+ let showInternal = $derived.by(() => {
+ return (customSettings.showInternalContainers as boolean) ?? false;
+ });
let collapsedGroupsState = $state<PersistedState<Record<string, boolean>> | null>(null);
let collapsedGroups = $derived(collapsedGroupsState?.current ?? {});
let columnVisibility = $state<Record<string, boolean>>({});
@@ -471,6 +495,15 @@
customSettings = { ...customSettings, groupByProject: value };
}
+ $effect(() => {
+ const current = requestOptions?.includeInternal;
+ if (showInternal && current !== true) {
+ setShowInternal(true);
+ } else if (!showInternal && current === true) {
+ setShowInternal(false);
+ }
+ });
+
function toggleGroup(groupName: string) {
if (!collapsedGroupsState) return;
collapsedGroupsState.current = {
@@ -897,7 +930,7 @@
bind:mobileFieldVisibility
bind:customSettings
bind:columnVisibility
- onRefresh={async (options) => (containers = await containerService.getContainers(options))}
+ onRefresh={refreshContainers}
{columns}
{mobileFields}
{bulkActions}
@@ -911,6 +944,9 @@
<DropdownMenu.CheckboxItem bind:checked={() => groupByProject, (v) => setGroupByProject(!!v)}>
{m.containers_group_by_project()}
</DropdownMenu.CheckboxItem>
+ <DropdownMenu.CheckboxItem bind:checked={() => showInternal, (v) => setShowInternal(!!v)}>
+ {`${m.common_show()} ${m.internal()} ${m.containers_title()}`}
+ </DropdownMenu.CheckboxItem>
{/snippet}
{#snippet GroupedTableView({
diff --git a/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte b/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte
index 4255d330c..ee118ae8e 100644
--- a/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte
+++ b/frontend/src/routes/(app)/volumes/[volumeName]/+page.svelte
@@ -14,16 +14,32 @@
import { untrack } from 'svelte';
import { volumeService } from '$lib/services/volume-service.js';
import { ResourceDetailLayout, type DetailAction } from '$lib/layouts';
+ import TabbedPageLayout from '$lib/layouts/tabbed-page-layout.svelte';
+ import { VolumeBrowser } from '$lib/components/file-browser';
+ import BackupList from '../components/volume-backup-table.svelte';
+ import settingsStore from '$lib/stores/config-store';
let { data } = $props();
let volume = $state(untrack(() => data.volume));
let containersDetailed = $state<{ id: string; name: string }[]>(untrack(() => data.containersDetailed ?? []));
+ const backupVolumeName = $derived.by(() => $settingsStore?.backupVolumeName || 'arcane-backups');
+ const isBackupVolume = $derived(volume?.name === backupVolumeName);
+
let isLoading = $state({ remove: false });
const createdDate = $derived(volume.createdAt ? format(new Date(volume.createdAt), 'PP p') : m.common_unknown());
+ let selectedTab = $state('overview');
+
+ const tabItems = $derived([
+ { value: 'overview', label: m.common_overview() },
+ { value: 'browser', label: m.volumes_nav_browser() },
+ { value: 'backups', label: m.volumes_nav_backups() }
+ ]);
+
async function handleRemoveVolumeConfirm(volumeName: string) {
const safeName = volumeName?.trim() || m.common_unknown();
+ if (safeName === backupVolumeName) return;
const message = volume.inUse
? `${m.volumes_remove_confirm_message({ name: safeName })}\n\n${m.volumes_remove_in_use_warning()}`
: m.volumes_remove_confirm_message({ name: safeName });
@@ -55,242 +71,287 @@
action: 'remove',
label: m.common_remove(),
loading: isLoading.remove,
- disabled: isLoading.remove,
+ disabled: isLoading.remove || isBackupVolume,
onclick: () => handleRemoveVolumeConfirm(volume.name)
}
]);
-</script>
-
-<ResourceDetailLayout backUrl="/volumes" backLabel={m.volumes_title()} title={volume.name} {actions}>
- {#snippet badges()}
- {#if volume.inUse}
- <StatusBadge variant="green" text={m.common_in_use()} />
- {:else}
- <StatusBadge variant="amber" text={m.common_unused()} />
- {/if}
- {#if volume.driver}
- <StatusBadge variant="blue" text={volume.driver} />
- {/if}
- {#if volume.scope}
- <StatusBadge variant="purple" text={volume.scope} />
- {/if}
- {/snippet}
- {#if volume}
- <div class="space-y-6">
- <Card.Root>
- <Card.Header icon={InfoIcon}>
- <div class="flex flex-col space-y-1.5">
- <Card.Title>{m.common_details_title({ resource: m.resource_volume_cap() })}</Card.Title>
- <Card.Description>{m.common_details_description({ resource: m.resource_volume() })}</Card.Description>
- </div>
- </Card.Header>
- <Card.Content class="p-4">
- <div class="grid grid-cols-1 gap-x-4 gap-y-6 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-6">
- <div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-gray-500/10 p-2">
- <BoxIcon class="size-5 text-gray-500" />
- </div>
- <div class="min-w-0 flex-1">
- <p class="text-muted-foreground text-sm font-medium">{m.common_name()}</p>
- <p class="mt-1 cursor-pointer text-sm font-semibold break-all select-all sm:text-base" title="Click to select">
- {volume.name}
- </p>
- </div>
- </div>
-
- <div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-blue-500/10 p-2">
- <VolumesIcon class="size-5 text-blue-500" />
- </div>
- <div class="min-w-0 flex-1">
- <p class="text-muted-foreground text-sm font-medium">{m.common_driver()}</p>
- <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">
- {volume.driver}
- </p>
- </div>
- </div>
+ function onTabChange(value: string) {
+ selectedTab = value;
+ }
+</script>
- <div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-green-500/10 p-2">
- <ClockIcon class="size-5 text-green-500" />
- </div>
- <div class="min-w-0 flex-1">
- <p class="text-muted-foreground text-sm font-medium">{m.common_created()}</p>
- <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">
- {createdDate}
- </p>
- </div>
- </div>
+{#if volume}
+ <TabbedPageLayout backUrl="/volumes" backLabel={m.volumes_title()} {tabItems} {selectedTab} {onTabChange}>
+ {#snippet headerInfo()}
+ <div class="flex flex-col gap-1">
+ <h1 class="text-2xl font-bold tracking-tight break-all sm:text-3xl">{volume.name}</h1>
+ <div class="flex flex-wrap items-center gap-2 pt-1">
+ {#if volume.inUse}
+ <StatusBadge variant="green" text={m.common_in_use()} />
+ {:else}
+ <StatusBadge variant="amber" text={m.common_unused()} />
+ {/if}
+ {#if volume.driver}
+ <StatusBadge variant="blue" text={volume.driver} />
+ {/if}
+ {#if volume.scope}
+ <StatusBadge variant="purple" text={volume.scope} />
+ {/if}
+ </div>
+ </div>
+ {/snippet}
- <div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-purple-500/10 p-2">
- <GlobeIcon class="size-5 text-purple-500" />
- </div>
- <div class="min-w-0 flex-1">
- <p class="text-muted-foreground text-sm font-medium">{m.common_scope()}</p>
- <p class="mt-1 cursor-pointer text-sm font-semibold capitalize select-all sm:text-base" title="Click to select">
- {volume.scope}
- </p>
- </div>
- </div>
+ {#snippet headerActions()}
+ <div class="flex items-center gap-2">
+ {#each actions as act (act.id)}
+ <ArcaneButton
+ action={act.action}
+ customLabel={act.label}
+ loading={act.loading}
+ disabled={act.disabled}
+ onclick={act.onclick}
+ />
+ {/each}
+ </div>
+ {/snippet}
- <div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-amber-500/10 p-2">
- <InfoIcon class="size-5 text-amber-500" />
- </div>
- <div class="min-w-0 flex-1">
- <p class="text-muted-foreground text-sm font-medium">{m.common_status()}</p>
- <p class="mt-1 text-base font-semibold">
- {#if volume.inUse}
- <StatusBadge variant="green" text={m.common_in_use()} />
- {:else}
- <StatusBadge variant="amber" text={m.common_unused()} />
- {/if}
- </p>
+ {#snippet tabContent(tab)}
+ <div class="space-y-6">
+ {#if tab === 'overview'}
+ <Card.Root>
+ <Card.Header icon={InfoIcon}>
+ <div class="flex flex-col space-y-1.5">
+ <Card.Title>{m.common_details_title({ resource: m.resource_volume_cap() })}</Card.Title>
+ <Card.Description>{m.common_details_description({ resource: m.resource_volume() })}</Card.Description>
</div>
- </div>
+ </Card.Header>
+ <Card.Content class="p-4">
+ <div class="grid grid-cols-1 gap-x-4 gap-y-6 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-6">
+ <div class="flex items-start gap-3">
+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-gray-500/10 p-2">
+ <BoxIcon class="size-5 text-gray-500" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <p class="text-muted-foreground text-sm font-medium">{m.common_name()}</p>
+ <p
+ class="mt-1 cursor-pointer text-sm font-semibold break-all select-all sm:text-base"
+ title="Click to select"
+ >
+ {volume.name}
+ </p>
+ </div>
+ </div>
- <div class="col-span-1 flex items-start gap-3 sm:col-span-2 lg:col-span-3 xl:col-span-4 2xl:col-span-6">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-teal-500/10 p-2">
- <LayersIcon class="size-5 text-teal-500" />
- </div>
- <div class="min-w-0 flex-1">
- <p class="text-muted-foreground text-sm font-medium">{m.common_mountpoint()}</p>
- <div class="bg-muted/50 mt-2 cursor-pointer rounded-lg border p-3 select-all" title="Click to select">
- <code class="font-mono text-sm break-all">{volume.mountpoint}</code>
+ <div class="flex items-start gap-3">
+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-blue-500/10 p-2">
+ <VolumesIcon class="size-5 text-blue-500" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <p class="text-muted-foreground text-sm font-medium">{m.common_driver()}</p>
+ <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">
+ {volume.driver}
+ </p>
+ </div>
</div>
- </div>
- </div>
- </div>
- </Card.Content>
- </Card.Root>
- <Card.Root>
- <Card.Header icon={ContainersIcon}>
- <div class="flex flex-col space-y-1.5">
- <Card.Title>{m.volumes_containers_using_title()}</Card.Title>
- <Card.Description>{m.volumes_containers_using_description()}</Card.Description>
- </div>
- </Card.Header>
- <Card.Content class="p-4">
- {#if containersDetailed.length > 0}
- <Card.Root variant="outlined">
- <Card.Content class="divide-y p-0">
- {#each containersDetailed as c (c.id)}
- <div class="flex flex-col p-3 sm:flex-row sm:items-center">
- <div class="mb-2 w-full font-medium break-all sm:mb-0 sm:w-1/3">
- <a href="/containers/{c.id}" class="text-primary flex items-center hover:underline">
- <ContainersIcon class="text-muted-foreground mr-1.5 size-3.5" />
- {c.name}
- </a>
- </div>
- <div class="w-full pl-0 sm:w-2/3 sm:pl-4">
- <code
- class="bg-muted text-muted-foreground cursor-pointer rounded px-1.5 py-0.5 font-mono text-xs break-all select-all sm:text-sm"
- title="Click to select"
- >
- {truncateString(c.id, 48)}
- </code>
- </div>
+ <div class="flex items-start gap-3">
+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-green-500/10 p-2">
+ <ClockIcon class="size-5 text-green-500" />
</div>
- {/each}
- </Card.Content>
- </Card.Root>
- {:else if volume.containers && volume.containers.length > 0}
- <!-- Fallback to IDs if names not resolved -->
- <Card.Root variant="subtle">
- <Card.Content class="divide-y p-0">
- {#each volume.containers as id (id)}
- <div class="flex items-center justify-between gap-3 p-3">
- <code class="font-mono text-sm break-all">{truncateString(id, 48)}</code>
- <a href={`/containers/${id}`} class="text-primary text-sm hover:underline">{m.common_view()}</a>
+ <div class="min-w-0 flex-1">
+ <p class="text-muted-foreground text-sm font-medium">{m.common_created()}</p>
+ <p class="mt-1 cursor-pointer text-sm font-semibold select-all sm:text-base" title="Click to select">
+ {createdDate}
+ </p>
</div>
- {/each}
- </Card.Content>
- </Card.Root>
- {:else}
- <div class="text-muted-foreground">{m.volumes_no_containers_using()}</div>
- {/if}
- </Card.Content>
- </Card.Root>
+ </div>
- {#if volume.labels && Object.keys(volume.labels).length > 0}
- <Card.Root>
- <Card.Header icon={TagIcon}>
- <div class="flex flex-col space-y-1.5">
- <Card.Title>{m.common_labels()}</Card.Title>
- <Card.Description>{m.volumes_labels_description()}</Card.Description>
- </div>
- </Card.Header>
- <Card.Content class="p-4">
- <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">
- {#each Object.entries(volume.labels) as [key, value] (key)}
- <Card.Root variant="subtle">
- <Card.Content class="flex flex-col gap-2 p-4">
- <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">{key}</div>
- <div
- class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"
+ <div class="flex items-start gap-3">
+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-purple-500/10 p-2">
+ <GlobeIcon class="size-5 text-purple-500" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <p class="text-muted-foreground text-sm font-medium">{m.common_scope()}</p>
+ <p
+ class="mt-1 cursor-pointer text-sm font-semibold capitalize select-all sm:text-base"
title="Click to select"
>
- {value}
+ {volume.scope}
+ </p>
+ </div>
+ </div>
+
+ <div class="flex items-start gap-3">
+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-amber-500/10 p-2">
+ <InfoIcon class="size-5 text-amber-500" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <p class="text-muted-foreground text-sm font-medium">{m.common_status()}</p>
+ <p class="mt-1 text-base font-semibold">
+ {#if volume.inUse}
+ <StatusBadge variant="green" text={m.common_in_use()} />
+ {:else}
+ <StatusBadge variant="amber" text={m.common_unused()} />
+ {/if}
+ </p>
+ </div>
+ </div>
+
+ <div class="col-span-1 flex items-start gap-3 sm:col-span-2 lg:col-span-3 xl:col-span-4 2xl:col-span-6">
+ <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-teal-500/10 p-2">
+ <LayersIcon class="size-5 text-teal-500" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <p class="text-muted-foreground text-sm font-medium">{m.common_mountpoint()}</p>
+ <div class="bg-muted/50 mt-2 cursor-pointer rounded-lg border p-3 select-all" title="Click to select">
+ <code class="font-mono text-sm break-all">{volume.mountpoint}</code>
</div>
+ </div>
+ </div>
+ </div>
+ </Card.Content>
+ </Card.Root>
+
+ <Card.Root>
+ <Card.Header icon={ContainersIcon}>
+ <div class="flex flex-col space-y-1.5">
+ <Card.Title>{m.volumes_containers_using_title()}</Card.Title>
+ <Card.Description>{m.volumes_containers_using_description()}</Card.Description>
+ </div>
+ </Card.Header>
+ <Card.Content class="p-4">
+ {#if containersDetailed.length > 0}
+ <Card.Root variant="outlined">
+ <Card.Content class="divide-y p-0">
+ {#each containersDetailed as c (c.id)}
+ <div class="flex flex-col p-3 sm:flex-row sm:items-center">
+ <div class="mb-2 w-full font-medium break-all sm:mb-0 sm:w-1/3">
+ <a href="/containers/{c.id}" class="text-primary flex items-center hover:underline">
+ <ContainersIcon class="text-muted-foreground mr-1.5 size-3.5" />
+ {c.name}
+ </a>
+ </div>
+ <div class="w-full pl-0 sm:w-2/3 sm:pl-4">
+ <code
+ class="bg-muted text-muted-foreground cursor-pointer rounded px-1.5 py-0.5 font-mono text-xs break-all select-all sm:text-sm"
+ title="Click to select"
+ >
+ {truncateString(c.id, 48)}
+ </code>
+ </div>
+ </div>
+ {/each}
</Card.Content>
</Card.Root>
- {/each}
- </div>
- </Card.Content>
- </Card.Root>
- {/if}
-
- {#if volume.options && Object.keys(volume.options).length > 0}
- <Card.Root>
- <Card.Header icon={VolumesIcon}>
- <div class="flex flex-col space-y-1.5">
- <Card.Title>{m.common_driver_options()}</Card.Title>
- <Card.Description>{m.volumes_driver_options_description()}</Card.Description>
- </div>
- </Card.Header>
- <Card.Content class="p-4">
- <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">
- {#each Object.entries(volume.options) as [key, value] (key)}
+ {:else if volume.containers && volume.containers.length > 0}
+ <!-- Fallback to IDs if names not resolved -->
<Card.Root variant="subtle">
- <Card.Content class="flex flex-col gap-2 p-4">
- <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">{key}</div>
- <div
- class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"
- title="Click to select"
- >
- {value}
- </div>
+ <Card.Content class="divide-y p-0">
+ {#each volume.containers as id (id)}
+ <div class="flex items-center justify-between gap-3 p-3">
+ <code class="font-mono text-sm break-all">{truncateString(id, 48)}</code>
+ <a href={`/containers/${id}`} class="text-primary text-sm hover:underline">{m.common_view()}</a>
+ </div>
+ {/each}
</Card.Content>
</Card.Root>
- {/each}
- </div>
- </Card.Content>
- </Card.Root>
- {/if}
+ {:else}
+ <div class="text-muted-foreground">{m.volumes_no_containers_using()}</div>
+ {/if}
+ </Card.Content>
+ </Card.Root>
- {#if (!volume.labels || Object.keys(volume.labels).length === 0) && (!volume.options || Object.keys(volume.options).length === 0)}
- <Card.Root class="bg-muted/10 border shadow-sm">
- <Card.Content class="pt-6 pb-6 text-center">
- <div class="flex flex-col items-center justify-center">
- <div class="bg-muted/30 mb-4 rounded-full p-3">
- <TagIcon class="text-muted-foreground size-5 opacity-50" />
- </div>
- <p class="text-muted-foreground">{m.volumes_no_labels_or_options()}</p>
- </div>
- </Card.Content>
- </Card.Root>
- {/if}
- </div>
- {:else}
+ {#if volume.labels && Object.keys(volume.labels).length > 0}
+ <Card.Root>
+ <Card.Header icon={TagIcon}>
+ <div class="flex flex-col space-y-1.5">
+ <Card.Title>{m.common_labels()}</Card.Title>
+ <Card.Description>{m.volumes_labels_description()}</Card.Description>
+ </div>
+ </Card.Header>
+ <Card.Content class="p-4">
+ <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">
+ {#each Object.entries(volume.labels) as [key, value] (key)}
+ <Card.Root variant="subtle">
+ <Card.Content class="flex flex-col gap-2 p-4">
+ <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">
+ {key}
+ </div>
+ <div
+ class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"
+ title="Click to select"
+ >
+ {value}
+ </div>
+ </Card.Content>
+ </Card.Root>
+ {/each}
+ </div>
+ </Card.Content>
+ </Card.Root>
+ {/if}
+
+ {#if volume.options && Object.keys(volume.options).length > 0}
+ <Card.Root>
+ <Card.Header icon={VolumesIcon}>
+ <div class="flex flex-col space-y-1.5">
+ <Card.Title>{m.common_driver_options()}</Card.Title>
+ <Card.Description>{m.volumes_driver_options_description()}</Card.Description>
+ </div>
+ </Card.Header>
+ <Card.Content class="p-4">
+ <div class="grid grid-cols-1 gap-3 lg:grid-cols-2 2xl:grid-cols-3">
+ {#each Object.entries(volume.options) as [key, value] (key)}
+ <Card.Root variant="subtle">
+ <Card.Content class="flex flex-col gap-2 p-4">
+ <div class="text-muted-foreground text-xs font-semibold tracking-wide break-all uppercase">
+ {key}
+ </div>
+ <div
+ class="text-foreground cursor-pointer font-mono text-sm font-medium break-all select-all"
+ title="Click to select"
+ >
+ {value}
+ </div>
+ </Card.Content>
+ </Card.Root>
+ {/each}
+ </div>
+ </Card.Content>
+ </Card.Root>
+ {/if}
+
+ {#if (!volume.labels || Object.keys(volume.labels).length === 0) && (!volume.options || Object.keys(volume.options).length === 0)}
+ <Card.Root class="bg-muted/10 border shadow-sm">
+ <Card.Content class="pt-6 pb-6 text-center">
+ <div class="flex flex-col items-center justify-center">
+ <div class="bg-muted/30 mb-4 rounded-full p-3">
+ <TagIcon class="text-muted-foreground size-5 opacity-50" />
+ </div>
+ <p class="text-muted-foreground">{m.volumes_no_labels_or_options()}</p>
+ </div>
+ </Card.Content>
+ </Card.Root>
+ {/if}
+ {:else if tab === 'browser'}
+ <VolumeBrowser volumeName={volume.name} />
+ {:else if tab === 'backups'}
+ <BackupList volumeName={volume.name} />
+ {/if}
+ </div>
+ {/snippet}
+ </TabbedPageLayout>
+{:else}
+ <ResourceDetailLayout backUrl="/volumes" backLabel={m.volumes_title()} title="Volume" {actions}>
<div class="flex flex-col items-center justify-center px-4 py-16 text-center">
<div class="bg-muted/30 mb-4 rounded-full p-4">
<BoxIcon class="text-muted-foreground size-10 opacity-70" />
</div>
<h2 class="mb-2 text-xl font-medium">{m.common_not_found_title({ resource: m.volumes_title() })}</h2>
- <p class="text-muted-foreground mb-6">{m.common_not_found_description({ resource: m.volumes_title().toLowerCase() })}</p>
+ <p class="text-muted-foreground mb-6">
+ {m.common_not_found_description({ resource: m.volumes_title().toLowerCase() })}
+ </p>
<ArcaneButton
action="cancel"
@@ -299,5 +360,5 @@
size="sm"
/>
</div>
- {/if}
-</ResourceDetailLayout>
+ </ResourceDetailLayout>
+{/if}
diff --git a/frontend/src/routes/(app)/volumes/components/volume-backup-table.svelte b/frontend/src/routes/(app)/volumes/components/volume-backup-table.svelte
new file mode 100644
index 000000000..918b215ab
--- /dev/null
+++ b/frontend/src/routes/(app)/volumes/components/volume-backup-table.svelte
@@ -0,0 +1,412 @@
+<script lang="ts">
+import { volumeBackupService, type VolumeBackupListResponse } from '$lib/services/volume-backup-service';
+ import { volumeService } from '$lib/services/volume-service';
+ import type { BackupEntry } from '$lib/types/file-browser.type';
+ import { onMount } from 'svelte';
+ import {
+ LoadingSpinnerIcon,
+ TrashIcon,
+ AddIcon,
+ ClockIcon,
+ VolumesIcon,
+ InfoIcon,
+ DownloadIcon,
+ RestartIcon,
+ EllipsisIcon,
+ FileTextIcon,
+ AlertIcon
+ } from '$lib/icons';
+ import { ArcaneButton } from '$lib/components/arcane-button';
+ import { toast } from 'svelte-sonner';
+ import * as m from '$lib/paraglide/messages.js';
+ import bytes from 'bytes';
+ import { format } from 'date-fns';
+ import ArcaneTable from '$lib/components/arcane-table/arcane-table.svelte';
+import type { SearchPaginationSortRequest } from '$lib/types/pagination.type';
+ import { UniversalMobileCard, type ColumnSpec, type MobileFieldVisibility } from '$lib/components/arcane-table';
+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu';
+ import { openConfirmDialog } from '$lib/components/confirm-dialog';
+ import { ResponsiveDialog } from '$lib/components/ui/responsive-dialog';
+ import { Input } from '$lib/components/ui/input';
+ import { ScrollArea } from '$lib/components/ui/scroll-area';
+ import * as Checkbox from '$lib/components/ui/checkbox';
+ import * as Alert from '$lib/components/ui/alert';
+
+ let { volumeName }: { volumeName: string } = $props();
+
+let backupsPaginated = $state<VolumeBackupListResponse>({
+ data: [],
+ pagination: {
+ currentPage: 1,
+ totalPages: 1,
+ totalItems: 0,
+ itemsPerPage: 10
+ }
+});
+let backupWarnings = $state<string[]>([]);
+
+ let requestOptions = $state<SearchPaginationSortRequest>({
+ pagination: { page: 1, limit: 10 },
+ sort: { column: 'createdAt', direction: 'desc' }
+ });
+
+ let loading = $state(true);
+ let creating = $state(false);
+ let restoringFiles = $state(false);
+ let showRestoreFiles = $state(false);
+ let restoreTarget = $state<BackupEntry | null>(null);
+ let backupFiles = $state<string[]>([]);
+ let backupFilesLoading = $state(false);
+ let backupFilesSearch = $state('');
+ let selectedPaths = $state<string[]>([]);
+ const filteredBackupFiles = $derived.by(() => {
+ const q = backupFilesSearch.trim().toLowerCase();
+ if (!q) return backupFiles;
+ return backupFiles.filter((p) => p.toLowerCase().includes(q));
+ });
+
+ async function loadData(options: SearchPaginationSortRequest): Promise<VolumeBackupListResponse> {
+ loading = true;
+ try {
+ const result = await volumeBackupService.listBackups(volumeName, options);
+ backupsPaginated = result;
+ backupWarnings = result.warnings ?? [];
+ return result;
+ } catch (e: any) {
+ toast.error(e.message || 'Failed to load backups');
+ return backupsPaginated;
+ } finally {
+ loading = false;
+ }
+ }
+
+ async function handleCreate() {
+ creating = true;
+ try {
+ await volumeBackupService.createBackup(volumeName);
+ toast.success(m.common_success());
+ await loadData(requestOptions);
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ } finally {
+ creating = false;
+ }
+ }
+
+ async function handleDelete(backup: BackupEntry) {
+ openConfirmDialog({
+ title: m.common_remove_title({ resource: 'Backup' }),
+ message: m.volumes_backup_delete_confirm(),
+ confirm: {
+ label: m.common_remove(),
+ destructive: true,
+ action: async () => {
+ try {
+ await volumeBackupService.deleteBackup(backup.id);
+ toast.success(m.common_delete_success({ resource: 'Backup' }));
+ await loadData(requestOptions);
+ } catch (e: any) {
+ toast.error(e.message || m.common_delete_failed({ resource: 'Backup' }));
+ }
+ }
+ }
+ });
+ }
+
+ async function openRestoreFilesDialog(backup: BackupEntry) {
+ restoreTarget = backup;
+ selectedPaths = [];
+ backupFiles = [];
+ backupFilesSearch = '';
+ showRestoreFiles = true;
+ backupFilesLoading = true;
+ try {
+ backupFiles = await volumeBackupService.listBackupFiles(backup.id);
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ } finally {
+ backupFilesLoading = false;
+ }
+ }
+
+ function togglePath(path: string, checked: boolean) {
+ if (checked) {
+ if (!selectedPaths.includes(path)) {
+ selectedPaths = [...selectedPaths, path];
+ }
+ return;
+ }
+ selectedPaths = selectedPaths.filter((p) => p !== path);
+ }
+
+ function selectAllVisible() {
+ const next = new Set(selectedPaths);
+ for (const p of filteredBackupFiles) {
+ next.add(p);
+ }
+ selectedPaths = Array.from(next);
+ }
+
+ function clearSelection() {
+ selectedPaths = [];
+ }
+
+ async function handleRestore(backup: BackupEntry) {
+ // Check if volume is in use
+ let usageWarning = '';
+ try {
+ const usage = await volumeService.getVolumeUsage(volumeName);
+ if (usage.inUse && usage.containers?.length > 0) {
+ usageWarning = m.volumes_backup_restore_in_use_warning({ count: usage.containers.length });
+ }
+ } catch {
+ // Ignore errors checking usage
+ }
+
+ openConfirmDialog({
+ title: m.volumes_backup_restore_title(),
+ message: m.volumes_backup_restore_message({ volumeName }) + usageWarning,
+ confirm: {
+ label: m.volumes_backups_restore(),
+ destructive: !!usageWarning,
+ action: async () => {
+ try {
+ await volumeBackupService.restoreBackup(volumeName, backup.id);
+ toast.success(m.volumes_backup_restore_success());
+ await loadData(requestOptions);
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ }
+ }
+ }
+ });
+ }
+
+ async function handleRestoreFiles() {
+ if (!restoreTarget) return;
+ if (!selectedPaths.length) return;
+
+ restoringFiles = true;
+ try {
+ await volumeBackupService.restoreBackupFiles(volumeName, restoreTarget.id, selectedPaths);
+ toast.success(m.volumes_backup_restore_files_success({ count: selectedPaths.length }));
+ showRestoreFiles = false;
+ } catch (e: any) {
+ toast.error(e.message || m.common_failed());
+ } finally {
+ restoringFiles = false;
+ }
+ }
+
+ function formatBytes(value: number): string {
+ return bytes.format(value, { unitSeparator: ' ' }) ?? '-';
+ }
+
+ onMount(async () => {
+ await loadData(requestOptions);
+ });
+
+ const columns = [
+ { accessorKey: 'id', title: m.common_id(), sortable: true, cell: IdCell },
+ { accessorKey: 'size', title: m.common_size(), sortable: true, cell: SizeCell },
+ { accessorKey: 'createdAt', title: m.common_created(), sortable: true, cell: CreatedCell }
+ ] satisfies ColumnSpec<BackupEntry>[];
+
+ const mobileFields = [{ id: 'size', label: m.common_size(), defaultVisible: true }];
+
+ let mobileFieldVisibility = $state<Record<string, boolean>>({});
+</script>
+
+{#snippet IdCell({ value }: { value: any })}
+ <code class="font-mono text-xs font-medium">{value}</code>
+{/snippet}
+
+{#snippet SizeCell({ value }: { value: any })}
+ {formatBytes(Number(value))}
+{/snippet}
+
+{#snippet CreatedCell({ value }: { value: any })}
+ {format(new Date(String(value)), 'PP p')}
+{/snippet}
+
+{#snippet RowActions({ item }: { item: BackupEntry })}
+ <DropdownMenu.Root>
+ <DropdownMenu.Trigger>
+ {#snippet child({ props })}
+ <ArcaneButton
+ {...props}
+ action="base"
+ tone="ghost"
+ size="icon"
+ class="relative size-8 p-0"
+ icon={EllipsisIcon}
+ showLabel={false}
+ customLabel={m.common_open_menu()}
+ />
+ {/snippet}
+ </DropdownMenu.Trigger>
+ <DropdownMenu.Content align="end">
+ <DropdownMenu.Group>
+ <DropdownMenu.Item onclick={() => handleRestore(item)}>
+ <RestartIcon class="size-4" />
+ Restore
+ </DropdownMenu.Item>
+ <DropdownMenu.Item onclick={() => openRestoreFilesDialog(item)}>
+ <FileTextIcon class="size-4" />
+ Restore files
+ </DropdownMenu.Item>
+ <DropdownMenu.Item onclick={() => volumeBackupService.downloadBackup(item.id)}>
+ <DownloadIcon class="size-4" />
+ {m.templates_download()}
+ </DropdownMenu.Item>
+ <DropdownMenu.Separator />
+ <DropdownMenu.Item variant="destructive" onclick={() => handleDelete(item)}>
+ <TrashIcon class="size-4" />
+ {m.common_remove()}
+ </DropdownMenu.Item>
+ </DropdownMenu.Group>
+ </DropdownMenu.Content>
+ </DropdownMenu.Root>
+{/snippet}
+
+{#snippet ToolbarActions()}
+ <ArcaneButton
+ action="create"
+ customLabel={m.volumes_backup_create()}
+ loading={creating}
+ disabled={creating}
+ onclick={handleCreate}
+ size="sm"
+ icon={AddIcon}
+ />
+{/snippet}
+
+{#snippet BackupMobileCardSnippet({
+ item,
+ mobileFieldVisibility
+}: {
+ item: BackupEntry;
+ mobileFieldVisibility: MobileFieldVisibility;
+})}
+ <UniversalMobileCard
+ {item}
+ icon={{ component: VolumesIcon, variant: 'blue' }}
+ title={(item) => item.id}
+ fields={[
+ {
+ label: m.common_size(),
+ getValue: (item) => formatBytes(item.size),
+ icon: InfoIcon,
+ iconVariant: 'gray',
+ show: mobileFieldVisibility.size ?? true
+ }
+ ]}
+ footer={{
+ label: m.common_created(),
+ getValue: (item) => format(new Date(item.createdAt), 'PP p'),
+ icon: ClockIcon
+ }}
+ rowActions={RowActions}
+ />
+{/snippet}
+
+<div class="space-y-4">
+ <div class="flex items-center justify-between">
+ <h2 class="text-lg font-semibold">{m.volumes_backups_title()}</h2>
+ </div>
+
+ {#if backupWarnings.length > 0}
+ <Alert.Root variant="warning" class="py-2 [&>svg]:top-2">
+ <AlertIcon class="size-4" />
+ <Alert.Description class="text-xs">
+ {backupWarnings[0]}
+ </Alert.Description>
+ </Alert.Root>
+ {/if}
+
+ <ArcaneTable
+ persistKey="arcane-volume-backup-table"
+ items={backupsPaginated}
+ bind:requestOptions
+ bind:mobileFieldVisibility
+ onRefresh={loadData}
+ {columns}
+ {mobileFields}
+ rowActions={RowActions}
+ mobileCard={BackupMobileCardSnippet}
+ customToolbarActions={ToolbarActions}
+ />
+</div>
+
+<ResponsiveDialog
+ bind:open={showRestoreFiles}
+ title="Restore files"
+ description="Select files from this backup to restore."
+ contentClass="sm:max-w-[640px]"
+>
+ {#snippet children()}
+ <div class="space-y-3 py-2">
+ <Alert.Root class="py-2 [&>svg]:top-2">
+ <InfoIcon class="size-4" />
+ <Alert.Description class="text-xs">
+ {m.volumes_backup_safety_info()}
+ </Alert.Description>
+ </Alert.Root>
+
+ <div class="flex items-center justify-between gap-2">
+ <Input class="h-9" placeholder="Search files" bind:value={backupFilesSearch} />
+ <div class="flex items-center gap-2">
+ <ArcaneButton action="base" tone="ghost" size="sm" onclick={selectAllVisible} customLabel="Select all" />
+ <ArcaneButton action="base" tone="ghost" size="sm" onclick={clearSelection} customLabel="Clear" />
+ </div>
+ </div>
+
+ <ScrollArea class="h-64 rounded-md border">
+ {#if backupFilesLoading}
+ <div class="flex items-center justify-center py-8">
+ <LoadingSpinnerIcon class="text-muted-foreground size-5" />
+ </div>
+ {:else if filteredBackupFiles.length === 0}
+ <div class="text-muted-foreground flex items-center justify-center py-8 text-sm">No files found in this backup.</div>
+ {:else}
+ <div class="divide-border/40 divide-y">
+ {#each filteredBackupFiles as filePath}
+ <div class="flex items-center gap-3 px-3 py-2">
+ <Checkbox.Root
+ checked={selectedPaths.includes(filePath)}
+ onCheckedChange={(value) => togglePath(filePath, !!value)}
+ />
+ <code class="font-mono text-xs break-all">{filePath}</code>
+ </div>
+ {/each}
+ </div>
+ {/if}
+ </ScrollArea>
+
+ <Alert.Root variant="warning" class="py-2 [&>svg]:top-2">
+ <AlertIcon class="size-4" />
+ <Alert.Description class="text-xs">
+ {m.volumes_backup_overwrite_warning()}
+ </Alert.Description>
+ </Alert.Root>
+ </div>
+ {/snippet}
+
+ {#snippet footer()}
+ <ArcaneButton
+ action="cancel"
+ onclick={() => {
+ showRestoreFiles = false;
+ selectedPaths = [];
+ backupFilesSearch = '';
+ }}
+ />
+ <ArcaneButton
+ action="create"
+ customLabel="Restore files"
+ onclick={handleRestoreFiles}
+ loading={restoringFiles}
+ disabled={restoringFiles || selectedPaths.length === 0}
+ />
+ {/snippet}
+</ResponsiveDialog>
diff --git a/frontend/src/routes/(app)/volumes/volume-table.svelte b/frontend/src/routes/(app)/volumes/volume-table.svelte
index 2b82cc242..e977c812c 100644
--- a/frontend/src/routes/(app)/volumes/volume-table.svelte
+++ b/frontend/src/routes/(app)/volumes/volume-table.svelte
@@ -19,6 +19,7 @@
import bytes from 'bytes';
import { TrashIcon, EllipsisIcon, InspectIcon, VolumesIcon, CalendarIcon } from '$lib/icons';
import { Spinner } from '$lib/components/ui/spinner';
+ import settingsStore from '$lib/stores/config-store';
let {
volumes = $bindable(),
@@ -34,6 +35,10 @@
removing: false
});
+ const backupVolumeName = $derived.by(() => $settingsStore?.backupVolumeName || 'arcane-backups');
+ const isBackupVolumeName = (name?: string) => (name ?? '') === backupVolumeName;
+ const isBackupVolume = (item: VolumeSummaryDto) => isBackupVolumeName(item.name);
+
// Lazy load volume sizes - this is a slow operation
let volumeSizesPromise = $state<Promise<Map<string, VolumeSizeInfo>> | null>(null);
@@ -51,6 +56,7 @@
async function handleRemoveVolumeConfirm(name: string) {
const safeName = name?.trim() || m.common_unknown();
+ if (isBackupVolumeName(safeName)) return;
openConfirmDialog({
title: m.common_remove_title({ resource: m.resource_volume() }),
message: m.common_remove_confirm({ resource: `${m.resource_volume()} "${safeName}"` }),
@@ -88,8 +94,14 @@
let failureCount = 0;
const idToName = new Map(volumes.data.map((v) => [v.id, v.name] as const));
+ const idsToDelete = ids.filter((id) => !isBackupVolumeName(idToName.get(id)));
+ if (!idsToDelete.length) {
+ isLoading.removing = false;
+ selectedIds = [];
+ return;
+ }
- for (const id of ids) {
+ for (const id of idsToDelete) {
const name = idToName.get(id);
const safeName = name?.trim() || m.common_unknown();
const result = await tryCatch(volumeService.deleteVolume(safeName));
@@ -136,14 +148,19 @@
{ id: 'driver', label: m.common_driver(), defaultVisible: true }
];
+ const deletableSelectedIds = $derived.by(() => {
+ const idToName = new Map(volumes.data.map((v) => [v.id, v.name] as const));
+ return (selectedIds ?? []).filter((id) => !isBackupVolumeName(idToName.get(id)));
+ });
+
const bulkActions = $derived.by<BulkAction[]>(() => [
{
id: 'remove',
- label: m.common_remove_selected_count({ count: selectedIds?.length ?? 0 }),
+ label: m.common_remove_selected_count({ count: deletableSelectedIds.length }),
action: 'remove',
- onClick: handleDeleteSelected,
+ onClick: () => handleDeleteSelected(deletableSelectedIds),
loading: isLoading.removing,
- disabled: isLoading.removing,
+ disabled: isLoading.removing || deletableSelectedIds.length === 0,
icon: TrashIcon
}
]);
@@ -268,7 +285,11 @@
<InspectIcon class="size-4" />
{m.common_inspect()}
</DropdownMenu.Item>
- <DropdownMenu.Item variant="destructive" onclick={() => handleRemoveVolumeConfirm(item.name)} disabled={item.inUse}>
+ <DropdownMenu.Item
+ variant="destructive"
+ onclick={() => handleRemoveVolumeConfirm(item.name)}
+ disabled={item.inUse || isBackupVolume(item)}
+ >
<TrashIcon class="size-4" />
{m.common_remove()}
</DropdownMenu.Item>
diff --git a/types/volume/backup.go b/types/volume/backup.go
new file mode 100644
index 000000000..e9f9aca8f
--- /dev/null
+++ b/types/volume/backup.go
@@ -0,0 +1,8 @@
+package volume
+
+type BackupEntry struct {
+ ID string `json:"id" doc:"Unique identifier of the backup"`
+ VolumeName string `json:"volumeName" doc:"Name of the volume"`
+ Size int64 `json:"size" doc:"Size of the backup archive in bytes"`
+ CreatedAt string `json:"createdAt" doc:"When the backup was created"`
+}
diff --git a/types/volume/browse.go b/types/volume/browse.go
new file mode 100644
index 000000000..d690a1f1d
--- /dev/null
+++ b/types/volume/browse.go
@@ -0,0 +1,21 @@
+package volume
+
+import "time"
+
+type FileEntry struct {
+ Name string `json:"name" doc:"Name of the file or directory"`
+ Path string `json:"path" doc:"Full path to the file"`
+ IsDirectory bool `json:"isDirectory" doc:"Whether this entry is a directory"`
+ Size int64 `json:"size" doc:"Size of the file in bytes"`
+ ModTime time.Time `json:"modTime" doc:"Last modification time"`
+ Mode string `json:"mode" doc:"File mode/permissions"`
+ IsSymlink bool `json:"isSymlink" doc:"Whether this entry is a symbolic link"`
+ LinkTarget string `json:"linkTarget,omitempty" doc:"Target of the symbolic link"`
+}
+
+type FileMetadata struct {
+ FileEntry
+ MimeType string `json:"mimeType" doc:"MIME type of the file"`
+ IsText bool `json:"isText" doc:"Whether the file is a text file"`
+ IsBinary bool `json:"isBinary" doc:"Whether the file is a binary file"`
+}