From 226caa6e1c808fe725ed335bfa295300ccf51ca7 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sun, 11 Oct 2026 12:08:44 -0600 Subject: [PATCH 01/15] fix(provider): prepare updates before publishing --- pkg/provider/download.go | 10 +- pkg/provider/update_archive.go | 321 +++++++ pkg/workspace/provider.go | 11 +- pkg/workspace/provider_update_archive_test.go | 72 ++ .../provider_update_extended_test.go | 411 ++++++++ pkg/workspace/provider_update_prepared.go | 529 +++++++++++ .../provider_update_prepared_test.go | 875 ++++++++++++++++++ .../provider_update_preservation_test.go | 182 ++++ .../managing-providers/manage-providers.mdx | 4 + 9 files changed, 2404 insertions(+), 11 deletions(-) create mode 100644 pkg/provider/update_archive.go create mode 100644 pkg/workspace/provider_update_archive_test.go create mode 100644 pkg/workspace/provider_update_extended_test.go create mode 100644 pkg/workspace/provider_update_prepared.go create mode 100644 pkg/workspace/provider_update_prepared_test.go create mode 100644 pkg/workspace/provider_update_preservation_test.go diff --git a/pkg/provider/download.go b/pkg/provider/download.go index f224999aea..9e45774111 100644 --- a/pkg/provider/download.go +++ b/pkg/provider/download.go @@ -157,10 +157,18 @@ func downloadWithRetry( binaryName string, binary *ProviderBinary, targetFolder string, +) (string, error) { + return downloadWithRetryUsing(binaryName, binary, func() (string, error) { + return downloadBinary(ctx, binaryName, binary, targetFolder) + }) +} + +func downloadWithRetryUsing( + binaryName string, binary *ProviderBinary, fetch func() (string, error), ) (string, error) { var binaryPath string err := retry.OnError(downloadBackoff, isRetriableError, func() error { - path, err := downloadBinary(ctx, binaryName, binary, targetFolder) + path, err := fetch() if err != nil { return err } diff --git a/pkg/provider/update_archive.go b/pkg/provider/update_archive.go new file mode 100644 index 0000000000..0ac54ab5db --- /dev/null +++ b/pkg/provider/update_archive.go @@ -0,0 +1,321 @@ +package provider + +import ( + "archive/tar" + "archive/zip" + "bufio" + "compress/gzip" + "context" + "errors" + "fmt" + "io" + "io/fs" + "os" + "path/filepath" + "runtime" + "strings" + + "github.com/devsy-org/devsy/pkg/download" + "github.com/devsy-org/devsy/pkg/gitcredentials" + "github.com/google/uuid" +) + +// DownloadUpdateBinaries prepares an already isolated provider update tree. +// Unlike the ordinary downloader it confines archive materialization with os.Root. +// Caller validates/seeds the tree and separately handles absolute local references. +func DownloadUpdateBinaries( + ctx context.Context, + binaries map[string][]*ProviderBinary, + target string, +) (map[string]string, error) { + result := map[string]string{} + for key, locations := range binaries { + binary := updateBinaryForPlatform(locations) + if binary == nil { + return nil, fmt.Errorf( + "no update binary %s matches %s/%s", + key, + runtime.GOOS, + runtime.GOARCH, + ) + } + path, err := prepareUpdateBinary(ctx, key, binary, target) + if err != nil { + return nil, err + } + result[key] = path + } + return result, nil +} + +func updateBinaryForPlatform(locations []*ProviderBinary) *ProviderBinary { + for _, binary := range locations { + if binary.OS == runtime.GOOS && binary.Arch == runtime.GOARCH { + return binary + } + } + return nil +} + +func prepareUpdateBinary( + ctx context.Context, + key string, + binary *ProviderBinary, + target string, +) (string, error) { + if filepath.IsAbs(binary.Path) { + return "", fmt.Errorf( + "update preparation must validate absolute reference separately: %s", + binary.Path, + ) + } + if !isRemotePath(binary.Path) || binary.ArchivePath == "" { + return downloadBinaryForPlatform(ctx, key, []*ProviderBinary{binary}, target) + } + family := filepath.Join(target, strings.ToLower(key)) + path := getBinaryPath(binary, family) + // The legacy cache contains only the executable; seeded sidecars remain unchanged on a hit. + if verifyOrRemoveBinary(path, binary.Checksum) || fromCache(binary, family) { + return path, nil + } + return downloadWithRetryUsing(key, binary, func() (string, error) { + return downloadConfinedUpdateArchive(ctx, binary, family) + }) +} + +func downloadConfinedUpdateArchive( + ctx context.Context, + binary *ProviderBinary, + family string, +) (_ string, err error) { + if err := os.MkdirAll(family, dirPerms); err != nil { + return "", err + } + root, err := os.OpenRoot(family) + if err != nil { + return "", err + } + defer func() { err = errors.Join(err, root.Close()) }() + if err = validUpdateArchiveName(binary.ArchivePath); err != nil { + return "", err + } + if err = root.Remove(binary.ArchivePath); err != nil && !errors.Is(err, fs.ErrNotExist) { + return "", err + } + if err = fetchUpdateArchive(ctx, root, binary.Path); err != nil { + return "", err + } + if err = finalizeUpdateArchive(ctx, root, binary.ArchivePath); err != nil { + return "", err + } + return getBinaryPath(binary, family), nil +} + +func finalizeUpdateArchive(ctx context.Context, root *os.Root, selected string) error { + if err := validateUpdateArchiveLinks(ctx, root); err != nil { + return err + } + file, err := root.Open(selected) + if err != nil { + return err + } + return errors.Join(file.Chmod(filePerms), file.Close()) +} + +func fetchUpdateArchive(ctx context.Context, root *os.Root, url string) (err error) { + body, err := download.File(ctx, url, download.WithCredentialResolver(gitcredentials.Resolver{})) + if err != nil { + return fmt.Errorf("download update archive: %w", err) + } + defer func() { err = errors.Join(err, body.Close()) }() + switch { + case strings.HasSuffix(url, zipSuffix): + return extractConfinedUpdateZip(ctx, root, body) + case isGzipOrTar(url): + return extractConfinedUpdateTar(ctx, root, body) + default: + return fmt.Errorf("unrecognized update archive format %s", url) + } +} + +func validUpdateArchiveName(name string) error { + clean := filepath.Clean(name) + if name == "" || filepath.IsAbs(name) || clean == ".." || + strings.HasPrefix(clean, ".."+string(filepath.Separator)) { + return fmt.Errorf("unsafe update archive member %q", name) + } + return nil +} + +func updateArchiveParents(root *os.Root, name string) error { + if err := validUpdateArchiveName(name); err != nil { + return err + } + return root.MkdirAll(filepath.Dir(name), 0o755) +} + +func openUpdateTarSource(input io.Reader) (io.ReadCloser, error) { + buffered := bufio.NewReader(input) + signature, err := buffered.Peek(2) + if err != nil { + return nil, err + } + if signature[0] == 31 && signature[1] == 139 { + return gzip.NewReader(buffered) + } + return io.NopCloser(buffered), nil +} + +func extractConfinedUpdateTar(ctx context.Context, root *os.Root, input io.Reader) (err error) { + source, err := openUpdateTarSource(input) + if err != nil { + return err + } + defer func() { err = errors.Join(err, source.Close()) }() + archive := tar.NewReader(source) + for { + if err := ctx.Err(); err != nil { + return err + } + header, err := archive.Next() + if errors.Is(err, io.EOF) { + return nil + } + if err != nil { + return err + } + if err = materializeUpdateTarEntry(root, archive, header); err != nil { + return fmt.Errorf("confined update archive member %q: %w", header.Name, err) + } + } +} + +func materializeUpdateTarEntry(root *os.Root, input io.Reader, header *tar.Header) error { + name := filepath.Clean(header.Name) + if err := updateArchiveParents(root, header.Name); err != nil { + return err + } + switch header.Typeflag { + case tar.TypeDir: + return root.MkdirAll(name, 0o755) + case tar.TypeSymlink: + if filepath.IsAbs(header.Linkname) { + return fmt.Errorf("absolute archive symlink is unsupported: %s", header.Linkname) + } + return root.Symlink(header.Linkname, name) + case tar.TypeLink: + return materializeUpdateTarLink(root, name, header.Linkname) + case tar.TypeReg: + return writeConfinedUpdateFile(root, name, input, header.FileInfo().Mode().Perm()|0o600) + default: + return fmt.Errorf("unsupported update archive entry type %d", header.Typeflag) + } +} + +func materializeUpdateTarLink(root *os.Root, name, target string) error { + if err := validUpdateArchiveName(target); err != nil { + return err + } + return root.Link(filepath.Clean(target), name) +} + +func writeConfinedUpdateFile(root *os.Root, name string, input io.Reader, mode fs.FileMode) error { + file, err := root.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm()) + if err != nil { + return err + } + _, copyErr := io.Copy(file, input) + return errors.Join(copyErr, file.Chmod(mode.Perm()), file.Close()) +} + +func extractConfinedUpdateZip(ctx context.Context, root *os.Root, input io.Reader) (err error) { + spoolName := ".update-zip-" + uuid.NewString() + spool, err := root.OpenFile(spoolName, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0o600) + if err != nil { + return err + } + defer func() { err = errors.Join(err, spool.Close(), root.Remove(spoolName)) }() + size, err := io.Copy(spool, input) + if err != nil { + return err + } + archive, err := zip.NewReader(spool, size) + if err != nil { + return err + } + for _, entry := range archive.File { + if err = ctx.Err(); err != nil { + return err + } + if filepath.Clean(entry.Name) == spoolName { + return errors.New("archive member conflicts with owned spool") + } + if err = materializeUpdateZipEntry(root, entry); err != nil { + return fmt.Errorf("confined update zip member %q: %w", entry.Name, err) + } + } + return nil +} + +func materializeUpdateZipEntry(root *os.Root, entry *zip.File) (err error) { + if err := updateArchiveParents(root, entry.Name); err != nil { + return err + } + name := filepath.Clean(entry.Name) + if entry.FileInfo().IsDir() { + return root.MkdirAll(name, 0o755) + } + body, err := entry.Open() + if err != nil { + return err + } + defer func() { err = errors.Join(err, body.Close()) }() + if entry.Mode()&os.ModeSymlink != 0 { + return materializeUpdateZipLink(root, name, body) + } + if !entry.Mode().IsRegular() { + return fmt.Errorf("unsupported update zip file type %s", entry.Mode()) + } + const limit = 2 << 30 + limited := &io.LimitedReader{R: body, N: limit + 1} + err = writeConfinedUpdateFile(root, name, limited, entry.Mode()) + if limited.N == 0 { + err = errors.Join(err, fmt.Errorf("update zip entry exceeds %d bytes", limit)) + } + return err +} + +func materializeUpdateZipLink(root *os.Root, name string, body io.Reader) error { + target, err := io.ReadAll(io.LimitReader(body, 4097)) + if err != nil { + return err + } + if len(target) > 4096 { + return errors.New("archive symlink target exceeds 4096 bytes") + } + if filepath.IsAbs(string(target)) { + return errors.New("absolute archive symlink is unsupported") + } + return root.Symlink(string(target), name) +} + +func validateUpdateArchiveLinks(ctx context.Context, root *os.Root) error { + return fs.WalkDir(root.FS(), ".", func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if err := ctx.Err(); err != nil { + return err + } + if entry.Type()&os.ModeSymlink != 0 { + info, err := root.Stat(name) + if err != nil { + return fmt.Errorf("unsafe update archive symlink %s: %w", name, err) + } + if !info.IsDir() && !info.Mode().IsRegular() { + return fmt.Errorf("unsupported archive symlink target %s", name) + } + } + return nil + }) +} diff --git a/pkg/workspace/provider.go b/pkg/workspace/provider.go index 51371bcbb7..2d6bc3e253 100644 --- a/pkg/workspace/provider.go +++ b/pkg/workspace/provider.go @@ -365,16 +365,7 @@ func updateProvider(ctx context.Context, p ProviderParams) (*provider.ProviderCo return nil, err } - err = config.UpdateConfig(p.DevsyConfig.DefaultContext, "", func(c *config.Config) error { - cleanupOldOptions(c, providerConfig) - clearInitialized(c, providerConfig.Name) - return nil - }) - if err != nil { - return nil, err - } - - if err := downloadAndSaveProvider(ctx, p, providerConfig); err != nil { + if err := replaceProviderPrepared(ctx, p, providerConfig); err != nil { return nil, err } diff --git a/pkg/workspace/provider_update_archive_test.go b/pkg/workspace/provider_update_archive_test.go new file mode 100644 index 0000000000..50c9a0b9e1 --- /dev/null +++ b/pkg/workspace/provider_update_archive_test.go @@ -0,0 +1,72 @@ +package workspace + +import ( + "archive/tar" + "bytes" + "compress/gzip" + "net/http" + "os" + "path/filepath" + "testing" + + "github.com/devsy-org/devsy/pkg/provider" + "github.com/stretchr/testify/require" +) + +type ownedArchiveEntry struct{ name, target, body string } + +func ownedContainmentArchive(t *testing.T, entries []ownedArchiveEntry) []byte { + t.Helper() + var data bytes.Buffer + gz := gzip.NewWriter(&data) + writer := tar.NewWriter(gz) + for _, entry := range entries { + header := &tar.Header{Name: entry.name, Mode: 0o700, Size: int64(len(entry.body))} + if entry.target != "" { + header.Typeflag = tar.TypeSymlink + header.Linkname = entry.target + header.Size = 0 + } + require.NoError(t, writer.WriteHeader(header)) + if entry.body != "" { + _, err := writer.Write([]byte(entry.body)) + require.NoError(t, err) + } + } + require.NoError(t, writer.Close()) + require.NoError(t, gz.Close()) + return data.Bytes() +} + +func TestProviderUpdateArchivePreservesOwnedDaemon(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old runtime")) + // Every link target cleans lexically to the extraction root, but the kernel + // follows prior links first. D reaches this test-owned provider directory. + archive := ownedContainmentArchive(t, []ownedArchiveEntry{ + {name: "linkA", target: "."}, + {name: "linkB", target: "linkA/.."}, + {name: "linkC", target: "linkB/.."}, + {name: "linkD", target: "linkC/.."}, + {name: "linkD/daemon/owned-state", body: "archive escaped staging into owned daemon"}, + {name: updateRuntimeName, body: updateExecutableContent}, + }) + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write(archive) }, + ) + binary := updateTestBinary(server.URL+"/owned.tar.gz", []byte(updateExecutableContent)) + binary.ArchivePath = updateRuntimeName + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + require.Error( + t, + err, + "confined preparation must reject the member before writing outside staging", + ) + actual, readErr := os.ReadFile(filepath.Join(f.dir, "daemon", "owned-state")) + require.NoError(t, readErr) + t.Logf("owned daemon sentinel after preparation error=%q", actual) + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} diff --git a/pkg/workspace/provider_update_extended_test.go b/pkg/workspace/provider_update_extended_test.go new file mode 100644 index 0000000000..a468cf5032 --- /dev/null +++ b/pkg/workspace/provider_update_extended_test.go @@ -0,0 +1,411 @@ +package workspace + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "runtime" + "strings" + "sync" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + updateRuntimeKey = "RUNTIME" + updateRuntimeName = "runtime" + updateKeptOption = "KEEP" + updateObsoleteOption = "OBSOLETE" + updateNoopCommand = "true" + updateReplacementVersion = "2.0.0" + updateFirstKey = "FIRST" + updateSecondKey = "SECOND" + updateWindowsOS = "windows" + updateSidecarPath = "lib/sidecar" + updateExecutableContent = "new executable" + updateUnrelatedContent = "keep" + updateRestoreFailure = "restore failure" + updateBackupPhase = "backup" + updatePromotionPhase = "promotion" + updateCurrentLink = "current" + updateMiddleLink = "middle" + updateEntryLink = "entry" +) + +type preservationFixture struct { + t *testing.T + config *config.Config + name, dir, binaries string + before map[string][]byte + options map[string]config.OptionValue + workspace *provider.Workspace +} + +func newPreservationFixture(t *testing.T) *preservationFixture { + t.Helper() + setupTestPathManager(t) + t.Setenv(config.EnvHome, t.TempDir()) + config.ResetPathManager() + f := &preservationFixture{ + t: t, + name: "update-preservation-extended", + before: map[string][]byte{}, + options: map[string]config.OptionValue{ + updateKeptOption: {Value: "kept", UserProvided: true}, + updateObsoleteOption: {Value: "retain on failure", UserProvided: true}, + }, + } + f.config = &config.Config{ + DefaultContext: testDefaultContext, + Contexts: map[string]*config.ContextConfig{testDefaultContext: { + DefaultProvider: f.name, + Providers: map[string]*config.ProviderConfig{ + f.name: {Initialized: true, InitAttempted: true, Options: f.options}, + }, + }}, + } + require.NoError(t, config.SaveConfig(f.config)) + old := &provider.ProviderConfig{ + Name: f.name, + Version: "1.0.0", + Exec: provider.ProviderCommands{Command: []string{updateNoopCommand}}, + Source: provider.ProviderSource{ + Internal: true, + Raw: "microsandbox", + }, + Options: map[string]*types.Option{updateKeptOption: {}, updateObsoleteOption: {}}, + } + require.NoError(t, provider.SaveProviderConfig(testDefaultContext, old)) + var err error + f.dir, err = provider.GetProviderDir(testDefaultContext, f.name) + require.NoError(t, err) + f.binaries, err = provider.GetProviderBinariesDir(testDefaultContext, f.name) + require.NoError(t, err) + path := filepath.Join(f.dir, provider.ProviderConfigFile) + // #nosec G304 -- Path is the manifest in this fixture's isolated provider directory. + f.before[path], err = os.ReadFile(path) + require.NoError(t, err) + f.put(filepath.Join(f.dir, "owned-sentinel"), []byte("untouched provider content")) + f.put(filepath.Join(f.dir, "daemon", "owned-state"), []byte("untouched daemon state")) + f.workspace = &provider.Workspace{ + ID: "existing-workspace", + UID: "original-uid", + Context: testDefaultContext, + Provider: provider.WorkspaceProviderConfig{ + Name: f.name, + Options: map[string]config.OptionValue{ + "WORKSPACE_OPTION": {Value: "original", UserProvided: true}, + }, + }, + } + require.NoError(t, provider.SaveWorkspaceConfig(f.workspace)) + t.Logf("isolated provider root: %s", f.dir) + return f +} + +func (f *preservationFixture) put(path string, data []byte) { + f.t.Helper() + require.NoError(f.t, os.MkdirAll(filepath.Dir(path), 0o700)) + // #nosec G306 -- The fixture writes executable bytes to test provider binary preservation. + require.NoError(f.t, os.WriteFile(path, data, 0o700)) + f.before[path] = append([]byte(nil), data...) +} + +func (f *preservationFixture) binaryPath(key string) string { + return filepath.Join(f.binaries, strings.ToLower(key), updateRuntimeName) +} + +func (f *preservationFixture) seedBinary(key string, content []byte) { + f.t.Helper() + f.put(f.binaryPath(key), content) + manifestPath := filepath.Join(f.dir, provider.ProviderConfigFile) + // #nosec G304 -- Manifest path belongs to this fixture's isolated provider directory. + raw, err := os.ReadFile(manifestPath) + require.NoError(f.t, err) + var old provider.ProviderConfig + require.NoError(f.t, json.Unmarshal(raw, &old)) + if old.Binaries == nil { + old.Binaries = map[string][]*provider.ProviderBinary{} + } + old.Binaries[key] = []*provider.ProviderBinary{ + updateTestBinary("unavailable-original-source/runtime", content), + } + require.NoError(f.t, provider.SaveProviderConfig(testDefaultContext, &old)) + // #nosec G304 -- Snapshot the manifest in this test-owned provider directory. + f.before[manifestPath], err = os.ReadFile(manifestPath) + require.NoError(f.t, err) +} + +func updateTestDigest(data []byte) string { + sum := sha256.Sum256(data) + return hex.EncodeToString(sum[:]) +} + +func updateTestBinary(path string, content []byte) *provider.ProviderBinary { + return &provider.ProviderBinary{ + OS: runtime.GOOS, + Arch: runtime.GOARCH, + Name: updateRuntimeName, + Path: path, + Checksum: updateTestDigest(content), + } +} + +func (f *preservationFixture) update(binaries map[string][]*provider.ProviderBinary) error { + f.t.Helper() + replacement := &provider.ProviderConfig{ + Name: f.name, + Version: updateReplacementVersion, + Exec: provider.ProviderCommands{Command: []string{updateNoopCommand}}, + Options: map[string]*types.Option{updateKeptOption: {}}, + Binaries: binaries, + } + raw, err := json.Marshal(replacement) + require.NoError(f.t, err) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + _, err = updateProvider( + ctx, + ProviderParams{ + DevsyConfig: f.config, + ProviderName: f.name, + Raw: raw, + Source: &provider.ProviderSource{ + Raw: "owned-replacement", + URL: "http://owned.invalid/provider.yaml", + }, + }, + ) + require.NoError(f.t, ctx.Err(), "update must terminate by concrete result, not deadline") + f.t.Logf("actual update result: %v", err) + return err +} + +func (f *preservationFixture) assertAssociation() *config.ProviderConfig { + f.t.Helper() + stored, err := config.LoadConfig(testDefaultContext, "") + require.NoError(f.t, err) + assert.Equal(f.t, f.name, stored.Current().DefaultProvider) + workspace, err := provider.LoadWorkspaceConfig(testDefaultContext, f.workspace.ID) + require.NoError(f.t, err) + assert.Equal(f.t, f.workspace.UID, workspace.UID) + assert.Equal(f.t, f.workspace.Provider, workspace.Provider) + state := stored.Current().Providers[f.name] + require.NotNil(f.t, state) + f.t.Logf( + "workspace and default association retained; initialized=%v options=%v", + state.Initialized, + state.Options, + ) + return state +} + +func (f *preservationFixture) assertFailedPreservation() { + f.t.Helper() + for path, expected := range f.before { + // #nosec G304 -- Every snapshot path is created and owned by this fixture. + actual, err := os.ReadFile(path) + f.t.Logf("preserved path %s: exists=%v", path, err == nil) + if assert.NoError(f.t, err, "existing bytes must survive: %s", path) { + assert.Equal(f.t, expected, actual, path) + } + } + state := f.assertAssociation() + assert.True(f.t, state.Initialized) + assert.True(f.t, state.InitAttempted) + assert.Equal(f.t, f.options, state.Options) +} + +func ownedProviderUpdateServer(t *testing.T, handler http.HandlerFunc) *httptest.Server { + t.Helper() + server := httptest.NewServer(handler) + t.Cleanup(func() { + server.CloseClientConnections() + server.Close() + t.Log("owned HTTP server closed and joined") + }) + return server +} + +func TestProviderUpdateSameNameHTTPFailurePreservesExisting(t *testing.T) { + f := newPreservationFixture(t) + old := []byte("old same-name runtime") + f.seedBinary(updateRuntimeKey, old) + var mu sync.Mutex + requests := 0 + oldPresentDuringRequest := false + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, r *http.Request) { + data, err := os.ReadFile(f.binaryPath(updateRuntimeKey)) + mu.Lock() + requests++ + oldPresentDuringRequest = err == nil && string(data) == string(old) + mu.Unlock() + http.Error(w, "owned artifact unavailable", http.StatusNotFound) + }) + err := f.update( + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: { + updateTestBinary(server.URL+"/runtime", []byte("different checksum")), + }, + }, + ) + require.ErrorContains(t, err, "received status code 404") + mu.Lock() + count, present := requests, oldPresentDuringRequest + mu.Unlock() + require.Equal(t, 1, count) + t.Logf("old same-name bytes present during HTTP request: %v", present) + assert.True( + t, + present, + "live old binary must not be removed before a replacement download succeeds", + ) + f.assertFailedPreservation() +} + +func TestProviderUpdatePartialMultiBinaryFailurePreservesExisting(t *testing.T) { + f := newPreservationFixture(t) + for _, key := range []string{updateFirstKey, updateSecondKey} { + f.seedBinary(key, []byte("old "+key)) + } + replacement := []byte("new complete bytes unique to " + f.dir) + var mu sync.Mutex + requests := 0 + firstKey := "" + firstPublishedBeforeFailure := false + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + defer mu.Unlock() + requests++ + if requests == 1 { + firstKey = strings.TrimPrefix(r.URL.Path, "/") + _, _ = w.Write(replacement) + return + } + data, err := os.ReadFile(f.binaryPath(firstKey)) + firstPublishedBeforeFailure = err == nil && string(data) == string(replacement) + http.Error(w, "second requested artifact deliberately fails", http.StatusNotFound) + }) + err := f.update(map[string][]*provider.ProviderBinary{ + updateFirstKey: { + updateTestBinary(server.URL+"/FIRST", replacement), + }, + updateSecondKey: {updateTestBinary(server.URL+"/SECOND", replacement)}, + }) + require.ErrorContains(t, err, "received status code 404") + mu.Lock() + count, first, published := requests, firstKey, firstPublishedBeforeFailure + mu.Unlock() + require.Equal(t, 2, count, "must complete first download before second request fails") + require.Contains(t, []string{updateFirstKey, updateSecondKey}, first) + t.Logf( + "actual first completed artifact=%s; replacement bytes visible in live tree before second failure=%v", + first, + published, + ) + assert.False( + t, + published, + "a partial replacement must not publish any new live bytes before all preparation succeeds", + ) + f.assertFailedPreservation() +} + +func TestProviderUpdateInstalledOnlyOfflineReuse(t *testing.T) { + f := newPreservationFixture(t) + content := []byte("valid already installed offline executable") + f.seedBinary(updateRuntimeKey, content) + // A relative source that does not exist: only the valid installed target can satisfy this update. + relative := filepath.Join( + "definitely-absent-provider-test", + filepath.Base(f.dir), + "source-runtime", + ) + _, statErr := os.Stat(relative) + require.ErrorIs(t, statErr, os.ErrNotExist) + err := f.update( + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary(relative, content)}, + }, + ) + require.NoError(t, err) + actual, err := os.ReadFile(f.binaryPath(updateRuntimeKey)) + require.NoError(t, err) + assert.Equal(t, content, actual) + for _, path := range []string{filepath.Join(f.dir, "owned-sentinel"), filepath.Join(f.dir, "daemon", "owned-state")} { + // #nosec G304 -- These are fixture-owned sentinel and daemon paths. + actual, err = os.ReadFile(path) + require.NoError(t, err) + assert.Equal(t, f.before[path], actual) + } + // Read persisted JSON directly: internal-load compatibility overlays must not hide stored state. + raw, err := os.ReadFile(filepath.Join(f.dir, provider.ProviderConfigFile)) + require.NoError(t, err) + var replacement provider.ProviderConfig + require.NoError(t, json.Unmarshal(raw, &replacement)) + assert.Equal(t, updateReplacementVersion, replacement.Version) + assert.Equal(t, f.name, replacement.Name) + assert.Equal(t, "owned-replacement", replacement.Source.Raw) + state := f.assertAssociation() + assert.False(t, state.Initialized) + assert.True(t, state.InitAttempted) + assert.Equal( + t, + map[string]config.OptionValue{updateKeptOption: f.options[updateKeptOption]}, + state.Options, + ) + t.Log( + "PASS: installed-only matching checksum reused without source file or network; " + + "successful-update state semantics preserved", + ) +} + +func TestProviderUpdateAbsoluteChecksumMismatchPreservesExternal(t *testing.T) { + f := newPreservationFixture(t) + external := filepath.Join(t.TempDir(), "externally-owned-runtime") + content := []byte("external local executable owned independently") + f.put(external, content) + require.False(t, strings.HasPrefix(external, f.dir+string(filepath.Separator))) + err := f.update( + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary(external, []byte("mismatched expected content"))}, + }, + ) + require.Error(t, err) + require.ErrorContains(t, err, "download binaries") + t.Logf( + "absolute source is outside providerDir; observed error after mismatch: %s", + fmt.Sprint(err), + ) + f.assertFailedPreservation() +} + +// Windows may require a privilege or Developer Mode to create symbolic links. +// Only tests that exercise links use this check; ordinary update tests still run. +func requireProviderUpdateSymlinks(t *testing.T) { + t.Helper() + root := t.TempDir() + file := filepath.Join(root, "file") + require.NoError(t, os.WriteFile(file, []byte("owned link capability control"), 0o600)) + dir := filepath.Join(root, "directory") + require.NoError(t, os.Mkdir(dir, 0o700)) + for _, target := range []string{file, dir} { + err := os.Symlink(target, target+"-link") + if err != nil && runtime.GOOS == updateWindowsOS { + t.Skipf("symbolic links unavailable on this Windows runner: %v", err) + } + require.NoError(t, err) + } +} diff --git a/pkg/workspace/provider_update_prepared.go b/pkg/workspace/provider_update_prepared.go new file mode 100644 index 0000000000..ee911976a0 --- /dev/null +++ b/pkg/workspace/provider_update_prepared.go @@ -0,0 +1,529 @@ +package workspace + +import ( + "context" + "errors" + "fmt" + "io" + "io/fs" + "os" + "path/filepath" + "runtime" + "slices" + "strings" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/hash" + "github.com/devsy-org/devsy/pkg/provider" +) + +// The caller holds the provider operation lock. This protects preparation +// failures, not concurrent readers or a crash between separate file commits. +func replaceProviderPrepared( + ctx context.Context, + p ProviderParams, + replacement *provider.ProviderConfig, +) (err error) { + prepared, err := prepareProviderReplacement(ctx, p, replacement) + if err != nil { + return err + } + defer func() { + if prepared.retain { + err = errors.Join( + err, + fmt.Errorf("provider recovery artifacts retained at %s", prepared.stage), + ) + } else if cleanupErr := removeProviderUpdateStage(prepared.stage); cleanupErr != nil { + err = errors.Join( + err, + fmt.Errorf( + "remove owned provider update staging (commit completed=%t): %w", + prepared.committed, + cleanupErr, + ), + ) + } + }() + if err = ctx.Err(); err != nil { + return err + } + return prepared.commit(p, replacement, defaultProviderUpdateCommitOps()) +} + +type preparedProviderReplacement struct { + stage, live, manifest string + oldManifest []byte + oldMode fs.FileMode + replaceBinaries bool + hadBinaries bool + backupMoved bool + installed bool + committed bool + retain bool +} + +func prepareProviderReplacement( + ctx context.Context, + p ProviderParams, + replacement *provider.ProviderConfig, +) (_ *preparedProviderReplacement, err error) { + prepared, err := newPreparedProviderReplacement(p, replacement) + if err != nil { + return nil, err + } + defer func() { + if err != nil { + err = errors.Join(err, removeProviderUpdateStage(prepared.stage)) + } + }() + if !prepared.replaceBinaries { + return prepared, ctx.Err() + } + if err = prepared.prepareBinaries(ctx, replacement.Binaries); err != nil { + return nil, err + } + return prepared, nil +} + +func newPreparedProviderReplacement( + p ProviderParams, + replacement *provider.ProviderConfig, +) (_ *preparedProviderReplacement, err error) { + dir, err := provider.GetProviderDir(p.DevsyConfig.DefaultContext, replacement.Name) + if err != nil { + return nil, err + } + if err = requireRegularProviderPath(dir, true); err != nil { + return nil, err + } + old, mode, err := readProviderUpdateManifest(dir) + if err != nil { + return nil, err + } + stage, err := os.MkdirTemp(dir, ".update-staging-") + if err != nil { + return nil, err + } + defer func() { + if err != nil { + err = errors.Join(err, removeProviderUpdateStage(stage)) + } + }() + if err = saveProviderUpdateBackup(stage, old, mode); err != nil { + return nil, err + } + return &preparedProviderReplacement{ + stage: stage, live: filepath.Join(dir, "binaries"), + manifest: filepath.Join(dir, provider.ProviderConfigFile), oldManifest: old, oldMode: mode, + replaceBinaries: len(replacement.Binaries) > 0, + }, nil +} + +func readProviderUpdateManifest(dir string) (data []byte, mode fs.FileMode, err error) { + root, err := os.OpenRoot(dir) + if err != nil { + return nil, 0, err + } + defer func() { err = errors.Join(err, root.Close()) }() + info, err := root.Lstat(provider.ProviderConfigFile) + if err != nil { + return nil, 0, err + } + if !info.Mode().IsRegular() { + return nil, 0, errors.New("provider update manifest must be a regular file") + } + data, err = root.ReadFile(provider.ProviderConfigFile) + return data, info.Mode().Perm(), err +} + +func saveProviderUpdateBackup(stage string, data []byte, mode fs.FileMode) (err error) { + root, err := os.OpenRoot(stage) + if err != nil { + return err + } + defer func() { err = errors.Join(err, root.Close()) }() + return root.WriteFile("old-provider.json", data, mode) +} + +func (p *preparedProviderReplacement) prepareBinaries( + ctx context.Context, + binaries map[string][]*provider.ProviderBinary, +) (err error) { + target := filepath.Join(p.stage, "binaries") + p.hadBinaries, err = copyProviderBinaryTree(ctx, p.live, target) + if err != nil { + return err + } + locations, err := stagedProviderLocations(ctx, binaries) + if err != nil { + return fmt.Errorf("download binaries: validate preparation: %w", err) + } + if _, err = provider.DownloadUpdateBinaries(ctx, locations, target); err != nil { + return fmt.Errorf("download binaries: %w", err) + } + if err = ctx.Err(); err != nil { + return err + } + // Archive sidecars are promoted together, but no link may lead outside staging. + _, err = copyProviderBinaryTree(ctx, target, "") + return err +} + +func requireRegularProviderPath(path string, directory bool) error { + info, err := os.Lstat(path) + if err != nil { + return err + } + if info.Mode()&os.ModeSymlink != 0 { + return fmt.Errorf("unsafe provider update symlink: %s", path) + } + if directory && info.IsDir() || !directory && info.Mode().IsRegular() { + return nil + } + return fmt.Errorf("unsupported provider update file type: %s", path) +} + +// A blank destination validates without copying. Seed regular bytes independently; +// contained relative links are copied as links only after their source graph validates. +func copyProviderBinaryTree(ctx context.Context, source, destination string) (_ bool, err error) { + info, err := os.Lstat(source) + if os.IsNotExist(err) { + if destination != "" { + return false, os.MkdirAll(destination, 0o700) + } + return false, nil + } + if err != nil { + return false, err + } + if !info.IsDir() { + return false, fmt.Errorf("unsafe provider update binaries root: %s", source) + } + root, err := os.OpenRoot(source) + if err != nil { + return false, err + } + defer func() { err = errors.Join(err, root.Close()) }() + if err = validateProviderSeed(ctx, root, source); err != nil { + return false, err + } + if destination == "" { + return true, nil + } + return true, copyProviderSeed(ctx, root, destination) +} + +type providerSeedCopier struct { + source, destination *os.Root + links map[string]string + directoryModes map[string]fs.FileMode + directories []string +} + +func copyProviderSeed(ctx context.Context, source *os.Root, destination string) (err error) { + if err = os.MkdirAll(destination, 0o700); err != nil { + return err + } + out, err := os.OpenRoot(destination) + if err != nil { + return err + } + defer func() { err = errors.Join(err, out.Close()) }() + copier := &providerSeedCopier{ + source: source, destination: out, + links: map[string]string{}, directoryModes: map[string]fs.FileMode{}, + } + err = fs.WalkDir(source.FS(), ".", func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if err := ctx.Err(); err != nil { + return err + } + return copier.copyEntry(name, entry) + }) + if err != nil { + return err + } + if err = copier.copyLinks(); err != nil { + return err + } + if err = copier.applyDirectoryModes(); err != nil { + return err + } + return validateProviderSeed(ctx, out, destination) +} + +func (c *providerSeedCopier) applyDirectoryModes() error { + // WalkDir records parents before children; apply final modes only after all writes. + for _, name := range slices.Backward(c.directories) { + if err := c.destination.Chmod(name, c.directoryModes[name]); err != nil { + return err + } + } + return nil +} + +func (c *providerSeedCopier) copyEntry(name string, entry fs.DirEntry) error { + info, err := entry.Info() + if err != nil { + return err + } + if info.Mode()&os.ModeSymlink != 0 { + c.links[name], err = c.source.Readlink(name) + return err + } + if info.IsDir() { + c.directoryModes[name] = info.Mode() + c.directories = append(c.directories, name) + return c.destination.MkdirAll(name, 0o700) + } + return copyProviderSeedFile(c.source, c.destination, name, info.Mode()) +} + +func copyProviderSeedFile(source, destination *os.Root, name string, mode fs.FileMode) error { + in, err := source.Open(name) + if err != nil { + return err + } + target, err := destination.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode.Perm()) + if err != nil { + return errors.Join(err, in.Close()) + } + _, copyErr := io.Copy(target, in) + return errors.Join(copyErr, target.Chmod(mode.Perm()), target.Close(), in.Close()) +} + +func (c *providerSeedCopier) copyLinks() error { + // Windows determines the link type from its target, so create dependencies first. + for len(c.links) > 0 { + copied := false + for name, target := range c.links { + // Keep dot components intact: a preceding symlink can change their resolution. + _, err := c.destination.Stat(filepath.Dir(name) + string(filepath.Separator) + target) + if errors.Is(err, fs.ErrNotExist) { + continue + } + if err != nil { + return err + } + if err = c.destination.Symlink(target, name); err != nil { + return err + } + delete(c.links, name) + copied = true + } + if !copied { + return errors.New("provider seed link dependencies could not be resolved") + } + } + return nil +} + +func validateProviderSeed(ctx context.Context, root *os.Root, display string) error { + return fs.WalkDir(root.FS(), ".", func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if err := ctx.Err(); err != nil { + return err + } + if err := validateProviderSeedEntry(root, name, entry); err != nil { + return fmt.Errorf("provider update seed %s: %w", display, err) + } + return nil + }) +} + +func validateProviderSeedEntry(root *os.Root, name string, entry fs.DirEntry) error { + if entry.Type()&os.ModeSymlink != 0 { + resolved, err := root.Stat(name) + if err != nil { + return fmt.Errorf("unsafe provider update symlink %s: %w", name, err) + } + if !resolved.IsDir() && !resolved.Mode().IsRegular() { + return fmt.Errorf("unsupported provider link target: %s", name) + } + return nil + } + if !entry.IsDir() && !entry.Type().IsRegular() { + return fmt.Errorf("unsupported provider update file type: %s", name) + } + return nil +} + +// Absolute files are user-owned references, not downloader targets. In particular, +// never call verifyOrRemoveBinary on them when a replacement checksum differs. +func stagedProviderLocations( + ctx context.Context, + binaries map[string][]*provider.ProviderBinary, +) (map[string][]*provider.ProviderBinary, error) { + staged := make(map[string][]*provider.ProviderBinary, len(binaries)) + for key, locations := range binaries { + if err := ctx.Err(); err != nil { + return nil, err + } + staged[key] = locations + for _, location := range locations { + if location.OS != runtime.GOOS || location.Arch != runtime.GOARCH { + continue + } + if err := validateProviderUpdateLocation(location); err != nil { + return nil, err + } + if filepath.IsAbs(location.Path) { + delete(staged, key) + } + break + } + } + return staged, nil +} + +func validateProviderUpdateLocation(location *provider.ProviderBinary) error { + if filepath.IsAbs(location.Path) { + return validateAbsoluteProviderBinary(location) + } + for _, target := range []string{location.Name, location.ArchivePath} { + clean := filepath.Clean(target) + if filepath.IsAbs(target) || clean == ".." || + strings.HasPrefix(clean, ".."+string(filepath.Separator)) { + return fmt.Errorf("unsafe provider update binary target: %s", target) + } + } + return nil +} + +func validateAbsoluteProviderBinary(location *provider.ProviderBinary) error { + info, err := os.Stat(location.Path) + if err != nil { + return err + } + if !info.Mode().IsRegular() { + return fmt.Errorf("absolute provider binary is not regular: %s", location.Path) + } + if location.Checksum == "" { + return nil + } + sum, err := hash.File(location.Path) + if err != nil { + return err + } + if !strings.EqualFold(sum, location.Checksum) { + return fmt.Errorf("absolute provider binary checksum mismatch: %s", location.Path) + } + return nil +} + +// Per-call operations keep phase-failure tests deterministic without mutable globals. +type providerUpdateCommitOps struct { + rename func(string, string) error + saveManifest func(string, *provider.ProviderConfig) error + updateConfig func(string, string, func(*config.Config) error) error + restoreManifest func(string, []byte, fs.FileMode) error +} + +func defaultProviderUpdateCommitOps() providerUpdateCommitOps { + return providerUpdateCommitOps{ + os.Rename, + provider.SaveProviderConfig, + config.UpdateConfig, + provider.WriteFileAtomic, + } +} + +func (p *preparedProviderReplacement) commit( + params ProviderParams, replacement *provider.ProviderConfig, ops providerUpdateCommitOps, +) error { + if p.replaceBinaries { + if p.hadBinaries { + if err := ops.rename(p.live, filepath.Join(p.stage, "backup")); err != nil { + return fmt.Errorf("backup old provider binaries: %w", err) + } + p.backupMoved = true + } + if err := ops.rename(filepath.Join(p.stage, "binaries"), p.live); err != nil { + return errors.Join( + fmt.Errorf("promote provider binaries: %w", err), + p.restoreBinaries(ops), + ) + } + p.installed = true + } + if err := ops.saveManifest(params.DevsyConfig.DefaultContext, replacement); err != nil { + return p.recoverCommit(err, ops) + } + if err := ops.updateConfig(params.DevsyConfig.DefaultContext, "", func(c *config.Config) error { + cleanupOldOptions(c, replacement) + clearInitialized(c, replacement.Name) + return nil + }); err != nil { + return p.recoverCommit(err, ops) + } + p.committed = true + return nil +} + +func (p *preparedProviderReplacement) recoverCommit( + original error, + ops providerUpdateCommitOps, +) error { + // SaveProviderConfig can return a sync error after rename; restore even then. + manifestErr := ops.restoreManifest(p.manifest, p.oldManifest, p.oldMode) + binariesErr := p.restoreBinaries(ops) + if manifestErr != nil || binariesErr != nil { + p.retain = true + } + return errors.Join(original, manifestErr, binariesErr) +} + +func (p *preparedProviderReplacement) restoreBinaries(ops providerUpdateCommitOps) error { + if p.installed { + // Retain failed new artifacts too; do not remove a live tree if this move fails. + if err := ops.rename(p.live, filepath.Join(p.stage, "failed-new")); err != nil { + p.retain = true + return fmt.Errorf("retain failed provider binaries: %w", err) + } + p.installed = false + } + if p.backupMoved { + if err := ops.rename(filepath.Join(p.stage, "backup"), p.live); err != nil { + p.retain = true + return fmt.Errorf("restore provider binary backup: %w", err) + } + p.backupMoved = false + } + return nil +} + +// Only a disposable owned staging tree reaches this helper; retained recovery +// artifacts and the live provider tree must never be made writable for cleanup. +func removeProviderUpdateStage(stage string) error { + root, err := os.OpenRoot(stage) + if errors.Is(err, fs.ErrNotExist) { + return nil + } + if err != nil { + return err + } + walkErr := fs.WalkDir( + root.FS(), + ".", + func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if !entry.IsDir() { + return nil + } + info, err := entry.Info() + if err != nil { + return err + } + return root.Chmod(name, info.Mode()|0o700) + }, + ) + closeErr := root.Close() + return errors.Join(walkErr, closeErr, os.RemoveAll(stage)) +} diff --git a/pkg/workspace/provider_update_prepared_test.go b/pkg/workspace/provider_update_prepared_test.go new file mode 100644 index 0000000000..abcee0efc6 --- /dev/null +++ b/pkg/workspace/provider_update_prepared_test.go @@ -0,0 +1,875 @@ +package workspace + +import ( + "archive/tar" + "archive/zip" + "bytes" + "compress/gzip" + "context" + "encoding/json" + "errors" + "io" + "io/fs" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "runtime" + "strings" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// compatibilityArchiveServer serves bytes from an owned httptest server. The +// common fixture cleanup closes idle connections and joins the server. +func compatibilityArchiveServer(t *testing.T, archive []byte) *httptest.Server { + t.Helper() + return ownedProviderUpdateServer(t, func(w http.ResponseWriter, _ *http.Request) { + _, _ = w.Write(archive) + }) +} + +func compatibilityTar( + t *testing.T, + gzipArchive bool, + entries []*tar.Header, + bodies map[string][]byte, +) []byte { + t.Helper() + var out bytes.Buffer + var writer io.Writer = &out + var gz *gzip.Writer + if gzipArchive { + gz = gzip.NewWriter(&out) + writer = gz + } + tarWriter := tar.NewWriter(writer) + for _, header := range entries { + require.NoError(t, tarWriter.WriteHeader(header)) + if body := bodies[header.Name]; len(body) != 0 { + _, err := tarWriter.Write(body) + require.NoError(t, err) + } + } + require.NoError(t, tarWriter.Close()) + if gz != nil { + require.NoError(t, gz.Close()) + } + return out.Bytes() +} + +func compatibilityZip(t *testing.T, entries []struct { + name string + mode os.FileMode + body []byte +}, +) []byte { + t.Helper() + var out bytes.Buffer + writer := zip.NewWriter(&out) + for _, item := range entries { + header := &zip.FileHeader{Name: item.name} + header.SetMode(item.mode) + member, err := writer.CreateHeader(header) + require.NoError(t, err) + _, err = member.Write(item.body) + require.NoError(t, err) + } + require.NoError(t, writer.Close()) + return out.Bytes() +} + +func assertSelectedExecutable(t *testing.T, path string, content []byte, checksum string) { + t.Helper() + actual, err := os.ReadFile( + path, + ) // #nosec G304 -- Selected executable belongs to the isolated update fixture. + require.NoError(t, err) + assert.Equal(t, content, actual) + info, err := os.Stat(path) + require.NoError(t, err) + if runtime.GOOS != updateWindowsOS { + assert.NotZero( + t, + info.Mode().Perm()&0o111, + "selected executable should retain executable permission", + ) + } + assert.Equal( + t, + checksum, + updateTestDigest(actual), + "selected archive member should match its declared checksum", + ) +} + +func TestProviderUpdateTarAndTgzCompatibility(t *testing.T) { + for _, gzipArchive := range []bool{false, true} { + t.Run(map[bool]string{false: "tar", true: "tgz"}[gzipArchive], func(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary("UNRELATED", []byte("keep unrelated installed binary")) + runtimeBytes := []byte("ordinary archive runtime bytes") + sidecarBytes := []byte("ordinary archive sibling sidecar") + archive := compatibilityTar(t, gzipArchive, []*tar.Header{ + { + Name: updateRuntimeName, + Typeflag: tar.TypeReg, + Mode: 0o755, + Size: int64(len(runtimeBytes)), + }, + { + Name: updateSidecarPath, + Typeflag: tar.TypeReg, + Mode: 0o750, + Size: int64(len(sidecarBytes)), + }, + }, map[string][]byte{updateRuntimeName: runtimeBytes, updateSidecarPath: sidecarBytes}) + extension := ".tar" + if gzipArchive { + extension = ".tgz" + } + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider"+extension, runtimeBytes) + binary.ArchivePath = updateRuntimeName + require.NoError( + t, + f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}), + ) + assertSelectedExecutable( + t, + f.binaryPath(updateRuntimeKey), + runtimeBytes, + binary.Checksum, + ) + sidecar := filepath.Join(f.binaries, updateRuntimeName, "lib", "sidecar") + actual, err := os.ReadFile( + sidecar, + ) // #nosec G304 -- Sidecar belongs to the isolated update fixture. + require.NoError(t, err) + assert.Equal(t, sidecarBytes, actual) + sidecarInfo, err := os.Stat(sidecar) + require.NoError(t, err) + if runtime.GOOS != updateWindowsOS { + assert.Equal( + t, + os.FileMode(0o750), + sidecarInfo.Mode().Perm(), + "ancillary executable mode must survive", + ) + } + unrelated, err := os.ReadFile(f.binaryPath("UNRELATED")) + require.NoError(t, err) + assert.Equal(t, []byte("keep unrelated installed binary"), unrelated) + }) + } +} + +func TestProviderUpdateZipCompatibility(t *testing.T) { + for _, includeLink := range []bool{false, true} { + t.Run( + map[bool]string{false: "plain archive", true: "contained file symlink"}[includeLink], + func(t *testing.T) { + if includeLink { + requireProviderUpdateSymlinks(t) + } + assertProviderUpdateZipCompatibility(t, includeLink) + }, + ) + } +} + +func assertProviderUpdateZipCompatibility(t *testing.T, includeLink bool) { + t.Helper() + f := newPreservationFixture(t) + runtimeBytes := []byte("ordinary zip runtime bytes") + sidecarBytes := []byte("ordinary zip ancillary sibling") + entries := []struct { + name string + mode os.FileMode + body []byte + }{ + {name: updateRuntimeName, mode: os.ModePerm | 0o755, body: runtimeBytes}, + {name: updateSidecarPath, mode: os.ModePerm | 0o644, body: sidecarBytes}, + } + if includeLink { + entries = append(entries, struct { + name string + mode os.FileMode + body []byte + }{ + name: "runtime-link", mode: os.ModeSymlink | 0o777, body: []byte(updateRuntimeName), + }) + } + archive := compatibilityZip(t, entries) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider.zip", runtimeBytes) + binary.ArchivePath = updateRuntimeName + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + assertSelectedExecutable(t, f.binaryPath(updateRuntimeKey), runtimeBytes, binary.Checksum) + if includeLink { + link := filepath.Join(f.binaries, updateRuntimeName, "runtime-link") + target, err := os.Readlink(link) + require.NoError(t, err) + assert.Equal(t, updateRuntimeName, target) + linked, err := os.ReadFile( + link, + ) // #nosec G304 -- Contained link belongs to the isolated update fixture. + require.NoError(t, err) + assert.Equal(t, runtimeBytes, linked) + } + sidecar, err := os.ReadFile(filepath.Join(f.binaries, updateRuntimeName, "lib", "sidecar")) + require.NoError(t, err) + assert.Equal(t, sidecarBytes, sidecar) +} + +func TestProviderUpdateTarContainedDirectoryLinkThenRegularMember(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + runtimeBytes := []byte("runtime beneath contained directory link") + sidecarBytes := []byte("sibling reached through contained directory link") + archive := compatibilityTar(t, false, []*tar.Header{ + {Name: "releases", Typeflag: tar.TypeDir, Mode: 0o755}, + {Name: "releases/v1", Typeflag: tar.TypeDir, Mode: 0o755}, + {Name: updateCurrentLink, Typeflag: tar.TypeSymlink, Linkname: "releases/v1", Mode: 0o777}, + { + Name: "current/runtime", + Typeflag: tar.TypeReg, + Mode: 0o755, + Size: int64(len(runtimeBytes)), + }, + { + Name: "current/lib/sidecar", + Typeflag: tar.TypeReg, + Mode: 0o644, + Size: int64(len(sidecarBytes)), + }, + }, map[string][]byte{"current/runtime": runtimeBytes, "current/lib/sidecar": sidecarBytes}) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider.tar", runtimeBytes) + binary.ArchivePath = filepath.Join(updateCurrentLink, updateRuntimeName) + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + assertSelectedExecutable( + t, + filepath.Join(f.binaries, updateRuntimeName, updateCurrentLink, updateRuntimeName), + runtimeBytes, + binary.Checksum, + ) + link := filepath.Join(f.binaries, updateRuntimeName, updateCurrentLink) + target, err := os.Readlink(link) + require.NoError(t, err) + assert.Equal(t, filepath.Join("releases", "v1"), filepath.FromSlash(target)) + actual, err := os.ReadFile( + filepath.Join(f.binaries, updateRuntimeName, "releases", "v1", "lib", "sidecar"), + ) + require.NoError(t, err) + assert.Equal(t, sidecarBytes, actual) +} + +func TestProviderUpdateTarHardlinkCompatibility(t *testing.T) { + f := newPreservationFixture(t) + runtimeBytes := []byte("hard-linked executable bytes") + archive := compatibilityTar(t, true, []*tar.Header{ + { + Name: updateRuntimeName, + Typeflag: tar.TypeReg, + Linkname: "", + Mode: 0o755, + Size: int64(len(runtimeBytes)), + }, + {Name: "runtime-copy", Typeflag: tar.TypeLink, Linkname: updateRuntimeName, Mode: 0o755}, + }, map[string][]byte{updateRuntimeName: runtimeBytes}) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider.tgz", runtimeBytes) + binary.ArchivePath = updateRuntimeName + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + assertSelectedExecutable(t, f.binaryPath(updateRuntimeKey), runtimeBytes, binary.Checksum) + copyPath := filepath.Join(f.binaries, updateRuntimeName, "runtime-copy") + // #nosec G304 -- Hardlink bytes are read only from the isolated archive fixture. + copyBytes, err := os.ReadFile(copyPath) + require.NoError(t, err) + assert.Equal(t, runtimeBytes, copyBytes) + selectedInfo, err := os.Stat(f.binaryPath(updateRuntimeKey)) + require.NoError(t, err) + copyInfo, err := os.Stat(copyPath) + require.NoError(t, err) + assert.True( + t, + os.SameFile(selectedInfo, copyInfo), + "tar hardlink should remain a hardlink after update preparation", + ) +} + +func TestProviderUpdateContainedSeedLinkInstalledOnlyReuse(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + content := []byte("installed executable reachable through a contained seed link") + versionDir := filepath.Join(f.binaries, updateRuntimeName, "releases", "v1") + // #nosec G301 -- The owned fixture reproduces a searchable installed binary directory. + require.NoError(t, os.MkdirAll(versionDir, 0o755)) + versionBinary := filepath.Join(versionDir, updateRuntimeName) + // #nosec G306 -- This test checks reuse of an installed executable with its executable mode. + require.NoError(t, os.WriteFile(versionBinary, content, 0o755)) + link := filepath.Join(f.binaries, updateRuntimeName, updateCurrentLink) + require.NoError(t, os.Symlink(filepath.Join("releases", "v1"), link)) + binaryPath := filepath.Join(updateCurrentLink, updateRuntimeName) + binary := updateTestBinary("https://offline.invalid/provider.tgz", content) + binary.ArchivePath = binaryPath + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + assertSelectedExecutable( + t, + filepath.Join(f.binaries, updateRuntimeName, binaryPath), + content, + binary.Checksum, + ) + target, err := os.Readlink(link) + require.NoError(t, err) + assert.Equal(t, filepath.Join("releases", "v1"), filepath.FromSlash(target)) + // #nosec G304 -- Installed executable belongs to the isolated update fixture. + actual, err := os.ReadFile(versionBinary) + require.NoError(t, err) + assert.Equal(t, content, actual) +} + +func TestProviderUpdateSelectedArchiveChecksumMismatchDoesNotPublish(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("previous selected executable")) + selected := []byte("new archive selected executable") + archive := compatibilityTar(t, true, []*tar.Header{ + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(selected))}, + {Name: updateSidecarPath, Typeflag: tar.TypeReg, Mode: 0o644, Size: int64(len(selected))}, + }, map[string][]byte{updateRuntimeName: selected, updateSidecarPath: selected}) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider.tgz", []byte("wrong selected checksum bytes")) + binary.ArchivePath = updateRuntimeName + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + require.ErrorContains(t, err, "checksum") + f.assertFailedPreservation() +} + +func preparedUpdateParams( + t *testing.T, + f *preservationFixture, + binaries map[string][]*provider.ProviderBinary, +) (ProviderParams, *provider.ProviderConfig) { + t.Helper() + replacement := &provider.ProviderConfig{ + Name: f.name, + Version: updateReplacementVersion, + Exec: provider.ProviderCommands{Command: []string{updateNoopCommand}}, + Options: map[string]*types.Option{ + updateKeptOption: {}, + }, + Binaries: binaries, + Source: provider.ProviderSource{Raw: "candidate-new"}, + } + raw, err := json.Marshal(replacement) + require.NoError(t, err) + return ProviderParams{ + DevsyConfig: f.config, + ProviderName: f.name, + Raw: raw, + Source: &replacement.Source, + }, replacement +} + +func assertNoUpdateStaging(t *testing.T, f *preservationFixture) { + t.Helper() + entries, err := os.ReadDir(f.dir) + require.NoError(t, err) + for _, entry := range entries { + assert.False(t, strings.HasPrefix(entry.Name(), ".update-staging-"), entry.Name()) + } +} + +func TestProviderUpdateChecksumFailure(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte("bad checksum")) }, + ) + err := f.update( + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary(server.URL+"/runtime", []byte("expected"))}, + }, + ) + require.Error(t, err) + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateCancellation(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + entered, handlerDone := make(chan struct{}), make(chan struct{}) + server := ownedProviderUpdateServer(t, func(_ http.ResponseWriter, r *http.Request) { + defer close(handlerDone) + close(entered) + <-r.Context().Done() + }) + params, _ := preparedUpdateParams( + t, + f, + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary(server.URL+"/runtime", []byte("new"))}, + }, + ) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + done := make(chan error, 1) + joined := make(chan struct{}) + go func() { + defer close(joined) + _, err := updateProvider(ctx, params) + done <- err + }() + cleanupProviderUpdateCaller(t, cancel, joined) + select { + case <-entered: + case <-time.After(3 * time.Second): + t.Fatal("request did not start") + } + cancel() + select { + case err := <-done: + require.ErrorIs(t, err, context.Canceled) + case <-time.After(3 * time.Second): + t.Fatal("update did not join") + } + select { + case <-handlerDone: + case <-time.After(3 * time.Second): + t.Fatal("handler did not join") + } + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} + +func cleanupProviderUpdateCaller(t *testing.T, cancel context.CancelFunc, joined <-chan struct{}) { + t.Helper() + t.Cleanup(func() { + cancel() + select { + case <-joined: + case <-time.After(3 * time.Second): + t.Error("update caller did not join during cleanup") + } + }) +} + +func TestProviderUpdateRejectsExistingSymlink(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + external := filepath.Join(t.TempDir(), "outside") + require.NoError(t, os.WriteFile(external, []byte("untouched"), 0o600)) + require.NoError(t, os.Symlink(external, filepath.Join(f.binaries, "outside-link"))) + err := f.update( + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary("absent-old-source", []byte("old"))}, + }, + ) + require.ErrorContains(t, err, "unsafe provider update symlink") + // #nosec G304 -- Outside sentinel is a separate test-owned temporary file. + data, err := os.ReadFile(external) + require.NoError(t, err) + assert.Equal(t, "untouched", string(data)) + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateValidAbsoluteAndNoBinary(t *testing.T) { + for _, absolute := range []bool{false, true} { + t.Run( + map[bool]string{false: "no binaries", true: "absolute reference"}[absolute], + func(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary("OLD", []byte("preserved unused bytes")) + binaries := map[string][]*provider.ProviderBinary{} + if absolute { + path := filepath.Join(t.TempDir(), "external") + f.put(path, []byte("external")) + binaries[updateRuntimeKey] = []*provider.ProviderBinary{ + updateTestBinary(path, []byte("external")), + } + } + require.NoError(t, f.update(binaries)) + for path, before := range f.before { + if filepath.Base(path) == provider.ProviderConfigFile { + continue + } + // #nosec G304 -- Snapshot path comes only from the test-owned fixture. + after, err := os.ReadFile(path) + require.NoError(t, err) + assert.Equal(t, before, after) + } + state := f.assertAssociation() + assert.False(t, state.Initialized) + assert.Equal( + t, + map[string]config.OptionValue{updateKeptOption: f.options[updateKeptOption]}, + state.Options, + ) + assertNoUpdateStaging(t, f) + }, + ) + } +} + +func TestProviderUpdateArchiveSuccessKeepsSiblings(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + f.seedBinary("UNRELATED", []byte(updateUnrelatedContent)) + var archive bytes.Buffer + gz := gzip.NewWriter(&archive) + tarWriter := tar.NewWriter(gz) + for name, data := range map[string]string{ + updateRuntimeName: updateExecutableContent, + updateSidecarPath: "required sidecar", + } { + require.NoError( + t, + tarWriter.WriteHeader(&tar.Header{Name: name, Mode: 0o755, Size: int64(len(data))}), + ) + _, err := tarWriter.Write([]byte(data)) + require.NoError(t, err) + } + require.NoError(t, tarWriter.Close()) + require.NoError(t, gz.Close()) + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write(archive.Bytes()) }, + ) + binary := updateTestBinary(server.URL+"/runtime.tar.gz", []byte(updateExecutableContent)) + binary.ArchivePath = updateRuntimeName + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + for path, want := range map[string]string{ + f.binaryPath(updateRuntimeKey): updateExecutableContent, + filepath.Join(f.binaries, updateRuntimeName, "lib", "sidecar"): "required sidecar", + f.binaryPath("UNRELATED"): updateUnrelatedContent, + filepath.Join(f.dir, "daemon", "owned-state"): "untouched daemon state", + } { + // #nosec G304 -- Snapshot path comes only from the test-owned fixture. + got, err := os.ReadFile(path) + require.NoError(t, err) + assert.Equal(t, want, string(got)) + } + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateSynchronousCommitRestoration(t *testing.T) { + for _, phase := range []string{ + updateBackupPhase, updatePromotionPhase, "manifest after save", "config before save", updateRestoreFailure, + } { + t.Run(phase, func(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + params, replacement := preparedUpdateParams( + t, + f, + map[string][]*provider.ProviderBinary{ + updateRuntimeKey: { + updateTestBinary("unavailable-original-source/runtime", []byte("old")), + }, + }, + ) + prepared, err := prepareProviderReplacement(context.Background(), params, replacement) + require.NoError(t, err) + defer func() { require.NoError(t, os.RemoveAll(prepared.stage)) }() + sentinel := errors.New("owned injected " + phase) + ops := updateCommitFailureOps(phase, sentinel) + err = prepared.commit(params, replacement, ops) + require.ErrorIs(t, err, sentinel) + if phase == updateRestoreFailure { + require.True(t, prepared.retain) + backup, readErr := os.ReadFile(filepath.Join(prepared.stage, "old-provider.json")) + require.NoError(t, readErr) + assert.Equal(t, f.before[prepared.manifest], backup) + require.ErrorContains(t, err, "owned restore failure") + } else { + require.False(t, prepared.retain) + f.assertFailedPreservation() + } + }) + } +} + +func updateCommitFailureOps(phase string, sentinel error) providerUpdateCommitOps { + ops := defaultProviderUpdateCommitOps() + switch phase { + case updateBackupPhase, updatePromotionPhase: + failAt := map[string]int{updateBackupPhase: 1, updatePromotionPhase: 2}[phase] + originalRename := ops.rename + calls := 0 + ops.rename = func(from, to string) error { + calls++ + if calls == failAt { + return sentinel + } + return originalRename(from, to) + } + case "manifest after save": + ops.saveManifest = func(context string, p *provider.ProviderConfig) error { + if err := provider.SaveProviderConfig(context, p); err != nil { + return err + } + return sentinel + } + case "config before save", updateRestoreFailure: + ops.updateConfig = func(string, string, func(*config.Config) error) error { return sentinel } + } + if phase == updateRestoreFailure { + ops.restoreManifest = func(string, []byte, fs.FileMode) error { return errors.New("owned restore failure") } + } + return ops +} + +func TestProviderUpdateCachedReplacement(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + content := []byte("new cached replacement " + f.dir) + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write(content) }, + ) + binaries := map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary(server.URL+"/runtime", content)}, + } + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + _, err := provider.DownloadBinaries(ctx, binaries, t.TempDir()) + require.NoError(t, err) + server.Close() + require.NoError(t, f.update(binaries)) + actual, err := os.ReadFile(f.binaryPath(updateRuntimeKey)) + require.NoError(t, err) + assert.Equal(t, content, actual) + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateRejectsEscapingBinaryTarget(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old")) + declaration := updateTestBinary("https://owned.invalid/runtime", []byte("new")) + declaration.Name = "../../../../daemon/owned-state" + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {declaration}}) + require.ErrorContains(t, err, "unsafe provider update binary target") + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateCachedArchiveReplacement(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old selected executable")) + sidecar := filepath.Join(f.binaries, updateRuntimeName, "lib", "seeded-sidecar") + f.put(sidecar, []byte("existing sidecar retained by legacy executable cache")) + content := []byte("cached archive replacement " + f.dir) + archive := compatibilityTar(t, true, []*tar.Header{ + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{updateRuntimeName: content}) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider.tgz", content) + binary.ArchivePath = updateRuntimeName + binaries := map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}} + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + _, err := provider.DownloadBinaries(ctx, binaries, t.TempDir()) + require.NoError(t, err) + server.Close() + require.NoError( + t, + f.update(binaries), + "closed archive server requires existing executable cache reuse", + ) + assertSelectedExecutable(t, f.binaryPath(updateRuntimeKey), content, binary.Checksum) + actual, err := os.ReadFile( + sidecar, + ) // #nosec G304 -- Sidecar belongs to the isolated update fixture. + require.NoError(t, err) + assert.Equal(t, f.before[sidecar], actual) + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateReadOnlyDirectorySeed(t *testing.T) { + if runtime.GOOS == updateWindowsOS || os.Geteuid() == 0 { + t.Skip("requires POSIX permission enforcement for an ordinary user") + } + for _, failure := range []bool{false, true} { + t.Run( + map[bool]string{false: "installed-only success", true: "download failure preserves live modes"}[failure], + func(t *testing.T) { + f := newPreservationFixture(t) + content := []byte("installed-only executable") + f.seedBinary(updateRuntimeKey, content) + ancillary, modes := seedReadOnlyAncillaryTree(t, f) + binary := updateTestBinary("unavailable-original-source/runtime", content) + if failure { + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, r *http.Request) { + http.Error(w, "owned missing replacement", http.StatusNotFound) + }, + ) + binary = updateTestBinary(server.URL+"/runtime", []byte("new replacement")) + } + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + if failure { + require.ErrorContains( + t, + err, + "404", + "seeding must succeed before the concrete download failure", + ) + f.assertFailedPreservation() + } else { + require.NoError(t, err) + // #nosec G304 -- Ancillary path belongs to the isolated archive fixture. + actual, readErr := os.ReadFile(ancillary) + require.NoError(t, readErr) + assert.Equal(t, f.before[ancillary], actual) + assertSelectedExecutable( + t, + f.binaryPath(updateRuntimeKey), + content, + binary.Checksum, + ) + } + for path, mode := range modes { + info, statErr := os.Stat(path) + require.NoError(t, statErr) + assert.Equal(t, mode, info.Mode().Perm(), path) + } + assertNoUpdateStaging(t, f) + }, + ) + } +} + +func seedReadOnlyAncillaryTree( + t *testing.T, + f *preservationFixture, +) (string, map[string]os.FileMode) { + t.Helper() + ancillary := filepath.Join(f.binaries, "unrelated", "read-only", "data") + f.put(ancillary, []byte("unchanged ancillary bytes")) + modes := map[string]os.FileMode{ + filepath.Dir(ancillary): 0o550, + filepath.Join(f.binaries, "unrelated"): 0o770, + } + t.Cleanup(func() { makeOwnedUpdateTreeRemovable(t, f.dir) }) + for path, mode := range modes { + require.NoError(t, os.Chmod(path, mode)) + } + return ancillary, modes +} + +func makeOwnedUpdateTreeRemovable(t *testing.T, directory string) { + t.Helper() + root, err := os.OpenRoot(directory) + if !assert.NoError(t, err) { + return + } + defer func() { assert.NoError(t, root.Close()) }() + err = fs.WalkDir(root.FS(), ".", func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if entry.IsDir() { + // #nosec G302 -- Owner rwx is required to remove directories in this test-owned tree. + return root.Chmod(name, 0o700) + } + return nil + }) + assert.NoError(t, err, "make only this test-owned tree removable") +} + +func TestProviderUpdateContainedSeedDirectoryLinkChain(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + content := []byte("installed executable reached through a directory link chain") + base := filepath.Join(f.binaries, updateRuntimeName) + f.put(filepath.Join(base, "releases", "v1", updateRuntimeName), content) + // Create source links in dependency order; staging must not depend on map iteration order. + targets := map[string]string{ + updateCurrentLink: filepath.Join("releases", "v1"), + updateMiddleLink: updateCurrentLink, + updateEntryLink: updateMiddleLink, + } + for _, name := range []string{updateCurrentLink, updateMiddleLink, updateEntryLink} { + require.NoError(t, os.Symlink(targets[name], filepath.Join(base, name))) + } + binary := updateTestBinary("https://offline.invalid/linked-provider.tgz", content) + binary.ArchivePath = filepath.Join(updateEntryLink, updateRuntimeName) + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + for name, want := range targets { + link := filepath.Join(base, name) + target, err := os.Readlink(link) + require.NoError(t, err) + assert.Equal(t, want, target) + info, err := os.Stat(link) + require.NoError(t, err) + assert.True(t, info.IsDir(), "seed link %s must retain directory traversal", name) + assertSelectedExecutable( + t, + filepath.Join(link, updateRuntimeName), + content, + binary.Checksum, + ) + } + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateFailedBinaryRestorationRetainsBackup(t *testing.T) { + f := newPreservationFixture(t) + content := []byte("old executable retained for recovery") + f.seedBinary(updateRuntimeKey, content) + binaries := map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {updateTestBinary("unavailable-original-source/runtime", content)}, + } + params, replacement := preparedUpdateParams(t, f, binaries) + prepared, err := prepareProviderReplacement(context.Background(), params, replacement) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, os.RemoveAll(prepared.stage)) }) + commitErr := errors.New("owned config commit failure") + restoreErr := errors.New("owned binary backup restoration failure") + ops := defaultProviderUpdateCommitOps() + ops.updateConfig = func(string, string, func(*config.Config) error) error { return commitErr } + rename := ops.rename + backup := filepath.Join(prepared.stage, updateBackupPhase) + ops.rename = func(from, to string) error { + if from == backup { + return restoreErr + } + return rename(from, to) + } + err = prepared.commit(params, replacement, ops) + require.ErrorIs(t, err, commitErr) + require.ErrorIs(t, err, restoreErr) + require.True(t, prepared.retain, "failed restoration must retain recoverable artifacts") + assertSelectedExecutable( + t, + filepath.Join(backup, updateRuntimeName, updateRuntimeName), + content, + updateTestDigest(content), + ) + // #nosec G304 -- Manifest belongs to the isolated prepared-update fixture. + manifest, err := os.ReadFile(prepared.manifest) + require.NoError(t, err) + assert.Equal(t, f.before[prepared.manifest], manifest, "manifest restoration still runs") + state := f.assertAssociation() + assert.True(t, state.Initialized) + assert.True(t, state.InitAttempted) + assert.Equal(t, f.options, state.Options) + require.DirExists(t, filepath.Join(prepared.stage, "failed-new")) + require.NoDirExists( + t, + prepared.live, + "failed rename must not claim the old binaries were restored", + ) +} diff --git a/pkg/workspace/provider_update_preservation_test.go b/pkg/workspace/provider_update_preservation_test.go new file mode 100644 index 0000000000..b02742dd4d --- /dev/null +++ b/pkg/workspace/provider_update_preservation_test.go @@ -0,0 +1,182 @@ +package workspace + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "runtime" + "sync/atomic" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestProviderUpdateFailedDownloadPreservesExisting(t *testing.T) { + f := newFailedDownloadFixture(t) + var requests atomic.Int64 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + requests.Add(1) + http.Error(w, "owned replacement artifact deliberately unavailable", http.StatusNotFound) + })) + t.Cleanup(func() { + server.CloseClientConnections() + server.Close() + t.Log( + "owned HTTP server closed and handlers joined; t.TempDir cleanup removes isolated provider/config/workspace state", + ) + }) + digest := sha256.Sum256([]byte(f.directory + " never served replacement")) + replacement := &provider.ProviderConfig{ + Name: f.name, Version: updateReplacementVersion, + Exec: provider.ProviderCommands{Command: []string{updateNoopCommand}}, + Options: map[string]*types.Option{updateKeptOption: {}}, + Binaries: map[string][]*provider.ProviderBinary{"NEW_RUNTIME": {{ + OS: runtime.GOOS, Arch: runtime.GOARCH, Name: "new-runtime", + Path: server.URL + "/runtime", Checksum: hex.EncodeToString(digest[:]), + }}}, + } + raw, err := json.Marshal(replacement) + require.NoError(t, err) + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + _, err = updateProvider(ctx, ProviderParams{ + DevsyConfig: f.config, + ProviderName: f.name, + Raw: raw, + Source: &provider.ProviderSource{ + URL: server.URL + "/provider.yaml", + Raw: server.URL + "/provider.yaml", + }, + }) + require.ErrorContains(t, err, "download binaries") + require.NoError(t, ctx.Err(), "failure must be artifact HTTP status, not deadline") + require.EqualValues(t, 1, requests.Load()) + t.Logf("actual updateProvider failure: %v", err) + f.assertPreserved(t) +} + +func (f *failedDownloadFixture) assertPreserved(t *testing.T) { + t.Helper() + for path, before := range f.files { + // #nosec G304 -- Snapshot paths are created only by the isolated preservation fixture. + after, readErr := os.ReadFile(path) + relative, relErr := filepath.Rel(f.directory, path) + require.NoError(t, relErr) + if assert.NoError( + t, + readErr, + "existing artifact %s must survive failed replacement", + relative, + ) { + assert.Equal(t, before, after, "existing artifact %s bytes must survive", relative) + } + t.Logf("preservation artifact %s: present=%v", relative, readErr == nil) + } + stored, err := config.LoadConfig(testDefaultContext, "") + require.NoError(t, err) + state := stored.Current().Providers[f.name] + require.NotNil(t, state) + assert.True(t, state.Initialized, "failed replacement must preserve initialized state") + assert.True(t, state.InitAttempted) + assert.Equal( + t, + f.options, + state.Options, + "failed replacement must preserve all existing options", + ) + assert.Equal(t, f.name, stored.Current().DefaultProvider) + t.Logf( + "persisted state: initialized=%v initAttempted=%v keep=%q obsolete=%q", + state.Initialized, + state.InitAttempted, + state.Options[updateKeptOption].Value, + state.Options[updateObsoleteOption].Value, + ) + loadedWorkspace, err := provider.LoadWorkspaceConfig(testDefaultContext, f.workspace.ID) + require.NoError(t, err) + assert.Equal(t, f.workspace.UID, loadedWorkspace.UID) + assert.Equal(t, f.workspace.Provider, loadedWorkspace.Provider) + t.Logf("workspace association retained: id=%s uid=%s provider=%s", loadedWorkspace.ID, + loadedWorkspace.UID, loadedWorkspace.Provider.Name) +} + +type failedDownloadFixture struct { + config *config.Config + name, directory string + options map[string]config.OptionValue + files map[string][]byte + workspace *provider.Workspace +} + +func newFailedDownloadFixture(t *testing.T) *failedDownloadFixture { + t.Helper() + setupTestPathManager(t) + t.Setenv(config.EnvHome, t.TempDir()) + config.ResetPathManager() + const name = "update-preservation-test" + oldOptions := map[string]config.OptionValue{ + updateKeptOption: {Value: "old-kept-value", UserProvided: true}, + updateObsoleteOption: {Value: "old-obsolete-value", UserProvided: true}, + } + initial := &config.Config{ + DefaultContext: testDefaultContext, + Contexts: map[string]*config.ContextConfig{ + testDefaultContext: { + DefaultProvider: name, + Providers: map[string]*config.ProviderConfig{ + name: {Initialized: true, InitAttempted: true, Options: oldOptions}, + }, + }, + }, + } + require.NoError(t, config.SaveConfig(initial)) + oldProvider := &provider.ProviderConfig{ + Name: name, Version: "1.0.0", + Exec: provider.ProviderCommands{Command: []string{updateNoopCommand}}, + Source: provider.ProviderSource{Internal: true, Raw: "microsandbox"}, + Options: map[string]*types.Option{updateKeptOption: {}, updateObsoleteOption: {}}, + } + require.NoError(t, provider.SaveProviderConfig(testDefaultContext, oldProvider)) + providerDir, err := provider.GetProviderDir(testDefaultContext, name) + require.NoError(t, err) + binariesDir, err := provider.GetProviderBinariesDir(testDefaultContext, name) + require.NoError(t, err) + oldBinary := filepath.Join(binariesDir, "old-runtime", "old-runtime") + require.NoError(t, os.MkdirAll(filepath.Dir(oldBinary), 0o700)) + // #nosec G306 -- The fixture must preserve an executable, not only a non-executable data file. + require.NoError(t, os.WriteFile(oldBinary, []byte("old executable bytes"), 0o700)) + sentinel := filepath.Join(providerDir, "owned-sentinel") + require.NoError(t, os.WriteFile(sentinel, []byte("existing provider user data"), 0o600)) + oldFiles := map[string][]byte{} + for _, path := range []string{filepath.Join(providerDir, provider.ProviderConfigFile), oldBinary, sentinel} { + // #nosec G304 -- These manifest, binary and sentinel paths are test-owned fixture files. + oldFiles[path], err = os.ReadFile(path) + require.NoError(t, err) + } + workspace := &provider.Workspace{ + ID: "preserved-ws", + UID: "original-uid", + Context: testDefaultContext, + Provider: provider.WorkspaceProviderConfig{ + Name: name, + Options: map[string]config.OptionValue{ + "WORKSPACE_OPTION": {Value: "unchanged", UserProvided: true}, + }, + }, + } + require.NoError(t, provider.SaveWorkspaceConfig(workspace)) + return &failedDownloadFixture{ + config: initial, name: name, directory: providerDir, + options: oldOptions, files: oldFiles, workspace: workspace, + } +} diff --git a/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx b/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx index 8f7d8718e4..d9a0b525ba 100644 --- a/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx +++ b/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx @@ -154,6 +154,10 @@ devsy provider set-source ../path-to/provider.yaml In the desktop app, use the provider's **Select version**, **Update**, and **Initialize** actions. +Devsy prepares all replacement binaries before changing the installed provider. A download, checksum, archive, or cancellation error during preparation keeps the installed binaries, provider settings, initialization state, and workspace associations intact. Absolute local binary paths are checked without modifying the referenced files. + +If publishing the prepared update fails, Devsy attempts to restore the previous files. If restoration fails, the error identifies retained recovery artifacts; keep those files for recovery. This does not guarantee recovery after a process or machine crash. Initialization runs after publication: an initialization failure leaves the new provider installed and available for another initialization attempt. + Existing workspaces keep the provider version they were created with. Recreate one with `devsy workspace up --recreate` to pick up the new version. ## Remove a provider From 7b9348436374b76312763762f5e7b17ed20a99a8 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Mon, 12 Oct 2026 23:42:20 -0600 Subject: [PATCH 02/15] fix(provider): preserve prepared binary families during updates --- pkg/provider/update_archive.go | 140 +++- pkg/provider/update_destination.go | 313 ++++++++ .../provider_update_prepared_test.go | 720 ++++++++++++++++++ .../managing-providers/manage-providers.mdx | 2 +- 4 files changed, 1159 insertions(+), 16 deletions(-) create mode 100644 pkg/provider/update_destination.go diff --git a/pkg/provider/update_archive.go b/pkg/provider/update_archive.go index 0ac54ab5db..58cfca2a38 100644 --- a/pkg/provider/update_archive.go +++ b/pkg/provider/update_archive.go @@ -17,6 +17,7 @@ import ( "github.com/devsy-org/devsy/pkg/download" "github.com/devsy-org/devsy/pkg/gitcredentials" + "github.com/devsy-org/devsy/pkg/hash" "github.com/google/uuid" ) @@ -28,6 +29,9 @@ func DownloadUpdateBinaries( binaries map[string][]*ProviderBinary, target string, ) (map[string]string, error) { + if err := validateUpdateBinaryKeys(binaries); err != nil { + return nil, err + } result := map[string]string{} for key, locations := range binaries { binary := updateBinaryForPlatform(locations) @@ -45,9 +49,29 @@ func DownloadUpdateBinaries( } result[key] = path } + // A reused alias can observe another requested family's later replacement. + // Recheck the complete prepared result before any live publication. + for key, locations := range binaries { + binary := updateBinaryForPlatform(locations) + if !updateBinaryMatches(result[key], binary.Checksum) { + return nil, fmt.Errorf( + "prepared update binary %s no longer matches its requested checksum", + key, + ) + } + } return result, nil } +func validateUpdateBinaryKeys(binaries map[string][]*ProviderBinary) error { + for key := range binaries { + if key == "" || optionNameRegEx.MatchString(key) { + return fmt.Errorf("unsafe provider update binary key %q", key) + } + } + return nil +} + func updateBinaryForPlatform(locations []*ProviderBinary) *ProviderBinary { for _, binary := range locations { if binary.OS == runtime.GOOS && binary.Arch == runtime.GOARCH { @@ -69,39 +93,80 @@ func prepareUpdateBinary( binary.Path, ) } - if !isRemotePath(binary.Path) || binary.ArchivePath == "" { - return downloadBinaryForPlatform(ctx, key, []*ProviderBinary{binary}, target) - } family := filepath.Join(target, strings.ToLower(key)) path := getBinaryPath(binary, family) - // The legacy cache contains only the executable; seeded sidecars remain unchanged on a hit. - if verifyOrRemoveBinary(path, binary.Checksum) || fromCache(binary, family) { + // Installed aliases are reusable, but checksum misses must not delete their targets. + if updateBinaryMatches(path, binary.Checksum) { return path, nil } + archive := isRemotePath(binary.Path) && binary.ArchivePath != "" + // A cache miss replaces the entire archive family. Do not first unlink a + // selected old executable whose parent may intentionally be read-only. + if archive && !cachedUpdateBinaryAvailable(binary) { + return downloadWithRetryUsing(key, binary, func() (string, error) { + return downloadConfinedUpdateArchive(ctx, binary, family) + }) + } + if err := prepareUpdateDestination(ctx, target, path); err != nil { + return "", fmt.Errorf("isolate update destination for %s: %w", key, err) + } + if !archive { + return downloadBinaryForPlatform(ctx, key, []*ProviderBinary{binary}, target) + } + return prepareUpdateArchive(ctx, key, binary, family) +} + +func prepareUpdateArchive( + ctx context.Context, + key string, + binary *ProviderBinary, + family string, +) (string, error) { + // The legacy cache contains only the executable; seeded sidecars remain unchanged on a hit. + if fromCache(binary, family) { + return getBinaryPath(binary, family), nil + } return downloadWithRetryUsing(key, binary, func() (string, error) { return downloadConfinedUpdateArchive(ctx, binary, family) }) } +func cachedUpdateBinaryAvailable(binary *ProviderBinary) bool { + path, err := getCachedBinaryPath(binary.Path) + return err == nil && updateBinaryMatches(path, binary.Checksum) +} + +// Match without the legacy verifier's destructive checksum-mismatch cleanup. +func updateBinaryMatches(path, checksum string) bool { + if _, err := os.Stat(path); err != nil { + return false + } + if checksum == "" { + return true + } + actual, err := hash.File(path) + return err == nil && strings.EqualFold(actual, checksum) +} + func downloadConfinedUpdateArchive( ctx context.Context, binary *ProviderBinary, family string, ) (_ string, err error) { - if err := os.MkdirAll(family, dirPerms); err != nil { + if err := validUpdateArchiveName(binary.ArchivePath); err != nil { return "", err } - root, err := os.OpenRoot(family) - if err != nil { + if err := removeUpdateArchiveFamily(family); err != nil { return "", err } - defer func() { err = errors.Join(err, root.Close()) }() - if err = validUpdateArchiveName(binary.ArchivePath); err != nil { + if err := os.MkdirAll(family, dirPerms); err != nil { return "", err } - if err = root.Remove(binary.ArchivePath); err != nil && !errors.Is(err, fs.ErrNotExist) { + root, err := os.OpenRoot(family) + if err != nil { return "", err } + defer func() { err = errors.Join(err, root.Close()) }() if err = fetchUpdateArchive(ctx, root, binary.Path); err != nil { return "", err } @@ -111,6 +176,44 @@ func downloadConfinedUpdateArchive( return getBinaryPath(binary, family), nil } +// Each download attempt replaces only its owned staged family; cache hits bypass this path. +func removeUpdateArchiveFamily(family string) error { + info, err := os.Lstat(family) + if errors.Is(err, fs.ErrNotExist) { + return nil + } + if err != nil { + return err + } + if info.IsDir() { + if err := makeUpdateArchiveFamilyWritable(family); err != nil { + return err + } + } + return os.RemoveAll(family) +} + +func makeUpdateArchiveFamilyWritable(family string) error { + root, err := os.OpenRoot(family) + if err != nil { + return err + } + walkErr := fs.WalkDir( + root.FS(), + ".", + func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if entry.Type()&os.ModeSymlink != 0 { + return nil + } + return root.Chmod(name, 0o700) + }, + ) + return errors.Join(walkErr, root.Close()) +} + func finalizeUpdateArchive(ctx context.Context, root *os.Root, selected string) error { if err := validateUpdateArchiveLinks(ctx, root); err != nil { return err @@ -191,6 +294,9 @@ func extractConfinedUpdateTar(ctx context.Context, root *os.Root, input io.Reade } func materializeUpdateTarEntry(root *os.Root, input io.Reader, header *tar.Header) error { + if header.Typeflag == tar.TypeXGlobalHeader { + return nil + } name := filepath.Clean(header.Name) if err := updateArchiveParents(root, header.Name); err != nil { return err @@ -199,10 +305,7 @@ func materializeUpdateTarEntry(root *os.Root, input io.Reader, header *tar.Heade case tar.TypeDir: return root.MkdirAll(name, 0o755) case tar.TypeSymlink: - if filepath.IsAbs(header.Linkname) { - return fmt.Errorf("absolute archive symlink is unsupported: %s", header.Linkname) - } - return root.Symlink(header.Linkname, name) + return materializeUpdateTarSymlink(root, name, header.Linkname) case tar.TypeLink: return materializeUpdateTarLink(root, name, header.Linkname) case tar.TypeReg: @@ -212,6 +315,13 @@ func materializeUpdateTarEntry(root *os.Root, input io.Reader, header *tar.Heade } } +func materializeUpdateTarSymlink(root *os.Root, name, target string) error { + if filepath.IsAbs(target) { + return fmt.Errorf("absolute archive symlink is unsupported: %s", target) + } + return root.Symlink(target, name) +} + func materializeUpdateTarLink(root *os.Root, name, target string) error { if err := validUpdateArchiveName(target); err != nil { return err diff --git a/pkg/provider/update_destination.go b/pkg/provider/update_destination.go new file mode 100644 index 0000000000..fc56911487 --- /dev/null +++ b/pkg/provider/update_destination.go @@ -0,0 +1,313 @@ +package provider + +import ( + "context" + "errors" + "fmt" + "io" + "io/fs" + "os" + "path/filepath" + "slices" + "strings" +) + +// prepareUpdateDestination separates only the destination's aliases before an +// update writes into the private staged tree. Installed read-only reuse bypasses +// this helper. The provider operation lock excludes cooperating writers; this +// is not a transaction against arbitrary concurrent filesystem replacement. +func prepareUpdateDestination(ctx context.Context, stageRoot, selectedPath string) (err error) { + stageRoot, selected, err := absoluteUpdateDestination(stageRoot, selectedPath) + if err != nil { + return err + } + root, err := os.OpenRoot(stageRoot) + if err != nil { + return err + } + defer func() { err = errors.Join(err, root.Close()) }() + return isolateUpdateDestination(ctx, root, selected) +} + +func absoluteUpdateDestination(stageRoot, selectedPath string) (string, string, error) { + stageRoot, err := filepath.Abs(stageRoot) + if err != nil { + return "", "", err + } + selectedPath, err = filepath.Abs(selectedPath) + if err != nil { + return "", "", err + } + selected, err := updateDestinationRelative(stageRoot, selectedPath) + if err != nil { + return "", "", err + } + if selected == "." { + return "", "", errors.New("provider update destination cannot be the staging root") + } + // Keep canonical target comparisons consistent on hosts whose temporary + // directory has a symlinked prefix, while retaining the lexical selection. + canonical, err := filepath.EvalSymlinks(stageRoot) + return canonical, selected, err +} + +func isolateUpdateDestination( + ctx context.Context, + root *os.Root, + selected string, +) error { + parts := strings.Split(selected, string(filepath.Separator)) + for index := range parts { + if err := ctx.Err(); err != nil { + return err + } + name := filepath.Join(parts[:index+1]...) + info, err := root.Lstat(name) + if errors.Is(err, fs.ErrNotExist) { + return nil + } + if err != nil { + return err + } + if index == len(parts)-1 { + return removeUpdateDestinationLeaf(root, name, info) + } + if err := isolateUpdateAncestor(ctx, root, name, info); err != nil { + return err + } + } + return nil +} + +func removeUpdateDestinationLeaf(root *os.Root, name string, info fs.FileInfo) error { + if !info.IsDir() { + return root.Remove(name) + } + return nil +} + +func isolateUpdateAncestor( + ctx context.Context, + root *os.Root, + name string, + info fs.FileInfo, +) error { + if info.Mode()&os.ModeSymlink != 0 { + return detachUpdateDirectory(ctx, root, root.Name(), name) + } + if !info.IsDir() { + return fmt.Errorf("provider update destination ancestor is not a directory: %s", name) + } + return nil +} + +func updateDestinationRelative(root, path string) (string, error) { + name, err := filepath.Rel(root, path) + if err != nil { + return "", err + } + if !filepath.IsLocal(name) { + return "", fmt.Errorf("provider update destination escapes staging: %s", path) + } + return name, nil +} + +func resolveUpdateDestination(root *os.Root, stageRoot, name string) (string, error) { + // Root.Stat checks confinement before EvalSymlinks supplies the canonical + // target needed to preserve a copied link's meaning after relocation. + if _, err := root.Stat(name); err != nil { + return "", err + } + resolved, err := filepath.EvalSymlinks(filepath.Join(stageRoot, name)) + if err != nil { + return "", err + } + return updateDestinationRelative(stageRoot, resolved) +} + +func detachUpdateDirectory(ctx context.Context, root *os.Root, stageRoot, name string) (err error) { + source, err := resolveUpdateDirectory(root, stageRoot, name) + if err != nil { + return err + } + parent := filepath.Join(stageRoot, filepath.Dir(name)) + temporary, err := os.MkdirTemp(parent, ".update-destination-") + if err != nil { + return err + } + defer func() { + if temporary != "" { + err = errors.Join(err, removeUpdateDestinationClone(temporary)) + } + }() + clone := updateDirectoryClone{ + root: root, stage: stageRoot, source: source, destination: name, temporary: temporary, + } + if err := clone.copy(ctx); err != nil { + return err + } + if err := ctx.Err(); err != nil { + return err + } + if err := root.Remove(name); err != nil { + return err + } + temporaryName := filepath.Join(filepath.Dir(name), filepath.Base(temporary)) + if err := root.Rename(temporaryName, name); err != nil { + return err + } + temporary = "" + return nil +} + +func resolveUpdateDirectory(root *os.Root, stageRoot, name string) (string, error) { + source, err := resolveUpdateDestination(root, stageRoot, name) + if err != nil { + return "", err + } + info, err := root.Stat(source) + if err != nil { + return "", err + } + if !info.IsDir() { + return "", fmt.Errorf( + "provider update ancestor alias does not target a directory: %s", + name, + ) + } + return source, nil +} + +type updateDirectoryClone struct { + root *os.Root + stage, source, destination, temporary string +} + +type updateDirectoryMode struct { + name string + mode fs.FileMode +} + +func (c *updateDirectoryClone) copy(ctx context.Context) (err error) { + source, err := c.root.OpenRoot(c.source) + if err != nil { + return err + } + defer func() { err = errors.Join(err, source.Close()) }() + out, err := os.OpenRoot(c.temporary) + if err != nil { + return err + } + defer func() { err = errors.Join(err, out.Close()) }() + directories, err := c.copyContents(ctx, source, out) + if err != nil { + return err + } + for _, directory := range slices.Backward(directories) { + if err := out.Chmod(directory.name, directory.mode); err != nil { + return err + } + } + return nil +} + +func (c *updateDirectoryClone) copyContents( + ctx context.Context, + source, out *os.Root, +) ([]updateDirectoryMode, error) { + var directories []updateDirectoryMode + err := fs.WalkDir(source.FS(), ".", func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if err := ctx.Err(); err != nil { + return err + } + // A link to an ancestor can place this temporary clone inside its source. + if filepath.Join(c.stage, c.source, name) == c.temporary { + return fs.SkipDir + } + info, err := entry.Info() + if err != nil { + return err + } + if info.IsDir() { + directories = append( + directories, + updateDirectoryMode{name: name, mode: info.Mode().Perm()}, + ) + return out.MkdirAll(name, 0o700) + } + return c.copyEntry(source, out, name, info) + }) + return directories, err +} + +func (c *updateDirectoryClone) copyEntry( + source, out *os.Root, + name string, + info fs.FileInfo, +) error { + if info.Mode()&os.ModeSymlink != 0 { + return c.copyLink(name) + } + if !info.Mode().IsRegular() { + return fmt.Errorf("unsupported provider update destination member: %s", name) + } + in, err := source.Open(name) + if err != nil { + return err + } + file, err := out.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) + if err != nil { + return errors.Join(err, in.Close()) + } + _, copyErr := io.Copy(file, in) + return errors.Join(copyErr, file.Chmod(info.Mode().Perm()), file.Close(), in.Close()) +} + +func (c *updateDirectoryClone) copyLink(name string) error { + target, err := resolveUpdateDestination(c.root, c.stage, filepath.Join(c.source, name)) + if err != nil { + return err + } + parent := filepath.Join(c.stage, c.destination, filepath.Dir(name)) + rebased, err := filepath.Rel(parent, filepath.Join(c.stage, target)) + if err != nil { + return err + } + temporary, err := updateDestinationRelative(c.stage, c.temporary) + if err != nil { + return err + } + // Use the whole stage root: Windows determines directory-link type by + // resolving its target, which can intentionally lie outside this clone. + return c.root.Symlink(rebased, filepath.Join(temporary, name)) +} + +// Only an unpromoted owned clone is made writable for removal. Never traverse +// symlink directories or chmod their targets during cleanup. +func removeUpdateDestinationClone(path string) error { + root, err := os.OpenRoot(path) + if err != nil { + return err + } + walkErr := fs.WalkDir( + root.FS(), + ".", + func(name string, entry fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if entry.Type()&os.ModeSymlink == 0 { + info, err := entry.Info() + if err != nil { + return err + } + return root.Chmod(name, info.Mode().Perm()|0o700) + } + return nil + }, + ) + return errors.Join(walkErr, root.Close(), os.RemoveAll(path)) +} diff --git a/pkg/workspace/provider_update_prepared_test.go b/pkg/workspace/provider_update_prepared_test.go index abcee0efc6..c50f276cd5 100644 --- a/pkg/workspace/provider_update_prepared_test.go +++ b/pkg/workspace/provider_update_prepared_test.go @@ -16,6 +16,7 @@ import ( "path/filepath" "runtime" "strings" + "sync/atomic" "testing" "time" @@ -64,6 +65,13 @@ func compatibilityTar( return out.Bytes() } +func singleExecutableUpdateArchive(t *testing.T, selected string, content []byte) []byte { + t.Helper() + return compatibilityTar(t, false, []*tar.Header{ + {Name: selected, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{selected: content}) +} + func compatibilityZip(t *testing.T, entries []struct { name string mode os.FileMode @@ -873,3 +881,715 @@ func TestProviderUpdateFailedBinaryRestorationRetainsBackup(t *testing.T) { "failed rename must not claim the old binaries were restored", ) } + +func TestProviderUpdatePAXGlobalMetadata(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old PAX runtime")) + content := []byte("new executable after global metadata") + const metadata = "global-metadata" + archive := compatibilityTar(t, false, []*tar.Header{ + { + Name: metadata, + Typeflag: tar.TypeXGlobalHeader, + PAXRecords: map[string]string{"comment": "owned global metadata"}, + }, + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{updateRuntimeName: content}) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/global.tar", content) + binary.ArchivePath = updateRuntimeName + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + t.Logf("PAX global-header update result: %v", err) + require.NoError(t, err) + assertSelectedExecutable(t, f.binaryPath(updateRuntimeKey), content, binary.Checksum) + require.NoFileExists(t, filepath.Join(f.binaries, updateRuntimeName, metadata)) + require.NoDirExists(t, filepath.Join(f.binaries, updateRuntimeName, metadata)) + assertNoUpdateStaging(t, f) +} + +const updateArchiveLink = "runtime-link" + +func linkedReplacementArchive(t *testing.T, linkType byte, content []byte, extra string) []byte { + t.Helper() + entries := []*tar.Header{ + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + {Name: updateArchiveLink, Typeflag: linkType, Linkname: updateRuntimeName, Mode: 0o777}, + {Name: updateSidecarPath, Typeflag: tar.TypeReg, Mode: 0o644, Size: int64(len(content))}, + } + bodies := map[string][]byte{updateRuntimeName: content, updateSidecarPath: content} + if extra != "" { + entries = append( + entries, + &tar.Header{Name: extra, Typeflag: tar.TypeReg, Mode: 0o644, Size: int64(len(content))}, + ) + bodies[extra] = content + } + return compatibilityTar(t, false, entries, bodies) +} + +func assertLinkedReplacement(t *testing.T, f *preservationFixture, linkType byte, content []byte) { + t.Helper() + selected := f.binaryPath(updateRuntimeKey) + assertSelectedExecutable(t, selected, content, updateTestDigest(content)) + link := filepath.Join(f.binaries, updateRuntimeName, updateArchiveLink) + // #nosec G304 -- Link is part of this test-owned provider archive. + linked, err := os.ReadFile(link) + require.NoError(t, err) + assert.Equal(t, content, linked) + if linkType == tar.TypeSymlink { + target, err := os.Readlink(link) + require.NoError(t, err) + assert.Equal(t, updateRuntimeName, target) + } else { + selectedInfo, err := os.Stat(selected) + require.NoError(t, err) + linkInfo, err := os.Stat(link) + require.NoError(t, err) + assert.True(t, os.SameFile(selectedInfo, linkInfo)) + } + sidecar, err := os.ReadFile(filepath.Join(f.binaries, updateRuntimeName, "lib", "sidecar")) + require.NoError(t, err) + assert.Equal(t, content, sidecar) + for _, path := range []string{ + f.binaryPath("UNRELATED"), + filepath.Join(f.dir, "owned-sentinel"), + filepath.Join(f.dir, "daemon", "owned-state"), + } { + // #nosec G304 -- These paths were populated and snapshotted by this isolated fixture. + actual, err := os.ReadFile(path) + require.NoError(t, err) + assert.Equal(t, f.before[path], actual) + } + assert.False(t, f.assertAssociation().Initialized) + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateConsecutiveLinkedArchives(t *testing.T) { + for _, linkType := range []byte{tar.TypeSymlink, tar.TypeLink} { + t.Run( + map[byte]string{tar.TypeSymlink: "symlink", tar.TypeLink: "hardlink"}[linkType], + func(t *testing.T) { + if linkType == tar.TypeSymlink { + requireProviderUpdateSymlinks(t) + } + f := newPreservationFixture(t) + f.seedBinary("UNRELATED", []byte("unrelated installed bytes")) + first, second := []byte("first linked release"), []byte("second linked release") + const stale = "obsolete-release-member" + archives := [][]byte{ + linkedReplacementArchive(t, linkType, first, stale), + linkedReplacementArchive(t, linkType, second, ""), + } + var requests atomic.Int64 + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { + index := requests.Add(1) - 1 + if index >= int64(len(archives)) { + http.Error(w, "unexpected additional request", http.StatusBadRequest) + return + } + _, _ = w.Write(archives[index]) + }, + ) + for _, content := range [][]byte{first, second} { + binary := updateTestBinary(server.URL+"/linked.tar", content) + binary.ArchivePath = updateRuntimeName + err := f.update( + map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}, + ) + t.Logf("consecutive archive request=%d result=%v", requests.Load(), err) + require.NoError(t, err) + assertLinkedReplacement(t, f, linkType, content) + } + require.EqualValues( + t, + 2, + requests.Load(), + "changed checksum must fetch a new archive", + ) + require.NoFileExists(t, filepath.Join(f.binaries, updateRuntimeName, stale)) + }, + ) + } +} + +func truncatedLinkedArchive(t *testing.T, linkType byte, content []byte) []byte { + t.Helper() + const partial = "attempt-only-member" + var data bytes.Buffer + writer := tar.NewWriter(&data) + for _, header := range []*tar.Header{ + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + {Name: updateArchiveLink, Typeflag: linkType, Linkname: updateRuntimeName, Mode: 0o777}, + {Name: partial, Typeflag: tar.TypeReg, Mode: 0o644, Size: int64(len(content))}, + {Name: "incomplete", Typeflag: tar.TypeReg, Mode: 0o644, Size: 128}, + } { + require.NoError(t, writer.WriteHeader(header)) + if header.Name == "incomplete" { + _, err := writer.Write([]byte("short")) + require.NoError(t, err) + break + } + if header.Typeflag == tar.TypeReg { + _, err := writer.Write(content) + require.NoError(t, err) + } + } + // Deliberately truncated member follows a completed link; this is a retriable tar read error. + require.Error(t, writer.Close()) + return data.Bytes() +} + +func TestProviderUpdateRetriesLinkedArchiveFromFreshFamily(t *testing.T) { + for _, linkType := range []byte{tar.TypeSymlink, tar.TypeLink} { + t.Run( + map[byte]string{tar.TypeSymlink: "symlink", tar.TypeLink: "hardlink"}[linkType], + func(t *testing.T) { + if linkType == tar.TypeSymlink { + requireProviderUpdateSymlinks(t) + } + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old live runtime")) + f.seedBinary("UNRELATED", []byte("unrelated installed bytes")) + content := []byte("complete archive after retry") + first := truncatedLinkedArchive(t, linkType, content) + second := linkedReplacementArchive(t, linkType, content, "") + var requests atomic.Int64 + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { + if requests.Add(1) == 1 { + _, _ = w.Write(first) + return + } + _, _ = w.Write(second) + }, + ) + binary := updateTestBinary(server.URL+"/retry.tar", content) + binary.ArchivePath = updateRuntimeName + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + t.Logf("linked archive retry requests=%d result=%v", requests.Load(), err) + require.EqualValues(t, 2, requests.Load()) + require.NoError(t, err) + assertLinkedReplacement(t, f, linkType, content) + require.NoFileExists( + t, + filepath.Join(f.binaries, updateRuntimeName, "attempt-only-member"), + ) + require.NoFileExists(t, filepath.Join(f.binaries, updateRuntimeName, "incomplete")) + }, + ) + } +} + +func TestProviderUpdateFamilyAliasPreservesUnrelatedBinary(t *testing.T) { + for _, cache := range []bool{false, true} { + t.Run( + map[bool]string{false: "fresh archive", true: "offline executable cache"}[cache], + func(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + old := []byte("unrelated executable must not change") + f.seedBinary("UNRELATED", old) + alias := filepath.Join(f.binaries, updateRuntimeName) + require.NoError(t, os.Symlink("unrelated", alias)) + content := []byte("replacement through alias " + f.dir) + archive := singleExecutableUpdateArchive(t, updateRuntimeName, content) + var requests atomic.Int64 + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { + requests.Add(1) + _, _ = w.Write(archive) + }, + ) + binary := updateTestBinary(server.URL+"/family-alias.tar", content) + binary.ArchivePath = updateRuntimeName + binaries := map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}} + if cache { + warmProviderUpdateCache(t, binaries, server) + } + require.NoError(t, f.update(binaries)) + require.EqualValues( + t, + 1, + requests.Load(), + "offline cache case must not fetch again", + ) + assertSelectedExecutable( + t, + f.binaryPath(updateRuntimeKey), + content, + binary.Checksum, + ) + actual, err := os.ReadFile(f.binaryPath("UNRELATED")) + t.Logf( + "unrelated binary after successful replacement: read error=%v bytes=%q", + err, + actual, + ) + require.NoError( + t, + err, + "updating an alias family must preserve the original target family", + ) + assert.Equal( + t, + old, + actual, + "cache preparation must not overwrite another family's executable", + ) + assertNoUpdateStaging(t, f) + }, + ) + } +} + +func warmProviderUpdateCache( + t *testing.T, + binaries map[string][]*provider.ProviderBinary, + server *httptest.Server, +) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + _, err := provider.DownloadBinaries(ctx, binaries, t.TempDir()) + require.NoError(t, err) + server.Close() +} + +func TestProviderUpdateFamilyAliasMatchingChecksumReuse(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + content := []byte("valid installed executable behind a contained family alias") + f.seedBinary("UNRELATED", content) + alias := filepath.Join(f.binaries, updateRuntimeName) + require.NoError(t, os.Symlink("unrelated", alias)) + binary := updateTestBinary("https://offline.invalid/matching-family.tar", content) + binary.ArchivePath = updateRuntimeName + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + assertSelectedExecutable(t, f.binaryPath(updateRuntimeKey), content, binary.Checksum) + assertSelectedExecutable(t, f.binaryPath("UNRELATED"), content, binary.Checksum) + target, err := os.Readlink(alias) + require.NoError(t, err) + assert.Equal(t, "unrelated", target, "matching installed reuse should not reset the family") + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateReadOnlySelectedArchiveFamily(t *testing.T) { + if runtime.GOOS == updateWindowsOS || os.Geteuid() == 0 { + t.Skip("requires POSIX permission enforcement for an ordinary user") + } + for _, failure := range []bool{false, true} { + t.Run( + map[bool]string{false: "fresh download", true: "failed download"}[failure], + func(t *testing.T) { + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old selected runtime")) + f.seedBinary("UNRELATED", []byte("unrelated runtime")) + oldMember := seedReadOnlySelectedUpdateFamily(t, f) + unrelatedInfo, err := os.Stat(f.binaryPath("UNRELATED")) + require.NoError(t, err) + content := []byte("fresh readonly-family replacement") + archive := singleExecutableUpdateArchive(t, updateRuntimeName, content) + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { + if failure { + http.Error(w, "owned replacement missing", http.StatusNotFound) + return + } + _, _ = w.Write(archive) + }, + ) + binary := updateTestBinary(server.URL+"/readonly.tar", content) + binary.ArchivePath = updateRuntimeName + err = f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + if failure { + require.ErrorContains(t, err, "404") + f.assertFailedPreservation() + memberInfo, statErr := os.Stat(oldMember) + require.NoError(t, statErr) + assert.Equal(t, os.FileMode(0o440), memberInfo.Mode().Perm()) + dirInfo, statErr := os.Stat(filepath.Dir(oldMember)) + require.NoError(t, statErr) + assert.Equal(t, os.FileMode(0o550), dirInfo.Mode().Perm()) + } else { + require.NoError(t, err) + assertSelectedExecutable( + t, + f.binaryPath(updateRuntimeKey), + content, + binary.Checksum, + ) + require.NoDirExists(t, filepath.Dir(oldMember)) + } + actual, readErr := os.ReadFile(f.binaryPath("UNRELATED")) + require.NoError(t, readErr) + assert.Equal(t, f.before[f.binaryPath("UNRELATED")], actual) + actualInfo, statErr := os.Stat(f.binaryPath("UNRELATED")) + require.NoError(t, statErr) + assert.Equal(t, unrelatedInfo.Mode().Perm(), actualInfo.Mode().Perm()) + assertNoUpdateStaging(t, f) + }, + ) + } +} + +func seedReadOnlySelectedUpdateFamily(t *testing.T, f *preservationFixture) string { + t.Helper() + oldMember := filepath.Join(f.binaries, updateRuntimeName, "old-readonly", "member") + f.put(oldMember, []byte("obsolete selected-family sidecar")) + t.Cleanup(func() { makeOwnedUpdateTreeRemovable(t, f.dir) }) + // #nosec G302 -- Owned fixture must exercise removal of a read-only selected family. + require.NoError(t, os.Chmod(oldMember, 0o440)) + // #nosec G302 -- Owned fixture preserves readable, non-writable directory permissions. + require.NoError(t, os.Chmod(filepath.Dir(oldMember), 0o550)) + return oldMember +} + +type updateAliasFixture struct { + fixture *preservationFixture + selected string + preserved map[string]os.FileMode +} + +func newUpdateAliasFixture(t *testing.T, kind string) updateAliasFixture { + t.Helper() + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + f.seedBinary("UNRELATED", []byte("unrelated executable retained through alias replacement")) + unrelatedSidecar := filepath.Join(f.binaries, "unrelated", "sidecar") + f.put(unrelatedSidecar, []byte("unrelated ancillary content")) + family := filepath.Join(f.binaries, updateRuntimeName) + selected := updateRuntimeName + if kind == "family" { + require.NoError(t, os.Symlink("unrelated", family)) + } else { + require.NoError(t, os.MkdirAll(family, 0o700)) + if kind == "nested" { + selected = "bin/runtime" + require.NoError(t, os.Symlink("../unrelated", filepath.Join(family, "bin"))) + } else { + require.Equal(t, "leaf", kind) + require.NoError( + t, + os.Symlink("../unrelated/runtime", filepath.Join(family, updateRuntimeName)), + ) + } + f.put(filepath.Join(family, "sidecar"), []byte("selected family ancillary content")) + } + preserved := map[string]os.FileMode{} + for _, path := range []string{f.binaryPath("UNRELATED"), unrelatedSidecar, filepath.Join(family, "sidecar")} { + info, err := os.Stat(path) + require.NoError(t, err) + preserved[path] = info.Mode().Perm() + if _, ok := f.before[path]; !ok { + f.before[path], err = os.ReadFile( + path, + ) // #nosec G304 -- Snapshot of an owned fixture alias. + require.NoError(t, err) + } + } + return updateAliasFixture{fixture: f, selected: selected, preserved: preserved} +} + +func (a updateAliasFixture) assertReplacement( + t *testing.T, + binary *provider.ProviderBinary, + content []byte, +) { + t.Helper() + selected := filepath.Join(a.fixture.binaries, updateRuntimeName, filepath.FromSlash(a.selected)) + assertSelectedExecutable(t, selected, content, binary.Checksum) + for path, mode := range a.preserved { + actual, err := os.ReadFile( + path, + ) // #nosec G304 -- All paths belong to this test-owned provider tree. + require.NoError(t, err) + assert.Equal(t, a.fixture.before[path], actual, path) + info, err := os.Stat(path) + require.NoError(t, err) + assert.Equal(t, mode, info.Mode().Perm(), path) + } + a.fixture.assertAssociation() + assertNoUpdateStaging(t, a.fixture) +} + +func TestProviderUpdateNestedAndLeafAliasOfflineCache(t *testing.T) { + for _, kind := range []string{"nested", "leaf"} { + t.Run(kind, func(t *testing.T) { + a := newUpdateAliasFixture(t, kind) + content := []byte("cached independent replacement " + a.fixture.dir) + archive := compatibilityTar(t, false, []*tar.Header{ + {Name: a.selected, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{a.selected: content}) + var requests atomic.Int64 + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, _ *http.Request) { + requests.Add(1) + _, _ = w.Write(archive) + }) + binary := updateTestBinary(server.URL+"/nested-alias.tar", content) + binary.ArchivePath = a.selected + binaries := map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}} + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + _, err := provider.DownloadBinaries(ctx, binaries, t.TempDir()) + require.NoError(t, err) + server.Close() + require.NoError( + t, + a.fixture.update(binaries), + "warmed executable cache must work with the source offline", + ) + require.EqualValues( + t, + 1, + requests.Load(), + "replacement must not fetch the archive again", + ) + a.assertReplacement(t, binary, content) + }) + } +} + +func TestProviderUpdatePlainAndLocalAncestorAlias(t *testing.T) { + for _, local := range []bool{false, true} { + t.Run( + map[bool]string{false: "plain remote", true: "relative local"}[local], + func(t *testing.T) { + a := newUpdateAliasFixture(t, "family") + content := []byte("independent plain replacement " + a.fixture.dir) + binary := updateTestBinary("source-runtime", content) + var requests atomic.Int64 + if local { + t.Chdir(t.TempDir()) + require.NoError(t, os.WriteFile(binary.Path, content, 0o600)) + } else { + server := ownedProviderUpdateServer( + t, + func(w http.ResponseWriter, _ *http.Request) { + requests.Add(1) + _, _ = w.Write(content) + }, + ) + binary.Path = server.URL + "/plain-runtime" + } + require.NoError( + t, + a.fixture.update( + map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}, + ), + ) + if local { + actual, err := os.ReadFile( + binary.Path, + ) // #nosec G304 -- Relative source in owned temporary cwd. + require.NoError(t, err) + assert.Equal(t, content, actual) + } else { + require.EqualValues(t, 1, requests.Load()) + } + a.assertReplacement(t, binary, content) + }, + ) + } +} + +func TestProviderUpdateAncestorRootAliasOfflineCache(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + old := []byte("original root descendant remains unchanged") + f.seedBinary("UNRELATED", old) + f.put( + filepath.Join(f.binaries, "unrelated", "sidecar"), + []byte("retained root descendant sidecar"), + ) + require.NoError(t, os.Symlink(".", filepath.Join(f.binaries, updateRuntimeName))) + require.NoError(t, os.Symlink("unrelated", filepath.Join(f.binaries, "directory-link"))) + require.NoError(t, os.Symlink("unrelated/runtime", filepath.Join(f.binaries, "file-link"))) + content := []byte("root alias cached replacement " + f.dir) + selected := "unrelated/runtime" + archive := compatibilityTar(t, false, []*tar.Header{ + {Name: selected, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{selected: content}) + var requests atomic.Int64 + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, _ *http.Request) { + requests.Add(1) + _, _ = w.Write(archive) + }) + binary := updateTestBinary(server.URL+"/ancestor-root.tar", content) + binary.ArchivePath = selected + binaries := map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}} + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + _, err := provider.DownloadBinaries(ctx, binaries, t.TempDir()) + require.NoError(t, err) + server.Close() + require.NoError( + t, + f.update(binaries), + "ancestor-root cloning must complete within the fixture deadline", + ) + require.EqualValues(t, 1, requests.Load(), "offline consumption must not refetch") + family := filepath.Join(f.binaries, updateRuntimeName) + assertSelectedExecutable( + t, + filepath.Join(family, filepath.FromSlash(selected)), + content, + binary.Checksum, + ) + assertSelectedExecutable(t, f.binaryPath("UNRELATED"), old, updateTestDigest(old)) + assertRebasedUpdateRootLinks(t, f, family, old) + assertNoUpdateStaging(t, f) +} + +func assertRebasedUpdateRootLinks(t *testing.T, f *preservationFixture, family string, old []byte) { + t.Helper() + for _, link := range []string{"directory-link", "file-link"} { + path := filepath.Join(family, link) + info, err := os.Lstat(path) + require.NoError(t, err) + require.NotZero(t, info.Mode()&os.ModeSymlink) + resolved, err := filepath.EvalSymlinks(path) + require.NoError(t, err) + original, err := filepath.EvalSymlinks(filepath.Join(f.binaries, link)) + require.NoError(t, err) + assert.Equal( + t, + original, + resolved, + "cloned link must keep the original target, not the replaced executable", + ) + } + for _, path := range []string{ + filepath.Join(family, "file-link"), filepath.Join(family, "directory-link", updateRuntimeName), + } { + assertSelectedExecutable(t, path, old, updateTestDigest(old)) + } + for _, base := range []string{f.binaries, family} { + path := filepath.Join(base, "unrelated", "sidecar") + actual, err := os.ReadFile(path) // #nosec G304 -- Original or cloned test-owned sidecar. + require.NoError(t, err) + assert.Equal(t, f.before[filepath.Join(f.binaries, "unrelated", "sidecar")], actual) + } + entries, err := os.ReadDir(family) + require.NoError(t, err) + for _, entry := range entries { + assert.NotContains( + t, + entry.Name(), + ".update-destination-", + "temporary clone must not copy itself", + ) + } + f.assertAssociation() +} + +func TestProviderUpdateReadOnlyNestedSelectedExecutable(t *testing.T) { + if runtime.GOOS == updateWindowsOS || os.Geteuid() == 0 { + t.Skip("requires POSIX permission enforcement for an ordinary user") + } + f := newPreservationFixture(t) + f.seedBinary("UNRELATED", []byte(updateUnrelatedContent)) + selected := "readonly/runtime" + oldPath := filepath.Join(f.binaries, updateRuntimeName, filepath.FromSlash(selected)) + f.put(oldPath, []byte("old selected executable inside readonly directory")) + t.Cleanup(func() { makeOwnedUpdateTreeRemovable(t, f.dir) }) + // #nosec G302 -- Owned executable deliberately has no owner-write permission. + require.NoError(t, os.Chmod(oldPath, 0o550)) + // #nosec G302 -- Owned fixture directory must remain searchable but non-writable. + require.NoError(t, os.Chmod(filepath.Dir(oldPath), 0o550)) + content := []byte("new selected executable after safe archive family reset") + archive := compatibilityTar(t, false, []*tar.Header{ + {Name: "readonly", Typeflag: tar.TypeDir, Mode: 0o755}, + {Name: selected, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{selected: content}) + var requests atomic.Int64 + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, _ *http.Request) { + requests.Add(1) + _, _ = w.Write(archive) + }) + binary := updateTestBinary(server.URL+"/readonly-selected.tar", content) + binary.ArchivePath = selected + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + require.EqualValues( + t, + 1, + requests.Load(), + "fresh archive must be fetched without a seeded cache", + ) + assertSelectedExecutable(t, oldPath, content, binary.Checksum) + actual, err := os.ReadFile(f.binaryPath("UNRELATED")) + require.NoError(t, err) + assert.Equal(t, f.before[f.binaryPath("UNRELATED")], actual) + f.assertAssociation() + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateConflictingReusedFamilyAlias(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + old := []byte("both selected families initially expose these old bytes") + f.seedBinary(updateFirstKey, old) + f.seedBinary(updateSecondKey, old) + firstFamily := filepath.Dir(f.binaryPath(updateFirstKey)) + require.NoError(t, os.Remove(f.binaryPath(updateFirstKey))) + require.NoError(t, os.Remove(firstFamily)) + target := filepath.Base(filepath.Dir(f.binaryPath(updateSecondKey))) + require.NoError(t, os.Symlink(target, firstFamily)) + content := []byte("only the second family requests these new bytes") + var missingRequests, replacementRequests atomic.Int64 + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/missing-first" { + missingRequests.Add(1) + http.Error(w, "owned first-family source deliberately unavailable", http.StatusNotFound) + return + } + replacementRequests.Add(1) + _, _ = w.Write(content) + }) + first := updateTestBinary(server.URL+"/missing-first", old) + second := updateTestBinary(server.URL+"/new-second", content) + err := f.update(map[string][]*provider.ProviderBinary{ + updateFirstKey: {first}, updateSecondKey: {second}, + }) + require.EqualValues(t, 1, replacementRequests.Load()) + t.Logf("first-family fetches=%d; update result=%v", missingRequests.Load(), err) + if err == nil { + // Independent materialization is permitted, but alias reuse must never + // publish the second family's bytes under the first family's checksum. + assertSelectedExecutable(t, f.binaryPath(updateFirstKey), old, first.Checksum) + assertSelectedExecutable(t, f.binaryPath(updateSecondKey), content, second.Checksum) + } else { + require.True( + t, + strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "checksum"), + "both map iteration orders must fail for the conflict, not an unrelated error: %v", + err, + ) + f.assertFailedPreservation() + link, linkErr := os.Readlink(firstFamily) + require.NoError(t, linkErr) + assert.Equal(t, target, link) + } + assertNoUpdateStaging(t, f) +} + +func TestProviderUpdateEmptyBinaryKeyPreservesUnrelatedFamily(t *testing.T) { + f := newPreservationFixture(t) + content := []byte("empty-key selected executable") + f.seedBinary("UNRELATED", []byte("retained unrelated installed executable")) + archive := compatibilityTar(t, false, []*tar.Header{ + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{updateRuntimeName: content}) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/empty-key.tar", content) + binary.ArchivePath = updateRuntimeName + + err := f.update(map[string][]*provider.ProviderBinary{"": {binary}}) + require.ErrorContains(t, err, "unsafe provider update binary key") + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} diff --git a/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx b/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx index d9a0b525ba..3e8e66e91a 100644 --- a/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx +++ b/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx @@ -154,7 +154,7 @@ devsy provider set-source ../path-to/provider.yaml In the desktop app, use the provider's **Select version**, **Update**, and **Initialize** actions. -Devsy prepares all replacement binaries before changing the installed provider. A download, checksum, archive, or cancellation error during preparation keeps the installed binaries, provider settings, initialization state, and workspace associations intact. Absolute local binary paths are checked without modifying the referenced files. +Devsy prepares the replacement provider’s installation binaries (`binaries`) before changing the installed provider. Runtime binaries declared under `agent.binaries` are prepared later by workspace operations. A download, checksum, archive, or cancellation error during preparation keeps the installed binaries, provider settings, initialization state, and workspace associations intact. Absolute local binary paths are checked without modifying the referenced files. If publishing the prepared update fails, Devsy attempts to restore the previous files. If restoration fails, the error identifies retained recovery artifacts; keep those files for recovery. This does not guarantee recovery after a process or machine crash. Initialization runs after publication: an initialization failure leaves the new provider installed and available for another initialization attempt. From 5d3003fd3102fc702dfd61bec55ba52c1c98d3cd Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 01:31:12 -0600 Subject: [PATCH 03/15] test(provider): require Windows update preservation coverage --- .github/workflows/pr-ci.yml | 73 +++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index d3843b938e..dfa6e6113d 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -131,6 +131,77 @@ jobs: go test -race -short -count=1 -v ./e2e/tests/up-docker-compose \ -run '^TestExpectedUIDMapping$' + provider-update-windows: + name: Provider Update Tests (windows-latest) + needs: [changes] + if: needs.changes.outputs.go == 'true' + runs-on: windows-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + + - name: setup Go + uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7 + with: + go-version-file: go.mod + + - name: run provider update tests and require Windows coverage + shell: pwsh + run: | + $jsonPath = Join-Path $env:RUNNER_TEMP 'provider-update-windows.jsonl' + $exitPath = Join-Path $env:RUNNER_TEMP 'provider-update-windows.exitcode' + & go test -race -json -count=1 -timeout 10m ./pkg/workspace -run '^TestProviderUpdate' | + Tee-Object -FilePath $jsonPath + $testExitCode = $LASTEXITCODE + Set-Content -LiteralPath $exitPath -Value $testExitCode -NoNewline + + if ($testExitCode -ne 0) { + Write-Error "Provider update tests failed with exit code $testExitCode" + exit $testExitCode + } + + $events = @( + Get-Content -LiteralPath $jsonPath | + ForEach-Object { try { ConvertFrom-Json -InputObject $_ -ErrorAction Stop } catch { $null } } | + Where-Object { $null -ne $_ } + ) + $criticalTests = @( + 'TestProviderUpdateZipCompatibility/plain_archive', + 'TestProviderUpdateZipCompatibility/contained_file_symlink', + 'TestProviderUpdateTarContainedDirectoryLinkThenRegularMember', + 'TestProviderUpdateContainedSeedDirectoryLinkChain', + 'TestProviderUpdateArchivePreservesOwnedDaemon' + ) + $status = 0 + foreach ($testName in $criticalTests) { + $testEvents = @($events | Where-Object { $_.Test -eq $testName }) + if ($testEvents.Count -eq 0) { + Write-Error "Required Windows provider update test produced no JSON events: $testName" + $status = 1 + continue + } + if (@($testEvents | Where-Object { $_.Action -eq 'skip' }).Count -gt 0) { + Write-Error "Required Windows provider update test was skipped: $testName" + $status = 1 + continue + } + if (@($testEvents | Where-Object { $_.Action -eq 'pass' }).Count -eq 0) { + Write-Error "Required Windows provider update test did not pass: $testName" + $status = 1 + } + } + exit $status + + - name: upload provider update test JSON on failure + if: failure() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + with: + name: provider-update-windows-test-json + path: | + ${{ runner.temp }}/provider-update-windows.jsonl + ${{ runner.temp }}/provider-update-windows.exitcode + if-no-files-found: ignore + can-read-secret: name: Can Read Secret runs-on: ubuntu-latest @@ -1201,6 +1272,7 @@ jobs: - lint - agent-skill - unit-tests + - provider-update-windows - licenses - build-cli - integration-tests-unprivileged @@ -1237,6 +1309,7 @@ jobs: check_result "lint" "${{ needs.lint.result }}" false || status=1 check_result "agent-skill" "${{ needs.agent-skill.result }}" false || status=1 check_result "unit-tests" "${{ needs.unit-tests.result }}" true || status=1 + check_result "provider-update-windows" "${{ needs.provider-update-windows.result }}" true || status=1 check_result "licenses" "${{ needs.licenses.result }}" true || status=1 check_result "build-cli" "${{ needs.build-cli.result }}" true || status=1 check_result "integration-tests-unprivileged" "${{ needs.integration-tests-unprivileged.result }}" true || status=1 From bcff13c107b4e3a9a89b4073f4ab8b19d3c25405 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 03:24:34 -0600 Subject: [PATCH 04/15] fix(provider): handle confined Windows parent symlinks --- .github/workflows/pr-ci.yml | 8 ++- .pre-commit-config.yaml | 4 +- go.mod | 2 +- mise.lock | 12 ++-- mise.toml | 2 +- pkg/provider/update_archive.go | 2 +- pkg/provider/update_destination.go | 4 +- pkg/provider/update_stat.go | 39 ++++++++++ pkg/provider/update_stat_test.go | 71 +++++++++++++++++++ pkg/workspace/provider_update_archive_test.go | 17 +++-- pkg/workspace/provider_update_prepared.go | 7 +- 11 files changed, 147 insertions(+), 21 deletions(-) create mode 100644 pkg/provider/update_stat.go create mode 100644 pkg/provider/update_stat_test.go diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index dfa6e6113d..379558b2ce 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -150,7 +150,7 @@ jobs: run: | $jsonPath = Join-Path $env:RUNNER_TEMP 'provider-update-windows.jsonl' $exitPath = Join-Path $env:RUNNER_TEMP 'provider-update-windows.exitcode' - & go test -race -json -count=1 -timeout 10m ./pkg/workspace -run '^TestProviderUpdate' | + & go test -race -json -count=1 -timeout 10m ./pkg/workspace ./pkg/provider -run '^(TestProviderUpdate|TestStatUpdatePath)' | Tee-Object -FilePath $jsonPath $testExitCode = $LASTEXITCODE Set-Content -LiteralPath $exitPath -Value $testExitCode -NoNewline @@ -170,7 +170,11 @@ jobs: 'TestProviderUpdateZipCompatibility/contained_file_symlink', 'TestProviderUpdateTarContainedDirectoryLinkThenRegularMember', 'TestProviderUpdateContainedSeedDirectoryLinkChain', - 'TestProviderUpdateArchivePreservesOwnedDaemon' + 'TestProviderUpdateArchivePreservesOwnedDaemon', + 'TestStatUpdatePath/nested_dot_directory', + 'TestStatUpdatePath/nested_cancelled_child', + 'TestStatUpdatePath/external_target', + 'TestStatUpdatePath/cycle' ) $status = 0 foreach ($testName in $criticalTests) { diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index aeebe549db..db53e2fc90 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -62,10 +62,10 @@ repos: rev: v2.13.2 hooks: - id: golangci-lint - language_version: 1.26.8 + language_version: 1.26.9 args: ["--timeout=10m"] - id: golangci-lint-fmt - language_version: 1.26.8 + language_version: 1.26.9 - repo: local hooks: - id: golangci-lint-ci-parity diff --git a/go.mod b/go.mod index 51a67c52fc..c7e4f0cafe 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/devsy-org/devsy -go 1.26.8 +go 1.26.9 require ( al.essio.dev/pkg/shellescape v1.6.1 diff --git a/mise.lock b/mise.lock index 510893da2d..1540b57535 100644 --- a/mise.lock +++ b/mise.lock @@ -20,17 +20,17 @@ url_api = "https://api.github.com/repos/cli/cli/releases/assets/542974295" provenance = "github-attestations" [[tools.go]] -version = "1.26.8" +version = "1.26.9" backend = "core:go" -specifiers = ["1.26.8"] +specifiers = ["1.26.9"] [tools.go."platforms.linux-x64"] -checksum = "sha256:d0f743b33e8d8945e6b1f432edd15785c70507121d6e2a723b21285eddf8b57b" -url = "https://dl.google.com/go/go1.26.8.linux-amd64.tar.gz" +checksum = "sha256:42d158b4d8f7b61ac0a830567c940a86098fb7aac52e467a5ebec03ef5cc2f8d" +url = "https://dl.google.com/go/go1.26.9.linux-amd64.tar.gz" [tools.go."platforms.macos-arm64"] -checksum = "sha256:a012b25b571bd0138a03dcd25375ceba866fe5ca822f426d2c66a4de56fd3f4b" -url = "https://dl.google.com/go/go1.26.8.darwin-arm64.tar.gz" +checksum = "sha256:f9bb7c0a02506c5d9bf0d1eb1f7ee6c7684f844ae49558308a0427b830e022cc" +url = "https://dl.google.com/go/go1.26.9.darwin-arm64.tar.gz" [[tools.golangci-lint]] version = "2.13.2" diff --git a/mise.toml b/mise.toml index b730560849..4a4a33351d 100644 --- a/mise.toml +++ b/mise.toml @@ -7,7 +7,7 @@ lockfile_platforms = ["linux-x64", "macos-arm64"] locked = true [tools] -go = "1.26.8" +go = "1.26.9" node = "24" task = "3.53.1" golangci-lint = "2.13.2" diff --git a/pkg/provider/update_archive.go b/pkg/provider/update_archive.go index 58cfca2a38..059346e714 100644 --- a/pkg/provider/update_archive.go +++ b/pkg/provider/update_archive.go @@ -418,7 +418,7 @@ func validateUpdateArchiveLinks(ctx context.Context, root *os.Root) error { return err } if entry.Type()&os.ModeSymlink != 0 { - info, err := root.Stat(name) + info, err := StatUpdatePath(root, name) if err != nil { return fmt.Errorf("unsafe update archive symlink %s: %w", name, err) } diff --git a/pkg/provider/update_destination.go b/pkg/provider/update_destination.go index fc56911487..667c0dedfd 100644 --- a/pkg/provider/update_destination.go +++ b/pkg/provider/update_destination.go @@ -115,7 +115,7 @@ func updateDestinationRelative(root, path string) (string, error) { func resolveUpdateDestination(root *os.Root, stageRoot, name string) (string, error) { // Root.Stat checks confinement before EvalSymlinks supplies the canonical // target needed to preserve a copied link's meaning after relocation. - if _, err := root.Stat(name); err != nil { + if _, err := StatUpdatePath(root, name); err != nil { return "", err } resolved, err := filepath.EvalSymlinks(filepath.Join(stageRoot, name)) @@ -165,7 +165,7 @@ func resolveUpdateDirectory(root *os.Root, stageRoot, name string) (string, erro if err != nil { return "", err } - info, err := root.Stat(source) + info, err := StatUpdatePath(root, source) if err != nil { return "", err } diff --git a/pkg/provider/update_stat.go b/pkg/provider/update_stat.go new file mode 100644 index 0000000000..13131f3f69 --- /dev/null +++ b/pkg/provider/update_stat.go @@ -0,0 +1,39 @@ +package provider + +import ( + "io/fs" + "os" + "path/filepath" + "runtime" + "syscall" +) + +// StatUpdatePath retains Root confinement while avoiding a Windows Root.Stat +// panic when a terminal relative link normalizes to its own parent directory. +// Windows cleans link targets before traversal; POSIX must retain kernel ordering. +func StatUpdatePath(root *os.Root, name string) (fs.FileInfo, error) { + if runtime.GOOS != "windows" { + return root.Stat(name) + } + original := name + // Match Root's link traversal bound without following arbitrary targets. + for remaining := 8; ; remaining-- { + parent, alias := updatePathParentAlias(root, name) + if !alias { + return root.Stat(name) + } + if remaining == 0 { + return nil, &os.PathError{Op: "stat", Path: original, Err: syscall.ELOOP} + } + name = parent + } +} + +func updatePathParentAlias(root *os.Root, name string) (string, bool) { + target, err := root.Readlink(name) + if err != nil || filepath.IsAbs(target) || filepath.VolumeName(target) != "" { + return "", false + } + parent := filepath.Dir(name) + return parent, parent != name && filepath.Join(parent, target) == parent +} diff --git a/pkg/provider/update_stat_test.go b/pkg/provider/update_stat_test.go new file mode 100644 index 0000000000..cf7e3a3aa5 --- /dev/null +++ b/pkg/provider/update_stat_test.go @@ -0,0 +1,71 @@ +package provider + +import ( + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestStatUpdatePath(t *testing.T) { + base := t.TempDir() + owned := filepath.Join(base, "owned") + nested := filepath.Join(owned, "nested") + require.NoError(t, os.MkdirAll(filepath.Join(nested, "sub"), 0o700)) + require.NoError(t, os.WriteFile(filepath.Join(owned, "file"), []byte("owned"), 0o600)) + require.NoError(t, os.Mkdir(filepath.Join(owned, "directory"), 0o700)) + require.NoError(t, os.Symlink(".", filepath.Join(nested, "dot"))) + require.NoError( + t, + os.Symlink("sub"+string(filepath.Separator)+"..", filepath.Join(nested, "cancelled")), + ) + require.NoError(t, os.Symlink("../file", filepath.Join(nested, "regular"))) + require.NoError(t, os.Symlink("../directory", filepath.Join(nested, "directory-link"))) + + outside := filepath.Join(base, "outside") + require.NoError(t, os.Mkdir(outside, 0o700)) + sentinel := filepath.Join(outside, "sentinel") + require.NoError(t, os.WriteFile(sentinel, []byte("untouched"), 0o600)) + require.NoError(t, os.Symlink("../../outside", filepath.Join(nested, "escape"))) + require.NoError(t, os.Symlink("cycle-b", filepath.Join(nested, "cycle-a"))) + require.NoError(t, os.Symlink("cycle-a", filepath.Join(nested, "cycle-b"))) + + root, err := os.OpenRoot(owned) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, root.Close()) }) + + t.Run("nested_dot_directory", func(t *testing.T) { + info, err := StatUpdatePath(root, filepath.Join("nested", "dot")) + require.NoError(t, err) + require.True(t, info.IsDir()) + }) + t.Run("nested_cancelled_child", func(t *testing.T) { + info, err := StatUpdatePath(root, filepath.Join("nested", "cancelled")) + require.NoError(t, err) + require.True(t, info.IsDir()) + }) + t.Run("regular_file", func(t *testing.T) { + info, err := StatUpdatePath(root, filepath.Join("nested", "regular")) + require.NoError(t, err) + require.True(t, info.Mode().IsRegular()) + require.Equal(t, int64(len("owned")), info.Size()) + }) + t.Run("directory_target", func(t *testing.T) { + info, err := StatUpdatePath(root, filepath.Join("nested", "directory-link")) + require.NoError(t, err) + require.True(t, info.IsDir()) + }) + t.Run("external_target", func(t *testing.T) { + _, err := StatUpdatePath(root, filepath.Join("nested", "escape")) + require.Error(t, err) + // #nosec G304 -- Sentinel belongs to this test's private temporary directory. + actual, readErr := os.ReadFile(sentinel) + require.NoError(t, readErr) + require.Equal(t, []byte("untouched"), actual) + }) + t.Run("cycle", func(t *testing.T) { + _, err := StatUpdatePath(root, filepath.Join("nested", "cycle-a")) + require.Error(t, err) + }) +} diff --git a/pkg/workspace/provider_update_archive_test.go b/pkg/workspace/provider_update_archive_test.go index 50c9a0b9e1..d640bb9264 100644 --- a/pkg/workspace/provider_update_archive_test.go +++ b/pkg/workspace/provider_update_archive_test.go @@ -7,6 +7,7 @@ import ( "net/http" "os" "path/filepath" + "runtime" "testing" "github.com/devsy-org/devsy/pkg/provider" @@ -42,16 +43,24 @@ func TestProviderUpdateArchivePreservesOwnedDaemon(t *testing.T) { requireProviderUpdateSymlinks(t) f := newPreservationFixture(t) f.seedBinary(updateRuntimeKey, []byte("old runtime")) - // Every link target cleans lexically to the extraction root, but the kernel - // follows prior links first. D reaches this test-owned provider directory. - archive := ownedContainmentArchive(t, []ownedArchiveEntry{ + entries := []ownedArchiveEntry{ {name: "linkA", target: "."}, {name: "linkB", target: "linkA/.."}, {name: "linkC", target: "linkB/.."}, {name: "linkD", target: "linkC/.."}, {name: "linkD/daemon/owned-state", body: "archive escaped staging into owned daemon"}, {name: updateRuntimeName, body: updateExecutableContent}, - }) + } + if runtime.GOOS == updateWindowsOS { + // Windows cleans link targets before traversal, so use a direct relative + // escape to the fixture-owned daemon rather than the POSIX link-order chain. + entries = []ownedArchiveEntry{ + {name: "escape", target: filepath.Join("..", "..", "..", "daemon")}, + {name: "escape/owned-state", body: "archive escaped staging into owned daemon"}, + {name: updateRuntimeName, body: updateExecutableContent}, + } + } + archive := ownedContainmentArchive(t, entries) server := ownedProviderUpdateServer( t, func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write(archive) }, diff --git a/pkg/workspace/provider_update_prepared.go b/pkg/workspace/provider_update_prepared.go index ee911976a0..72c094b959 100644 --- a/pkg/workspace/provider_update_prepared.go +++ b/pkg/workspace/provider_update_prepared.go @@ -301,7 +301,10 @@ func (c *providerSeedCopier) copyLinks() error { copied := false for name, target := range c.links { // Keep dot components intact: a preceding symlink can change their resolution. - _, err := c.destination.Stat(filepath.Dir(name) + string(filepath.Separator) + target) + _, err := provider.StatUpdatePath( + c.destination, + filepath.Dir(name)+string(filepath.Separator)+target, + ) if errors.Is(err, fs.ErrNotExist) { continue } @@ -338,7 +341,7 @@ func validateProviderSeed(ctx context.Context, root *os.Root, display string) er func validateProviderSeedEntry(root *os.Root, name string, entry fs.DirEntry) error { if entry.Type()&os.ModeSymlink != 0 { - resolved, err := root.Stat(name) + resolved, err := provider.StatUpdatePath(root, name) if err != nil { return fmt.Errorf("unsafe provider update symlink %s: %w", name, err) } From 2e737f60803804721ff0be69644847e059532b48 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 03:48:00 -0600 Subject: [PATCH 05/15] test(provider): classify unavailable Windows symlink privileges --- pkg/provider/update_stat_test.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/pkg/provider/update_stat_test.go b/pkg/provider/update_stat_test.go index cf7e3a3aa5..cf343e9a1b 100644 --- a/pkg/provider/update_stat_test.go +++ b/pkg/provider/update_stat_test.go @@ -1,8 +1,11 @@ package provider import ( + "errors" "os" "path/filepath" + "runtime" + "syscall" "testing" "github.com/stretchr/testify/require" @@ -10,6 +13,7 @@ import ( func TestStatUpdatePath(t *testing.T) { base := t.TempDir() + requireUpdateStatSymlinks(t, base) owned := filepath.Join(base, "owned") nested := filepath.Join(owned, "nested") require.NoError(t, os.MkdirAll(filepath.Join(nested, "sub"), 0o700)) @@ -69,3 +73,18 @@ func TestStatUpdatePath(t *testing.T) { require.Error(t, err) }) } + +func requireUpdateStatSymlinks(t *testing.T, base string) { + t.Helper() + if runtime.GOOS == "windows" { + probe := filepath.Join(base, "symlink-capability") + err := os.Symlink(".", probe) + // ERROR_PRIVILEGE_NOT_HELD is Windows errno 1314; other setup errors must fail. + const privilegeNotHeld = syscall.Errno(1314) + if errors.Is(err, privilegeNotHeld) { + t.Skipf("Windows account cannot create symbolic links: %v", err) + } + require.NoError(t, err) + require.NoError(t, os.Remove(probe)) + } +} From 37df5eb97779863b3c006c3c2488e669621868b0 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 08:02:44 -0600 Subject: [PATCH 06/15] fix(provider): retain successful updates after staging cleanup errors --- pkg/workspace/provider_update_prepared.go | 38 +++++--- .../provider_update_prepared_test.go | 88 +++++++++++++++++++ 2 files changed, 115 insertions(+), 11 deletions(-) diff --git a/pkg/workspace/provider_update_prepared.go b/pkg/workspace/provider_update_prepared.go index 72c094b959..08939cb6be 100644 --- a/pkg/workspace/provider_update_prepared.go +++ b/pkg/workspace/provider_update_prepared.go @@ -14,6 +14,7 @@ import ( "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/hash" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/provider" ) @@ -23,6 +24,15 @@ func replaceProviderPrepared( ctx context.Context, p ProviderParams, replacement *provider.ProviderConfig, +) (err error) { + return replaceProviderPreparedWithOps(ctx, p, replacement, defaultProviderUpdateCommitOps()) +} + +func replaceProviderPreparedWithOps( + ctx context.Context, + p ProviderParams, + replacement *provider.ProviderConfig, + ops providerUpdateCommitOps, ) (err error) { prepared, err := prepareProviderReplacement(ctx, p, replacement) if err != nil { @@ -34,21 +44,25 @@ func replaceProviderPrepared( err, fmt.Errorf("provider recovery artifacts retained at %s", prepared.stage), ) - } else if cleanupErr := removeProviderUpdateStage(prepared.stage); cleanupErr != nil { + } else if cleanupErr := ops.removeStage(prepared.stage); cleanupErr != nil { + if prepared.committed && err == nil { + log.Warnf( + "remove provider update staging %s after commit: %v", + prepared.stage, + cleanupErr, + ) + return + } err = errors.Join( err, - fmt.Errorf( - "remove owned provider update staging (commit completed=%t): %w", - prepared.committed, - cleanupErr, - ), + fmt.Errorf("remove owned provider update staging: %w", cleanupErr), ) } }() if err = ctx.Err(); err != nil { return err } - return prepared.commit(p, replacement, defaultProviderUpdateCommitOps()) + return prepared.commit(p, replacement, ops) } type preparedProviderReplacement struct { @@ -425,14 +439,16 @@ type providerUpdateCommitOps struct { saveManifest func(string, *provider.ProviderConfig) error updateConfig func(string, string, func(*config.Config) error) error restoreManifest func(string, []byte, fs.FileMode) error + removeStage func(string) error } func defaultProviderUpdateCommitOps() providerUpdateCommitOps { return providerUpdateCommitOps{ - os.Rename, - provider.SaveProviderConfig, - config.UpdateConfig, - provider.WriteFileAtomic, + rename: os.Rename, + saveManifest: provider.SaveProviderConfig, + updateConfig: config.UpdateConfig, + restoreManifest: provider.WriteFileAtomic, + removeStage: removeProviderUpdateStage, } } diff --git a/pkg/workspace/provider_update_prepared_test.go b/pkg/workspace/provider_update_prepared_test.go index c50f276cd5..2956c84a06 100644 --- a/pkg/workspace/provider_update_prepared_test.go +++ b/pkg/workspace/provider_update_prepared_test.go @@ -608,6 +608,94 @@ func TestProviderUpdateSynchronousCommitRestoration(t *testing.T) { } } +func TestProviderUpdateStageCleanupFailure(t *testing.T) { + for _, tc := range []struct { + name string + committed bool + }{{name: "after commit", committed: true}, {name: "before commit"}} { + t.Run(tc.name, func(t *testing.T) { + f := newPreservationFixture(t) + params, replacement, updated := cleanupFailureUpdateFixture(t, f) + + cleanupErr := errors.New("owned staging cleanup failure") + var stage string + ops := defaultProviderUpdateCommitOps() + ops.removeStage = func(path string) error { + stage = path + return cleanupErr + } + t.Cleanup(func() { + if stage != "" { + require.NoError(t, os.RemoveAll(stage)) + } + }) + if !tc.committed { + commitErr := errors.New("owned manifest commit failure") + ops.saveManifest = func(string, *provider.ProviderConfig) error { return commitErr } + // The failed commit is rolled back; its original cause and the + // staging cleanup failure must both remain visible. + err := replaceProviderPreparedWithOps( + context.Background(), + params, + replacement, + ops, + ) + require.ErrorIs(t, err, commitErr) + require.ErrorIs(t, err, cleanupErr) + require.DirExists(t, stage) + f.assertFailedPreservation() + return + } + + require.NoError( + t, + replaceProviderPreparedWithOps(context.Background(), params, replacement, ops), + ) + require.DirExists( + t, + stage, + "the simulated cleanup failure leaves only disposable staging data", + ) + assertCommittedCleanupUpdate(t, f, updated) + }) + } +} + +func cleanupFailureUpdateFixture( + t *testing.T, + f *preservationFixture, +) (ProviderParams, *provider.ProviderConfig, []byte) { + t.Helper() + f.seedBinary(updateRuntimeKey, []byte("old provider runtime")) + updated := []byte("updated provider runtime") + server := compatibilityArchiveServer( + t, + singleExecutableUpdateArchive(t, updateRuntimeName, updated), + ) + binary := updateTestBinary(server.URL+"/runtime.tar", updated) + binary.ArchivePath = updateRuntimeName + params, replacement := preparedUpdateParams(t, f, map[string][]*provider.ProviderBinary{ + updateRuntimeKey: {binary}, + }) + return params, replacement, updated +} + +func assertCommittedCleanupUpdate(t *testing.T, f *preservationFixture, updated []byte) { + t.Helper() + assertSelectedExecutable(t, f.binaryPath(updateRuntimeKey), updated, updateTestDigest(updated)) + stored, err := provider.LoadProviderConfig(testDefaultContext, f.name) + require.NoError(t, err) + assert.Equal(t, updateReplacementVersion, stored.Version) + state := f.assertAssociation() + assert.False(t, state.Initialized) + assert.True(t, state.InitAttempted) + assert.Equal( + t, + map[string]config.OptionValue{updateKeptOption: f.options[updateKeptOption]}, + state.Options, + ) +} + func updateCommitFailureOps(phase string, sentinel error) providerUpdateCommitOps { ops := defaultProviderUpdateCommitOps() switch phase { From a9b8d08656b000706e48e734296a3eed3738b973 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 09:23:23 -0600 Subject: [PATCH 07/15] fix(provider): normalize archive symlink separators on Windows --- pkg/provider/update_archive.go | 6 ++- .../provider_update_prepared_test.go | 43 ++++++++++++++++++- 2 files changed, 45 insertions(+), 4 deletions(-) diff --git a/pkg/provider/update_archive.go b/pkg/provider/update_archive.go index 059346e714..953079b8bb 100644 --- a/pkg/provider/update_archive.go +++ b/pkg/provider/update_archive.go @@ -319,7 +319,9 @@ func materializeUpdateTarSymlink(root *os.Root, name, target string) error { if filepath.IsAbs(target) { return fmt.Errorf("absolute archive symlink is unsupported: %s", target) } - return root.Symlink(target, name) + // Archive symlink targets use slash separators; os.Root.Symlink does not + // normalize them on Windows as os.Symlink does. + return root.Symlink(filepath.FromSlash(target), name) } func materializeUpdateTarLink(root *os.Root, name, target string) error { @@ -406,7 +408,7 @@ func materializeUpdateZipLink(root *os.Root, name string, body io.Reader) error if filepath.IsAbs(string(target)) { return errors.New("absolute archive symlink is unsupported") } - return root.Symlink(string(target), name) + return root.Symlink(filepath.FromSlash(string(target)), name) } func validateUpdateArchiveLinks(ctx context.Context, root *os.Root) error { diff --git a/pkg/workspace/provider_update_prepared_test.go b/pkg/workspace/provider_update_prepared_test.go index 2956c84a06..37972bf56d 100644 --- a/pkg/workspace/provider_update_prepared_test.go +++ b/pkg/workspace/provider_update_prepared_test.go @@ -27,6 +27,8 @@ import ( "github.com/stretchr/testify/require" ) +const updateLinkedSidecarPath = "current/lib/sidecar" + // compatibilityArchiveServer serves bytes from an owned httptest server. The // common fixture cleanup closes idle connections and joins the server. func compatibilityArchiveServer(t *testing.T, archive []byte) *httptest.Server { @@ -252,12 +254,12 @@ func TestProviderUpdateTarContainedDirectoryLinkThenRegularMember(t *testing.T) Size: int64(len(runtimeBytes)), }, { - Name: "current/lib/sidecar", + Name: updateLinkedSidecarPath, Typeflag: tar.TypeReg, Mode: 0o644, Size: int64(len(sidecarBytes)), }, - }, map[string][]byte{"current/runtime": runtimeBytes, "current/lib/sidecar": sidecarBytes}) + }, map[string][]byte{"current/runtime": runtimeBytes, updateLinkedSidecarPath: sidecarBytes}) server := compatibilityArchiveServer(t, archive) binary := updateTestBinary(server.URL+"/provider.tar", runtimeBytes) binary.ArchivePath = filepath.Join(updateCurrentLink, updateRuntimeName) @@ -279,6 +281,43 @@ func TestProviderUpdateTarContainedDirectoryLinkThenRegularMember(t *testing.T) assert.Equal(t, sidecarBytes, actual) } +func TestProviderUpdateZipContainedDirectoryLinkThenRegularMember(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + runtimeBytes := []byte("runtime beneath contained zip directory link") + sidecarBytes := []byte("sibling reached through contained zip directory link") + archive := compatibilityZip(t, []struct { + name string + mode os.FileMode + body []byte + }{ + {name: "releases/", mode: os.ModeDir | 0o755}, + {name: "releases/v1/", mode: os.ModeDir | 0o755}, + {name: updateCurrentLink, mode: os.ModeSymlink | 0o777, body: []byte("releases/v1")}, + {name: "current/" + updateRuntimeName, mode: os.ModePerm | 0o755, body: runtimeBytes}, + {name: updateLinkedSidecarPath, mode: os.ModePerm | 0o644, body: sidecarBytes}, + }) + server := compatibilityArchiveServer(t, archive) + binary := updateTestBinary(server.URL+"/provider.zip", runtimeBytes) + binary.ArchivePath = filepath.Join(updateCurrentLink, updateRuntimeName) + require.NoError(t, f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}})) + assertSelectedExecutable( + t, + filepath.Join(f.binaries, updateRuntimeName, updateCurrentLink, updateRuntimeName), + runtimeBytes, + binary.Checksum, + ) + link := filepath.Join(f.binaries, updateRuntimeName, updateCurrentLink) + target, err := os.Readlink(link) + require.NoError(t, err) + assert.Equal(t, filepath.Join("releases", "v1"), filepath.FromSlash(target)) + actual, err := os.ReadFile( + filepath.Join(f.binaries, updateRuntimeName, "releases", "v1", "lib", "sidecar"), + ) + require.NoError(t, err) + assert.Equal(t, sidecarBytes, actual) +} + func TestProviderUpdateTarHardlinkCompatibility(t *testing.T) { f := newPreservationFixture(t) runtimeBytes := []byte("hard-linked executable bytes") From e47c3604539eb0f08500abfdd75fd99e666e8397 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 10:51:39 -0600 Subject: [PATCH 08/15] fix(ci): avoid Windows Go cache post-job timeouts --- .github/workflows/pr-ci.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index 0ccbf1189f..e4a32fd8db 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -146,6 +146,8 @@ jobs: uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7 with: go-version-file: go.mod + # Archiving the Windows Go cache exceeded this job's budget after tests passed. + cache: false - name: run provider update tests and require Windows coverage shell: pwsh @@ -243,6 +245,8 @@ jobs: - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7 with: go-version-file: go.mod + # Windows cache archiving can consume the post-job budget after a successful build. + cache: ${{ runner.os != 'Windows' }} - name: get operating system lowercase id: os From b983124b12959de624d5cde7525bbc432cc7e688 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 13:36:27 -0600 Subject: [PATCH 09/15] fix(provider): validate staged aliases and restore directory modes --- .github/workflows/pr-ci.yml | 6 + pkg/provider/update_archive.go | 58 ++++-- pkg/provider/update_destination.go | 140 ++++++++++++-- ...provider_update_absolute_reference_test.go | 176 +++++++++++++++++ pkg/workspace/provider_update_prepared.go | 183 ++++++++++++++++-- .../provider_update_prepared_test.go | 12 +- ...ovider_update_readonly_destination_test.go | 177 +++++++++++++++++ .../managing-providers/manage-providers.mdx | 2 +- 8 files changed, 694 insertions(+), 60 deletions(-) create mode 100644 pkg/workspace/provider_update_absolute_reference_test.go create mode 100644 pkg/workspace/provider_update_readonly_destination_test.go diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index e4a32fd8db..02fc14bda1 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -176,6 +176,12 @@ jobs: 'TestProviderUpdateZipContainedDirectoryLinkThenRegularMember', 'TestProviderUpdateContainedSeedDirectoryLinkChain', 'TestProviderUpdateArchivePreservesOwnedDaemon', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/unchanged_managed_target_succeeds', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/changed_managed_target_rejects_and_preserves_live_state', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/contained_symlink_follows_changed_staged_target', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/external_symlink_into_managed_tree_fails_closed', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/case-variant_managed_path_cannot_bypass_validation', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/outside_reference_remains_untouched_while_managed_tree_updates', 'TestStatUpdatePath/nested_dot_directory', 'TestStatUpdatePath/nested_cancelled_child', 'TestStatUpdatePath/external_target', diff --git a/pkg/provider/update_archive.go b/pkg/provider/update_archive.go index 953079b8bb..a58d9a6e8e 100644 --- a/pkg/provider/update_archive.go +++ b/pkg/provider/update_archive.go @@ -86,7 +86,7 @@ func prepareUpdateBinary( key string, binary *ProviderBinary, target string, -) (string, error) { +) (path string, err error) { if filepath.IsAbs(binary.Path) { return "", fmt.Errorf( "update preparation must validate absolute reference separately: %s", @@ -94,38 +94,66 @@ func prepareUpdateBinary( ) } family := filepath.Join(target, strings.ToLower(key)) - path := getBinaryPath(binary, family) + path = getBinaryPath(binary, family) // Installed aliases are reusable, but checksum misses must not delete their targets. if updateBinaryMatches(path, binary.Checksum) { return path, nil } archive := isRemotePath(binary.Path) && binary.ArchivePath != "" - // A cache miss replaces the entire archive family. Do not first unlink a - // selected old executable whose parent may intentionally be read-only. if archive && !cachedUpdateBinaryAvailable(binary) { - return downloadWithRetryUsing(key, binary, func() (string, error) { - return downloadConfinedUpdateArchive(ctx, binary, family) - }) + return prepareFreshUpdateArchive(ctx, key, binary, target) } - if err := prepareUpdateDestination(ctx, target, path); err != nil { + return prepareSelectedUpdate(ctx, key, binary, target) +} + +func prepareSelectedUpdate( + ctx context.Context, + key string, + binary *ProviderBinary, + target string, +) (result string, err error) { + family := filepath.Join(target, strings.ToLower(key)) + path := getBinaryPath(binary, family) + archive := isRemotePath(binary.Path) && binary.ArchivePath != "" + restoreDestination, err := prepareUpdateDestination(ctx, target, path) + if err != nil { return "", fmt.Errorf("isolate update destination for %s: %w", key, err) } + defer func() { + if restoreDestination != nil { + err = errors.Join(err, restoreDestination()) + } + }() if !archive { return downloadBinaryForPlatform(ctx, key, []*ProviderBinary{binary}, target) } - return prepareUpdateArchive(ctx, key, binary, family) + if fromCache(binary, family) { + return getBinaryPath(binary, family), nil + } + // A failed cache copy falls back to replacing the archive family. Restore + // selected-entry parents first so their modes are not applied to fresh archive directories. + if restoreErr := restoreDestination(); restoreErr != nil { + restoreDestination = nil + return "", fmt.Errorf("restore staged update destination permissions: %w", restoreErr) + } + restoreDestination = nil + return prepareFreshUpdateArchive(ctx, key, binary, target) } -func prepareUpdateArchive( +func prepareFreshUpdateArchive( ctx context.Context, key string, binary *ProviderBinary, - family string, -) (string, error) { - // The legacy cache contains only the executable; seeded sidecars remain unchanged on a hit. - if fromCache(binary, family) { - return getBinaryPath(binary, family), nil + target string, +) (path string, err error) { + family := filepath.Join(target, strings.ToLower(key)) + // An uncached archive replaces the whole family; only its staged parent needs + // temporary write access because the family reset handles descendant modes. + restoreFamily, err := prepareUpdateDestinationParent(target, family) + if err != nil { + return "", fmt.Errorf("prepare update family parent for %s: %w", key, err) } + defer func() { err = errors.Join(err, restoreFamily()) }() return downloadWithRetryUsing(key, binary, func() (string, error) { return downloadConfinedUpdateArchive(ctx, binary, family) }) diff --git a/pkg/provider/update_destination.go b/pkg/provider/update_destination.go index 667c0dedfd..489ae6c18b 100644 --- a/pkg/provider/update_destination.go +++ b/pkg/provider/update_destination.go @@ -12,21 +12,44 @@ import ( "strings" ) -// prepareUpdateDestination separates only the destination's aliases before an -// update writes into the private staged tree. Installed read-only reuse bypasses -// this helper. The provider operation lock excludes cooperating writers; this -// is not a transaction against arbitrary concurrent filesystem replacement. -func prepareUpdateDestination(ctx context.Context, stageRoot, selectedPath string) (err error) { +// prepareUpdateDestination isolates destination aliases and retains temporary +// write access only to staged parents it must mutate. Installed read-only reuse +// bypasses this helper. Callers must restore the original modes before publishing. +func prepareUpdateDestination( + ctx context.Context, + stageRoot, selectedPath string, +) (restore func() error, err error) { stageRoot, selected, err := absoluteUpdateDestination(stageRoot, selectedPath) if err != nil { - return err + return nil, err } root, err := os.OpenRoot(stageRoot) if err != nil { - return err + return nil, err + } + permissions := updateDestinationPermissions{root: root, changed: map[string]fs.FileMode{}} + if err := permissions.isolateDestination(ctx, selected); err != nil { + return nil, errors.Join(err, permissions.restore()) } - defer func() { err = errors.Join(err, root.Close()) }() - return isolateUpdateDestination(ctx, root, selected) + return permissions.restore, nil +} + +// prepareUpdateDestinationParent makes an archive family's staged parent writable +// while the family is removed and recreated, then restores its original mode. +func prepareUpdateDestinationParent(stageRoot, selectedPath string) (func() error, error) { + stageRoot, selected, err := absoluteUpdateDestination(stageRoot, selectedPath) + if err != nil { + return nil, err + } + root, err := os.OpenRoot(stageRoot) + if err != nil { + return nil, err + } + permissions := updateDestinationPermissions{root: root, changed: map[string]fs.FileMode{}} + if err := permissions.allowWrite(filepath.Dir(selected)); err != nil { + return nil, errors.Join(err, permissions.restore()) + } + return permissions.restore, nil } func absoluteUpdateDestination(stageRoot, selectedPath string) (string, string, error) { @@ -51,34 +74,111 @@ func absoluteUpdateDestination(stageRoot, selectedPath string) (string, string, return canonical, selected, err } -func isolateUpdateDestination( +func (p *updateDestinationPermissions) isolateDestination( ctx context.Context, - root *os.Root, selected string, ) error { parts := strings.Split(selected, string(filepath.Separator)) for index := range parts { - if err := ctx.Err(); err != nil { + name := filepath.Join(parts[:index+1]...) + continued, err := p.isolateEntry(ctx, name, index == len(parts)-1) + if err != nil { return err } - name := filepath.Join(parts[:index+1]...) - info, err := root.Lstat(name) - if errors.Is(err, fs.ErrNotExist) { + if !continued { return nil } - if err != nil { + } + return nil +} + +func (p *updateDestinationPermissions) isolateEntry( + ctx context.Context, name string, leaf bool, +) (bool, error) { + if err := ctx.Err(); err != nil { + return false, err + } + info, err := p.root.Lstat(name) + if errors.Is(err, fs.ErrNotExist) { + return false, p.allowExistingParentWrite(filepath.Dir(name)) + } + if err != nil { + return false, err + } + if leaf { + return false, p.isolateLeaf(name, info) + } + if err := p.isolateAncestor(ctx, name, info); err != nil { + return false, err + } + return true, nil +} + +func (p *updateDestinationPermissions) isolateLeaf(name string, info fs.FileInfo) error { + if !info.IsDir() { + if err := p.allowWrite(filepath.Dir(name)); err != nil { return err } - if index == len(parts)-1 { - return removeUpdateDestinationLeaf(root, name, info) - } - if err := isolateUpdateAncestor(ctx, root, name, info); err != nil { + } + return removeUpdateDestinationLeaf(p.root, name, info) +} + +func (p *updateDestinationPermissions) isolateAncestor( + ctx context.Context, name string, info fs.FileInfo, +) error { + if info.Mode()&os.ModeSymlink != 0 { + if err := p.allowWrite(filepath.Dir(name)); err != nil { return err } } + return isolateUpdateAncestor(ctx, p.root, name, info) +} + +type updateDestinationPermissions struct { + root *os.Root + changed map[string]fs.FileMode + order []string +} + +func (p *updateDestinationPermissions) allowWrite(name string) error { + if _, ok := p.changed[name]; ok { + return nil + } + info, err := p.root.Lstat(name) + if err != nil { + return err + } + if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 { + return fmt.Errorf("provider update destination parent is not a directory: %s", name) + } + mode := info.Mode() + if mode.Perm()&0o200 == 0 { + if err := p.root.Chmod(name, mode|0o200); err != nil { + return fmt.Errorf("make staged update parent writable %s: %w", name, err) + } + p.changed[name] = mode + p.order = append(p.order, name) + } return nil } +func (p *updateDestinationPermissions) allowExistingParentWrite(name string) error { + if _, err := p.root.Lstat(name); errors.Is(err, fs.ErrNotExist) { + return nil + } else if err != nil { + return err + } + return p.allowWrite(name) +} + +func (p *updateDestinationPermissions) restore() error { + var err error + for _, name := range slices.Backward(p.order) { + err = errors.Join(err, p.root.Chmod(name, p.changed[name])) + } + return errors.Join(err, p.root.Close()) +} + func removeUpdateDestinationLeaf(root *os.Root, name string, info fs.FileInfo) error { if !info.IsDir() { return root.Remove(name) diff --git a/pkg/workspace/provider_update_absolute_reference_test.go b/pkg/workspace/provider_update_absolute_reference_test.go new file mode 100644 index 0000000000..025cc69c63 --- /dev/null +++ b/pkg/workspace/provider_update_absolute_reference_test.go @@ -0,0 +1,176 @@ +package workspace + +import ( + "os" + "path/filepath" + "strings" + "testing" + + "github.com/devsy-org/devsy/pkg/provider" + "github.com/stretchr/testify/require" +) + +const absoluteReferenceAliasKey = "ALIAS" + +func absoluteReferenceArchiveBinary(t *testing.T, content []byte) *provider.ProviderBinary { + t.Helper() + server := compatibilityArchiveServer( + t, + singleExecutableUpdateArchive(t, content), + ) + binary := updateTestBinary(server.URL+"/provider.tar", content) + binary.ArchivePath = updateRuntimeName + return binary +} + +func TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget(t *testing.T) { + t.Run("unchanged managed target succeeds", testUnchangedManagedAbsoluteReference) + + t.Run("changed managed target rejects and preserves live state", func(t *testing.T) { + assertChangedManagedAbsoluteReferenceRejected(t, false) + }) + + t.Run("contained symlink follows changed staged target", func(t *testing.T) { + assertChangedManagedAbsoluteReferenceRejected(t, true) + }) + + t.Run("external symlink into managed tree fails closed", testExternalSymlinkIntoManagedTree) + t.Run( + "case-variant managed path cannot bypass validation", + testCaseVariantManagedAbsoluteReference, + ) + + t.Run( + "outside reference remains untouched while managed tree updates", + testOutsideAbsoluteReferenceUnchanged, + ) +} + +func testUnchangedManagedAbsoluteReference(t *testing.T) { + f := newPreservationFixture(t) + managedContent := []byte("unchanged managed executable") + f.seedBinary("B", managedContent) + + err := f.update(map[string][]*provider.ProviderBinary{ + absoluteReferenceAliasKey: {updateTestBinary(f.binaryPath("B"), managedContent)}, + "C": { + absoluteReferenceArchiveBinary(t, []byte("updated independent executable")), + }, + }) + require.NoError(t, err) + actual, err := os.ReadFile(f.binaryPath("B")) + require.NoError(t, err) + require.Equal(t, managedContent, actual) + stored, err := provider.LoadProviderConfig(testDefaultContext, f.name) + require.NoError(t, err) + require.Equal(t, f.binaryPath("B"), stored.Binaries[absoluteReferenceAliasKey][0].Path) + f.assertAssociation() + assertNoUpdateStaging(t, f) +} + +func testExternalSymlinkIntoManagedTree(t *testing.T) { + requireProviderUpdateSymlinks(t) + f := newPreservationFixture(t) + managedContent := []byte("managed executable") + f.seedBinary("B", managedContent) + externalAlias := filepath.Join(t.TempDir(), "external-alias") + require.NoError(t, os.Symlink(f.binaryPath("B"), externalAlias)) + + err := f.update(map[string][]*provider.ProviderBinary{ + absoluteReferenceAliasKey: {updateTestBinary(externalAlias, managedContent)}, + "B": { + absoluteReferenceArchiveBinary(t, []byte("updated managed executable")), + }, + }) + require.ErrorContains(t, err, "external alias; unsupported") + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) + info, statErr := os.Lstat(externalAlias) + require.NoError(t, statErr) + require.NotZero(t, info.Mode()&os.ModeSymlink) +} + +func testOutsideAbsoluteReferenceUnchanged(t *testing.T) { + f := newPreservationFixture(t) + outsideContent := []byte("independently owned executable") + outsidePath := filepath.Join(t.TempDir(), "outside-runtime") + f.put(outsidePath, outsideContent) + f.seedBinary("B", []byte("old managed executable")) + + err := f.update(map[string][]*provider.ProviderBinary{ + "OUTSIDE": {updateTestBinary(outsidePath, outsideContent)}, + "B": {absoluteReferenceArchiveBinary(t, []byte("new managed executable"))}, + }) + require.NoError(t, err) + // #nosec G304 -- outsidePath was created inside this test's owned temp directory. + actual, err := os.ReadFile(outsidePath) + require.NoError(t, err) + require.Equal(t, outsideContent, actual) + stored, err := provider.LoadProviderConfig(testDefaultContext, f.name) + require.NoError(t, err) + require.Equal(t, outsidePath, stored.Binaries["OUTSIDE"][0].Path) + f.assertAssociation() + assertNoUpdateStaging(t, f) +} + +func testCaseVariantManagedAbsoluteReference(t *testing.T) { + f := newPreservationFixture(t) + oldContent := []byte("old managed executable") + f.seedBinary("B", oldContent) + caseVariantRoot := strings.ToUpper(f.binaries) + liveInfo, err := os.Stat(f.binaries) + require.NoError(t, err) + variantInfo, err := os.Stat(caseVariantRoot) + if os.IsNotExist(err) { + t.Skip("case-variant path does not resolve on this filesystem") + } + require.NoError(t, err) + if !os.SameFile(liveInfo, variantInfo) { + t.Skip("case-variant path is a different directory on this filesystem") + } + variantPath := filepath.Join(caseVariantRoot, "b", updateRuntimeName) + err = f.update(map[string][]*provider.ProviderBinary{ + absoluteReferenceAliasKey: {updateTestBinary(variantPath, oldContent)}, + "B": { + absoluteReferenceArchiveBinary(t, []byte("new managed executable")), + }, + }) + require.Error(t, err) + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) +} + +func assertChangedManagedAbsoluteReferenceRejected(t *testing.T, throughSymlink bool) { + t.Helper() + f := newPreservationFixture(t) + oldContent := []byte("old managed executable") + newContent := []byte("new managed executable") + f.seedBinary("B", oldContent) + aliasPath := f.binaryPath("B") + aliasKey := absoluteReferenceAliasKey + replacementKey := "B" + if throughSymlink { + aliasKey = "REFERENCE" + replacementKey = absoluteReferenceAliasKey + aliasPath = f.binaryPath(absoluteReferenceAliasKey) + require.NoError(t, os.MkdirAll(filepath.Dir(aliasPath), 0o700)) + require.NoError(t, os.Symlink(filepath.Join("..", "b", updateRuntimeName), aliasPath)) + } + + updated := map[string][]*provider.ProviderBinary{ + aliasKey: {updateTestBinary(aliasPath, oldContent)}, + replacementKey: {absoluteReferenceArchiveBinary(t, newContent)}, + } + err := f.update(updated) + require.ErrorContains(t, err, "absolute provider binary checksum mismatch") + f.assertFailedPreservation() + assertNoUpdateStaging(t, f) + if throughSymlink { + info, statErr := os.Lstat(aliasPath) + require.NoError(t, statErr) + require.NotZero(t, info.Mode()&os.ModeSymlink) + target, readErr := os.Readlink(aliasPath) + require.NoError(t, readErr) + require.Equal(t, filepath.Join("..", "b", updateRuntimeName), target) + } +} diff --git a/pkg/workspace/provider_update_prepared.go b/pkg/workspace/provider_update_prepared.go index 08939cb6be..16db817322 100644 --- a/pkg/workspace/provider_update_prepared.go +++ b/pkg/workspace/provider_update_prepared.go @@ -169,7 +169,7 @@ func (p *preparedProviderReplacement) prepareBinaries( if err != nil { return err } - locations, err := stagedProviderLocations(ctx, binaries) + locations, absoluteReferences, err := stagedProviderLocations(ctx, binaries, p.live, target) if err != nil { return fmt.Errorf("download binaries: validate preparation: %w", err) } @@ -181,7 +181,31 @@ func (p *preparedProviderReplacement) prepareBinaries( } // Archive sidecars are promoted together, but no link may lead outside staging. _, err = copyProviderBinaryTree(ctx, target, "") - return err + if err != nil { + return err + } + return validateStagedAbsoluteReferences(ctx, absoluteReferences) +} + +func validateStagedAbsoluteReferences( + ctx context.Context, + references []stagedAbsoluteProviderReference, +) error { + for _, reference := range references { + if err := ctx.Err(); err != nil { + return err + } + if err := validateAbsoluteProviderBinaryAtPath( + reference.binary, + reference.stagedPath, + ); err != nil { + return fmt.Errorf( + "absolute provider binary reference changed during preparation: %w", + err, + ) + } + } + return nil } func requireRegularProviderPath(path string, directory bool) error { @@ -375,27 +399,146 @@ func validateProviderSeedEntry(root *os.Root, name string, entry fs.DirEntry) er func stagedProviderLocations( ctx context.Context, binaries map[string][]*provider.ProviderBinary, -) (map[string][]*provider.ProviderBinary, error) { + live, stagedRoot string, +) (map[string][]*provider.ProviderBinary, []stagedAbsoluteProviderReference, error) { staged := make(map[string][]*provider.ProviderBinary, len(binaries)) + var absoluteReferences []stagedAbsoluteProviderReference for key, locations := range binaries { if err := ctx.Err(); err != nil { - return nil, err + return nil, nil, err } staged[key] = locations - for _, location := range locations { - if location.OS != runtime.GOOS || location.Arch != runtime.GOARCH { - continue - } - if err := validateProviderUpdateLocation(location); err != nil { - return nil, err - } - if filepath.IsAbs(location.Path) { - delete(staged, key) - } - break + reference, absolute, err := stagedProviderLocationReference(locations, live, stagedRoot) + if err != nil { + return nil, nil, err + } + if reference != nil { + absoluteReferences = append(absoluteReferences, *reference) + } + if absolute { + delete(staged, key) + } + } + return staged, absoluteReferences, nil +} + +func stagedProviderLocationReference( + locations []*provider.ProviderBinary, + live, stagedRoot string, +) (*stagedAbsoluteProviderReference, bool, error) { + for _, location := range locations { + if location.OS != runtime.GOOS || location.Arch != runtime.GOARCH { + continue + } + if err := validateProviderUpdateLocation(location); err != nil { + return nil, false, err + } + if !filepath.IsAbs(location.Path) { + return nil, false, nil + } + stagedPath, managed, err := projectManagedAbsoluteReference(location.Path, live, stagedRoot) + if err != nil { + return nil, true, err + } + if managed { + return &stagedAbsoluteProviderReference{ + binary: location, + stagedPath: stagedPath, + }, true, nil + } + return nil, true, nil + } + return nil, false, nil +} + +type stagedAbsoluteProviderReference struct { + binary *provider.ProviderBinary + stagedPath string +} + +func projectManagedAbsoluteReference(path, live, stagedRoot string) (string, bool, error) { + pathAbs, err := filepath.Abs(path) + if err != nil { + return "", false, err + } + liveAbs, err := filepath.Abs(live) + if err != nil { + return "", false, err + } + stagedPath, managed, err := projectLexicalManagedReference( + path, + pathAbs, + liveAbs, + stagedRoot, + ) + if err != nil || managed { + return stagedPath, managed, err + } + return rejectExternalManagedAlias(path, liveAbs) +} + +func projectLexicalManagedReference( + path, pathAbs, liveAbs, stagedRoot string, +) (string, bool, error) { + relative, err := filepath.Rel(liveAbs, pathAbs) + if err != nil || !filepath.IsLocal(relative) { + return "", false, nil + } + if filepath.Clean(path) != path { + return "", false, fmt.Errorf("ambiguous absolute provider reference path: %s", path) + } + return filepath.Join(stagedRoot, relative), true, nil +} + +func rejectExternalManagedAlias(path, liveAbs string) (string, bool, error) { + // An external symlink into the live tree remains attached to the promoted path, + // but cannot be projected without changing its traversal semantics. + resolvedPath, err := filepath.EvalSymlinks(path) + if err != nil { + return "", false, fmt.Errorf("resolve absolute provider reference %s: %w", path, err) + } + contained, err := sharesManagedDirectoryAncestor(liveAbs, resolvedPath) + if err != nil { + return "", false, err + } + if contained { + return "", false, unsupportedExternalManagedAlias(path) + } + return "", false, nil +} + +func unsupportedExternalManagedAlias(path string) error { + return fmt.Errorf( + "absolute provider reference resolves into managed binaries through an external alias; unsupported: %s", + path, + ) +} + +func sharesManagedDirectoryAncestor(live, resolvedPath string) (bool, error) { + liveInfo, err := os.Stat(live) + if os.IsNotExist(err) { + return false, nil + } + if err != nil { + return false, fmt.Errorf("stat managed provider binaries %s: %w", live, err) + } + for ancestor := resolvedPath; ; ancestor = filepath.Dir(ancestor) { + info, err := os.Stat(ancestor) + if err != nil { + return false, fmt.Errorf( + "stat absolute provider reference ancestor %s: %w", + ancestor, + err, + ) + } + if os.SameFile(liveInfo, info) { + return true, nil + } + parent := filepath.Dir(ancestor) + if parent == ancestor { + return false, nil } } - return staged, nil } func validateProviderUpdateLocation(location *provider.ProviderBinary) error { @@ -413,7 +556,11 @@ func validateProviderUpdateLocation(location *provider.ProviderBinary) error { } func validateAbsoluteProviderBinary(location *provider.ProviderBinary) error { - info, err := os.Stat(location.Path) + return validateAbsoluteProviderBinaryAtPath(location, location.Path) +} + +func validateAbsoluteProviderBinaryAtPath(location *provider.ProviderBinary, path string) error { + info, err := os.Stat(path) if err != nil { return err } @@ -423,7 +570,7 @@ func validateAbsoluteProviderBinary(location *provider.ProviderBinary) error { if location.Checksum == "" { return nil } - sum, err := hash.File(location.Path) + sum, err := hash.File(path) if err != nil { return err } diff --git a/pkg/workspace/provider_update_prepared_test.go b/pkg/workspace/provider_update_prepared_test.go index 37972bf56d..992a476e1e 100644 --- a/pkg/workspace/provider_update_prepared_test.go +++ b/pkg/workspace/provider_update_prepared_test.go @@ -67,11 +67,11 @@ func compatibilityTar( return out.Bytes() } -func singleExecutableUpdateArchive(t *testing.T, selected string, content []byte) []byte { +func singleExecutableUpdateArchive(t *testing.T, content []byte) []byte { t.Helper() return compatibilityTar(t, false, []*tar.Header{ - {Name: selected, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, - }, map[string][]byte{selected: content}) + {Name: updateRuntimeName, Typeflag: tar.TypeReg, Mode: 0o755, Size: int64(len(content))}, + }, map[string][]byte{updateRuntimeName: content}) } func compatibilityZip(t *testing.T, entries []struct { @@ -709,7 +709,7 @@ func cleanupFailureUpdateFixture( updated := []byte("updated provider runtime") server := compatibilityArchiveServer( t, - singleExecutableUpdateArchive(t, updateRuntimeName, updated), + singleExecutableUpdateArchive(t, updated), ) binary := updateTestBinary(server.URL+"/runtime.tar", updated) binary.ArchivePath = updateRuntimeName @@ -1222,7 +1222,7 @@ func TestProviderUpdateFamilyAliasPreservesUnrelatedBinary(t *testing.T) { alias := filepath.Join(f.binaries, updateRuntimeName) require.NoError(t, os.Symlink("unrelated", alias)) content := []byte("replacement through alias " + f.dir) - archive := singleExecutableUpdateArchive(t, updateRuntimeName, content) + archive := singleExecutableUpdateArchive(t, content) var requests atomic.Int64 server := ownedProviderUpdateServer( t, @@ -1319,7 +1319,7 @@ func TestProviderUpdateReadOnlySelectedArchiveFamily(t *testing.T) { unrelatedInfo, err := os.Stat(f.binaryPath("UNRELATED")) require.NoError(t, err) content := []byte("fresh readonly-family replacement") - archive := singleExecutableUpdateArchive(t, updateRuntimeName, content) + archive := singleExecutableUpdateArchive(t, content) server := ownedProviderUpdateServer( t, func(w http.ResponseWriter, _ *http.Request) { diff --git a/pkg/workspace/provider_update_readonly_destination_test.go b/pkg/workspace/provider_update_readonly_destination_test.go new file mode 100644 index 0000000000..a294eb1da1 --- /dev/null +++ b/pkg/workspace/provider_update_readonly_destination_test.go @@ -0,0 +1,177 @@ +package workspace + +import ( + "net/http" + "os" + "path/filepath" + "runtime" + "sync/atomic" + "testing" + + "github.com/devsy-org/devsy/pkg/provider" + "github.com/stretchr/testify/require" +) + +type readOnlyDirectUpdateCase struct { + name string + missingLeaf bool + missingFamily bool + failure bool + reuse bool +} + +func TestProviderUpdateDirectBinaryUnderReadOnlyParent(t *testing.T) { + if runtime.GOOS == updateWindowsOS || os.Geteuid() == 0 { + t.Skip("requires POSIX permission enforcement for an ordinary user") + } + + cases := []readOnlyDirectUpdateCase{ + {name: "replace existing leaf"}, + {name: "failed download restores modes", failure: true}, + {name: "matching checksum reuses installed leaf", reuse: true}, + {name: "create missing leaf", missingLeaf: true}, + {name: "create missing family", missingFamily: true}, + } + for _, testCase := range cases { + t.Run(testCase.name, func(t *testing.T) { + runReadOnlyDirectUpdateCase(t, testCase) + }) + } +} + +func runReadOnlyDirectUpdateCase(t *testing.T, testCase readOnlyDirectUpdateCase) { + t.Helper() + f, selected, parent := seedReadOnlyDirectUpdateCase(t, testCase) + old := []byte("old owner-writable selected executable") + updated := []byte("new direct remote executable") + if testCase.reuse { + updated = old + } + var requests atomic.Int64 + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, _ *http.Request) { + requests.Add(1) + if testCase.failure { + http.Error(w, "owned replacement unavailable", http.StatusNotFound) + return + } + _, _ = w.Write(updated) + }) + binary := updateTestBinary(server.URL+"/runtime", updated) + err := f.update(map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}) + if testCase.failure { + assertFailedReadOnlyDirectUpdate(t, f, err, requests.Load()) + } else { + require.NoError(t, err) + wantRequests := int64(1) + if testCase.reuse { + wantRequests = 0 + } + require.EqualValues(t, wantRequests, requests.Load()) + assertSelectedExecutable(t, selected, updated, binary.Checksum) + f.assertAssociation() + } + if !testCase.missingFamily { + info, statErr := os.Stat(parent) + require.NoError(t, statErr) + require.Equal( + t, + os.FileMode(0o550), + info.Mode().Perm(), + "staged parent mode must be restored before publication", + ) + } + assertNoUpdateStaging(t, f) +} + +func seedReadOnlyDirectUpdateCase( + t *testing.T, + testCase readOnlyDirectUpdateCase, +) (*preservationFixture, string, string) { + t.Helper() + f := newPreservationFixture(t) + f.seedBinary(updateRuntimeKey, []byte("old owner-writable selected executable")) + selected := f.binaryPath(updateRuntimeKey) + parent := filepath.Dir(selected) + t.Cleanup(func() { makeOwnedUpdateTreeRemovable(t, f.dir) }) + if testCase.missingFamily { + require.NoError(t, os.RemoveAll(parent)) + } else { + if testCase.missingLeaf { + require.NoError(t, os.Remove(selected)) + } else { + // #nosec G302 -- The fixture reproduces a writable file below a read-only parent. + require.NoError(t, os.Chmod(selected, 0o700)) + } + // #nosec G302 -- The fixture reproduces ordinary staged-copy permission preservation. + require.NoError(t, os.Chmod(parent, 0o550)) + } + return f, selected, parent +} + +func assertFailedReadOnlyDirectUpdate( + t *testing.T, + f *preservationFixture, + err error, + requests int64, +) { + t.Helper() + require.ErrorContains(t, err, "404") + require.EqualValues(t, 1, requests) + f.assertFailedPreservation() +} + +func TestDownloadUpdateBinaryUnderReadOnlyStagingRoot(t *testing.T) { + if runtime.GOOS == updateWindowsOS || os.Geteuid() == 0 { + t.Skip("requires POSIX permission enforcement for an ordinary user") + } + + for _, missingFamily := range []bool{false, true} { + name := "existing read-only family" + if missingFamily { + name = "missing family" + } + t.Run(name, func(t *testing.T) { + root := filepath.Join(t.TempDir(), "binaries") + require.NoError(t, os.Mkdir(root, 0o700)) + selected := filepath.Join(root, "runtime", updateRuntimeName) + if !missingFamily { + require.NoError(t, os.Mkdir(filepath.Dir(selected), 0o700)) + // #nosec G306 -- Test input is intentionally owner-writable under a read-only directory. + require.NoError(t, os.WriteFile(selected, []byte("old staged bytes"), 0o700)) + // #nosec G302 -- Exercise permission preservation for an existing nested staged directory. + require.NoError(t, os.Chmod(filepath.Dir(selected), 0o550)) + } + unrelated := filepath.Join(root, "unrelated", "kept") + require.NoError(t, os.MkdirAll(filepath.Dir(unrelated), 0o700)) + require.NoError(t, os.WriteFile(unrelated, []byte("unrelated staged data"), 0o600)) + t.Cleanup(func() { makeOwnedUpdateTreeRemovable(t, root) }) + // #nosec G302 -- The staged root is deliberately read-only for the direct downloader. + require.NoError(t, os.Chmod(root, 0o550)) + + updated := []byte("replacement staged binary") + server := ownedProviderUpdateServer(t, func(w http.ResponseWriter, _ *http.Request) { + _, _ = w.Write(updated) + }) + binary := updateTestBinary(server.URL+"/runtime", updated) + paths, err := provider.DownloadUpdateBinaries( + t.Context(), + map[string][]*provider.ProviderBinary{updateRuntimeKey: {binary}}, + root, + ) + require.NoError(t, err) + require.Equal(t, selected, paths[updateRuntimeKey]) + assertSelectedExecutable(t, selected, updated, binary.Checksum) + actual, err := os.ReadFile(unrelated) // #nosec G304 -- Fixture-owned stage file. + require.NoError(t, err) + require.Equal(t, []byte("unrelated staged data"), actual) + info, err := os.Stat(root) + require.NoError(t, err) + require.Equal(t, os.FileMode(0o550), info.Mode().Perm()) + if !missingFamily { + info, err = os.Stat(filepath.Dir(selected)) + require.NoError(t, err) + require.Equal(t, os.FileMode(0o550), info.Mode().Perm()) + } + }) + } +} diff --git a/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx b/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx index 3e8e66e91a..ae8ff7a51e 100644 --- a/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx +++ b/sites/docs-devsy-sh/content/docs/managing-providers/manage-providers.mdx @@ -154,7 +154,7 @@ devsy provider set-source ../path-to/provider.yaml In the desktop app, use the provider's **Select version**, **Update**, and **Initialize** actions. -Devsy prepares the replacement provider’s installation binaries (`binaries`) before changing the installed provider. Runtime binaries declared under `agent.binaries` are prepared later by workspace operations. A download, checksum, archive, or cancellation error during preparation keeps the installed binaries, provider settings, initialization state, and workspace associations intact. Absolute local binary paths are checked without modifying the referenced files. +Devsy prepares the replacement provider’s installation binaries (`binaries`) before changing the installed provider. Runtime binaries declared under `agent.binaries` are prepared later by workspace operations. A download, checksum, archive, or cancellation error during preparation keeps the installed binaries, provider settings, initialization state, and workspace associations intact. Absolute local binary paths are checked without modifying the referenced files. References into the managed binaries directory must also match the prepared result; ambiguous aliases into that directory are rejected before publication. If publishing the prepared update fails, Devsy attempts to restore the previous files. If restoration fails, the error identifies retained recovery artifacts; keep those files for recovery. This does not guarantee recovery after a process or machine crash. Initialization runs after publication: an initialization failure leaves the new provider installed and available for another initialization attempt. From 0d86035f86e2d5b295a6f3fded400f9b57a1c395 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 14:44:19 -0600 Subject: [PATCH 10/15] fix(ci): report all Windows provider coverage failures --- .github/workflows/pr-ci.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index 9593b35bf1..33ff1ae98f 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -160,7 +160,7 @@ jobs: Set-Content -LiteralPath $exitPath -Value $testExitCode -NoNewline if ($testExitCode -ne 0) { - Write-Error "Provider update tests failed with exit code $testExitCode" + Write-Host "::error::Provider update tests failed with exit code $testExitCode" exit $testExitCode } @@ -191,17 +191,17 @@ jobs: foreach ($testName in $criticalTests) { $testEvents = @($events | Where-Object { $_.Test -eq $testName }) if ($testEvents.Count -eq 0) { - Write-Error "Required Windows provider update test produced no JSON events: $testName" + Write-Host "::error::Required Windows provider update test produced no JSON events: $testName" $status = 1 continue } if (@($testEvents | Where-Object { $_.Action -eq 'skip' }).Count -gt 0) { - Write-Error "Required Windows provider update test was skipped: $testName" + Write-Host "::error::Required Windows provider update test was skipped: $testName" $status = 1 continue } if (@($testEvents | Where-Object { $_.Action -eq 'pass' }).Count -eq 0) { - Write-Error "Required Windows provider update test did not pass: $testName" + Write-Host "::error::Required Windows provider update test did not pass: $testName" $status = 1 } } From 6f54850633b5672e136645a9189dbef7095ec6aa Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 14:53:57 -0600 Subject: [PATCH 11/15] test(provider): check symlink capability for staged alias coverage --- pkg/workspace/provider_update_absolute_reference_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/pkg/workspace/provider_update_absolute_reference_test.go b/pkg/workspace/provider_update_absolute_reference_test.go index 025cc69c63..c41bc8ba33 100644 --- a/pkg/workspace/provider_update_absolute_reference_test.go +++ b/pkg/workspace/provider_update_absolute_reference_test.go @@ -150,6 +150,7 @@ func assertChangedManagedAbsoluteReferenceRejected(t *testing.T, throughSymlink aliasKey := absoluteReferenceAliasKey replacementKey := "B" if throughSymlink { + requireProviderUpdateSymlinks(t) aliasKey = "REFERENCE" replacementKey = absoluteReferenceAliasKey aliasPath = f.binaryPath(absoluteReferenceAliasKey) From 3ebbcf548a65957fa03d021b144683d69c0b97c5 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 15:05:55 -0600 Subject: [PATCH 12/15] fix(ci): retain Windows Go caching with cold-run headroom --- .github/workflows/pr-ci.yml | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index 33ff1ae98f..368ae4e356 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -138,7 +138,8 @@ jobs: needs: [changes] if: needs.changes.outputs.go == 'true' runs-on: windows-latest - timeout-minutes: 20 + # Allow cold Go compilation and the post-job cache save to complete. + timeout-minutes: 30 steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 @@ -146,8 +147,6 @@ jobs: uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7 with: go-version-file: go.mod - # Archiving the Windows Go cache exceeded this job's budget after tests passed. - cache: false - name: run provider update tests and require Windows coverage shell: pwsh @@ -242,7 +241,8 @@ jobs: - runner: ubuntu-latest - runner: macos-latest - runner: windows-latest - job_timeout_minutes: 30 + # Cold builds need room to save the Go cache after artifact uploads. + job_timeout_minutes: 45 runs-on: ${{ matrix.runner }} timeout-minutes: ${{ matrix.job_timeout_minutes || 20 }} steps: @@ -251,8 +251,6 @@ jobs: - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7 with: go-version-file: go.mod - # Windows cache archiving can consume the post-job budget after a successful build. - cache: ${{ runner.os != 'Windows' }} - name: get operating system lowercase id: os From 5edb781ae5a6b180ea00fce64fd12e9d51f0e6db Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 17:44:26 -0600 Subject: [PATCH 13/15] fix(provider): preserve valid staged update inputs --- .github/workflows/pr-ci.yml | 3 + pkg/provider/update_archive.go | 3 +- pkg/provider/update_archive_sparse_test.go | 114 ++++++++++++++++++ ...provider_update_absolute_reference_test.go | 54 +++++++++ pkg/workspace/provider_update_prepared.go | 15 +-- 5 files changed, 178 insertions(+), 11 deletions(-) create mode 100644 pkg/provider/update_archive_sparse_test.go diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index 368ae4e356..e3d9403b5b 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -176,6 +176,9 @@ jobs: 'TestProviderUpdateContainedSeedDirectoryLinkChain', 'TestProviderUpdateArchivePreservesOwnedDaemon', 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/unchanged_managed_target_succeeds', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/changed_managed_target_with_matching_new_checksum_succeeds', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/replaced_managed_symlink_with_matching_new_checksum_succeeds', + 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/new_managed_target_with_matching_checksum_succeeds', 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/changed_managed_target_rejects_and_preserves_live_state', 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/contained_symlink_follows_changed_staged_target', 'TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget/external_symlink_into_managed_tree_fails_closed', diff --git a/pkg/provider/update_archive.go b/pkg/provider/update_archive.go index a58d9a6e8e..a0dbfd106a 100644 --- a/pkg/provider/update_archive.go +++ b/pkg/provider/update_archive.go @@ -336,7 +336,8 @@ func materializeUpdateTarEntry(root *os.Root, input io.Reader, header *tar.Heade return materializeUpdateTarSymlink(root, name, header.Linkname) case tar.TypeLink: return materializeUpdateTarLink(root, name, header.Linkname) - case tar.TypeReg: + case tar.TypeReg, tar.TypeGNUSparse: + // archive/tar.Reader expands GNU sparse holes into the logical file stream. return writeConfinedUpdateFile(root, name, input, header.FileInfo().Mode().Perm()|0o600) default: return fmt.Errorf("unsupported update archive entry type %d", header.Typeflag) diff --git a/pkg/provider/update_archive_sparse_test.go b/pkg/provider/update_archive_sparse_test.go new file mode 100644 index 0000000000..67ded8ed7a --- /dev/null +++ b/pkg/provider/update_archive_sparse_test.go @@ -0,0 +1,114 @@ +package provider + +import ( + "archive/tar" + "bytes" + "context" + "fmt" + "io" + "os" + "path/filepath" + "testing" + + "github.com/devsy-org/devsy/pkg/extract" + "github.com/stretchr/testify/require" +) + +func TestExtractConfinedUpdateTarExpandsGNUSparseExecutable(t *testing.T) { + archive := gnuSparseUpdateArchive(t) + wantExecutable := []byte("#!/bin\x00\x00\x00sh\n") + wantSidecar := []byte("provider metadata\n") + + legacyDir := t.TempDir() + require.NoError(t, extract.Extract(bytes.NewReader(archive), legacyDir)) + // #nosec G304 -- legacyDir and the archive are owned entirely by this fixture. + legacyExecutable, err := os.ReadFile(filepath.Join(legacyDir, "bin", "runtime")) + require.NoError(t, err) + require.Equal(t, wantExecutable, legacyExecutable) + + destination := filepath.Join(t.TempDir(), "provider") + require.NoError(t, os.Mkdir(destination, 0o700)) + root, err := os.OpenRoot(destination) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, root.Close()) }) + + require.NoError(t, extractConfinedUpdateTar( + context.Background(), root, bytes.NewReader(archive), + )) + require.NoError(t, finalizeUpdateArchive(context.Background(), root, "bin/runtime")) + + executable, err := root.ReadFile("bin/runtime") + require.NoError(t, err) + require.Equal(t, wantExecutable, executable) + executableInfo, err := root.Stat("bin/runtime") + require.NoError(t, err) + require.Equal(t, os.FileMode(0o755), executableInfo.Mode().Perm()) + + sidecar, err := root.ReadFile("bin/provider.json") + require.NoError(t, err) + require.Equal(t, wantSidecar, sidecar) + sidecarInfo, err := root.Stat("bin/provider.json") + require.NoError(t, err) + require.Equal(t, os.FileMode(0o640), sidecarInfo.Mode().Perm()) +} + +// This fixture is a GNU sparse tar stream parsed by archive/tar.Reader. The +// regular-file header is patched to the GNU sparse type with two data extents. +func gnuSparseUpdateArchive(t *testing.T) []byte { + t.Helper() + var buf bytes.Buffer + writer := tar.NewWriter(&buf) + physical := []byte("#!/binsh\n") + require.NoError(t, writer.WriteHeader(&tar.Header{ + Name: "bin/runtime", Mode: 0o755, Size: int64(len(physical)), Format: tar.FormatGNU, + })) + _, err := writer.Write(physical) + require.NoError(t, err) + sidecar := []byte("provider metadata\n") + require.NoError(t, writer.WriteHeader(&tar.Header{ + Name: "bin/provider.json", Mode: 0o640, Size: int64(len(sidecar)), + })) + _, err = writer.Write(sidecar) + require.NoError(t, err) + require.NoError(t, writer.Close()) + + archive := buf.Bytes() + header := archive[:512] + header[156] = tar.TypeGNUSparse + putSparseNumber(t, header[386:398], 0) + putSparseNumber(t, header[398:410], 6) + putSparseNumber(t, header[410:422], 9) + putSparseNumber(t, header[422:434], 3) + putSparseNumber(t, header[483:495], 12) + for i := 148; i < 156; i++ { + header[i] = ' ' + } + var checksum int + for _, b := range header { + checksum += int(b) + } + copy(header[148:156], fmt.Sprintf("%06o\x00 ", checksum)) + return archive +} + +func putSparseNumber(t *testing.T, field []byte, value int64) { + t.Helper() + text := fmt.Sprintf("%011o\x00", value) + require.Len(t, text, len(field)) + copy(field, text) +} + +func TestGNUArchiveFixtureHasExpandedSparseData(t *testing.T) { + archive := gnuSparseUpdateArchive(t) + reader := tar.NewReader(bytes.NewReader(archive)) + header, err := reader.Next() + require.NoError(t, err) + require.Equal(t, byte(tar.TypeGNUSparse), header.Typeflag) + require.Equal(t, int64(12), header.Size) + body, err := io.ReadAll(reader) + require.NoError(t, err) + require.Equal(t, []byte("#!/bin\x00\x00\x00sh\n"), body) + header, err = reader.Next() + require.NoError(t, err) + require.Equal(t, "bin/provider.json", header.Name) +} diff --git a/pkg/workspace/provider_update_absolute_reference_test.go b/pkg/workspace/provider_update_absolute_reference_test.go index c41bc8ba33..785037faa6 100644 --- a/pkg/workspace/provider_update_absolute_reference_test.go +++ b/pkg/workspace/provider_update_absolute_reference_test.go @@ -25,6 +25,15 @@ func absoluteReferenceArchiveBinary(t *testing.T, content []byte) *provider.Prov func TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget(t *testing.T) { t.Run("unchanged managed target succeeds", testUnchangedManagedAbsoluteReference) + t.Run("changed managed target with matching new checksum succeeds", func(t *testing.T) { + assertManagedAbsoluteReplacementAccepted(t, false, true) + }) + t.Run("replaced managed symlink with matching new checksum succeeds", func(t *testing.T) { + assertManagedAbsoluteReplacementAccepted(t, true, true) + }) + t.Run("new managed target with matching checksum succeeds", func(t *testing.T) { + assertManagedAbsoluteReplacementAccepted(t, false, false) + }) t.Run("changed managed target rejects and preserves live state", func(t *testing.T) { assertChangedManagedAbsoluteReferenceRejected(t, false) @@ -46,6 +55,51 @@ func TestProviderUpdateAbsoluteReferenceUsesFinalStagedTarget(t *testing.T) { ) } +func assertManagedAbsoluteReplacementAccepted(t *testing.T, throughSymlink, seedTarget bool) { + t.Helper() + f := newPreservationFixture(t) + oldContent := []byte("old managed executable") + newContent := []byte("new managed executable") + if seedTarget { + f.seedBinary("B", oldContent) + } + aliasPath := f.binaryPath("B") + aliasKey := absoluteReferenceAliasKey + replacementKey := "B" + if throughSymlink { + requireProviderUpdateSymlinks(t) + aliasKey = "REFERENCE" + replacementKey = absoluteReferenceAliasKey + aliasPath = f.binaryPath(absoluteReferenceAliasKey) + require.NoError(t, os.MkdirAll(filepath.Dir(aliasPath), 0o700)) + require.NoError(t, os.Symlink(filepath.Join("..", "b", updateRuntimeName), aliasPath)) + } + alias := updateTestBinary(aliasPath, newContent) + err := f.update(map[string][]*provider.ProviderBinary{ + aliasKey: {alias}, + replacementKey: {absoluteReferenceArchiveBinary(t, newContent)}, + }) + require.NoError(t, err) + // #nosec G304 -- aliasPath is confined to this fixture's owned provider tree. + actual, err := os.ReadFile(aliasPath) + require.NoError(t, err) + require.Equal(t, newContent, actual) + info, err := os.Lstat(aliasPath) + require.NoError(t, err) + require.True(t, info.Mode().IsRegular()) + stored, err := provider.LoadProviderConfig(testDefaultContext, f.name) + require.NoError(t, err) + require.Equal(t, aliasPath, stored.Binaries[aliasKey][0].Path) + require.Equal(t, alias.Checksum, stored.Binaries[aliasKey][0].Checksum) + if throughSymlink { + preserved, readErr := os.ReadFile(f.binaryPath("B")) + require.NoError(t, readErr) + require.Equal(t, oldContent, preserved) + } + f.assertAssociation() + assertNoUpdateStaging(t, f) +} + func testUnchangedManagedAbsoluteReference(t *testing.T) { f := newPreservationFixture(t) managedContent := []byte("unchanged managed executable") diff --git a/pkg/workspace/provider_update_prepared.go b/pkg/workspace/provider_update_prepared.go index 16db817322..3b0d9e26b7 100644 --- a/pkg/workspace/provider_update_prepared.go +++ b/pkg/workspace/provider_update_prepared.go @@ -394,8 +394,9 @@ func validateProviderSeedEntry(root *os.Root, name string, entry fs.DirEntry) er return nil } -// Absolute files are user-owned references, not downloader targets. In particular, -// never call verifyOrRemoveBinary on them when a replacement checksum differs. +// Absolute locations are references, never downloader targets. Managed references +// are checked after preparation, which can replace or create their targets. +// Outside references are checked in place without destructive checksum cleanup. func stagedProviderLocations( ctx context.Context, binaries map[string][]*provider.ProviderBinary, @@ -430,11 +431,8 @@ func stagedProviderLocationReference( if location.OS != runtime.GOOS || location.Arch != runtime.GOARCH { continue } - if err := validateProviderUpdateLocation(location); err != nil { - return nil, false, err - } if !filepath.IsAbs(location.Path) { - return nil, false, nil + return nil, false, validateProviderUpdateLocation(location) } stagedPath, managed, err := projectManagedAbsoluteReference(location.Path, live, stagedRoot) if err != nil { @@ -446,7 +444,7 @@ func stagedProviderLocationReference( stagedPath: stagedPath, }, true, nil } - return nil, true, nil + return nil, true, validateAbsoluteProviderBinary(location) } return nil, false, nil } @@ -542,9 +540,6 @@ func sharesManagedDirectoryAncestor(live, resolvedPath string) (bool, error) { } func validateProviderUpdateLocation(location *provider.ProviderBinary) error { - if filepath.IsAbs(location.Path) { - return validateAbsoluteProviderBinary(location) - } for _, target := range []string{location.Name, location.ArchivePath} { clean := filepath.Clean(target) if filepath.IsAbs(target) || clean == ".." || From 339604e15c4761548900d2ebb02a2f351892fa89 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 18:47:05 -0600 Subject: [PATCH 14/15] test(ssh): observe owned reverse-forward listener closure --- cmd/workspace/gpg_tunnel_test.go | 41 +++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 11 deletions(-) diff --git a/cmd/workspace/gpg_tunnel_test.go b/cmd/workspace/gpg_tunnel_test.go index 66254ad433..d8440e42b6 100644 --- a/cmd/workspace/gpg_tunnel_test.go +++ b/cmd/workspace/gpg_tunnel_test.go @@ -11,6 +11,7 @@ import ( "path/filepath" "slices" "strings" + "sync" "testing" "time" @@ -104,7 +105,7 @@ func TestGPGTunnelRebindsWhenManagedReverseForwardExits(t *testing.T) { replacement := tunnel.forward tunnel.stopForward() waitForManagedReverseForward(t, replacement) - assertReverseForwardListenerReleased(t, forwards.listeners[1]) + assertManagedReverseForwardListenerClosed(t, forwards.listeners[1]) } type testGPGReverseForwards struct { @@ -112,7 +113,7 @@ type testGPGReverseForwards struct { userMapping string userForward *managedReverseForward userListener net.Listener - listeners []net.Listener + listeners []*closeObservedListener } func (f *testGPGReverseForwards) start( @@ -164,13 +165,30 @@ func assertUserReverseForwardActive( } } -func assertReverseForwardListenerReleased(t *testing.T, stopped net.Listener) { +func assertManagedReverseForwardListenerClosed(t *testing.T, stopped *closeObservedListener) { t.Helper() - if listener, err := net.Listen("tcp", stopped.Addr().String()); err != nil { - t.Fatalf("replacement listener still bound after stop: %v", err) - } else { - _ = listener.Close() + select { + case <-stopped.closed: + default: + t.Fatal("managed forward completed without closing its owned listener") + } +} + +type closeObservedListener struct { + net.Listener + closed chan struct{} + once sync.Once +} + +func (l *closeObservedListener) Close() error { + if err := l.Listener.Close(); err != nil { + if errors.Is(err, net.ErrClosed) { + l.once.Do(func() { close(l.closed) }) + } + return err } + l.once.Do(func() { close(l.closed) }) + return nil } func TestGPGTunnelRetriesUserMappingsAfterInitialBindFailure(t *testing.T) { @@ -210,11 +228,12 @@ func TestGPGTunnelRetriesUserMappingsAfterInitialBindFailure(t *testing.T) { func startTestManagedReverseForward( ctx context.Context, client *ssh.Client, -) (*managedReverseForward, net.Listener, error) { +) (*managedReverseForward, *closeObservedListener, error) { listener, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { return nil, nil, err } + observed := &closeObservedListener{Listener: listener, closed: make(chan struct{})} forwardCtx, cancel := context.WithCancel(ctx) done := make(chan error, 1) go runManagedReverseForward(managedReverseForwardRun{ @@ -224,14 +243,14 @@ func startTestManagedReverseForward( forward: boundReverseForward{ portMapping: "gpg socket", mapping: port.Mapping{ - Host: port.Address{Protocol: "tcp", Address: listener.Addr().String()}, + Host: port.Address{Protocol: "tcp", Address: observed.Addr().String()}, Container: port.Address{Protocol: "tcp", Address: "127.0.0.1:1"}, }, - listener: listener, + listener: observed, }, doneChan: done, }) - return &managedReverseForward{cancel: cancel, done: done}, listener, nil + return &managedReverseForward{cancel: cancel, done: done}, observed, nil } func waitForManagedReverseForward(t *testing.T, forward *managedReverseForward) { From dc539e0dcb1cb1706c6611764da36196426e64eb Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 13 Oct 2026 19:11:28 -0600 Subject: [PATCH 15/15] test(runtime): prepare existing-workspace source migration coverage --- cmd/provider/set_source_init_failure_test.go | 122 +++++++ .../up/provider_microsandbox_migration.go | 322 ++++++++++++++++++ 2 files changed, 444 insertions(+) create mode 100644 cmd/provider/set_source_init_failure_test.go create mode 100644 e2e/tests/up/provider_microsandbox_migration.go diff --git a/cmd/provider/set_source_init_failure_test.go b/cmd/provider/set_source_init_failure_test.go new file mode 100644 index 0000000000..65df1b6d77 --- /dev/null +++ b/cmd/provider/set_source_init_failure_test.go @@ -0,0 +1,122 @@ +package provider + +import ( + "context" + "os" + "path/filepath" + "testing" + "time" + + "github.com/devsy-org/devsy/cmd/flags" + "github.com/devsy-org/devsy/pkg/config" + provider2 "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" + "github.com/devsy-org/devsy/pkg/workspace" + "github.com/stretchr/testify/require" + "sigs.k8s.io/yaml" +) + +func TestSetSourceInitFailureKeepsCommittedReplacementAndWorkspace(t *testing.T) { + initial, userOption := setupInitializedSourceProvider(t) + + associated := &provider2.Workspace{ + ID: "existing", UID: "existing-generation", Context: initial.DefaultContext, + Provider: provider2.WorkspaceProviderConfig{Name: testProviderFoo}, + } + require.NoError(t, provider2.SaveWorkspaceConfig(associated)) + workspaceDir, err := provider2.GetWorkspaceDir(initial.DefaultContext, associated.ID) + require.NoError(t, err) + recordPath := filepath.Join(workspaceDir, provider2.WorkspaceConfigFile) + // #nosec G304 -- recordPath is the isolated fixture workspace record. + recordBefore, err := os.ReadFile(recordPath) + require.NoError(t, err) + markerPath := filepath.Join(workspaceDir, "retained-content") + require.NoError(t, os.WriteFile(markerPath, []byte("existing-workspace-content"), 0o600)) + + missingInit := filepath.Join(t.TempDir(), "missing-init-executable") + replacement, err := provider2.LoadProviderConfig(initial.DefaultContext, testProviderFoo) + require.NoError(t, err) + replacement.Version = "2.0.0" + replacement.Exec.Init = []string{missingInit} + replacementSource := filepath.Join(t.TempDir(), "replacement.yaml") + replacement.Source = provider2.ProviderSource{File: replacementSource, Raw: replacementSource} + replacementBytes, err := yaml.Marshal(replacement) + require.NoError(t, err) + require.NoError(t, os.WriteFile(replacementSource, replacementBytes, 0o600)) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + cmd := &SetSourceCmd{GlobalFlags: &flags.GlobalFlags{}, Use: true} + err = cmd.Run(ctx, initial, []string{testProviderFoo, replacementSource}) + require.ErrorContains(t, err, "init:") + require.ErrorContains(t, err, "missing-init-executable") + + assertFailedSourceReplacement( + t, + initial.DefaultContext, + replacement, + userOption, + ) + // #nosec G304 -- recordPath is the same isolated fixture workspace record. + recordAfter, err := os.ReadFile(recordPath) + require.NoError(t, err) + require.Equal(t, recordBefore, recordAfter) + // #nosec G304 -- markerPath is created in this fixture workspace directory. + markerAfter, err := os.ReadFile(markerPath) + require.NoError(t, err) + require.Equal(t, "existing-workspace-content", string(markerAfter)) +} + +func setupInitializedSourceProvider(t *testing.T) (*config.Config, config.OptionValue) { + t.Helper() + t.Setenv("DEVSY_HOME", t.TempDir()) + initial := setupProviderOperationTest(t) + oldSource := filepath.Join(t.TempDir(), "old.yaml") + old := &provider2.ProviderConfig{ + Name: testProviderFoo, Version: "1.0.0", + Options: map[string]*types.Option{"REGION": {Default: "default-region"}}, + Exec: provider2.ProviderCommands{Command: []string{"unused-command"}}, + } + oldBytes, err := yaml.Marshal(old) + require.NoError(t, err) + require.NoError(t, os.WriteFile(oldSource, oldBytes, 0o600)) + _, err = workspace.AddProvider(context.Background(), initial, testProviderFoo, oldSource) + require.NoError(t, err) + userOption := config.OptionValue{Value: "user-region", UserProvided: true} + require.NoError( + t, + config.UpdateConfig(initial.DefaultContext, "", func(c *config.Config) error { + c.Current().DefaultProvider = testProviderFoo + c.Current().Providers[testProviderFoo].Initialized = true + c.Current().Providers[testProviderFoo].Options = map[string]config.OptionValue{ + "REGION": userOption, + } + return nil + }), + ) + + return initial, userOption +} + +func assertFailedSourceReplacement( + t *testing.T, + contextName string, + expected *provider2.ProviderConfig, + userOption config.OptionValue, +) { + t.Helper() + installed, err := provider2.LoadProviderConfig(contextName, testProviderFoo) + require.NoError(t, err) + require.Equal(t, expected.Version, installed.Version) + require.Equal(t, expected.Source.Raw, installed.Source.Raw) + require.Equal(t, expected.Exec.Init, installed.Exec.Init) + stored, err := config.LoadConfig(contextName, "") + require.NoError(t, err) + state := stored.Current().Providers[testProviderFoo] + require.NotNil(t, state) + require.False(t, state.Initialized) + require.True(t, state.InitAttempted) + require.Contains(t, state.InitError, "missing-init-executable") + require.Equal(t, userOption.Value, state.Options["REGION"].Value) + require.True(t, state.Options["REGION"].UserProvided) + require.Equal(t, testProviderFoo, stored.Current().DefaultProvider) +} diff --git a/e2e/tests/up/provider_microsandbox_migration.go b/e2e/tests/up/provider_microsandbox_migration.go new file mode 100644 index 0000000000..5ff2d6f7c5 --- /dev/null +++ b/e2e/tests/up/provider_microsandbox_migration.go @@ -0,0 +1,322 @@ +package up + +import ( + "context" + "encoding/json" + "fmt" + "os" + "path/filepath" + "strings" + "time" + + "github.com/devsy-org/devsy/e2e/framework" + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/devcontainer" + "github.com/devsy-org/devsy/pkg/encoding" + providerpkg "github.com/devsy-org/devsy/pkg/provider" + "github.com/onsi/ginkgo/v2" + "github.com/onsi/gomega" +) + +const ( + microsandboxMigrationSuiteLabel = "up-provider-microsandbox-source-migration" + microsandboxMigrationRootMarker = "/root/devsy-source-migration-marker" + microsandboxMigrationVolumeDir = "/source-migration-volume" + microsandboxMigrationMarker = "source-migration-preserved" + microsandboxMigrationSource = "source-migration-source" +) + +var _ = ginkgo.Describe( + "existing MicroSandbox workspace source migration", + ginkgo.Label(microsandboxMigrationSuiteLabel), + func() { + ginkgo.DescribeTable( + "migrates the existing provider without replacing its workspace or VM", + func(ctx context.Context, stopped bool) { + fixture := newMicrosandboxMigrationFixture(ctx) + fixture.initialize(ctx, stopped) + fixture.migrate(ctx, stopped) + fixture.deleteWorkspace(ctx) + }, + ginkgo.Entry( + "running workspace", + false, + ginkgo.Label("microsandbox-external"), + ginkgo.SpecTimeout(framework.TimeoutLong()), + ), + ginkgo.Entry( + "stopped workspace", + true, + ginkgo.Label("microsandbox-external"), + ginkgo.SpecTimeout(framework.TimeoutLong()), + ), + ) + }, +) + +type microsandboxMigrationFixture struct { + framework *framework.Framework + workspace string + sandbox string + uid string + label string + volume string + volumeOwned bool + workspaceState compatibilityWorkspaceState + vmState safeRecreateInspection + bootID string + options map[string]config.OptionValue +} + +func newMicrosandboxMigrationFixture( + ctx context.Context, +) *microsandboxMigrationFixture { + session := newMicrosandboxTestSession(ctx) + home := ginkgo.GinkgoT().TempDir() + ginkgo.GinkgoT().Setenv("HOME", home) + ginkgo.GinkgoT().Setenv("USERPROFILE", home) + ginkgo.GinkgoT().Setenv("MSB_HOME", filepath.Join(home, "microsandbox")) + ginkgo.GinkgoT().Setenv( + "MSB_CONFIG_PATH", + filepath.Join(home, "microsandbox", "config.json"), + ) + + workspace := session.newWorkspace() + session.addProvider(ctx, microsandboxResourceBuiltin, "microsandbox") + uid := encoding.CreateNewUID("", filepath.Base(workspace)) + fixture := µsandboxMigrationFixture{ + framework: session.framework, + workspace: workspace, + uid: uid, + label: "devsy.source-migration=" + uid, + volume: "devsy-source-migration-" + uid, + } + fixture.sandbox = "devsy-" + fixture.uid + fixture.registerCleanup() + + framework.ExpectNoError(fixture.framework.DevsyProviderUse(ctx, "microsandbox", + microsandboxResourceOption, "MICROSANDBOX_MEMORY=1024", + microsandboxResourceOption, "MICROSANDBOX_STORAGE=2", + microsandboxResourceOption, "MICROSANDBOX_EPHEMERAL=false")) + assertMicrosandboxEphemeralAbsent(ctx, fixture.label) + out, err := microsandboxResourceCommand(ctx, "list", "--quiet") + framework.ExpectNoError(err, string(out)) + gomega.Expect(strings.Fields(string(out))).NotTo(gomega.ContainElement(fixture.sandbox)) + out, err = microsandboxResourceCommand(ctx, "volume", "create", fixture.volume) + framework.ExpectNoError(err, string(out)) + fixture.volumeOwned = true + fixture.writeConfig() + + return fixture +} + +func (fixture *microsandboxMigrationFixture) registerCleanup() { + // Cleanup is deliberately independent: a failed workspace deletion must not + // prevent the exact owned sandbox fallback or named volume removal. + ginkgo.DeferCleanup(func(cleanupCtx context.Context) error { + if !fixture.volumeOwned { + return nil + } + cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(cleanupCtx), time.Minute) + defer cancel() + out, err := microsandboxResourceCommand(cleanupCtx, "volume", "rm", fixture.volume) + if err != nil { + return fmt.Errorf("remove owned migration volume: %w: %s", err, out) + } + return nil + }) + ginkgo.DeferCleanup(func(cleanupCtx context.Context) error { + cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(cleanupCtx), time.Minute) + defer cancel() + out, err := microsandboxResourceCommand(cleanupCtx, "list", "--quiet") + if err != nil { + return fmt.Errorf("list migration sandbox for cleanup: %w: %s", err, out) + } + for name := range strings.FieldsSeq(string(out)) { + if name == fixture.sandbox { + out, err = microsandboxResourceCommand(cleanupCtx, "remove", "--force", name) + if err != nil { + return fmt.Errorf("remove owned migration sandbox: %w: %s", err, out) + } + break + } + } + return nil + }) + ginkgo.DeferCleanup(fixture.framework.CleanupWorkspace, fixture.workspace) +} + +func (fixture *microsandboxMigrationFixture) writeConfig() { + devcontainerConfig := struct { + Image string `json:"image"` + ContainerUser string `json:"containerUser"` + RemoteUser string `json:"remoteUser"` + Mounts []string `json:"mounts"` + }{ + Image: microsandboxResourceImage, + ContainerUser: microsandboxRootUser, + RemoteUser: microsandboxRootUser, + Mounts: []string{ + "type=volume,source=" + fixture.volume + ",target=" + microsandboxMigrationVolumeDir, + }, + } + data, err := json.Marshal(devcontainerConfig) + framework.ExpectNoError(err) + framework.ExpectNoError(os.WriteFile( + filepath.Join(fixture.workspace, ".devcontainer.json"), data, 0o600, + )) + framework.ExpectNoError(os.WriteFile( + filepath.Join(fixture.workspace, microsandboxMigrationSource), + []byte(microsandboxMigrationMarker), 0o600, + )) +} + +func (fixture *microsandboxMigrationFixture) initialize(ctx context.Context, stopped bool) { + assertMigrationProvider("microsandbox", true, providerpkg.MicrosandboxDriver, "microsandbox") + devsyConfig, err := config.LoadConfig("", "") + framework.ExpectNoError(err) + gomega.Expect(devsyConfig.Current().DefaultProvider).To(gomega.Equal("microsandbox")) + providerConfig := devsyConfig.Current().Providers["microsandbox"] + gomega.Expect(providerConfig).NotTo(gomega.BeNil()) + gomega.Expect(providerConfig.Initialized).To(gomega.BeTrue()) + fixture.options = migrationOptions(providerConfig.Options) + assertMigrationOptions(fixture.options) + + framework.ExpectNoError(fixture.framework.DevsyUp( + ctx, + fixture.workspace, + "--devcontainer", ".devcontainer.json", + "--uid", fixture.uid, + "--id-label", fixture.label, + )) + workspace, err := fixture.framework.FindWorkspace(ctx, fixture.workspace) + framework.ExpectNoError(err) + gomega.Expect(workspace.UID).To(gomega.Equal(fixture.uid)) + gomega.Expect(workspace.Provider.Name).To(gomega.Equal("microsandbox")) + gomega.Expect("devsy-" + devcontainer.GetRunnerIDFromWorkspace(workspace)). + To(gomega.Equal(fixture.sandbox)) + fixture.workspaceState = snapshotCompatibilityWorkspace(ctx, workspace) + fixture.vmState = inspectSafeRecreate(ctx, fixture.sandbox) + gomega.Expect(fixture.vmState.Status).To(gomega.Equal("Running")) + _, err = fixture.framework.DevsySSHOnce(ctx, fixture.workspace, + "printf '%s' '"+microsandboxMigrationMarker+"' > "+microsandboxMigrationRootMarker+ + " && printf '%s' '"+microsandboxMigrationMarker+"' > "+ + microsandboxMigrationVolumeDir+"/marker") + framework.ExpectNoError(err) + fixture.bootID = microsandboxStorageBootID(ctx, fixture.framework, fixture.workspace) + if stopped { + framework.ExpectNoError(fixture.framework.DevsyWorkspaceStop(ctx, fixture.workspace)) + fixture.vmState = inspectSafeRecreate(ctx, fixture.sandbox) + gomega.Expect(fixture.vmState.Status).To(gomega.Equal("Stopped")) + } +} + +func (fixture *microsandboxMigrationFixture) migrate(ctx context.Context, stopped bool) { + framework.ExpectNoError(fixture.framework.DevsyProviderSetSource( + ctx, "microsandbox", microsandboxExternalProvider, + )) + assertMigrationProvider("microsandbox", false, providerpkg.ExternalDriver, + microsandboxExternalProvider) + devsyConfig, err := config.LoadConfig("", "") + framework.ExpectNoError(err) + gomega.Expect(devsyConfig.Current().DefaultProvider).To(gomega.Equal("microsandbox")) + providerConfig := devsyConfig.Current().Providers["microsandbox"] + gomega.Expect(providerConfig).NotTo(gomega.BeNil()) + gomega.Expect(providerConfig.Initialized).To(gomega.BeTrue()) + gomega.Expect(providerConfig.InitError).To(gomega.BeEmpty()) + afterOptions := migrationOptions(providerConfig.Options) + assertMigrationOptions(afterOptions) + gomega.Expect(afterOptions).To(gomega.Equal(fixture.options)) + + workspace, err := fixture.framework.FindWorkspace(ctx, fixture.workspace) + framework.ExpectNoError(err) + gomega.Expect(snapshotCompatibilityWorkspace(ctx, workspace)). + To(gomega.Equal(fixture.workspaceState)) + vmAfterMigration := inspectSafeRecreate(ctx, fixture.sandbox) + gomega.Expect(vmAfterMigration.CreatedAt).To(gomega.Equal(fixture.vmState.CreatedAt)) + if stopped { + gomega.Expect(vmAfterMigration.Status).To(gomega.Equal("Stopped")) + } else { + gomega.Expect(vmAfterMigration.Status).To(gomega.Equal("Running")) + gomega.Expect(microsandboxStorageBootID(ctx, fixture.framework, fixture.workspace)). + To(gomega.Equal(fixture.bootID)) + fixture.assertMarkers(ctx) + } + + framework.ExpectNoError(fixture.framework.DevsyUp(ctx, fixture.workspace)) + workspace, err = fixture.framework.FindWorkspace(ctx, fixture.workspace) + framework.ExpectNoError(err) + gomega.Expect(workspace.ID).To(gomega.Equal(fixture.workspaceState.ID)) + gomega.Expect(workspace.UID).To(gomega.Equal(fixture.uid)) + gomega.Expect(workspace.Provider.Name).To(gomega.Equal("microsandbox")) + gomega.Expect(snapshotCompatibilityWorkspace(ctx, workspace)). + To(gomega.Equal(fixture.workspaceState)) + vmAfterUp := inspectSafeRecreate(ctx, fixture.sandbox) + gomega.Expect(vmAfterUp.Status).To(gomega.Equal("Running")) + gomega.Expect(vmAfterUp.CreatedAt).To(gomega.Equal(fixture.vmState.CreatedAt)) + bootAfterUp := microsandboxStorageBootID(ctx, fixture.framework, fixture.workspace) + if stopped { + gomega.Expect(bootAfterUp).NotTo(gomega.Equal(fixture.bootID)) + } else { + gomega.Expect(bootAfterUp).To(gomega.Equal(fixture.bootID)) + } + fixture.assertMarkers(ctx) +} + +func (fixture *microsandboxMigrationFixture) assertMarkers(ctx context.Context) { + for _, path := range []string{ + microsandboxMigrationRootMarker, + microsandboxMigrationVolumeDir + "/marker", + filepath.ToSlash(filepath.Join("/workspaces", filepath.Base(fixture.workspace), microsandboxMigrationSource)), + } { + out, err := fixture.framework.DevsySSHOnce(ctx, fixture.workspace, "cat "+path) + framework.ExpectNoError(err, out) + gomega.Expect(strings.TrimSpace(out)).To(gomega.Equal(microsandboxMigrationMarker)) + } +} + +func (fixture *microsandboxMigrationFixture) deleteWorkspace(ctx context.Context) { + framework.ExpectNoError(fixture.framework.DevsyWorkspaceDelete(ctx, fixture.workspace)) + gomega.Expect(providerpkg.WorkspaceExists(config.DefaultContext, fixture.workspaceState.ID)). + To(gomega.BeFalse(), "the migrated workspace record should be deleted") + out, err := microsandboxResourceCommand(ctx, "list", "--quiet") + framework.ExpectNoError(err, string(out)) + gomega.Expect(strings.Fields(string(out))).NotTo(gomega.ContainElement(fixture.sandbox)) +} + +func assertMigrationProvider( + name string, + internal bool, + driver string, + rawSource string, +) { + providerConfig, err := providerpkg.LoadProviderConfig(config.DefaultContext, name) + framework.ExpectNoError(err) + gomega.Expect(providerConfig.Name).To(gomega.Equal(name)) + gomega.Expect(providerConfig.Source.Internal).To(gomega.Equal(internal)) + gomega.Expect(providerConfig.Source.Raw).To(gomega.Equal(rawSource)) + gomega.Expect(providerConfig.Agent.Driver).To(gomega.Equal(driver)) +} + +func migrationOptions(options map[string]config.OptionValue) map[string]config.OptionValue { + shared := make(map[string]config.OptionValue, 3) + for _, key := range []string{ + "MICROSANDBOX_MEMORY", "MICROSANDBOX_STORAGE", "MICROSANDBOX_EPHEMERAL", + } { + shared[key] = options[key] + } + return shared +} + +func assertMigrationOptions(options map[string]config.OptionValue) { + for key, value := range map[string]string{ + "MICROSANDBOX_MEMORY": "1024", + "MICROSANDBOX_STORAGE": "2", + "MICROSANDBOX_EPHEMERAL": "false", + } { + option, ok := options[key] + gomega.Expect(ok).To(gomega.BeTrue(), "shared option %s must remain configured", key) + gomega.Expect(option.Value).To(gomega.Equal(value), "shared option %s", key) + gomega.Expect(option.UserProvided).To(gomega.BeTrue(), "shared option %s", key) + } +}