Skip to content

Modern Docker Management, Designed for Everyone

refactor: move manual file reading/writing/parsing to go.getarcane.app/acfs (#3552)

Kyle Mendellbcdbe817ca51
diff --git a/backend/go.mod b/backend/go.mod
index 6deeaa862..368987d4c 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -56,6 +56,7 @@ require (
github.com/stretchr/testify v1.11.1
github.com/subosito/gotenv v1.6.0
github.com/wneessen/go-mail v0.8.1
+ go.getarcane.app/acfs v0.2.0
go.getarcane.app/builds v0.3.0
go.getarcane.app/docker/convert v0.1.0
go.getarcane.app/streams v0.3.1
diff --git a/backend/go.sum b/backend/go.sum
index 13a57478e..b6a5171e1 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -756,6 +756,8 @@ github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
+go.getarcane.app/acfs v0.2.0 h1:m7yXsLIB4MfsAE/AFP54RgtMXUr+AFEVCNiF5784XYI=
+go.getarcane.app/acfs v0.2.0/go.mod h1:sU3t21KctTsQM3OW10+RNB0Z6lR+YfaSr5Nxubq3cpI=
go.getarcane.app/builds v0.3.0 h1:6fCgHy6PaEr3LpCtiF1iCdT4nuV3D3xvUHnV+E/0cqk=
go.getarcane.app/builds v0.3.0/go.mod h1:yZJDSh9XX/sgZlwx7lghHEucgZeQ74Gr/Fx+XdR2bdk=
go.getarcane.app/docker/convert v0.1.0 h1:prlIOs6dMx6CdnetsJFZ6ak0vcistM3DcH5lrZiFHBU=
diff --git a/backend/internal/build/workspace_handler.go b/backend/internal/build/workspace_handler.go
index e838e7dc6..1f6c3a9c1 100644
--- a/backend/internal/build/workspace_handler.go
+++ b/backend/internal/build/workspace_handler.go
@@ -192,7 +192,7 @@ func (h *BuildWorkspaceHandler) UploadFile(ctx context.Context, input *UploadBui
}
defer func() { _ = file.Close() }()
- if err := h.service.UploadFile(ctx, input.Path, file, fileHeader.Filename); err != nil {
+ if err := h.service.UploadFile(ctx, input.Path, file, fileHeader.Filename, fileHeader.Size); err != nil {
return nil, huma.Error500InternalServerError(err.Error())
}
return &base.ApiResponse[base.MessageResponse]{
diff --git a/backend/internal/build/workspace_service.go b/backend/internal/build/workspace_service.go
index 34c557be6..4bf0a30d9 100644
--- a/backend/internal/build/workspace_service.go
+++ b/backend/internal/build/workspace_service.go
@@ -15,7 +15,9 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
+ acfsutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/acfs"
workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
+ "go.getarcane.app/acfs"
)
const defaultBuildsDirectory = "/builds"
@@ -41,49 +43,14 @@ func (s *BuildWorkspaceService) ListDirectory(ctx context.Context, dirPath strin
return nil, errors.WrapIf(err, "invalid path")
}
- targetPath, err := joinBuildRoot(root, cleaned)
- if err != nil {
- return nil, err
- }
-
- entries, err := os.ReadDir(targetPath)
+ entries, err := acfs.List(ctx, root, cleaned)
if err != nil {
return nil, errors.WrapIf(err, "failed to list directory")
}
results := make([]workspacetypes.FileEntry, 0, len(entries))
for _, entry := range entries {
- info, err := entry.Info()
- if err != nil {
- continue
- }
-
- entryPath := path.Join(cleaned, entry.Name())
- if entryPath == "" {
- entryPath = "/"
- }
-
- isSymlink := entry.Type()&os.ModeSymlink != 0
- mode := info.Mode().String()
-
- fileEntry := workspacetypes.FileEntry{
- Name: entry.Name(),
- Path: entryPath,
- IsDirectory: info.IsDir(),
- Size: info.Size(),
- ModTime: info.ModTime(),
- Mode: mode,
- IsSymlink: isSymlink,
- }
-
- if isSymlink {
- target, err := os.Readlink(filepath.Join(targetPath, entry.Name()))
- if err == nil && target != "" {
- fileEntry.LinkTarget = resolveLinkTarget(root, target)
- }
- }
-
- results = append(results, fileEntry)
+ results = append(results, acfsutils.FileEntry(entry))
}
return results, nil
@@ -101,30 +68,17 @@ func (s *BuildWorkspaceService) GetFileContent(ctx context.Context, filePath str
return nil, "", errors.WrapIf(err, "invalid path")
}
- fullPath, err := joinBuildRoot(root, cleaned)
- if err != nil {
- return nil, "", err
- }
-
- info, err := os.Stat(fullPath)
- if err != nil {
- return nil, "", errors.WrapIf(err, "failed to stat file")
- }
- if info.IsDir() {
- return nil, "", errors.New("path is a directory")
- }
-
if maxBytes <= 0 {
maxBytes = 1048576
}
- file, err := os.Open(fullPath)
+ file, _, err := acfs.OpenRead(ctx, root, cleaned, maxBytes)
if err != nil {
return nil, "", errors.WrapIf(err, "failed to open file")
}
defer func() { _ = file.Close() }()
- content, err := io.ReadAll(io.LimitReader(file, maxBytes))
+ content, err := io.ReadAll(file)
if err != nil {
return nil, "", errors.WrapIf(err, "failed to read file")
}
@@ -145,35 +99,22 @@ func (s *BuildWorkspaceService) DownloadFile(ctx context.Context, filePath strin
return nil, 0, errors.WrapIf(err, "invalid path")
}
- fullPath, err := joinBuildRoot(root, cleaned)
- if err != nil {
- return nil, 0, err
- }
-
- info, err := os.Stat(fullPath)
- if err != nil {
- return nil, 0, errors.WrapIf(err, "failed to stat file")
- }
- if info.IsDir() {
- return nil, 0, errors.New("path is a directory")
- }
-
- file, err := os.Open(fullPath)
+ file, size, err := acfs.OpenRead(ctx, root, cleaned, 0)
if err != nil {
return nil, 0, errors.WrapIf(err, "failed to open file")
}
- return file, info.Size(), nil
+ return file, size, nil
}
-func (s *BuildWorkspaceService) UploadFile(ctx context.Context, destPath string, content io.Reader, filename string) error {
+func (s *BuildWorkspaceService) UploadFile(ctx context.Context, destPath string, content io.Reader, filename string, size int64) error {
slog.DebugContext(ctx, "build workspace: upload file", "dest_path", destPath, "filename", filename)
root, err := s.resolveRoot()
if err != nil {
return err
}
- safeFilename, err := sanitizeUploadFilename(filename)
+ safeFilename, err := sanitizeUploadFilenameInternal(filename)
if err != nil {
return err
}
@@ -183,23 +124,12 @@ func (s *BuildWorkspaceService) UploadFile(ctx context.Context, destPath string,
return errors.WrapIf(err, "invalid path")
}
- dirPath, err := joinBuildRoot(root, cleaned)
- if err != nil {
- return err
- }
-
- if err := os.MkdirAll(dirPath, 0o755); err != nil {
+ if err := acfs.MkdirAll(ctx, root, cleaned, 0o755); err != nil {
return errors.WrapIf(err, "failed to create directory")
}
- targetFile := filepath.Join(dirPath, safeFilename)
- file, err := os.Create(targetFile)
- if err != nil {
- return errors.WrapIf(err, "failed to create file")
- }
- defer func() { _ = file.Close() }()
-
- if _, err := io.Copy(file, content); err != nil {
+ targetFile := path.Join(cleaned, safeFilename)
+ if _, err := acfs.WriteFrom(ctx, root, targetFile, content, size, 0o644); err != nil {
return errors.WrapIf(err, "failed to write file")
}
@@ -218,16 +148,11 @@ func (s *BuildWorkspaceService) CreateDirectory(ctx context.Context, dirPath str
return errors.WrapIf(err, "invalid path")
}
- fullPath, err := joinBuildRoot(root, cleaned)
- if err != nil {
- return err
- }
-
if cleaned == "/" {
return nil
}
- if err := os.MkdirAll(fullPath, 0o755); err != nil {
+ if err := acfs.MkdirAll(ctx, root, cleaned, 0o755); err != nil {
return errors.WrapIf(err, "failed to create directory")
}
@@ -250,12 +175,7 @@ func (s *BuildWorkspaceService) DeleteFile(ctx context.Context, filePath string)
return errors.New("cannot delete root directory")
}
- fullPath, err := joinBuildRoot(root, cleaned)
- if err != nil {
- return err
- }
-
- if err := os.RemoveAll(fullPath); err != nil {
+ if err := acfs.RemoveAll(ctx, root, cleaned); err != nil {
return errors.WrapIf(err, "failed to delete path")
}
@@ -284,7 +204,7 @@ func (s *BuildWorkspaceService) resolveRoot() (string, error) {
return cleaned, nil
}
-func sanitizeUploadFilename(filename string) (string, error) {
+func sanitizeUploadFilenameInternal(filename string) (string, error) {
name := strings.TrimSpace(filename)
if name == "" {
return "", errors.New("invalid filename")
@@ -310,38 +230,3 @@ func sanitizeUploadFilename(filename string) (string, error) {
return base, nil
}
-
-func joinBuildRoot(root, cleaned string) (string, error) {
- rel := strings.TrimPrefix(cleaned, "/")
- fullPath := filepath.Join(root, filepath.FromSlash(rel))
- if !utils.IsWithinRoot(root, fullPath) {
- return "", errors.New("invalid path: outside builds directory")
- }
- if _, err := utils.ResolveWithinRoot(root, fullPath); err != nil {
- return "", errors.WrapIf(err, "invalid path: outside builds directory")
- }
- return fullPath, nil
-}
-
-func resolveLinkTarget(root, target string) string {
- if target == "" {
- return ""
- }
- if filepath.IsAbs(target) {
- targetClean := filepath.Clean(target)
- if utils.IsWithinRoot(root, targetClean) {
- rel, err := filepath.Rel(root, targetClean)
- if err != nil {
- return "(external)"
- }
- rel = filepath.ToSlash(rel)
- if rel == "." || rel == "" {
- return "/"
- }
- return "/" + rel
- }
- return "(external)"
- }
-
- return filepath.ToSlash(target)
-}
diff --git a/backend/internal/project/workspace.go b/backend/internal/project/workspace.go
index 8db864f54..9b4dadf0f 100644
--- a/backend/internal/project/workspace.go
+++ b/backend/internal/project/workspace.go
@@ -14,9 +14,12 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/models"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
+ acfsutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/acfs"
workspacepkg "github.com/getarcaneapp/arcane/backend/v2/pkg/workspace"
projecttypes "github.com/getarcaneapp/arcane/types/v2/project"
workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
+ "go.getarcane.app/acfs"
+ acfstypes "go.getarcane.app/acfs/types"
)
func (s *ProjectService) GetProjectWorkspace(ctx context.Context, projectID string) (*workspacetypes.Workspace, error) {
@@ -46,7 +49,7 @@ func (s *ProjectService) GetProjectWorkspace(ctx context.Context, projectID stri
}
func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID, relativePath string) (*workspacetypes.FileContent, error) {
- proj, rel, fullPath, info, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)
+ proj, rel, fullPath, entry, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)
if err != nil {
return nil, err
}
@@ -54,26 +57,31 @@ func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID,
response := &workspacetypes.FileContent{
Path: fullPath,
RelativePath: rel,
- Name: filepath.Base(fullPath),
- Size: info.Size(),
+ Name: entry.Name,
+ Size: entry.Size,
}
- if info.IsDir() {
+ if entry.IsDirectory {
return nil, common.Classify(common.ErrProjectWorkspaceBadRequest, errors.New("workspace path is a directory"))
}
- if info.Mode()&os.ModeSymlink != 0 {
+ if entry.IsSymlink {
response.ReadOnlyReason = workspacetypes.FileReadOnlySymlink
return response, nil
}
- if !info.Mode().IsRegular() {
+ if !acfsutils.IsRegular(entry) {
response.ReadOnlyReason = workspacetypes.FileReadOnlySpecial
return response, nil
}
maxBytes := workspacepkg.MaxFileSizeBytes(s.config.ProjectWorkspaceMaxFileSizeMB)
- if info.Size() > maxBytes {
+ if entry.Size > maxBytes {
response.ReadOnlyReason = workspacetypes.FileReadOnlyTooLarge
return response, nil
}
- content, err := os.ReadFile(fullPath)
+ reader, _, err := acfs.OpenRead(ctx, proj.Path, "/"+rel, maxBytes)
+ if err != nil {
+ return nil, classifyProjectWorkspaceACFSErrorInternal(err, "read project workspace file")
+ }
+ defer func() { _ = reader.Close() }()
+ content, err := io.ReadAll(reader)
if err != nil {
return nil, errors.WrapIf(err, "read project workspace file")
}
@@ -88,35 +96,18 @@ func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID,
}
func (s *ProjectService) DownloadProjectWorkspaceFile(ctx context.Context, projectID, relativePath string) (io.ReadCloser, int64, string, error) {
- proj, rel, _, info, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)
+ proj, rel, _, entry, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)
if err != nil {
return nil, 0, "", err
}
- if info.IsDir() {
+ if entry.IsDirectory {
return nil, 0, "", common.Classify(common.ErrProjectWorkspaceBadRequest, errors.New("workspace path is a directory"))
}
- root, err := os.OpenRoot(proj.Path)
- if err != nil {
- return nil, 0, "", errors.WrapIf(err, "open project workspace")
- }
- file, err := root.Open(filepath.ToSlash(rel))
+ file, size, err := acfs.OpenRead(ctx, proj.Path, "/"+rel, 0)
if err != nil {
- _ = root.Close()
- return nil, 0, "", errors.WrapIf(err, "open project workspace file")
+ return nil, 0, "", classifyProjectWorkspaceACFSErrorInternal(err, "open project workspace file")
}
- return &projectWorkspaceDownloadInternal{ReadCloser: file, root: root}, info.Size(), filepath.Base(rel), nil
-}
-
-type projectWorkspaceDownloadInternal struct {
- io.ReadCloser
-
- root *os.Root
-}
-
-func (d *projectWorkspaceDownloadInternal) Close() error {
- fileErr := d.ReadCloser.Close()
- rootErr := d.root.Close()
- return errors.Combine(fileErr, rootErr)
+ return file, size, filepath.Base(rel), nil
}
func (s *ProjectService) UpdateProjectWorkspace(ctx context.Context, projectID string, manifest projecttypes.WorkspaceUpdateManifest, uploads map[int][]byte, user models.User) (*workspacetypes.Workspace, error) {
@@ -163,14 +154,14 @@ func (s *ProjectService) UpdateProjectWorkspace(ctx context.Context, projectID s
return s.GetProjectWorkspace(ctx, projectID)
}
-func (s *ProjectService) resolveProjectWorkspacePathInternal(ctx context.Context, projectID, relativePath string) (*models.Project, string, string, os.FileInfo, error) {
+func (s *ProjectService) resolveProjectWorkspacePathInternal(ctx context.Context, projectID, relativePath string) (*models.Project, string, string, acfstypes.Entry, error) {
proj, err := s.GetProjectFromDatabaseByID(ctx, projectID)
if err != nil {
- return nil, "", "", nil, err
+ return nil, "", "", acfstypes.Entry{}, err
}
rel, err := utils.NormalizeRelativePath(relativePath)
if err != nil {
- return nil, "", "", nil, common.Classify(common.ErrProjectWorkspaceForbidden, errors.WrapIf(err, "invalid project workspace path"))
+ return nil, "", "", acfstypes.Entry{}, common.Classify(common.ErrProjectWorkspaceForbidden, errors.WrapIf(err, "invalid project workspace path"))
}
composeFileName := projects.DefaultComposeFileName
if composeFile, resolveErr := s.ResolveProjectComposeFile(ctx, proj); resolveErr == nil {
@@ -179,17 +170,30 @@ func (s *ProjectService) resolveProjectWorkspacePathInternal(ctx context.Context
rootName, _, _ := strings.Cut(rel, "/")
protected := projects.ProtectedProjectFilePaths(composeFileName)
if protected[rel] || protected[rootName] {
- return nil, "", "", nil, common.Classify(common.ErrProjectWorkspaceForbidden, errors.New("project configuration is not part of the workspace"))
+ return nil, "", "", acfstypes.Entry{}, common.Classify(common.ErrProjectWorkspaceForbidden, errors.New("project configuration is not part of the workspace"))
}
fullPath := filepath.Join(proj.Path, filepath.FromSlash(rel))
- info, err := os.Lstat(fullPath)
+ entry, err := acfs.Stat(ctx, proj.Path, "/"+rel)
if err != nil {
if os.IsNotExist(err) {
- return nil, "", "", nil, common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))
+ return nil, "", "", acfstypes.Entry{}, common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))
}
- return nil, "", "", nil, errors.WrapIf(err, "inspect project workspace file")
+ return nil, "", "", acfstypes.Entry{}, classifyProjectWorkspaceACFSErrorInternal(err, "inspect project workspace file")
+ }
+ return proj, rel, fullPath, entry, nil
+}
+
+func classifyProjectWorkspaceACFSErrorInternal(err error, operation string) error {
+ switch {
+ case errors.Is(err, acfs.ErrInvalidPath),
+ errors.Is(err, acfs.ErrOutsideRoot),
+ errors.Is(err, acfs.ErrSymlinkLoop):
+ return common.Classify(common.ErrProjectWorkspaceForbidden, errors.WrapIf(err, operation))
+ case os.IsNotExist(err):
+ return common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))
+ default:
+ return errors.WrapIf(err, operation)
}
- return proj, rel, fullPath, info, nil
}
func (s *ProjectService) projectWorkspaceApplyOptionsInternal(ctx context.Context, proj *models.Project, expectedRevision string) projects.ProjectWorkspaceApplyOptions {
diff --git a/backend/internal/volume/helper_container.go b/backend/internal/volume/helper_container.go
index 8bb46ecb6..7d8373c8d 100644
--- a/backend/internal/volume/helper_container.go
+++ b/backend/internal/volume/helper_container.go
@@ -3,6 +3,7 @@ package volume
import (
"bytes"
"context"
+ "encoding/json"
"io"
"log/slog"
"strings"
@@ -21,6 +22,7 @@ import (
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/client"
"github.com/samber/mo"
+ acfstypes "go.getarcane.app/acfs/types"
)
// volumeHelper tracks a reused helper container and the last
@@ -31,6 +33,36 @@ type volumeHelper struct {
id string
lastUsedAt time.Time
inUse int
+ protocol int
+}
+
+func (s *VolumeService) requireVolumeHelperACFSInternal(ctx context.Context, volumeName, containerID string) error {
+ s.helperMu.Lock()
+ helper := s.helperByVolume[volumeName]
+ if helper != nil && helper.id == containerID && helper.protocol >= acfstypes.ProtocolVersion {
+ s.helperMu.Unlock()
+ return nil
+ }
+ s.helperMu.Unlock()
+
+ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"acfs", "version"})
+ if err != nil {
+ return errors.WrapIf(err, "volume workspace requires an ACFS-capable tools image: "+strings.TrimSpace(stderr))
+ }
+ var response acfstypes.VersionResponse
+ if err := json.Unmarshal([]byte(stdout), &response); err != nil {
+ return errors.WrapIf(err, "parse ACFS tools-image capability")
+ }
+ if response.Protocol < acfstypes.ProtocolVersion {
+ return errors.Errorf("volume workspace requires ACFS protocol %d, tools image provides protocol %d", acfstypes.ProtocolVersion, response.Protocol)
+ }
+
+ s.helperMu.Lock()
+ if helper = s.helperByVolume[volumeName]; helper != nil && helper.id == containerID {
+ helper.protocol = response.Protocol
+ }
+ s.helperMu.Unlock()
+ return nil
}
const volumeHelperImage = volumehelper.DefaultToolsImage
diff --git a/backend/internal/volume/workspace.go b/backend/internal/volume/workspace.go
index 04b60469a..d3ddf86c1 100644
--- a/backend/internal/volume/workspace.go
+++ b/backend/internal/volume/workspace.go
@@ -2,19 +2,21 @@ package volume
import (
"archive/tar"
+ "bytes"
"context"
"crypto/sha256"
"encoding/hex"
+ "encoding/json"
stderrors "errors"
"fmt"
"io"
"log/slog"
"net/http"
- "os"
"path"
"slices"
"strconv"
"strings"
+ "sync"
"time"
"emperror.dev/errors"
@@ -25,61 +27,17 @@ import (
dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
+ acfsutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/acfs"
workspacepkg "github.com/getarcaneapp/arcane/backend/v2/pkg/workspace"
volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/mount"
"github.com/moby/moby/client"
+ "go.getarcane.app/acfs"
+ acfstypes "go.getarcane.app/acfs/types"
)
-const volumeWorkspaceTreeScriptInternal = `export LC_ALL=C
-depth_budget="$1"
-entry_budget="$2"
-truncated=0
-stop=0
-
-walk() {
- for full in "$1"/..?* "$1"/.[!.]* "$1"/*; do
- case "$stop" in 1) return ;; esac
- metadata=$(stat -c '%s|%y|%A' -- "$full" 2>/dev/null) || continue
- case "$entry_budget" in '') truncated=1; stop=1; return ;; esac
-
- name=${full##*/}
- case "$2" in '') rel=$name ;; *) rel="$2/$name" ;; esac
- size=${metadata%%|*}
- metadata=${metadata#*|}
- mtime=${metadata%|*}
- mode=${metadata##*|}
- link=
- case "$mode" in
- l*) kind=l; link=$(readlink "$full" 2>/dev/null) || link= ;;
- d*) kind=d ;;
- -*) kind=f ;;
- *) kind=s ;;
- esac
- printf '%s\0%s\0%s\0%s\0%s\0%s\0' "$rel" "$kind" "$size" "$mtime" "$mode" "$link"
- entry_budget=${entry_budget#?}
-
- case "$kind" in
- d)
- next_depth=${3#?}
- case "$next_depth" in
- '')
- for child in "$full"/..?* "$full"/.[!.]* "$full"/*; do
- if stat -c '%A' -- "$child" >/dev/null 2>&1; then truncated=1; break; fi
- done
- ;;
- *) walk "$full" "$rel" "$next_depth" ;;
- esac
- ;;
- esac
- done
-}
-
-walk /volume '' "$depth_budget"
-printf 'ARCANE_TREE_END\0%s\0' "$truncated"`
-
func (s *VolumeService) GetVolumeWorkspace(ctx context.Context, volumeName string) (*workspacetypes.Workspace, error) {
defer s.workspaceLocks.RLock(volumeName)()
@@ -100,6 +58,9 @@ func (s *VolumeService) GetVolumeWorkspace(ctx context.Context, volumeName strin
return nil, err
}
defer cleanup()
+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {
+ return nil, err
+ }
slog.DebugContext(ctx, "volume workspace helper acquired", "volume", volumeName, "container_id", containerID, "duration", time.Since(helperStartedAt))
scanStartedAt := time.Now()
@@ -120,61 +81,99 @@ func (s *VolumeService) readVolumeWorkspaceFromContainerInternal(ctx context.Con
if maxEntries <= 0 {
maxEntries = 10000
}
- depthBudget := strings.Repeat("d", maxDepth)
- entryBudget := strings.Repeat("e", maxEntries)
- stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", volumeWorkspaceTreeScriptInternal, "sh", depthBudget, entryBudget})
+
+ pipeReader, pipeWriter := io.Pipe()
+ dockerClient, err := s.dockerService.GetClient(ctx)
if err != nil {
- return nil, classifyVolumeWorkspaceExecErrorInternal(err, stderr, "read volume workspace")
+ return nil, err
}
- return parseVolumeWorkspaceTreeInternal(stdout, maxEntries, s.volumeWorkspaceMaxFileSizeBytesInternal())
-}
+ var stderr bytes.Buffer
+ done := make(chan error, 1)
+ go func() {
+ cmd := []string{
+ "acfs", "walk", "--root", "/volume", "--path", "/",
+ "--max-depth", strconv.Itoa(maxDepth), "--max-entries", strconv.Itoa(maxEntries),
+ }
+ exitCode, execErr := dockerutil.ExecInContainer(ctx, dockerClient, containerID, client.ExecCreateOptions{
+ AttachStdout: true,
+ AttachStderr: true,
+ Cmd: cmd,
+ }, pipeWriter, &stderr)
+ if execErr == nil && exitCode != 0 {
+ execErr = errors.Errorf("acfs walk exited with code %d", exitCode)
+ }
+ _ = pipeWriter.CloseWithError(execErr)
+ done <- execErr
+ }()
-func parseVolumeWorkspaceTreeInternal(stdout string, maxEntries int, configuredMaxFileSizeBytes ...int64) (*workspacetypes.Workspace, error) {
- maxFileSizeBytes := workspacepkg.MaxFileSizeBytes(workspacepkg.DefaultMaxFileSizeMB)
- if len(configuredMaxFileSizeBytes) == 1 && configuredMaxFileSizeBytes[0] > 0 {
- maxFileSizeBytes = configuredMaxFileSizeBytes[0]
- }
- fields := strings.Split(stdout, "\x00")
- if len(fields) > 0 && fields[len(fields)-1] == "" {
- fields = fields[:len(fields)-1]
+ workspace, parseErr := decodeVolumeWorkspaceWalkInternal(pipeReader, maxEntries, s.volumeWorkspaceMaxFileSizeBytesInternal())
+ if parseErr != nil {
+ _ = pipeReader.CloseWithError(parseErr)
}
- if len(fields) < 2 || fields[len(fields)-2] != "ARCANE_TREE_END" || (fields[len(fields)-1] != "0" && fields[len(fields)-1] != "1") {
- return nil, errors.New("invalid volume workspace truncation marker")
+ execErr := <-done
+ _ = pipeReader.Close()
+ if execErr != nil {
+ return nil, classifyVolumeWorkspaceExecErrorInternal(execErr, stderr.String(), "read volume workspace")
}
- truncated := fields[len(fields)-1] == "1"
- fields = fields[:len(fields)-2]
- if len(fields)%6 != 0 {
- return nil, errors.New("invalid volume workspace file entry")
+ if parseErr != nil {
+ return nil, errors.WrapIf(parseErr, "parse volume workspace")
}
- entries := make([]workspacetypes.FileEntry, 0, min(len(fields)/6, maxEntries+1))
- classifications := make(map[string]string, min(len(fields)/6, maxEntries+1))
- for i := 0; i+5 < len(fields); i += 6 {
- if fields[i] == "" {
- continue
+
+ return workspace, nil
+}
+
+func decodeVolumeWorkspaceWalkInternal(source io.Reader, maxEntries int, maxFileSizeBytes int64) (*workspacetypes.Workspace, error) {
+ decoder := json.NewDecoder(source)
+ files := make([]workspacetypes.FileEntry, 0, min(maxEntries, 256))
+ classifications := make(map[string]string, min(maxEntries, 256))
+ trailerSeen := false
+ truncated := false
+ for {
+ var record acfstypes.WalkRecord
+ err := decoder.Decode(&record)
+ if stderrors.Is(err, io.EOF) {
+ break
}
- entry, classification, err := parseVolumeWorkspaceEntryInternal(fields[i:i+6], maxFileSizeBytes)
if err != nil {
return nil, err
}
- classifications[entry.RelativePath] = classification
- entries = append(entries, entry)
+ if record.Version != acfstypes.ProtocolVersion {
+ return nil, errors.Errorf("unsupported acfs protocol %d", record.Version)
+ }
+ if trailerSeen {
+ return nil, errors.New("acfs walk emitted a record after its trailer")
+ }
+ if record.End {
+ trailerSeen = true
+ truncated = record.Truncated
+ if record.Count != len(files) {
+ return nil, errors.New("acfs walk trailer count does not match emitted entries")
+ }
+ continue
+ }
+ if record.Entry == nil {
+ return nil, errors.New("acfs walk emitted an empty record")
+ }
+ if len(files) >= maxEntries {
+ return nil, errors.New("acfs walk exceeded the requested entry limit")
+ }
+ fileEntry, classification := volumeWorkspaceEntryFromACFSInternal(*record.Entry, maxFileSizeBytes)
+ classifications[fileEntry.RelativePath] = classification
+ files = append(files, fileEntry)
+ }
+ if !trailerSeen {
+ return nil, errors.New("acfs walk ended without a trailer")
}
- revisionEntries := slices.Clone(entries)
+ revisionEntries := slices.Clone(files)
slices.SortFunc(revisionEntries, func(a, b workspacetypes.FileEntry) int {
return strings.Compare(a.RelativePath, b.RelativePath)
})
- truncated = truncated || len(entries) > maxEntries
- if len(revisionEntries) > maxEntries {
- revisionEntries = revisionEntries[:maxEntries]
- }
- entries = slices.Clone(revisionEntries)
-
h := sha256.New()
for _, entry := range revisionEntries {
utils.WriteFileTreeRevisionEntry(h, entry.RelativePath, classifications[entry.RelativePath], entry.Size, entry.ModTime.UnixNano(), entry.Mode, false)
}
- slices.SortFunc(entries, func(a, b workspacetypes.FileEntry) int {
+ slices.SortFunc(files, func(a, b workspacetypes.FileEntry) int {
if a.IsDirectory != b.IsDirectory {
if a.IsDirectory {
return -1
@@ -183,75 +182,35 @@ func parseVolumeWorkspaceTreeInternal(stdout string, maxEntries int, configuredM
}
return strings.Compare(a.RelativePath, b.RelativePath)
})
-
return &workspacetypes.Workspace{
- Files: entries,
+ Files: files,
FileTreeRevision: hex.EncodeToString(h.Sum(nil)),
FileTreeTruncated: truncated,
}, nil
}
-func parseVolumeWorkspaceEntryInternal(fields []string, maxFileSizeBytes int64) (workspacetypes.FileEntry, string, error) {
- relativePath := fields[0]
- size, err := strconv.ParseInt(fields[2], 10, 64)
- if err != nil {
- return workspacetypes.FileEntry{}, "", errors.WrapIf(err, "parse volume workspace file size")
- }
- modTime, err := parseVolumeWorkspaceModTimeInternal(fields[3])
- if err != nil {
- return workspacetypes.FileEntry{}, "", errors.WrapIf(err, "parse volume workspace modification time")
- }
-
- mode := fields[4]
- classificationKey := "kind:" + fields[1]
- if mode != "" {
- classificationKey = "mode:" + mode[:1]
- }
- classification := "special"
- switch classificationKey {
- case "kind:d", "mode:d":
- classification = "dir"
- case "kind:l", "mode:l":
- classification = "symlink"
- case "kind:f", "mode:-":
- classification = "file"
- }
-
- entry := workspacetypes.FileEntry{
- ModTime: modTime,
- Name: path.Base(relativePath),
- Path: "/" + relativePath,
- RelativePath: relativePath,
- Mode: mode,
- LinkTarget: fields[5],
- Size: size,
- IsDirectory: classification == "dir",
- IsSymlink: classification == "symlink",
- }
- switch classification {
- case "dir":
- entry.Size = 0
- entry.Editable = true
- case "symlink":
- entry.ReadOnlyReason = workspacetypes.FileReadOnlySymlink
- case "special":
- entry.ReadOnlyReason = workspacetypes.FileReadOnlySpecial
- case "file":
- if size > maxFileSizeBytes {
- entry.ReadOnlyReason = workspacetypes.FileReadOnlyTooLarge
+func volumeWorkspaceEntryFromACFSInternal(entry acfstypes.Entry, maxFileSizeBytes int64) (workspacetypes.FileEntry, string) {
+ fileEntry := acfsutils.FileEntry(entry)
+ fileEntry.RelativePath = strings.TrimPrefix(entry.Path, "/")
+ switch {
+ case entry.IsDirectory:
+ fileEntry.Size = 0
+ fileEntry.Editable = true
+ return fileEntry, "dir"
+ case entry.IsSymlink:
+ fileEntry.ReadOnlyReason = workspacetypes.FileReadOnlySymlink
+ return fileEntry, "symlink"
+ case acfsutils.IsRegular(entry):
+ if entry.Size > maxFileSizeBytes {
+ fileEntry.ReadOnlyReason = workspacetypes.FileReadOnlyTooLarge
} else {
- entry.Editable = true
+ fileEntry.Editable = true
}
+ return fileEntry, "file"
+ default:
+ fileEntry.ReadOnlyReason = workspacetypes.FileReadOnlySpecial
+ return fileEntry, "special"
}
- return entry, classification, nil
-}
-
-func parseVolumeWorkspaceModTimeInternal(value string) (time.Time, error) {
- trimmed := strings.TrimSpace(value)
- if seconds, err := strconv.ParseFloat(trimmed, 64); err == nil {
- return time.Unix(0, int64(seconds*float64(time.Second))), nil
- }
- return time.Parse("2006-01-02 15:04:05 -0700", trimmed)
}
func (s *VolumeService) volumeWorkspaceMaxFileSizeBytesInternal() int64 {
@@ -276,37 +235,46 @@ func (s *VolumeService) GetVolumeWorkspaceFile(ctx context.Context, volumeName,
return nil, err
}
defer cleanup()
- dockerClient, err := s.dockerService.GetClient(ctx)
- if err != nil {
+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {
return nil, err
}
- statResult, err := dockerClient.ContainerStatPath(ctx, containerID, client.ContainerStatPathOptions{Path: path.Join("/volume", rel)})
+ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{
+ "acfs", "stat", "--root", "/volume", "--path", "/" + rel,
+ })
if err != nil {
- if cerrdefs.IsNotFound(err) {
- return nil, common.Classify(common.ErrVolumeWorkspaceNotFound, errors.New("volume workspace file not found"))
- }
- return nil, errors.WrapIf(err, "inspect volume workspace file")
+ return nil, classifyVolumeWorkspaceExecErrorInternal(err, stderr, "inspect volume workspace file")
}
- stat := statResult.Stat
- if stat.Mode&os.ModeSymlink != 0 {
- return &workspacetypes.FileContent{Path: "/" + rel, RelativePath: rel, Name: path.Base(rel), Size: stat.Size, ReadOnlyReason: workspacetypes.FileReadOnlySymlink}, nil
+ var statResponse acfstypes.StatResponse
+ if err := json.Unmarshal([]byte(stdout), &statResponse); err != nil {
+ return nil, errors.WrapIf(err, "parse volume workspace stat")
}
- if stat.Mode.IsDir() {
+ if statResponse.Version != acfstypes.ProtocolVersion {
+ return nil, errors.Errorf("unsupported acfs protocol %d", statResponse.Version)
+ }
+ entry := statResponse.Entry
+ if entry.IsSymlink {
+ return &workspacetypes.FileContent{Path: "/" + rel, RelativePath: rel, Name: path.Base(rel), Size: entry.Size, ReadOnlyReason: workspacetypes.FileReadOnlySymlink}, nil
+ }
+ if entry.IsDirectory {
return nil, common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("path is a directory"))
}
- if !stat.Mode.IsRegular() {
- return volumeWorkspaceFileContentResponseInternal(rel, "special", stat.Size, nil, s.volumeWorkspaceMaxFileSizeBytesInternal())
+ if !acfsutils.IsRegular(entry) {
+ return volumeWorkspaceFileContentResponseInternal(rel, "special", entry.Size, nil, s.volumeWorkspaceMaxFileSizeBytesInternal())
}
maxFileSizeBytes := s.volumeWorkspaceMaxFileSizeBytesInternal()
- if stat.Size > maxFileSizeBytes {
- return volumeWorkspaceFileContentResponseInternal(rel, "regular", stat.Size, nil, maxFileSizeBytes)
+ if entry.Size > maxFileSizeBytes {
+ return volumeWorkspaceFileContentResponseInternal(rel, "regular", entry.Size, nil, maxFileSizeBytes)
}
- reader, size, err := volumehelper.DownloadFileFromContainer(ctx, dockerClient, containerID, path.Join("/volume", rel), func() {})
+ previewLimit := maxFileSizeBytes
+ if previewLimit < int64(^uint64(0)>>1) {
+ previewLimit++
+ }
+ reader, size, err := s.startVolumeWorkspaceReadInternal(ctx, containerID, rel, previewLimit, func() {})
if err != nil {
return nil, errors.WrapIf(err, "read volume workspace file")
}
- content, readErr := io.ReadAll(io.LimitReader(reader, maxFileSizeBytes+1))
+ content, readErr := io.ReadAll(reader)
closeErr := reader.Close()
if readErr != nil {
return nil, errors.WrapIf(readErr, "read volume workspace file content")
@@ -314,7 +282,7 @@ func (s *VolumeService) GetVolumeWorkspaceFile(ctx context.Context, volumeName,
if closeErr != nil {
return nil, errors.WrapIf(closeErr, "close volume workspace file content")
}
- if int64(len(content)) > maxFileSizeBytes || size > maxFileSizeBytes {
+ if size > maxFileSizeBytes {
return volumeWorkspaceFileContentResponseInternal(rel, "regular", size, nil, maxFileSizeBytes)
}
return volumeWorkspaceFileContentResponseInternal(rel, "regular", size, content, maxFileSizeBytes)
@@ -340,19 +308,113 @@ func (s *VolumeService) DownloadVolumeWorkspaceFile(ctx context.Context, volumeN
cleanup()
unlock()
}
- parent := path.Dir(rel)
- if parent != "." {
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, parent, false); err != nil {
- cleanupAndUnlock()
- return nil, 0, err
+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {
+ cleanupAndUnlock()
+ return nil, 0, err
+ }
+ return s.startVolumeWorkspaceReadInternal(ctx, containerID, rel, 0, cleanupAndUnlock)
+}
+
+type volumeWorkspaceReadStreamInternal struct {
+ pipe *io.PipeReader
+ done <-chan error
+ cleanup func()
+ remaining int64
+ once sync.Once
+ err error
+}
+
+func (r *volumeWorkspaceReadStreamInternal) Read(buffer []byte) (int, error) {
+ if r.remaining == 0 {
+ var extra [1]byte
+ read, readErr := r.pipe.Read(extra[:])
+ closeErr := r.Close()
+ if read != 0 {
+ return 0, errors.New("acfs read emitted bytes beyond its framed payload")
+ }
+ if closeErr != nil {
+ return 0, closeErr
+ }
+ if readErr != nil && !stderrors.Is(readErr, io.EOF) {
+ return 0, readErr
+ }
+ return 0, io.EOF
+ }
+ if int64(len(buffer)) > r.remaining {
+ buffer = buffer[:r.remaining]
+ }
+ read, err := r.pipe.Read(buffer)
+ r.remaining -= int64(read)
+ if err != nil && r.remaining > 0 {
+ closeErr := r.Close()
+ if closeErr != nil {
+ return read, stderrors.Join(err, closeErr)
}
}
+ return read, err
+}
+
+func (r *volumeWorkspaceReadStreamInternal) Close() error {
+ r.once.Do(func() {
+ _ = r.pipe.Close()
+ r.err = <-r.done
+ r.cleanup()
+ })
+ return r.err
+}
+
+func (s *VolumeService) startVolumeWorkspaceReadInternal(ctx context.Context, containerID, relativePath string, limit int64, cleanup func()) (io.ReadCloser, int64, error) {
+ pipeReader, pipeWriter := io.Pipe()
dockerClient, err := s.dockerService.GetClient(ctx)
if err != nil {
- cleanupAndUnlock()
+ cleanup()
return nil, 0, err
}
- return volumehelper.DownloadFileFromContainer(ctx, dockerClient, containerID, path.Join("/volume", rel), cleanupAndUnlock)
+ done := make(chan error, 1)
+ cmd := []string{"acfs", "read", "--root", "/volume", "--path", "/" + relativePath}
+ if limit > 0 {
+ cmd = append(cmd, "--limit", strconv.FormatInt(limit, 10))
+ }
+ go func() {
+ var stderr bytes.Buffer
+ exitCode, execErr := dockerutil.ExecInContainer(ctx, dockerClient, containerID, client.ExecCreateOptions{
+ AttachStdout: true,
+ AttachStderr: true,
+ Cmd: cmd,
+ }, pipeWriter, &stderr)
+ if execErr == nil && exitCode != 0 {
+ execErr = errors.Errorf("acfs read exited with code %d", exitCode)
+ }
+ if execErr != nil {
+ execErr = classifyVolumeWorkspaceExecErrorInternal(execErr, stderr.String(), "read volume workspace file")
+ }
+ _ = pipeWriter.CloseWithError(execErr)
+ done <- execErr
+ }()
+
+ payloadSize, err := acfs.ReadStreamHeader(pipeReader)
+ if err != nil {
+ _ = pipeReader.CloseWithError(err)
+ execErr := <-done
+ cleanup()
+ if execErr != nil {
+ return nil, 0, execErr
+ }
+ return nil, 0, errors.WrapIf(err, "parse volume workspace read header")
+ }
+ if payloadSize > uint64(1<<63-1) {
+ _ = pipeReader.Close()
+ <-done
+ cleanup()
+ return nil, 0, errors.New("volume workspace file is too large")
+ }
+ size := int64(payloadSize)
+ return &volumeWorkspaceReadStreamInternal{
+ pipe: pipeReader,
+ done: done,
+ cleanup: cleanup,
+ remaining: size,
+ }, size, nil
}
func (s *VolumeService) validateVolumeHelperSupportInternal(ctx context.Context, volumeName string) error {
@@ -396,6 +458,30 @@ func volumeWorkspaceFileContentResponseInternal(relativePath, kind string, size
}
func classifyVolumeWorkspaceExecErrorInternal(err error, stderr, fallbackContext string) error {
+ var response acfstypes.ErrorResponse
+ if decodeErr := json.Unmarshal([]byte(strings.TrimSpace(stderr)), &response); decodeErr == nil && response.Version == acfstypes.ProtocolVersion {
+ switch response.Code {
+ case acfstypes.ErrorInvalidPath, acfstypes.ErrorOutsideRoot, acfstypes.ErrorSymlink, acfstypes.ErrorSymlinkLoop:
+ return common.Classify(common.ErrVolumeWorkspaceForbidden, errors.New(response.Message))
+ case acfstypes.ErrorNotFound:
+ return common.Classify(common.ErrVolumeWorkspaceNotFound, errors.New("volume workspace file not found"))
+ case acfstypes.ErrorAlreadyExist:
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume workspace destination already exists"))
+ case acfstypes.ErrorNotDirectory:
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume workspace parent is not a directory"))
+ case acfstypes.ErrorNotFile:
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume workspace path is not a regular file"))
+ case acfstypes.ErrorNotEmpty:
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume directory is not empty; recursive delete is required"))
+ case acfstypes.ErrorIsDirectory:
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("path is a directory"))
+ case acfstypes.ErrorSizeMismatch, acfstypes.ErrorRootRemoval:
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New(response.Message))
+ case acfstypes.ErrorInternal:
+ return errors.WrapIf(err, fallbackContext)
+ }
+ }
+
message := stderr + " " + err.Error()
switch {
case strings.Contains(message, "ARCANE_SYMLINK"):
@@ -500,6 +586,9 @@ func (s *VolumeService) UpdateVolumeWorkspace(ctx context.Context, volumeName st
return nil, err
}
defer cleanup()
+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {
+ return nil, err
+ }
slog.DebugContext(ctx, "volume workspace mutation helper acquired", "volume", volumeName, "container_id", containerID, "dedicated", needsBackups, "duration", time.Since(helperStartedAt))
revisionScanStartedAt := time.Now()
@@ -540,11 +629,13 @@ func (s *VolumeService) UpdateVolumeWorkspace(ctx context.Context, volumeName st
slog.DebugContext(ctx, "volume workspace backup completed", "volume", volumeName, "scope_count", len(scope), "duration", time.Since(backupStartedAt))
applyStartedAt := time.Now()
- if err := applyVolumeWorkspaceChangesTransactionInternal(
+ if err := s.applyVolumeWorkspaceChangesInternal(
+ ctx,
+ dockerClient,
+ containerID,
+ volumeName,
manifest.FileChanges,
- func(index int, change volumetypes.WorkspaceFileChange) error {
- return s.applyVolumeWorkspaceChangeInternal(ctx, containerID, change, stagedFiles[index], volumeName)
- },
+ stagedFiles,
func() error { return s.restoreVolumeWorkspaceScopeInternal(ctx, containerID, backup) },
); err != nil {
return nil, err
@@ -591,7 +682,7 @@ func (s *VolumeService) stageVolumeWorkspaceChangesInternal(ctx context.Context,
}
stagedPath := fmt.Sprintf("/tmp/arcane-workspace/change-%d", index)
content := uploads[*change.UploadIndex]
- reader := io.NopCloser(strings.NewReader(string(content)))
+ reader := io.NopCloser(bytes.NewReader(content))
size := int64(len(content))
stagedFiles[index] = volumeWorkspaceStagedFileInternal{path: stagedPath, size: size}
stagedContents = append(stagedContents, volumeWorkspaceStagedContentInternal{
@@ -616,22 +707,138 @@ func validateVolumeWorkspaceRevisionInternal(expected, current string) error {
return nil
}
-func applyVolumeWorkspaceChangesTransactionInternal(
+func (s *VolumeService) applyVolumeWorkspaceChangesInternal(
+ ctx context.Context,
+ dockerClient *client.Client,
+ containerID string,
+ volumeName string,
changes []volumetypes.WorkspaceFileChange,
- apply func(int, volumetypes.WorkspaceFileChange) error,
+ stagedFiles map[int]volumeWorkspaceStagedFileInternal,
rollback func() error,
) error {
- for index, change := range changes {
- if err := apply(index, change); err != nil {
- if rollbackErr := rollback(); rollbackErr != nil {
- return stderrors.Join(err, errors.WrapIf(rollbackErr, "failed to roll back volume workspace"))
+ rollbackFailureInternal := func(applyErr error) error {
+ if rollbackErr := rollback(); rollbackErr != nil {
+ return stderrors.Join(applyErr, errors.WrapIf(rollbackErr, "failed to roll back volume workspace"))
+ }
+ return applyErr
+ }
+
+ for index := 0; index < len(changes); {
+ if changes[index].Operation == volumetypes.FileOpRestoreFile {
+ rel, _ := utils.NormalizeRelativePath(changes[index].RelativePath)
+ if err := s.restoreVolumeWorkspaceFileInternal(ctx, containerID, volumeName, changes[index].BackupID, rel); err != nil {
+ return rollbackFailureInternal(err)
}
- return err
+ index++
+ continue
+ }
+
+ end := index
+ for end < len(changes) && changes[end].Operation != volumetypes.FileOpRestoreFile {
+ end++
}
+ if err := s.executeVolumeWorkspaceACFSBatchInternal(ctx, dockerClient, containerID, changes[index:end], stagedFiles, index); err != nil {
+ return rollbackFailureInternal(err)
+ }
+ index = end
}
return nil
}
+func (s *VolumeService) executeVolumeWorkspaceACFSBatchInternal(
+ ctx context.Context,
+ dockerClient *client.Client,
+ containerID string,
+ changes []volumetypes.WorkspaceFileChange,
+ stagedFiles map[int]volumeWorkspaceStagedFileInternal,
+ startIndex int,
+) error {
+ applyChanges := make([]acfstypes.ApplyChange, 0, len(changes))
+ for offset, change := range changes {
+ applyChange, err := mapVolumeWorkspaceChangeToACFSInternal(change, stagedFiles[startIndex+offset])
+ if err != nil {
+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, err)
+ }
+ applyChanges = append(applyChanges, applyChange)
+ }
+
+ manifestContent, err := json.Marshal(acfstypes.ApplyManifest{
+ Version: acfstypes.ProtocolVersion,
+ Changes: applyChanges,
+ })
+ if err != nil {
+ return errors.WrapIf(err, "encode volume workspace apply manifest")
+ }
+ manifestName := fmt.Sprintf("manifest-%d.json", startIndex)
+ if err := s.copyVolumeWorkspaceFilesToContainerInternal(ctx, dockerClient, containerID, []volumeWorkspaceStagedContentInternal{{
+ name: manifestName,
+ content: io.NopCloser(bytes.NewReader(manifestContent)),
+ size: int64(len(manifestContent)),
+ }}); err != nil {
+ return err
+ }
+
+ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{
+ "acfs", "apply", "--root", "/volume", "--staging", "/tmp/arcane-workspace", "--manifest", manifestName,
+ })
+ if err != nil {
+ return classifyVolumeWorkspaceExecErrorInternal(err, stderr, "apply volume workspace changes")
+ }
+ var response acfstypes.ApplyResponse
+ if err := json.Unmarshal([]byte(stdout), &response); err != nil {
+ return errors.WrapIf(err, "parse volume workspace apply response")
+ }
+ if response.Version != acfstypes.ProtocolVersion || response.Applied != len(applyChanges) {
+ return errors.New("invalid volume workspace apply response")
+ }
+ return nil
+}
+
+func mapVolumeWorkspaceChangeToACFSInternal(change volumetypes.WorkspaceFileChange, staged volumeWorkspaceStagedFileInternal) (acfstypes.ApplyChange, error) {
+ relativePath, err := utils.NormalizeRelativePath(change.RelativePath)
+ if err != nil {
+ return acfstypes.ApplyChange{}, err
+ }
+ result := acfstypes.ApplyChange{Path: "/" + relativePath, Recursive: change.Recursive}
+ switch change.Operation {
+ case volumetypes.FileOpCreateFile:
+ result.Operation = acfstypes.ApplyCreateFile
+ result.StagedName = path.Base(staged.path)
+ result.Size = staged.size
+ case volumetypes.FileOpUpdateFile:
+ result.Operation = acfstypes.ApplyUpdateFile
+ result.StagedName = path.Base(staged.path)
+ result.Size = staged.size
+ case volumetypes.FileOpCreateFolder:
+ result.Operation = acfstypes.ApplyCreateFolder
+ result.Recursive = false
+ case volumetypes.FileOpRename:
+ newName, nameErr := utils.ValidateFileName(change.NewName)
+ if nameErr != nil {
+ return acfstypes.ApplyChange{}, nameErr
+ }
+ result.Operation = acfstypes.ApplyRename
+ result.TargetPath = "/" + path.Join(path.Dir(relativePath), newName)
+ result.Recursive = false
+ case volumetypes.FileOpMove:
+ parent := ""
+ if strings.TrimSpace(change.NewParentPath) != "" {
+ parent, err = utils.NormalizeRelativePath(change.NewParentPath)
+ if err != nil {
+ return acfstypes.ApplyChange{}, err
+ }
+ }
+ result.Operation = acfstypes.ApplyMove
+ result.TargetPath = "/" + path.Join(parent, path.Base(relativePath))
+ result.Recursive = false
+ case volumetypes.FileOpDelete:
+ result.Operation = acfstypes.ApplyDelete
+ default:
+ return acfstypes.ApplyChange{}, errors.Errorf("unsupported volume workspace operation %q", change.Operation)
+ }
+ return result, nil
+}
+
func validateVolumeWorkspaceFileChangeInternal(change volumetypes.WorkspaceFileChange) error {
if _, err := utils.NormalizeRelativePath(change.RelativePath); err != nil {
return errors.WrapIf(err, "invalid volume workspace path")
@@ -901,169 +1108,6 @@ for rel do rm -rf -- "/volume/$rel"; done`, "sh"}, removePaths...)
return nil
}
-const (
- volumeWorkspaceCreateFileScriptInternal = `set -e
-target="/volume/$1"
-parent=/volume
-case "$2" in '') ;; *) parent="/volume/$2" ;; esac
-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi
-if parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null); then
- case "$parent_mode" in
- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;
- d*) ;;
- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;
- esac
-fi
-mkdir -p -- "$parent"
-parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null) || { echo ARCANE_NOT_DIRECTORY >&2; exit 47; }
-case "$parent_mode" in
- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;
- d*) ;;
- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;
-esac
-umask 022
-set -C
-head -c "$4" "$3" > "$target"`
- volumeWorkspaceCreateFolderScriptInternal = `set -e
-target="/volume/$1"
-parent=/volume
-case "$2" in '') ;; *) parent="/volume/$2" ;; esac
-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi
-if parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null); then
- case "$parent_mode" in
- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;
- d*) ;;
- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;
- esac
-fi
-mkdir -p -- "$parent"
-parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null) || { echo ARCANE_NOT_DIRECTORY >&2; exit 47; }
-case "$parent_mode" in
- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;
- d*) ;;
- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;
-esac
-umask 022
-mkdir -m 0755 -- "$target"`
- volumeWorkspaceUpdateFileScriptInternal = `set -e
-target="/volume/$1"
-target_mode=$(stat -c '%A' -- "$target" 2>/dev/null) || { echo ARCANE_NOT_FOUND >&2; exit 44; }
-case "$target_mode" in
- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;
- -*) ;;
- *) echo ARCANE_NOT_FILE >&2; exit 46 ;;
-esac
-head -c "$3" "$2" > "$target"`
- volumeWorkspaceRenameScriptInternal = `set -e
-source="/volume/$1"
-target="/volume/$2"
-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi
-mv -- "$source" "$target"`
- volumeWorkspaceMoveScriptInternal = `set -e
-source="/volume/$1"
-parent="/volume/$2"
-target="/volume/$3"
-parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null) || { echo ARCANE_NOT_DIRECTORY >&2; exit 47; }
-case "$parent_mode" in d*) ;; *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;; esac
-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi
-mv -- "$source" "$target"`
- volumeWorkspaceDeleteScriptInternal = `set -e
-target="/volume/$1"
-case "$2" in
- 1) rm -rf -- "$target" ;;
- *)
- target_mode=$(stat -c '%A' -- "$target" 2>/dev/null) || { echo ARCANE_NOT_FOUND >&2; exit 44; }
- case "$target_mode" in
- d*) if ! rmdir -- "$target"; then echo ARCANE_NOT_EMPTY >&2; exit 48; fi ;;
- *) rm -- "$target" ;;
- esac
- ;;
-esac`
-)
-
-func (s *VolumeService) applyVolumeWorkspaceChangeInternal(ctx context.Context, containerID string, change volumetypes.WorkspaceFileChange, stagedFile volumeWorkspaceStagedFileInternal, volumeName string) error {
- rel, _ := utils.NormalizeRelativePath(change.RelativePath)
- if change.Operation == volumetypes.FileOpRestoreFile {
- return s.restoreVolumeWorkspaceFileInternal(ctx, containerID, volumeName, change.BackupID, rel)
- }
- cmd, err := s.volumeWorkspaceMutationCommandInternal(ctx, containerID, change, stagedFile, rel)
- if err != nil {
- return err
- }
- _, stderr, err := s.execInContainerInternal(ctx, containerID, cmd)
- if err != nil {
- return classifyVolumeWorkspaceExecErrorInternal(err, stderr, "apply volume workspace change")
- }
- if strings.TrimSpace(stderr) != "" {
- slog.DebugContext(ctx, "volume workspace change stderr", "operation", change.Operation, "path", rel, "stderr", strings.TrimSpace(stderr))
- }
- return nil
-}
-
-func (s *VolumeService) volumeWorkspaceMutationCommandInternal(ctx context.Context, containerID string, change volumetypes.WorkspaceFileChange, stagedFile volumeWorkspaceStagedFileInternal, rel string) ([]string, error) {
- var cmd []string
- parent := path.Dir(rel)
- if parent == "." {
- parent = ""
- }
- switch change.Operation {
- case volumetypes.FileOpCreateFile:
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, true); err != nil {
- return nil, err
- }
- cmd = []string{"sh", "-c", volumeWorkspaceCreateFileScriptInternal, "sh", rel, parent, stagedFile.path, strconv.FormatInt(stagedFile.size, 10)}
- case volumetypes.FileOpCreateFolder:
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, true); err != nil {
- return nil, err
- }
- cmd = []string{"sh", "-c", volumeWorkspaceCreateFolderScriptInternal, "sh", rel, parent}
- case volumetypes.FileOpUpdateFile:
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {
- return nil, err
- }
- cmd = []string{"sh", "-c", volumeWorkspaceUpdateFileScriptInternal, "sh", rel, stagedFile.path, strconv.FormatInt(stagedFile.size, 10)}
- case volumetypes.FileOpRename:
- newName, _ := utils.ValidateFileName(change.NewName)
- target := path.Join(path.Dir(rel), newName)
- if target == rel {
- return nil, common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("new name must change the file path"))
- }
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {
- return nil, err
- }
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, target, true); err != nil {
- return nil, err
- }
- cmd = []string{"sh", "-c", volumeWorkspaceRenameScriptInternal, "sh", rel, target}
- case volumetypes.FileOpMove:
- parent = ""
- if strings.TrimSpace(change.NewParentPath) != "" {
- parent, _ = utils.NormalizeRelativePath(change.NewParentPath)
- }
- target := path.Join(parent, path.Base(rel))
- if target == rel || (parent != "" && utils.FilePathMatches(parent, rel)) {
- return nil, common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("invalid move destination"))
- }
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {
- return nil, err
- }
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, target, true); err != nil {
- return nil, err
- }
- cmd = []string{"sh", "-c", volumeWorkspaceMoveScriptInternal, "sh", rel, parent, target}
- case volumetypes.FileOpDelete:
- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {
- return nil, err
- }
- recursive := "0"
- if change.Recursive {
- recursive = "1"
- }
- cmd = []string{"sh", "-c", volumeWorkspaceDeleteScriptInternal, "sh", rel, recursive}
- }
- return cmd, nil
-}
-
func (s *VolumeService) restoreVolumeWorkspaceFileInternal(ctx context.Context, containerID, volumeName, backupID, rel string) error {
if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, true); err != nil {
return err
diff --git a/backend/internal/volume/workspace_test.go b/backend/internal/volume/workspace_test.go
index d19997f2a..87f6f3ec8 100644
--- a/backend/internal/volume/workspace_test.go
+++ b/backend/internal/volume/workspace_test.go
@@ -2,8 +2,8 @@ package volume
import (
"archive/tar"
+ "bytes"
"context"
- "encoding/base64"
"encoding/binary"
"encoding/json"
"errors"
@@ -14,6 +14,7 @@ import (
"net/http/httptest"
"os"
"os/exec"
+ "slices"
"strconv"
"strings"
"testing"
@@ -30,6 +31,8 @@ import (
"github.com/moby/moby/api/types/volume"
"github.com/moby/moby/client"
"github.com/stretchr/testify/require"
+ "go.getarcane.app/acfs"
+ acfstypes "go.getarcane.app/acfs/types"
)
func newVolumeWorkspaceTestDockerClientInternal(t *testing.T, server *httptest.Server) *client.Client {
@@ -168,27 +171,34 @@ func TestDownloadVolumeWorkspaceFileHoldsReadLockUntilClosed(t *testing.T) {
"Id": "helper",
"State": map[string]any{"Running": true},
})
- case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/helper/archive"):
- w.Header().Set("Content-Type", "application/x-tar")
- content := []byte("content")
- stat, err := json.Marshal(container.PathStat{Name: "file.txt", Size: int64(len(content)), Mode: 0o600})
- if err != nil {
- t.Errorf("marshal download path stat: %v", err)
- return
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/helper/exec"):
+ var request struct {
+ Cmd []string `json:"Cmd"`
}
- w.Header().Set("X-Docker-Container-Path-Stat", base64.StdEncoding.EncodeToString(stat))
- tarWriter := tar.NewWriter(w)
- if err := tarWriter.WriteHeader(&tar.Header{Name: "file.txt", Mode: 0o600, Size: int64(len(content))}); err != nil {
- t.Errorf("write download header: %v", err)
+ if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+ t.Errorf("decode exec request: %v", err)
return
}
- if _, err := tarWriter.Write(content); err != nil {
- t.Errorf("write download content: %v", err)
+ wantCommand := []string{"acfs", "read", "--root", "/volume", "--path", "/file.txt"}
+ if !slices.Equal(request.Cmd, wantCommand) {
+ t.Errorf("unexpected read command: %v", request.Cmd)
return
}
- if err := tarWriter.Close(); err != nil {
- t.Errorf("close download archive: %v", err)
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]string{"Id": "read-exec"})
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/exec/read-exec/start"):
+ _, _ = io.Copy(io.Discard, r.Body)
+ content := []byte("content")
+ var output bytes.Buffer
+ if err := acfs.WriteStreamHeader(&output, uint64(len(content))); err != nil {
+ t.Errorf("write ACFS stream header: %v", err)
+ return
}
+ _, _ = output.Write(content)
+ writeDockerExecAttachResponseInternal(t, w, output.String())
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/exec/read-exec/json"):
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]any{"Running": false, "ExitCode": 0})
default:
http.Error(w, "unexpected Docker request: "+r.Method+" "+r.URL.Path, http.StatusInternalServerError)
}
@@ -198,7 +208,7 @@ func TestDownloadVolumeWorkspaceFileHoldsReadLockUntilClosed(t *testing.T) {
service := &VolumeService{
dockerService: docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newVolumeWorkspaceTestDockerClientInternal(t, server)),
helperByVolume: map[string]*volumeHelper{
- "workspace-volume": {id: "helper", lastUsedAt: time.Now()},
+ "workspace-volume": {id: "helper", lastUsedAt: time.Now(), protocol: acfstypes.ProtocolVersion},
},
}
reader, size, err := service.DownloadVolumeWorkspaceFile(context.Background(), "workspace-volume", "file.txt")
@@ -217,115 +227,6 @@ func TestDownloadVolumeWorkspaceFileHoldsReadLockUntilClosed(t *testing.T) {
unlockMutation()
}
-func volumeWorkspaceTreeRecordInternal(relativePath, kind, size, modTime, mode, linkTarget string) string {
- return strings.Join([]string{relativePath, kind, size, modTime, mode, linkTarget}, "\x00") + "\x00"
-}
-
-func volumeWorkspaceTreeOutputInternal(truncated bool, records string) string {
- marker := "0"
- if truncated {
- marker = "1"
- }
- return records + "ARCANE_TREE_END\x00" + marker + "\x00"
-}
-
-func TestParseVolumeWorkspaceTreeInternalSortsAndClassifiesFromMode(t *testing.T) {
- stdout := volumeWorkspaceTreeOutputInternal(false,
- volumeWorkspaceTreeRecordInternal("z.txt", "d", "4", "1700000000.25", "-rw-r--r--", "")+
- volumeWorkspaceTreeRecordInternal("folder/link", "f", "7", "1700000001.5", "lrwxrwxrwx", "../z.txt")+
- volumeWorkspaceTreeRecordInternal("folder/child.txt", "d", "5", "1700000001.75", "-rw-r--r--", "")+
- volumeWorkspaceTreeRecordInternal("folder", "f", "4096", "1700000002", "drwxr-xr-x", "")+
- volumeWorkspaceTreeRecordInternal("empty", "f", "4096", "1700000003", "drwx------", "")+
- volumeWorkspaceTreeRecordInternal("special", "f", "0", "1700000004", "prw-------", ""))
-
- workspace, err := parseVolumeWorkspaceTreeInternal(stdout, 10)
- require.NoError(t, err)
- require.False(t, workspace.FileTreeTruncated)
- require.Equal(t, []string{"empty", "folder", "folder/child.txt", "folder/link", "special", "z.txt"}, []string{
- workspace.Files[0].RelativePath,
- workspace.Files[1].RelativePath,
- workspace.Files[2].RelativePath,
- workspace.Files[3].RelativePath,
- workspace.Files[4].RelativePath,
- workspace.Files[5].RelativePath,
- })
- require.Zero(t, workspace.Files[0].Size)
- require.Zero(t, workspace.Files[1].Size)
- require.True(t, workspace.Files[0].IsDirectory)
- require.True(t, workspace.Files[1].IsDirectory)
- require.False(t, workspace.Files[2].IsDirectory)
- require.False(t, workspace.Files[3].IsDirectory)
- require.False(t, workspace.Files[4].IsDirectory)
- require.False(t, workspace.Files[5].IsDirectory)
- require.True(t, workspace.Files[3].IsSymlink)
- require.Equal(t, "../z.txt", workspace.Files[3].LinkTarget)
- require.NotEmpty(t, workspace.FileTreeRevision)
-
- reordered, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,
- volumeWorkspaceTreeRecordInternal("empty", "d", "4096", "1700000003", "drwx------", "")+
- volumeWorkspaceTreeRecordInternal("folder", "d", "4096", "1700000002", "drwxr-xr-x", "")+
- volumeWorkspaceTreeRecordInternal("folder/child.txt", "f", "5", "1700000001.75", "-rw-r--r--", "")+
- volumeWorkspaceTreeRecordInternal("z.txt", "f", "4", "1700000000.25", "-rw-r--r--", "")+
- volumeWorkspaceTreeRecordInternal("special", "s", "0", "1700000004", "prw-------", "")+
- volumeWorkspaceTreeRecordInternal("folder/link", "l", "7", "1700000001.5", "lrwxrwxrwx", "../z.txt")), 10)
- require.NoError(t, err)
- require.Equal(t, workspace.FileTreeRevision, reordered.FileTreeRevision)
-}
-
-func TestParseVolumeWorkspaceTreeInternalFallsBackToKindWithoutMode(t *testing.T) {
- workspace, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,
- volumeWorkspaceTreeRecordInternal("folder", "d", "4096", "1", "", "")+
- volumeWorkspaceTreeRecordInternal("link", "l", "3", "2", "", "folder")+
- volumeWorkspaceTreeRecordInternal("regular", "f", "4", "3", "", "")), 10)
- require.NoError(t, err)
- require.True(t, workspace.Files[0].IsDirectory)
- require.Zero(t, workspace.Files[0].Size)
- require.True(t, workspace.Files[1].IsSymlink)
-
- special, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,
- volumeWorkspaceTreeRecordInternal("folder", "d", "4096", "1", "", "")+
- volumeWorkspaceTreeRecordInternal("link", "l", "3", "2", "", "folder")+
- volumeWorkspaceTreeRecordInternal("regular", "s", "4", "3", "", "")), 10)
- require.NoError(t, err)
- require.NotEqual(t, workspace.FileTreeRevision, special.FileTreeRevision)
-}
-
-func TestParseVolumeWorkspaceTreeInternalReportsBothLimits(t *testing.T) {
- entries := volumeWorkspaceTreeRecordInternal("b", "f", "1", "1", "-rw-r--r--", "") +
- volumeWorkspaceTreeRecordInternal("a", "f", "1", "1", "-rw-r--r--", "")
-
- depthLimited, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(true, entries), 10)
- require.NoError(t, err)
- require.True(t, depthLimited.FileTreeTruncated)
-
- entryLimited, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false, entries), 1)
- require.NoError(t, err)
- require.True(t, entryLimited.FileTreeTruncated)
- require.Len(t, entryLimited.Files, 1)
- require.Equal(t, "a", entryLimited.Files[0].RelativePath)
-
- _, err = parseVolumeWorkspaceTreeInternal(entries+"invalid\x000\x00", 10)
- require.Error(t, err)
-}
-
-func TestParseVolumeWorkspaceModTimeInternalPreservesNanoseconds(t *testing.T) {
- modTime, err := parseVolumeWorkspaceModTimeInternal("2026-08-02 16:09:00.123456789 +0000")
- require.NoError(t, err)
- require.Equal(t, 123456789, modTime.Nanosecond())
-}
-
-func TestParseVolumeWorkspaceTreeInternalPreservesUnusualNamesAndSpecialFiles(t *testing.T) {
- workspace, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,
- volumeWorkspaceTreeRecordInternal(".hidden", "f", "1", "1", "-rw-r--r--", "")+
- volumeWorkspaceTreeRecordInternal("line\nbreak", "s", "0", "2", "prw-------", "")), 10)
- require.NoError(t, err)
- require.Equal(t, []string{".hidden", "line\nbreak"}, []string{
- workspace.Files[0].RelativePath,
- workspace.Files[1].RelativePath,
- })
- require.NotEmpty(t, workspace.FileTreeRevision)
-}
-
func TestVolumeWorkspaceFileContentResponseInternal(t *testing.T) {
const maxFileSizeBytes int64 = 10 * 1024 * 1024
text := []byte("hello")
@@ -418,15 +319,8 @@ func TestVolumeWorkspaceRollbackPathsInternalRemovesDeepestFirst(t *testing.T) {
func TestVolumeWorkspaceHelperScriptsUseSupportedTooling(t *testing.T) {
helperScripts := []string{
- volumeWorkspaceTreeScriptInternal,
volumeWorkspaceValidatePathScriptInternal,
volumeWorkspaceBackupCreateScriptInternal,
- volumeWorkspaceCreateFileScriptInternal,
- volumeWorkspaceCreateFolderScriptInternal,
- volumeWorkspaceUpdateFileScriptInternal,
- volumeWorkspaceRenameScriptInternal,
- volumeWorkspaceMoveScriptInternal,
- volumeWorkspaceDeleteScriptInternal,
restoreBackupFilesScriptInternal,
}
scripts := strings.Join(helperScripts, "\n")
@@ -449,9 +343,6 @@ func TestVolumeWorkspaceHelperScriptsUseSupportedTooling(t *testing.T) {
} {
require.NotContains(t, scripts, unsupported)
}
- require.Contains(t, volumeWorkspaceCreateFileScriptInternal, "head -c")
- require.Contains(t, volumeWorkspaceCreateFolderScriptInternal, "mkdir -m 0755")
- require.Contains(t, volumeWorkspaceUpdateFileScriptInternal, "head -c")
require.Contains(t, volumeWorkspaceBackupCreateScriptInternal, `printf 'absent\0%s\0'`)
require.Contains(t, volumeWorkspaceBackupCreateScriptInternal, `cd "$parent"`)
require.NotContains(t, volumeWorkspaceBackupCreateScriptInternal, " -C ")
@@ -594,11 +485,15 @@ func TestUpdateVolumeWorkspaceRejectsStaleRevisionBeforeStaging(t *testing.T) {
}
execCommands = append(execCommands, request.Cmd)
w.Header().Set("Content-Type", "application/json")
- _ = json.NewEncoder(w).Encode(map[string]string{"Id": "tree-exec"})
- case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/exec/tree-exec/start"):
+ _ = json.NewEncoder(w).Encode(map[string]string{"Id": fmt.Sprintf("workspace-exec-%d", len(execCommands)-1)})
+ case r.Method == http.MethodPost && strings.Contains(r.URL.Path, "/exec/workspace-exec-") && strings.HasSuffix(r.URL.Path, "/start"):
_, _ = io.Copy(io.Discard, r.Body)
- writeDockerExecAttachResponseInternal(t, w, volumeWorkspaceTreeOutputInternal(false, ""))
- case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/exec/tree-exec/json"):
+ output := "{\"version\":\"0.2.0\",\"revision\":\"test\",\"buildTime\":\"test\",\"protocol\":2}\n"
+ if strings.Contains(r.URL.Path, "workspace-exec-1") {
+ output = "{\"end\":true,\"version\":2}\n"
+ }
+ writeDockerExecAttachResponseInternal(t, w, output)
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/exec/workspace-exec-") && strings.HasSuffix(r.URL.Path, "/json"):
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{"Running": false, "ExitCode": 0})
case r.Method == http.MethodPut && strings.HasSuffix(r.URL.Path, "/containers/helper/archive"):
@@ -627,8 +522,9 @@ func TestUpdateVolumeWorkspaceRejectsStaleRevisionBeforeStaging(t *testing.T) {
require.Nil(t, workspace)
require.ErrorIs(t, err, common.ErrVolumeWorkspaceConflict)
- require.Len(t, execCommands, 1)
- require.Contains(t, execCommands[0], volumeWorkspaceTreeScriptInternal)
+ require.Len(t, execCommands, 2)
+ require.Equal(t, []string{"acfs", "version"}, execCommands[0])
+ require.Equal(t, []string{"acfs", "walk", "--root", "/volume", "--path", "/", "--max-depth", "50", "--max-entries", "10000"}, execCommands[1])
require.Zero(t, archiveCopies)
}
@@ -695,43 +591,6 @@ func TestCreateVolumeWorkspaceMutationContainerUsesDedicatedBackupHelper(t *test
require.Equal(t, 1, removeCalls)
}
-func TestApplyVolumeWorkspaceChangesTransactionInternalRollsBackEveryMutationStage(t *testing.T) {
- changes := []volumetypes.WorkspaceFileChange{
- {Operation: volumetypes.FileOpCreateFolder, RelativePath: "one"},
- {Operation: volumetypes.FileOpRename, RelativePath: "one", NewName: "two"},
- {Operation: volumetypes.FileOpDelete, RelativePath: "two", Recursive: true},
- }
- applyFailure := errors.New("apply failed")
- for failureIndex := range changes {
- t.Run(changes[failureIndex].Operation, func(t *testing.T) {
- applied := make([]int, 0, failureIndex+1)
- rollbackCalls := 0
- err := applyVolumeWorkspaceChangesTransactionInternal(changes, func(index int, _ volumetypes.WorkspaceFileChange) error {
- applied = append(applied, index)
- if index == failureIndex {
- return applyFailure
- }
- return nil
- }, func() error {
- rollbackCalls++
- return nil
- })
- require.ErrorIs(t, err, applyFailure)
- require.Equal(t, failureIndex+1, len(applied))
- require.Equal(t, 1, rollbackCalls)
- })
- }
-
- rollbackFailure := errors.New("rollback failed")
- err := applyVolumeWorkspaceChangesTransactionInternal(changes, func(_ int, _ volumetypes.WorkspaceFileChange) error {
- return applyFailure
- }, func() error {
- return rollbackFailure
- })
- require.ErrorIs(t, err, applyFailure)
- require.ErrorIs(t, err, rollbackFailure)
-}
-
func TestVolumeWorkspaceScriptsAgainstToolsImage(t *testing.T) {
if os.Getenv("ARCANE_VOLUME_WORKSPACE_DOCKER_TEST") != "1" {
t.Skip("set ARCANE_VOLUME_WORKSPACE_DOCKER_TEST=1 to run the helper image integration test")
@@ -766,41 +625,29 @@ func TestVolumeWorkspaceScriptsAgainstToolsImage(t *testing.T) {
printf child > /volume/folder/nested/child.txt
printf hidden > /volume/.hidden
printf alpha > /volume/z.txt`)
- treeOutput := runInVolume(volumeName, `sh -c "$1" sh "$2" "$3"`, volumeWorkspaceTreeScriptInternal, strings.Repeat("d", 5), strings.Repeat("e", 100))
- workspace, err := parseVolumeWorkspaceTreeInternal(treeOutput, 100)
- require.NoError(t, err)
- require.Equal(t, []string{"folder", "folder/nested", ".hidden", "folder/nested/child.txt", "z.txt"}, []string{
- workspace.Files[0].RelativePath,
- workspace.Files[1].RelativePath,
- workspace.Files[2].RelativePath,
- workspace.Files[3].RelativePath,
- workspace.Files[4].RelativePath,
- })
- require.True(t, workspace.Files[0].IsDirectory)
- require.True(t, workspace.Files[1].IsDirectory)
- require.False(t, workspace.Files[2].IsDirectory)
- require.False(t, workspace.Files[3].IsDirectory)
- require.False(t, workspace.Files[4].IsDirectory)
-
- runInVolume(volumeName, `sh -c "$1" sh folder/nested/child.txt 0`, volumeWorkspaceValidatePathScriptInternal)
- runInVolume(volumeName, `sh -c "$1" sh missing/path 1`, volumeWorkspaceValidatePathScriptInternal)
- runInVolume(volumeName, `sh -c "$1" sh nested ''`, volumeWorkspaceCreateFolderScriptInternal)
- runInVolume(volumeName, `printf one > /tmp/staged
-sh -c "$1" sh nested/a.txt nested /tmp/staged 3`, volumeWorkspaceCreateFileScriptInternal)
+ treeOutput := runInVolume(volumeName, `acfs walk --root /volume --path / --max-depth 5 --max-entries 100`)
+ require.Contains(t, treeOutput, `"path":"/folder/nested/child.txt"`)
+ require.Contains(t, treeOutput, `"path":"/.hidden"`)
+ require.Contains(t, treeOutput, `"end":true`)
+
+ runInVolume(volumeName, `set -e
+mkdir -p /tmp/staging
+printf one > /tmp/staging/change-0
+printf '%s' '{"changes":[{"operation":"create_folder","path":"/nested"},{"operation":"create_file","path":"/nested/a.txt","stagedName":"change-0","size":3}],"version":2}' > /tmp/staging/manifest.json
+acfs apply --root /volume --staging /tmp/staging --manifest manifest.json >/dev/null`)
require.Equal(t, "644 3\n", runInVolume(volumeName, `stat -c '%a %s' /volume/nested/a.txt`))
- runInVolume(volumeName, `printf updated > /tmp/staged
-sh -c "$1" sh nested/a.txt /tmp/staged 7`, volumeWorkspaceUpdateFileScriptInternal)
- require.Equal(t, "updated", runInVolume(volumeName, `head -c 7 /volume/nested/a.txt`))
-
- runInVolume(volumeName, `sh -c "$1" sh nested/a.txt nested/b.txt`, volumeWorkspaceRenameScriptInternal)
- runInVolume(volumeName, `sh -c "$1" sh dest ''`, volumeWorkspaceCreateFolderScriptInternal)
- runInVolume(volumeName, `sh -c "$1" sh nested/b.txt dest dest/b.txt`, volumeWorkspaceMoveScriptInternal)
+ runInVolume(volumeName, `set -e
+mkdir -p /tmp/staging
+printf updated > /tmp/staging/change-0
+printf '%s' '{"changes":[{"operation":"update_file","path":"/nested/a.txt","stagedName":"change-0","size":7},{"operation":"rename","path":"/nested/a.txt","targetPath":"/nested/b.txt"},{"operation":"create_folder","path":"/dest"},{"operation":"move","path":"/nested/b.txt","targetPath":"/dest/b.txt"}],"version":2}' > /tmp/staging/manifest.json
+acfs apply --root /volume --staging /tmp/staging --manifest manifest.json >/dev/null`)
+ require.Equal(t, "updated", runInVolume(volumeName, `head -c 7 /volume/dest/b.txt`))
restored := runInVolume(volumeName, `set -e
sh -c "$1" sh dest/b.txt /tmp/backup.tar >/dev/null
-sh -c "$2" sh dest/b.txt 0
+acfs remove --root /volume --path /dest/b.txt
tar -xf /tmp/backup.tar -C /volume/dest
-head -c 7 /volume/dest/b.txt`, volumeWorkspaceBackupCreateScriptInternal, volumeWorkspaceDeleteScriptInternal)
+head -c 7 /volume/dest/b.txt`, volumeWorkspaceBackupCreateScriptInternal)
require.Equal(t, "updated", restored)
runInVolume(volumeName, `mkdir -p "/volume/Test Folder"
diff --git a/backend/pkg/libarcane/volumehelper/container_files.go b/backend/pkg/libarcane/volumehelper/container_files.go
index 9e6cc1780..82050fe5d 100644
--- a/backend/pkg/libarcane/volumehelper/container_files.go
+++ b/backend/pkg/libarcane/volumehelper/container_files.go
@@ -4,13 +4,9 @@ import (
"archive/tar"
"context"
"io"
- "strings"
"emperror.dev/errors"
- "github.com/moby/moby/api/types/container"
"github.com/moby/moby/client"
-
- "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
)
type cleanupReadCloserInternal struct {
@@ -20,36 +16,6 @@ type cleanupReadCloserInternal struct {
cleanup func()
}
-func IsLegacyHelperContainer(c container.Summary) bool {
- if !libarcane.IsInternalContainer(c.Labels) {
- return false
- }
-
- command := strings.ToLower(c.Command)
- if !strings.Contains(command, "sleep") || !strings.Contains(command, "infinity") {
- return false
- }
-
- for _, m := range c.Mounts {
- if m.Destination == "/volume" {
- return true
- }
- }
-
- return false
-}
-
-func IsHelperContainer(c container.Summary) bool {
- if IsLegacyHelperContainer(c) {
- return true
- }
- if !libarcane.IsInternalContainer(c.Labels) {
- return false
- }
-
- return strings.EqualFold(c.Labels[ContainerLabel], "true")
-}
-
func (c *cleanupReadCloserInternal) Close() error {
err := c.Closer.Close()
c.cleanup()
diff --git a/backend/pkg/libarcane/volumehelper/container_files_test.go b/backend/pkg/libarcane/volumehelper/container_files_test.go
index e28932a61..e693fb7c5 100644
--- a/backend/pkg/libarcane/volumehelper/container_files_test.go
+++ b/backend/pkg/libarcane/volumehelper/container_files_test.go
@@ -4,10 +4,7 @@ import (
"archive/tar"
"testing"
- "github.com/moby/moby/api/types/container"
"github.com/stretchr/testify/require"
-
- "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
)
func TestValidateDownloadHeaderInternalRejectsDirectories(t *testing.T) {
@@ -16,94 +13,3 @@ func TestValidateDownloadHeaderInternalRejectsDirectories(t *testing.T) {
require.NoError(t, validateDownloadHeaderInternal(&tar.Header{Typeflag: tar.TypeSymlink, Mode: 0o777}))
require.NoError(t, validateDownloadHeaderInternal(&tar.Header{Typeflag: tar.TypeFifo, Mode: 0o644}))
}
-
-func TestIsLegacyVolumeHelperContainerInternal(t *testing.T) {
- tests := []struct {
- name string
- summary container.Summary
- want bool
- }{
- {
- name: "legacy helper signature matches",
- summary: container.Summary{
- Labels: map[string]string{
- libarcane.InternalResourceLabel: "true",
- },
- Command: "sleep infinity",
- Mounts: []container.MountPoint{
- {Destination: "/volume"},
- },
- },
- want: true,
- },
- {
- name: "internal trivy-like helper is not treated as legacy volume helper",
- summary: container.Summary{
- Labels: map[string]string{
- libarcane.InternalResourceLabel: "true",
- },
- Command: "trivy image --quiet alpine:latest",
- Mounts: []container.MountPoint{
- {Destination: "/var/run/docker.sock"},
- },
- },
- want: false,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- require.Equal(t, tt.want, IsLegacyHelperContainer(tt.summary))
- })
- }
-}
-
-func TestIsVolumeHelperContainerInternal_UsesExplicitHelperLabel(t *testing.T) {
- tests := []struct {
- name string
- summary container.Summary
- want bool
- }{
- {
- name: "new helper label matches",
- summary: container.Summary{
- Labels: map[string]string{
- libarcane.InternalResourceLabel: "true",
- ContainerLabel: "true",
- },
- },
- want: true,
- },
- {
- name: "generic internal volume mount does not match",
- summary: container.Summary{
- Labels: map[string]string{
- libarcane.InternalResourceLabel: "true",
- },
- Mounts: []container.MountPoint{
- {Destination: "/volume"},
- },
- },
- want: false,
- },
- {
- name: "legacy helper still matches",
- summary: container.Summary{
- Labels: map[string]string{
- libarcane.InternalResourceLabel: "true",
- },
- Command: "sleep infinity",
- Mounts: []container.MountPoint{
- {Destination: "/volume"},
- },
- },
- want: true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- require.Equal(t, tt.want, IsHelperContainer(tt.summary))
- })
- }
-}
diff --git a/backend/pkg/projects/includes.go b/backend/pkg/projects/includes.go
index 04a28c303..81abdbafa 100644
--- a/backend/pkg/projects/includes.go
+++ b/backend/pkg/projects/includes.go
@@ -8,7 +8,6 @@ import (
"emperror.dev/errors"
- pkgutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
"github.com/samber/mo"
"go.yaml.in/yaml/v4"
)
@@ -29,7 +28,7 @@ func expandEnvVarsInternal(s string, envMap EnvMap) string {
// the compose file points at. Callers must validate containment and symlinks before
// reading include content or returning inc.Content to users.
// - WRITE/DELETE: Restricted to files within the project directory only for security.
-// Always go through ValidateIncludePathForWrite or WriteIncludeFile.
+// Always go through ValidateIncludePathForWrite.
type IncludeFile struct {
Path string `json:"path"`
@@ -338,30 +337,3 @@ func ValidateIncludePathForWrite(projectDir, includePath string) (string, error)
return absFullPath, nil
}
-
-// WriteIncludeFile writes content to an include file path
-func WriteIncludeFile(projectDir, includePath, content string) error {
- // Get validated absolute path - only allows writes within project
- validatedPath, err := ValidateIncludePathForWrite(projectDir, includePath)
- if err != nil {
- return err
- }
-
- dir := filepath.Dir(validatedPath)
- if dir == "" || dir == "." {
- return errors.Errorf("invalid include path: cannot create directory '%s'", dir)
- }
-
- // Only create directory if it doesn't exist
- if _, err := os.Stat(dir); errors.Is(err, os.ErrNotExist) {
- if err := os.MkdirAll(dir, pkgutils.DirPerm); err != nil {
- return errors.WrapIf(err, "failed to create directory")
- }
- }
-
- if err := os.WriteFile(validatedPath, []byte(content), pkgutils.FilePerm); err != nil {
- return errors.WrapIf(err, "failed to write include file")
- }
-
- return nil
-}
diff --git a/backend/pkg/projects/includes_test.go b/backend/pkg/projects/includes_test.go
index 026853355..2a52d497b 100644
--- a/backend/pkg/projects/includes_test.go
+++ b/backend/pkg/projects/includes_test.go
@@ -6,8 +6,6 @@ import (
"runtime"
"testing"
- pkgutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
- "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -68,78 +66,7 @@ func TestParseIncludes_ExpandsArrayPathForm(t *testing.T) {
}
-func TestWriteIncludeFilePermissions(t *testing.T) {
- // Save original perms
- origFilePerm := pkgutils.FilePerm
- origDirPerm := pkgutils.DirPerm
- defer func() {
- pkgutils.FilePerm = origFilePerm
- pkgutils.DirPerm = origDirPerm
- }()
-
- projectDir := t.TempDir()
- includePath := filepath.Join("includes", "config.yaml")
- content := "services: {}\n"
-
- t.Run("Uses custom permissions", func(t *testing.T) {
- pkgutils.FilePerm = 0o600
- pkgutils.DirPerm = 0o700
- {
-
- err := WriteIncludeFile(projectDir, includePath, content)
- require.NoError(t, err,
- "WriteIncludeFile() returned error: %v", err)
- }
-
- targetPath := filepath.Join(projectDir, includePath)
- info, err := os.Stat(targetPath)
-
- require.NoError(t, err,
- "failed to stat include file: %v", err)
-
- // On Linux/macOS, we can check permissions. On Windows, it's more limited.
- if runtime.GOOS != "windows" {
-
- assert.Equal(t, os.FileMode(0o600), info.Mode().Perm(),
- "unexpected file permissions: got %o, want %o", info.Mode().Perm(), 0o600)
-
- dirInfo, err := os.Stat(filepath.Dir(targetPath))
-
- require.NoError(t, err,
- "failed to stat include directory: %v", err)
-
- assert.Equal(t, os.FileMode(0o700), dirInfo.Mode().Perm(),
- "unexpected directory permissions: got %o, want %o", dirInfo.Mode().Perm(), 0o700)
-
- }
- })
-}
-
-func TestWriteIncludeFileCreatesSafeDirectory(t *testing.T) {
- t.Parallel()
-
- projectDir := t.TempDir()
- includePath := filepath.Join("includes", "config.yaml")
- content := "services: {}\n"
- {
-
- err := WriteIncludeFile(projectDir, includePath, content)
- require.NoError(t, err,
- "WriteIncludeFile() returned error: %v", err)
- }
-
- targetPath := filepath.Join(projectDir, includePath)
- data, err := os.ReadFile(targetPath)
-
- require.NoError(t, err,
- "failed to read include file: %v", err)
-
- require.Equal(t, content, string(data),
- "unexpected file content: got %q, want %q", string(data), content)
-
-}
-
-func TestWriteIncludeFileRejectsSymlinkEscape(t *testing.T) {
+func TestValidateIncludePathForWriteRejectsSymlinkEscape(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("symlink creation requires elevated privileges on Windows")
}
@@ -149,16 +76,9 @@ func TestWriteIncludeFileRejectsSymlinkEscape(t *testing.T) {
outsideDir := t.TempDir()
linkPath := filepath.Join(projectDir, "link")
- {
- err := os.Symlink(outsideDir, linkPath)
- require.NoError(t, err,
- "failed to create symlink: %v", err)
- }
+ require.NoError(t, os.Symlink(outsideDir, linkPath), "failed to create symlink")
includePath := filepath.Join("link", "escape.yaml")
- err := WriteIncludeFile(projectDir, includePath, "malicious: true\n")
-
- require.Error(t, err,
- "WriteIncludeFile() succeeded but expected rejection for symlink escape")
-
+ _, err := ValidateIncludePathForWrite(projectDir, includePath)
+ require.Error(t, err, "ValidateIncludePathForWrite() succeeded but expected rejection for symlink escape")
}
diff --git a/backend/pkg/utils/acfs/entry.go b/backend/pkg/utils/acfs/entry.go
new file mode 100644
index 000000000..dc92907d7
--- /dev/null
+++ b/backend/pkg/utils/acfs/entry.go
@@ -0,0 +1,35 @@
+// Package acfs maps ACFS protocol types to Arcane workspace contracts.
+package acfs
+
+import (
+ "strings"
+ "time"
+
+ "github.com/getarcaneapp/arcane/types/v2/workspace"
+ acfstypes "go.getarcane.app/acfs/types"
+)
+
+// FileEntry converts ACFS metadata to Arcane's shared workspace entry type.
+func FileEntry(entry acfstypes.Entry) workspace.FileEntry {
+ modTime := entry.ModTime
+ if entry.ModTimeUnixNano != 0 {
+ modTime = time.Unix(0, entry.ModTimeUnixNano)
+ }
+
+ return workspace.FileEntry{
+ ModTime: modTime,
+ Name: entry.Name,
+ Path: entry.Path,
+ RelativePath: entry.Path,
+ Mode: entry.Mode,
+ LinkTarget: entry.LinkTarget,
+ Size: entry.Size,
+ IsDirectory: entry.IsDirectory,
+ IsSymlink: entry.IsSymlink,
+ }
+}
+
+// IsRegular reports whether an ACFS entry describes a regular file.
+func IsRegular(entry acfstypes.Entry) bool {
+ return !entry.IsDirectory && !entry.IsSymlink && strings.HasPrefix(entry.Mode, "-")
+}
diff --git a/backend/pkg/utils/path_util.go b/backend/pkg/utils/path_util.go
index 9794911c6..e2aba30cf 100644
--- a/backend/pkg/utils/path_util.go
+++ b/backend/pkg/utils/path_util.go
@@ -1,15 +1,12 @@
package utils
import (
- "bytes"
"hash"
"io"
- "os"
"path"
"path/filepath"
"strconv"
"strings"
- "unicode/utf8"
"emperror.dev/errors"
)
@@ -69,10 +66,6 @@ func FilePathMatches(relativePath, rootPath string) bool {
return relativePath == rootPath || strings.HasPrefix(relativePath, rootPath+"/")
}
-func IsBinaryFileContent(content []byte) bool {
- return !utf8.Valid(content) || bytes.IndexByte(content, 0) >= 0
-}
-
func WriteFileTreeRevisionEntry(h hash.Hash, relativePath, kind string, size, modTimeUnixNano int64, mode string, protected bool) {
protectedFlag := ""
if protected {
@@ -90,50 +83,6 @@ func WriteFileTreeRevisionEntry(h hash.Hash, relativePath, kind string, size, mo
_, _ = h.Write([]byte{'\n'})
}
-// IsWithinRoot reports whether target is root or lies beneath it. Both paths are
-// cleaned first; neither is resolved, so this only proves the *spelling* of the
-// path stays inside root. Use ResolveWithinRoot when a symlink could redirect it.
-func IsWithinRoot(root, target string) bool {
- rootClean := filepath.Clean(root)
- targetClean := filepath.Clean(target)
- if targetClean == rootClean {
- return true
- }
- return strings.HasPrefix(targetClean, rootClean+string(os.PathSeparator))
-}
-
-// ResolveWithinRoot resolves symlinks in both root and target and returns the
-// resolved target, verifying it stays inside root. A target that does not exist
-// yet is allowed: its parent is resolved instead, so create/write paths work.
-//
-// This is the check that makes containment real. A lexical test alone accepts a
-// symlink that sits inside root but points at /etc, which is then read, written
-// or removed through as if it were an in-root file.
-func ResolveWithinRoot(root, target string) (string, error) {
- resolvedRoot, err := filepath.EvalSymlinks(filepath.Clean(root))
- if err != nil {
- return "", errors.WrapIff(err, "failed to resolve root directory %q", root)
- }
-
- cleanTarget := filepath.Clean(target)
- resolved, err := filepath.EvalSymlinks(cleanTarget)
- if err != nil {
- if !os.IsNotExist(err) {
- return "", errors.WrapIff(err, "failed to resolve path %q", target)
- }
- resolvedParent, parentErr := filepath.EvalSymlinks(filepath.Dir(cleanTarget))
- if parentErr != nil {
- return "", errors.WrapIff(parentErr, "failed to resolve parent directory of %q", target)
- }
- resolved = filepath.Join(resolvedParent, filepath.Base(cleanTarget))
- }
-
- if !IsWithinRoot(resolvedRoot, resolved) {
- return "", errors.Errorf("path %q resolves outside %q", target, root)
- }
- return resolved, nil
-}
-
// SanitizeBrowsePath normalizes a path within a rooted file browser.
func SanitizeBrowsePath(input string) (string, error) {
trimmed := strings.TrimSpace(input)
diff --git a/backend/pkg/utils/path_util_test.go b/backend/pkg/utils/path_util_test.go
index ae35aec8c..68ca74a37 100644
--- a/backend/pkg/utils/path_util_test.go
+++ b/backend/pkg/utils/path_util_test.go
@@ -3,7 +3,6 @@ package utils
import (
"crypto/sha256"
"encoding/hex"
- "strings"
"testing"
"github.com/stretchr/testify/require"
@@ -33,8 +32,6 @@ func TestFileTreeRevisionEntryIsStable(t *testing.T) {
h := sha256.New()
WriteFileTreeRevisionEntry(h, "folder/file.txt", "file", 12, 1234, "-rw-r--r--", false)
require.Equal(t, "95f6a8dc033860a753fee2a04a21580d43087967d732a717d3e7a18f88ea4f65", hex.EncodeToString(h.Sum(nil)))
- require.False(t, IsBinaryFileContent([]byte(strings.Repeat("a", 8))))
- require.True(t, IsBinaryFileContent([]byte{'a', 0, 'b'}))
}
func TestSanitizeBrowsePath(t *testing.T) {
diff --git a/go.work.sum b/go.work.sum
index adf0542da..76a383d33 100644
--- a/go.work.sum
+++ b/go.work.sum
@@ -2015,6 +2015,8 @@ go.etcd.io/gofail v0.2.0 h1:p19drv16FKK345a09a1iubchlw/vmRuksmRzgBIGjcA=
go.etcd.io/gofail v0.2.0/go.mod h1:nL3ILMGfkXTekKI3clMBNazKnjUZjYLKmBHzsVAnC1o=
go.etcd.io/raft/v3 v3.6.0 h1:5NtvbDVYpnfZWcIHgGRk9DyzkBIXOi8j+DDp1IcnUWQ=
go.etcd.io/raft/v3 v3.6.0/go.mod h1:nLvLevg6+xrVtHUmVaTcTz603gQPHfh7kUAwV6YpfGo=
+go.getarcane.app/acfs v0.2.0 h1:m7yXsLIB4MfsAE/AFP54RgtMXUr+AFEVCNiF5784XYI=
+go.getarcane.app/acfs v0.2.0/go.mod h1:sU3t21KctTsQM3OW10+RNB0Z6lR+YfaSr5Nxubq3cpI=
go.getarcane.app/updater v0.3.6 h1:+BqoycaRsHj+cLVSzcYQuqbHxUKbtmaozMNblz5bVSw=
go.getarcane.app/updater v0.3.6/go.mod h1:2ENitZR/lA5MuBn60OZYR5wvU3ZCE+pAgfrebfOlRDA=
go.getarcane.app/updater v0.3.7 h1:WqHsxudvt8gvCR7iSHdxdzwH0+hM0FAh64bSypBX9Mo=