Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
217 changes: 44 additions & 173 deletions pkg/config/pathmanager.go
Original file line number Diff line number Diff line change
Expand Up @@ -35,6 +35,17 @@ func homeOverrideDir(sub ...string) (string, bool, error) {
return dir, true, err
}

// joinUnder returns elems joined beneath the directory produced by parent.
// A parent error is returned unchanged.
func joinUnder(parent func() (string, error), elems ...string) (string, error) {
dir, err := parent()
if err != nil {
return "", err
}

return filepath.Join(append([]string{dir}, elems...)...), nil
}

// PathManager centralises filesystem paths. Layout:
//
// ConfigDir()/DataDir() (same directory today; both may be $DEVSY_HOME)
Expand Down Expand Up @@ -128,30 +139,15 @@ func (b *basePathManager) ConfigFilePath() (string, error) {
// --- Data sub-paths (context-relative) ---

func (b *basePathManager) ContextDir(context string) (string, error) {
dir, err := b.pm.DataDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "contexts", context), nil
return joinUnder(b.pm.DataDir, "contexts", context)
}

func (b *basePathManager) WorkspacesDir(context string) (string, error) {
dir, err := b.ContextDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, "workspaces"), nil
return b.inContext(context, "workspaces")
}

func (b *basePathManager) WorkspaceDir(context, workspaceID string) (string, error) {
dir, err := b.WorkspacesDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, workspaceID), nil
return b.inContext(context, "workspaces", workspaceID)
}

// WorkspaceAgentDir is where host-side `devsy internal agent workspace ...` invocations
Expand All @@ -160,252 +156,127 @@ func (b *basePathManager) WorkspaceDir(context, workspaceID string) (string, err
// agent invocations still resolve their home via FindAgentHomeDir and are
// unaffected.
func (b *basePathManager) WorkspaceAgentDir(context, workspaceID string) (string, error) {
dir, err := b.WorkspaceDir(context, workspaceID)
if err != nil {
return "", err
}

return filepath.Join(dir, "agent"), nil
return b.inContext(context, "workspaces", workspaceID, "agent")
}

// WorkspaceContentsDir is the per-context parent of workspace content folders.
// It is never removed on delete, keeping a stable host inode for the bind-mount
// source's parent across up -> delete -> up (avoids Docker Desktop's stale
// file-share inode cache).
func (b *basePathManager) WorkspaceContentsDir(context string) (string, error) {
dir, err := b.ContextDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, "contents"), nil
return b.inContext(context, "contents")
}

// WorkspaceContentDir is the bind-mount source leaf under WorkspaceContentsDir.
func (b *basePathManager) WorkspaceContentDir(context, workspaceID string) (string, error) {
dir, err := b.WorkspaceContentsDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, workspaceID), nil
return b.inContext(context, "contents", workspaceID)
}

// WorkspaceLogDir is the per-workspace log directory used by the desktop's
// streaming-log store. Lives under WorkspaceDir for the same reason as
// WorkspaceAgentDir.
func (b *basePathManager) WorkspaceLogDir(context, workspaceID string) (string, error) {
dir, err := b.WorkspaceDir(context, workspaceID)
if err != nil {
return "", err
}

return filepath.Join(dir, "logs"), nil
return b.inContext(context, "workspaces", workspaceID, "logs")
}

func (b *basePathManager) MachinesDir(context string) (string, error) {
dir, err := b.ContextDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, "machines"), nil
return b.inContext(context, "machines")
}

func (b *basePathManager) MachineDir(context, machineID string) (string, error) {
dir, err := b.MachinesDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, machineID), nil
return b.inContext(context, "machines", machineID)
}

func (b *basePathManager) ProvidersDir(context string) (string, error) {
dir, err := b.ContextDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, "providers"), nil
return b.inContext(context, "providers")
}

func (b *basePathManager) ProviderDir(context, providerName string) (string, error) {
dir, err := b.ProvidersDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, providerName), nil
return b.inContext(context, "providers", providerName)
}

func (b *basePathManager) ProviderBinariesDir(context, providerName string) (string, error) {
dir, err := b.ProviderDir(context, providerName)
if err != nil {
return "", err
}

return filepath.Join(dir, "binaries"), nil
return b.inContext(context, "providers", providerName, "binaries")
}

func (b *basePathManager) ProviderDaemonDir(context, providerName string) (string, error) {
dir, err := b.ProviderDir(context, providerName)
if err != nil {
return "", err
}

return filepath.Join(dir, "daemon"), nil
return b.inContext(context, "providers", providerName, "daemon")
}

func (b *basePathManager) ProInstancesDir(context string) (string, error) {
dir, err := b.ContextDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, "pro_instances"), nil
return b.inContext(context, "pro_instances")
}

func (b *basePathManager) ProInstanceDir(context, proInstanceHost string) (string, error) {
dir, err := b.ProInstancesDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, proInstanceHost), nil
return b.inContext(context, "pro_instances", proInstanceHost)
}

func (b *basePathManager) LocksDir(context string) (string, error) {
dir, err := b.ContextDir(context)
if err != nil {
return "", err
}

return filepath.Join(dir, "locks"), nil
return b.inContext(context, "locks")
}

// --- Cache sub-paths ---

func (b *basePathManager) AgentCacheDir() (string, error) {
dir, err := b.pm.CacheDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "agents"), nil
return joinUnder(b.pm.CacheDir, "agents")
}

func (b *basePathManager) ProviderDownloadCacheDir() (string, error) {
dir, err := b.pm.CacheDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "providers"), nil
return joinUnder(b.pm.CacheDir, "providers")
}

func (b *basePathManager) FeatureCacheDir(hashedID string) (string, error) {
dir, err := b.pm.CacheDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "features", hashedID), nil
return joinUnder(b.pm.CacheDir, "features", hashedID)
}

func (b *basePathManager) PlatformCacheDir() (string, error) {
dir, err := b.pm.CacheDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "platform"), nil
return joinUnder(b.pm.CacheDir, "platform")
}

func (b *basePathManager) SSHKeysDir() (string, error) {
dir, err := b.pm.CacheDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "keys"), nil
return joinUnder(b.pm.CacheDir, "keys")
}

// --- Runtime sub-paths ---

func (b *basePathManager) DaemonPIDFile() (string, error) {
dir, err := b.pm.RuntimeDir()
if err != nil {
return "", err
}

return filepath.Join(dir, DaemonProcessName+".pid"), nil
return joinUnder(b.pm.RuntimeDir, DaemonProcessName+".pid")
}

func (b *basePathManager) DaemonLockFile() (string, error) {
dir, err := b.pm.RuntimeDir()
if err != nil {
return "", err
}

return filepath.Join(dir, DaemonProcessName+".lock"), nil
return joinUnder(b.pm.RuntimeDir, DaemonProcessName+".lock")
}

func (b *basePathManager) DaemonStreamsFile() (string, error) {
dir, err := b.pm.RuntimeDir()
if err != nil {
return "", err
}

return filepath.Join(dir, DaemonProcessName+".streams"), nil
return joinUnder(b.pm.RuntimeDir, DaemonProcessName+".streams")
}

func (b *basePathManager) ProcessPIDFile(name string) (string, error) {
dir, err := b.pm.RuntimeDir()
if err != nil {
return "", err
}

return filepath.Join(dir, name+".pid"), nil
return joinUnder(b.pm.RuntimeDir, name+".pid")
}

func (b *basePathManager) ProcessLockFile(name string) (string, error) {
dir, err := b.pm.RuntimeDir()
if err != nil {
return "", err
}

return filepath.Join(dir, name+".lock"), nil
return joinUnder(b.pm.RuntimeDir, name+".lock")
}

func (b *basePathManager) ProcessStreamsFile(name string) (string, error) {
dir, err := b.pm.RuntimeDir()
if err != nil {
return "", err
}

return filepath.Join(dir, name+".streams"), nil
return joinUnder(b.pm.RuntimeDir, name+".streams")
}

// --- State sub-paths ---

func (b *basePathManager) LogDir() (string, error) {
dir, err := b.pm.StateDir()
if err != nil {
return "", err
}

return filepath.Join(dir, "logs"), nil
return joinUnder(b.pm.StateDir, "logs")
}

// TaskDir holds state files for detached background tasks.
func (b *basePathManager) TaskDir() (string, error) {
dir, err := b.pm.StateDir()
if err != nil {
return "", err
}
return joinUnder(b.pm.StateDir, "tasks")
}

return filepath.Join(dir, "tasks"), nil
// inContext returns elems joined beneath ContextDir(context).
func (b *basePathManager) inContext(context string, elems ...string) (string, error) {
return joinUnder(func() (string, error) { return b.ContextDir(context) }, elems...)
}

var (
Expand Down
14 changes: 14 additions & 0 deletions pkg/config/pathmanager_test.go
Original file line number Diff line number Diff line change
@@ -1,8 +1,11 @@
package config

import (
"errors"
"path/filepath"
"testing"

"github.com/stretchr/testify/require"
)

func TestDefaultPathManagerSingleton(t *testing.T) {
Expand All @@ -17,6 +20,17 @@ func TestDefaultPathManagerSingleton(t *testing.T) {
}
}

func TestJoinUnderPropagatesParentErrorAndJoinsElems(t *testing.T) {
parentErr := errors.New("parent unavailable")
got, err := joinUnder(func() (string, error) { return "", parentErr }, "a", "b")
require.ErrorIs(t, err, parentErr)
require.Empty(t, got)

got, err = joinUnder(func() (string, error) { return "/base", nil }, "a", "b")
require.NoError(t, err)
require.Equal(t, filepath.Join("/base", "a", "b"), got)
}

func TestSetPathManagerOverride(t *testing.T) {
ResetPathManager()
t.Cleanup(ResetPathManager)
Expand Down
Loading