From 051fbab66c29d47f8d8f626e05bf2b7fd77066ca Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 4 Nov 2026 09:17:31 -0600 Subject: [PATCH 1/3] fix(runtime): release leaked resources and simplify duplicated pkg and cmd code --- CONTRIBUTING.md | 14 +++ cmd/config/read.go | 35 ++---- cmd/internal/agent_daemon.go | 18 ++- cmd/internal/agent_daemon_test.go | 45 +++++++ cmd/internal/runusercommands.go | 52 ++++---- cmd/internal/runusercommands_test.go | 23 +++- cmd/pro/logout.go | 80 ++++++++----- cmd/pro/provider/health.go | 1 + cmd/pro/provider/health_test.go | 67 +++++++++++ cmd/pro/start.go | 85 +++++++------ cmd/pro/start_reachability_test.go | 113 ++++++++++++++++++ cmd/provider/set.go | 20 +--- cmd/workspace/gpg_tunnel.go | 25 ++-- hack/ci/suites.yaml | 7 ++ pkg/agent/binary.go | 70 +++-------- pkg/agent/binary_cache_test.go | 102 ++++++++++++++++ .../exec_stream_cancellation_unix_test.go | 29 ++++- pkg/agent/delivery/kubernetes.go | 3 +- pkg/compose/helper.go | 65 ++++------ pkg/credentials/github_test.go | 8 +- pkg/credentials/host_test.go | 4 +- pkg/credentials/readiness_test.go | 4 +- pkg/credentials/server.go | 9 +- pkg/credentials/server_test.go | 79 +++++++++++- pkg/daemon/platform/local_server.go | 40 +++---- pkg/devcontainer/feature/extend.go | 51 ++++---- pkg/devcontainer/graph/graph.go | 26 +--- pkg/devcontainer/graph/graph_test.go | 23 ++++ pkg/devcontainer/metadata/metadata.go | 37 ++---- pkg/docker/helper.go | 5 +- pkg/docker/helper_test.go | 3 + pkg/dockercredentials/dockercredentials.go | 37 +----- pkg/dockercredentials/helper.go | 28 +---- pkg/dockerinstall/executor.go | 28 ++--- pkg/dotfiles/dotfiles.go | 6 +- pkg/driver/apple/build.go | 20 ++-- pkg/driver/kubernetes/helper.go | 47 ++++---- pkg/driver/kubernetes/pod_lifecycle_test.go | 25 ++++ pkg/driver/kubernetes/run.go | 25 ++-- pkg/envfile/envfile.go | 35 ++---- pkg/ide/opener/browser_tunnel.go | 1 + pkg/ide/opener/browser_tunnel_fd_unix_test.go | 93 ++++++++++++++ pkg/ide/opener/opener.go | 44 ++----- pkg/log/streamer.go | 13 +- pkg/open/open.go | 18 +-- pkg/platform/kubeconfig.go | 57 +++++---- pkg/platform/version.go | 5 +- pkg/platform/version_test.go | 71 +++++++++++ pkg/pty/ptytest/ptytest_windows.go | 15 +-- pkg/secrets/local_store.go | 37 +++--- pkg/secrets/store_internal_test.go | 29 +++++ pkg/ssh/keys.go | 50 +++----- pkg/stdio/listener.go | 7 +- pkg/task/task.go | 12 +- 54 files changed, 1185 insertions(+), 661 deletions(-) create mode 100644 cmd/pro/provider/health_test.go create mode 100644 cmd/pro/start_reachability_test.go create mode 100644 pkg/agent/binary_cache_test.go create mode 100644 pkg/ide/opener/browser_tunnel_fd_unix_test.go diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b71b7620a8..b70cc056a4 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -165,6 +165,20 @@ mise installs the pinned `protoc`. The task installs the Go protobuf plugins. ## Test your changes +### Go resource lifecycle checks + +Run affected packages with `go test -race -short -count=1`, then run +`mise run cli:lint:ci`. Resource cleanup changes need coverage of failure paths +as well as successful calls. + +The browser tunnel regression in `pkg/ide/opener` exhausts file descriptors in +an isolated subprocess on Linux and macOS. It checks that a failed helper launch +releases its reserved port. Platform reachability tests in `cmd/pro` use local +HTTP servers to check connection cleanup between probes. + +Cross-compilation checks platform buildability, not runtime behavior. Windows +PTY tests run through the `windows-pty` step in `hack/ci/suites.yaml`. + ### Quick start 1. Build Devsy: diff --git a/cmd/config/read.go b/cmd/config/read.go index 0334a047c0..7ec92b55ce 100644 --- a/cmd/config/read.go +++ b/cmd/config/read.go @@ -196,31 +196,7 @@ func (cmd *ReadCmd) resolveConfigFromContainer(ctx context.Context) ( return nil, "", fmt.Errorf("container %s not found", cmd.ContainerID) } - containerDetails := &details[0] - subCtx := &devcconfig.SubstitutionContext{} - - imageMetadata, err := metadata.GetImageMetadataFromContainer( - containerDetails, - subCtx, - ) - if err != nil { - return nil, "", fmt.Errorf("get image metadata from container: %w", err) - } - - parsedConfig := &devcconfig.DevContainerConfig{} - if len(imageMetadata.Config) > 0 { - last := imageMetadata.Config[len(imageMetadata.Config)-1] - parsedConfig.DevContainerConfigBase = last.DevContainerConfigBase - parsedConfig.DevContainerActions = last.DevContainerActions - parsedConfig.NonComposeBase = last.NonComposeBase - } - - workspaceFolder := containerDetails.Config.WorkingDir - if workspaceFolder == "" { - workspaceFolder = "/" - } - - return parsedConfig, workspaceFolder, nil + return configFromContainerDetails(&details[0]) } func (cmd *ReadCmd) resolveConfigFromIDLabels(ctx context.Context) ( @@ -234,7 +210,16 @@ func (cmd *ReadCmd) resolveConfigFromIDLabels(ctx context.Context) ( return nil, "", err } + return configFromContainerDetails(containerDetails) +} + +func configFromContainerDetails(containerDetails *devcconfig.ContainerDetails) ( + *devcconfig.DevContainerConfig, + string, + error, +) { subCtx := &devcconfig.SubstitutionContext{} + imageMetadata, err := metadata.GetImageMetadataFromContainer( containerDetails, subCtx, diff --git a/cmd/internal/agent_daemon.go b/cmd/internal/agent_daemon.go index e2401a44ac..790634996c 100644 --- a/cmd/internal/agent_daemon.go +++ b/cmd/internal/agent_daemon.go @@ -499,13 +499,20 @@ func (cmd *DaemonCmd) shutdownWorkspace( func (cmd *DaemonCmd) effectiveShutdownAction( workspace *provider2.AgentWorkspaceInfo, ) string { + if action, ok := workspaceShutdownAction(workspace); ok { + return action + } + return cmd.ShutdownAction +} + +func workspaceShutdownAction(workspace *provider2.AgentWorkspaceInfo) (string, bool) { if workspace != nil && workspace.LastDevContainerConfig != nil && workspace.LastDevContainerConfig.Config != nil && workspace.LastDevContainerConfig.Config.ShutdownAction != "" { - return workspace.LastDevContainerConfig.Config.ShutdownAction + return workspace.LastDevContainerConfig.Config.ShutdownAction, true } - return cmd.ShutdownAction + return "", false } func (cmd *DaemonCmd) runShutdownCommand( @@ -772,10 +779,9 @@ func blockedWorkspaceResult( } func shutdownActionEnabled(workspace *provider2.AgentWorkspaceInfo, fallback string) bool { - action := fallback - if workspace.LastDevContainerConfig != nil && workspace.LastDevContainerConfig.Config != nil && - workspace.LastDevContainerConfig.Config.ShutdownAction != "" { - action = workspace.LastDevContainerConfig.Config.ShutdownAction + action, ok := workspaceShutdownAction(workspace) + if !ok { + action = fallback } return len(workspace.Agent.Exec.Shutdown) > 0 && action != config.ShutdownActionNone } diff --git a/cmd/internal/agent_daemon_test.go b/cmd/internal/agent_daemon_test.go index b5ff4ac57a..c3bf844ce7 100644 --- a/cmd/internal/agent_daemon_test.go +++ b/cmd/internal/agent_daemon_test.go @@ -157,6 +157,51 @@ func TestEffectiveShutdownAction(t *testing.T) { }) } +func TestShutdownActionEnabled(t *testing.T) { + tests := []struct { + name string + action string + fallback string + command types.StrArray + want bool + }{ + { + name: "workspace none overrides fallback", + action: config.ShutdownActionNone, + fallback: config.ShutdownActionStopContainer, + command: types.StrArray{testEcho}, + }, + { + name: "workspace action overrides none", + action: config.ShutdownActionStopContainer, + fallback: config.ShutdownActionNone, + command: types.StrArray{testEcho}, + want: true, + }, + { + name: "empty action uses fallback", + fallback: config.ShutdownActionStopContainer, + command: types.StrArray{testEcho}, + want: true, + }, + {name: "empty fallback is enabled", command: types.StrArray{testEcho}, want: true}, + {name: "command required", action: config.ShutdownActionStopContainer}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ws := workspaceWithShutdownAction(tt.action) + ws.Agent.Exec.Shutdown = tt.command + assert.Equal(t, tt.want, shutdownActionEnabled(ws, tt.fallback)) + }) + } + t.Run("empty configured action uses fallback", func(t *testing.T) { + ws := workspaceWithShutdownAction(config.ShutdownActionNone) + ws.LastDevContainerConfig.Config.ShutdownAction = "" + ws.Agent.Exec.Shutdown = types.StrArray{testEcho} + assert.True(t, shutdownActionEnabled(ws, config.ShutdownActionStopContainer)) + }) +} + func TestEffectiveActivity(t *testing.T) { orig := activityFilePath t.Cleanup(func() { activityFilePath = orig }) diff --git a/cmd/internal/runusercommands.go b/cmd/internal/runusercommands.go index 7b922bc54a..f74dfe22e7 100644 --- a/cmd/internal/runusercommands.go +++ b/cmd/internal/runusercommands.go @@ -487,15 +487,17 @@ func (cmd *RunUserCommandsCmd) runLifecycleHooks( }) } +type lifecycleHook struct { + name string + cmds []types.LifecycleHook + skip bool +} + func (cmd *RunUserCommandsCmd) runLifecycleHooksUnscoped( params *workspace.LifecycleExecParams, result *devcconfig.Result, ) error { - hooks := []struct { - name string - cmds []types.LifecycleHook - skip bool - }{ + hooks := []lifecycleHook{ {"onCreateCommand", result.MergedConfig.OnCreateCommands, cmd.SkipOnCreate}, {updateContentCommand, result.MergedConfig.UpdateContentCommands, cmd.SkipUpdateContent}, {"postCreateCommand", result.MergedConfig.PostCreateCommands, cmd.SkipPostCreate}, @@ -503,11 +505,15 @@ func (cmd *RunUserCommandsCmd) runLifecycleHooksUnscoped( {"postAttachCommand", result.MergedConfig.PostAttachCommands, cmd.SkipPostAttach}, } - waitForBoundary := resolveWaitForBoundary(result) + waitForBoundary := resolveWaitForBoundary(hooks, result) + prebuildBoundary := 0 + if cmd.Prebuild { + prebuildBoundary = resolveWaitForBoundary(hooks, nil) + } boundaryName := hooks[waitForBoundary].name for i, hook := range hooks { - if cmd.shouldStopLifecycle(i, waitForBoundary, boundaryName) { + if cmd.shouldStopLifecycle(i, prebuildBoundary, waitForBoundary, boundaryName) { return nil } if hook.skip { @@ -522,10 +528,10 @@ func (cmd *RunUserCommandsCmd) runLifecycleHooksUnscoped( } func (cmd *RunUserCommandsCmd) shouldStopLifecycle( - i, waitForBoundary int, + i, prebuildBoundary, waitForBoundary int, boundaryName string, ) bool { - if cmd.Prebuild && i >= 2 { + if cmd.Prebuild && i > prebuildBoundary { log.Debugf( "stopping lifecycle execution (%s: after %s)", names.Flag(names.Prebuild), @@ -558,27 +564,21 @@ func execLifecycleHooks( return nil } -func resolveWaitForBoundary(result *devcconfig.Result) int { - if result == nil || result.MergedConfig == nil { - return 1 +func resolveWaitForBoundary(hooks []lifecycleHook, result *devcconfig.Result) int { + waitFor := updateContentCommand + if result != nil && result.MergedConfig != nil && result.MergedConfig.WaitFor != "" { + waitFor = result.MergedConfig.WaitFor } - hookNames := []string{ - "onCreateCommand", - updateContentCommand, - "postCreateCommand", - "postStartCommand", - "postAttachCommand", - } - waitFor := result.MergedConfig.WaitFor - if waitFor == "" { - waitFor = updateContentCommand - } - for i, name := range hookNames { - if name == waitFor { + fallback := 0 + for i, hook := range hooks { + if hook.name == updateContentCommand { + fallback = i + } + if hook.name == waitFor { return i } } - return 1 + return fallback } // runRecording is the fresh run opened for one run-user-commands invocation. diff --git a/cmd/internal/runusercommands_test.go b/cmd/internal/runusercommands_test.go index 357a280ca5..fdf7580b5b 100644 --- a/cmd/internal/runusercommands_test.go +++ b/cmd/internal/runusercommands_test.go @@ -318,6 +318,13 @@ func TestRunUserCommandsCmd_Validate(t *testing.T) { } func TestResolveWaitForBoundary(t *testing.T) { + hooks := []lifecycleHook{ + {name: hookOnCreate}, + {name: hookUpdateContent}, + {name: hookPostCreate}, + {name: hookPostStart}, + {name: hookPostAttach}, + } tests := []struct { name string waitFor string @@ -340,14 +347,26 @@ func TestResolveWaitForBoundary(t *testing.T) { }, }, } - got := resolveWaitForBoundary(result) + got := resolveWaitForBoundary(hooks, result) assert.Equal(t, tt.want, got) }) } } func TestResolveWaitForBoundary_NilResult(t *testing.T) { - assert.Equal(t, 1, resolveWaitForBoundary(nil)) + hooks := []lifecycleHook{{name: hookOnCreate}, {name: hookUpdateContent}} + assert.Equal(t, 1, resolveWaitForBoundary(hooks, nil)) + assert.Equal(t, 1, resolveWaitForBoundary(hooks, &devcconfig.Result{})) +} + +func TestResolveWaitForBoundary_UsesHookOrder(t *testing.T) { + hooks := []lifecycleHook{{name: hookUpdateContent}, {name: hookOnCreate}} + result := &devcconfig.Result{MergedConfig: &devcconfig.MergedDevContainerConfig{ + DevContainerConfigBase: devcconfig.DevContainerConfigBase{WaitFor: hookOnCreate}, + }} + assert.Equal(t, 1, resolveWaitForBoundary(hooks, result)) + result.MergedConfig.WaitFor = "unknownHook" + assert.Equal(t, 0, resolveWaitForBoundary(hooks, result)) } func TestBuildLifecycleEnvArgs_Nil(t *testing.T) { diff --git a/cmd/pro/logout.go b/cmd/pro/logout.go index 93543f3d7f..7ecc28b963 100644 --- a/cmd/pro/logout.go +++ b/cmd/pro/logout.go @@ -54,7 +54,6 @@ func NewLogoutCmd(flags *platformflags.GlobalFlags) *cobra.Command { return logoutCmd } -//nolint:cyclop,funlen // logout sequences provider/daemon teardown; complexity reflects domain workflow func (cmd *LogoutCmd) Run(ctx context.Context, args []string) error { if len(args) != 1 { return fmt.Errorf("specify a platform instance to log out of") @@ -67,16 +66,12 @@ func (cmd *LogoutCmd) Run(ctx context.Context, args []string) error { // load platform instance config platformInstanceName := args[0] - platformInstanceConfig, err := provider.LoadPlatformInstanceConfig( + platformInstanceConfig, ignored, err := cmd.loadLogoutInstance( devsyConfig.DefaultContext, platformInstanceName, ) - if err != nil { - if os.IsNotExist(err) && cmd.IgnoreNotFound { - return nil - } - - return fmt.Errorf("load platform instance %s: %w", platformInstanceName, err) + if err != nil || ignored { + return err } providerConfig, err := provider.LoadProviderConfig( @@ -89,30 +84,7 @@ func (cmd *LogoutCmd) Run(ctx context.Context, args []string) error { // stop daemon and clean up local workspaces if providerConfig.IsDaemonProvider() { - // clean up local workspaces - workspaces, err := workspace.ListLocalWorkspaces( - devsyConfig.DefaultContext, - false, - ) - if err != nil { - log.Warnf("failed to list workspaces: %v", err) - } else { - cleanupLocalWorkspaces(ctx, devsyConfig, workspaces, workspaceCleanup{ - providerName: providerConfig.Name, - owner: cmd.Owner, - }) - } - - daemonClient := daemon.NewLocalClient(platformInstanceConfig.Provider) - err = daemonClient.Shutdown(ctx) - if err != nil { - log.Warnf("failed to shut down daemon: %v", err) - } - log.Debug("waiting for daemon to shut down") - err = waitDaemonStopped(ctx, providerConfig.Name) - if err != nil { - log.Warnf("failed to wait for daemon to be stopped: %v", err) - } + cmd.cleanupLogoutDaemon(ctx, devsyConfig, platformInstanceConfig, providerConfig) } if err := deletePlatformInstanceFiles( @@ -126,6 +98,50 @@ func (cmd *LogoutCmd) Run(ctx context.Context, args []string) error { return nil } +func (cmd *LogoutCmd) loadLogoutInstance( + contextName, name string, +) (*provider.PlatformInstance, bool, error) { + instance, err := provider.LoadPlatformInstanceConfig(contextName, name) + if err != nil { + if os.IsNotExist(err) && cmd.IgnoreNotFound { + return nil, true, nil + } + return nil, false, fmt.Errorf("load platform instance %s: %w", name, err) + } + return instance, false, nil +} + +func (cmd *LogoutCmd) cleanupLogoutDaemon( + ctx context.Context, + devsyConfig *config.Config, + platformInstanceConfig *provider.PlatformInstance, + providerConfig *provider.ProviderConfig, +) { + workspaces, err := workspace.ListLocalWorkspaces( + devsyConfig.DefaultContext, + false, + ) + if err != nil { + log.Warnf("failed to list workspaces: %v", err) + } else { + cleanupLocalWorkspaces(ctx, devsyConfig, workspaces, workspaceCleanup{ + providerName: providerConfig.Name, + owner: cmd.Owner, + }) + } + + daemonClient := daemon.NewLocalClient(platformInstanceConfig.Provider) + err = daemonClient.Shutdown(ctx) + if err != nil { + log.Warnf("failed to shut down daemon: %v", err) + } + log.Debug("waiting for daemon to shut down") + err = waitDaemonStopped(ctx, providerConfig.Name) + if err != nil { + log.Warnf("failed to wait for daemon to be stopped: %v", err) + } +} + func deletePlatformInstanceFiles(contextName string, instance *provider.PlatformInstance) error { opLock, err := provider.GetProviderOperationLock(contextName, instance.Provider) if err != nil { diff --git a/cmd/pro/provider/health.go b/cmd/pro/provider/health.go index 291df3ff4c..fdb9536555 100644 --- a/cmd/pro/provider/health.go +++ b/cmd/pro/provider/health.go @@ -58,6 +58,7 @@ func (cmd *HealthCmd) Run( if err != nil { return err } + defer func() { _ = res.Body.Close() }() healthCheck := HealthCheck{ Healthy: res.StatusCode == http.StatusOK, } diff --git a/cmd/pro/provider/health_test.go b/cmd/pro/provider/health_test.go new file mode 100644 index 0000000000..2c8ca6376b --- /dev/null +++ b/cmd/pro/provider/health_test.go @@ -0,0 +1,67 @@ +package provider + +import ( + "context" + "fmt" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/devsy-org/devsy/cmd/pro/flags" + devsyhttp "github.com/devsy-org/devsy/pkg/http" +) + +type healthBody struct { + io.Reader + closed bool +} + +func (b *healthBody) Close() error { + b.closed = true + return nil +} + +type healthTransport struct { + body *healthBody +} + +func (t healthTransport) RoundTrip(_ *http.Request) (*http.Response, error) { + return &http.Response{StatusCode: http.StatusOK, Body: t.body, Header: make(http.Header)}, nil +} + +func TestHealthClosesResponseBody(t *testing.T) { + client := devsyhttp.GetHTTPClient() + originalTransport := client.Transport + t.Cleanup(func() { client.Transport = originalTransport }) + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = io.WriteString( + w, + `{"kind":"Self","apiVersion":"management.devsy.sh/v1","status":{}}`, + ) + })) + defer server.Close() + configPath := filepath.Join(t.TempDir(), "config.json") + if err := os.WriteFile( + configPath, + []byte(fmt.Sprintf(`{"host":%q,"accesskey":"test"}`, server.URL)), + 0o600, + ); err != nil { + t.Fatal(err) + } + + body := &healthBody{Reader: strings.NewReader("healthy")} + client.Transport = healthTransport{body: body} + cmd := &HealthCmd{GlobalFlags: &flags.GlobalFlags{Config: configPath}} + if err := cmd.Run(context.Background(), nil, io.Discard, io.Discard); err != nil { + t.Fatal(err) + } + if !body.closed { + t.Fatal("health response body was not closed") + } +} diff --git a/cmd/pro/start.go b/cmd/pro/start.go index c4a3aeb4c1..2e7536e90f 100644 --- a/cmd/pro/start.go +++ b/cmd/pro/start.go @@ -907,6 +907,7 @@ func (cmd *StartCmd) pingDevsyRouter(ctx context.Context, devsyPod *corev1.Pod) }, }, } + defer httpClient.CloseIdleConnections() log.Infof("Waiting until Devsy Platform is reachable at https://%s", devsyRouterDomain) err = wait.PollUntilContextTimeout( ctx, @@ -928,6 +929,7 @@ func (cmd *StartCmd) pingDevsyRouter(ctx context.Context, devsyPod *corev1.Pod) if err != nil { return false, nil } + defer func() { _ = resp.Body.Close() }() return resp.StatusCode == http.StatusOK, nil }, @@ -1025,6 +1027,7 @@ func (cmd *StartCmd) loginViaCLI(url string) error { InsecureSkipVerify: true, //nolint:gosec // existing behaviour for self-signed platform endpoints }, //nolint:gosec // self-signed platform cert } + defer tr.CloseIdleConnections() httpClient := &http.Client{Transport: tr} resp, err := httpClient.Post(fmt.Sprintf(loginPath, url), "application/json", loginRequestBuf) @@ -1430,6 +1433,7 @@ type version struct { func isHostReachable(ctx context.Context, host string) (bool, error) { transport := http.DefaultTransport.(*http.Transport).Clone() + defer transport.CloseIdleConnections() // we disable http2 as Kubernetes has problems with this transport.ForceAttemptHTTP2 = false transport.TLSClientConfig = &tls.Config{ @@ -1443,7 +1447,11 @@ func isHostReachable(ctx context.Context, host string) (bool, error) { return false, fmt.Errorf("error creating request with context: %w", err) } resp, err := client.Do(req) - if err == nil && resp.StatusCode == http.StatusOK { + if err != nil { + return false, nil + } + defer func() { _ = resp.Body.Close() }() + if resp.StatusCode == http.StatusOK { out, err := io.ReadAll(resp.Body) if err != nil { return false, nil @@ -1481,28 +1489,48 @@ type helmTarget struct { namespace string } +func helmArgs(args []string, target helmTarget, extraArgs []string) []string { + args = append( + args, + helmRepositoryConfig, + kubeContextValue, + target.kubeContext, + namespaceValue, + target.namespace, + ) + if target.chartRepo != "" { + args = append(args, "--repo", target.chartRepo) + } + return append(args, extraArgs...) +} + +func setHelmWorkdir(cmd *exec.Cmd, target helmTarget) error { + if target.chartRepo == "" { + return nil + } + workdir, err := getHelmWorkdir(target.chartName) + if err != nil { + return err + } + cmd.Dir = workdir + return nil +} + func upgradeRelease( ctx context.Context, target helmTarget, extraArgs []string, ) error { // now we install devsy - args := []string{ + args := make([]string, 0, 12+len(extraArgs)) + args = append(args, "upgrade", defaultReleaseName, target.chartName, "--install", "--create-namespace", - helmRepositoryConfig, - kubeContextValue, - target.kubeContext, - namespaceValue, - target.namespace, - } - if target.chartRepo != "" { - args = append(args, "--repo", target.chartRepo) - } - args = append(args, extraArgs...) + ) + args = helmArgs(args, target, extraArgs) fmt.Fprint(os.Stderr, "\n") log.Infof("Executing command: helm %s\n", strings.Join(args, " ")) @@ -1511,13 +1539,8 @@ func upgradeRelease( ctx, "helm", args...) // #nosec G204 -- helm args are constructed internally - if target.chartRepo != "" { - helmWorkDir, err := getHelmWorkdir(target.chartName) - if err != nil { - return err - } - - helmCmd.Dir = helmWorkDir + if err := setHelmWorkdir(helmCmd, target); err != nil { + return err } output, err := helmCmd.CombinedOutput() if err != nil { @@ -1533,32 +1556,20 @@ func getReleaseManifests( target helmTarget, extraArgs []string, ) (string, error) { - args := []string{ + args := make([]string, 0, 10+len(extraArgs)) + args = append(args, "template", defaultReleaseName, target.chartName, - helmRepositoryConfig, - kubeContextValue, - target.kubeContext, - namespaceValue, - target.namespace, - } - if target.chartRepo != "" { - args = append(args, "--repo", target.chartRepo) - } - args = append(args, extraArgs...) + ) + args = helmArgs(args, target, extraArgs) helmCmd := exec.CommandContext( ctx, "helm", args...) // #nosec G204 -- helm args are constructed internally - if target.chartRepo != "" { - helmWorkDir, err := getHelmWorkdir(target.chartName) - if err != nil { - return "", err - } - - helmCmd.Dir = helmWorkDir + if err := setHelmWorkdir(helmCmd, target); err != nil { + return "", err } output, err := helmCmd.CombinedOutput() if err != nil { diff --git a/cmd/pro/start_reachability_test.go b/cmd/pro/start_reachability_test.go new file mode 100644 index 0000000000..0e1b26f052 --- /dev/null +++ b/cmd/pro/start_reachability_test.go @@ -0,0 +1,113 @@ +package pro + +import ( + "context" + "net" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/require" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/fake" +) + +func TestHostReachabilityClosesConnection(t *testing.T) { + for _, status := range []int{http.StatusOK, http.StatusServiceUnavailable} { + t.Run(http.StatusText(status), func(t *testing.T) { + closed := make(chan struct{}) + var once sync.Once + server := httptest.NewUnstartedServer( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(status) + _, _ = w.Write([]byte(`{"version":"v1.0.0"}`)) + }), + ) + server.Config.ConnState = func(_ net.Conn, state http.ConnState) { + if state == http.StateClosed { + once.Do(func() { close(closed) }) + } + } + server.StartTLS() + defer server.Close() + + ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second) + defer cancel() + reachable, err := isHostReachable(ctx, strings.TrimPrefix(server.URL, "https://")) + require.NoError(t, err) + require.Equal(t, status == http.StatusOK, reachable) + select { + case <-closed: + case <-time.After(time.Second): + t.Fatal("reachability probe retained its connection after returning") + } + }) + } +} + +func TestRouterProbeClosesFailedResponseBeforeRetry(t *testing.T) { + closed := make(chan struct{}) + var once sync.Once + server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Length", "100") + w.WriteHeader(http.StatusServiceUnavailable) + w.(http.Flusher).Flush() + <-r.Context().Done() + once.Do(func() { close(closed) }) + })) + defer server.Close() + domain := strings.TrimPrefix(server.URL, "https://") + cmd := &StartCmd{ + KubeClient: fake.NewClientset(&corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{Name: DevsyRouterDomainSecret, Namespace: "probe"}, + Data: map[string][]byte{"domain": []byte(domain)}, + }), + } + ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second) + done := make(chan struct{}) + defer func() { + cancel() + <-done + }() + go func() { + defer close(done) + _, _ = cmd.pingDevsyRouter( + ctx, + &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "probe"}}, + ) + }() + select { + case <-closed: + case <-time.After(time.Second): + t.Fatal("router probe retained a failed response during the retry delay") + } +} + +func TestLoginClosesTransportOnInvalidResponse(t *testing.T) { + closed := make(chan struct{}) + var once sync.Once + server := httptest.NewUnstartedServer( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + _, _ = w.Write([]byte("not json")) + }), + ) + server.Config.ConnState = func(_ net.Conn, state http.ConnState) { + if state == http.StateClosed { + once.Do(func() { close(closed) }) + } + } + server.StartTLS() + defer server.Close() + + cmd := &StartCmd{} + require.Error(t, cmd.loginViaCLI(server.URL)) + select { + case <-closed: + case <-time.After(time.Second): + t.Fatal("login retained its transport connection after returning") + } +} diff --git a/cmd/provider/set.go b/cmd/provider/set.go index 18d98b992b..5c7300740c 100644 --- a/cmd/provider/set.go +++ b/cmd/provider/set.go @@ -104,8 +104,8 @@ func (cmd *SetCmd) Run(ctx context.Context, args []string) error { } if cmd.Dry { - if err := cmd.saveOrPrintConfig(devsyConfig, providerWithOptions); err != nil { - return err + if err := printOptions(devsyConfig, providerWithOptions, "json", true); err != nil { + return fmt.Errorf("print options: %w", err) } } @@ -145,19 +145,3 @@ func (cmd *SetCmd) loadProviderInContext( } return devsyConfig, providerWithOptions, nil } - -func (cmd *SetCmd) saveOrPrintConfig( - devsyConfig *config.Config, - providerWithOptions *workspace.ProviderWithOptions, -) error { - if cmd.Dry { - if err := printOptions(devsyConfig, providerWithOptions, "json", true); err != nil { - return fmt.Errorf("print options: %w", err) - } - return nil - } - if err := config.SaveConfig(devsyConfig); err != nil { - return fmt.Errorf("save config: %w", err) - } - return nil -} diff --git a/cmd/workspace/gpg_tunnel.go b/cmd/workspace/gpg_tunnel.go index 45281c413d..b82727642c 100644 --- a/cmd/workspace/gpg_tunnel.go +++ b/cmd/workspace/gpg_tunnel.go @@ -241,28 +241,25 @@ func desktopGPGDiagnosticPath(path string) (string, error) { } func gpgForwardFailureCode(err error) string { - switch { - case strings.Contains(err.Error(), "start gpg-agent reverse forward"): - return "reverse_forward_failed" - case strings.Contains(err.Error(), "detect gpg-agent socket path"): - return "host_agent_socket_unavailable" - case strings.Contains(err.Error(), "export local ownertrust from GPG"): - return "host_gpg_configuration_unavailable" - default: - return "setup_failed" - } + code, _ := classifyGPGForwardFailure(err) + return code } func gpgForwardFailureReason(err error) string { + _, reason := classifyGPGForwardFailure(err) + return reason +} + +func classifyGPGForwardFailure(err error) (string, string) { switch { case strings.Contains(err.Error(), "start gpg-agent reverse forward"): - return "GPG reverse forwarding failed" + return "reverse_forward_failed", "GPG reverse forwarding failed" case strings.Contains(err.Error(), "detect gpg-agent socket path"): - return "Host GPG agent socket unavailable" + return "host_agent_socket_unavailable", "Host GPG agent socket unavailable" case strings.Contains(err.Error(), "export local ownertrust from GPG"): - return "Unable to read host GPG configuration" + return "host_gpg_configuration_unavailable", "Unable to read host GPG configuration" default: - return "GPG agent setup failed" + return "setup_failed", "GPG agent setup failed" } } diff --git a/hack/ci/suites.yaml b/hack/ci/suites.yaml index 6ea8045668..c6e4a2cdc1 100644 --- a/hack/ci/suites.yaml +++ b/hack/ci/suites.yaml @@ -71,6 +71,13 @@ unit: require_tests: [TestTaskQueriesRejectUncertainRecords, TestGetWaitsForWriterHoldingExclusiveFileHandle] args: [-race, -count=1, -timeout=10m] + - name: windows-pty + description: native Windows pseudoconsole and PTY test helpers + os: [windows] + packages: [./pkg/pty, ./pkg/pty/ptytest] + require_tests: [TestStartWindowsSuite, TestPtytestSuite] + args: [-race, -short, -count=1, -timeout=5m] + - name: windows-detached-workspace-lifecycle description: native Windows detached workers, followers, and task results os: [windows] diff --git a/pkg/agent/binary.go b/pkg/agent/binary.go index 70e1676c67..c733f46515 100644 --- a/pkg/agent/binary.go +++ b/pkg/agent/binary.go @@ -313,44 +313,32 @@ func (s *HTTPDownloadSource) cacheAndReturn( } }() - if !s.prepareCacheDir(arch, body, pw, &streamErr) { - return - } - - s.streamAndCache(arch, body, pw, &streamErr) + streamErr = s.streamAndCache(arch, body, pw) }() return pr, nil } -func (s *HTTPDownloadSource) prepareCacheDir( +func (s *HTTPDownloadSource) streamAndCache( arch string, body io.ReadCloser, pw *io.PipeWriter, - streamErr *error, -) bool { +) error { cachePath := s.Cache.pathFor(arch) if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { // #nosec G301 // Cache directory creation failed; fall back to direct streaming if _, copyErr := io.Copy(pw, body); copyErr != nil { - *streamErr = fmt.Errorf("mkdir failed (%v), fallback copy failed: %w", err, copyErr) + return fmt.Errorf("mkdir failed (%v), fallback copy failed: %w", err, copyErr) } - return false + return nil } - return true -} -func (s *HTTPDownloadSource) streamAndCache( - arch string, - body io.ReadCloser, - pw *io.PipeWriter, - streamErr *error, -) { - cachePath := s.Cache.pathFor(arch) - file, tmpPath, err := s.createTempFile(cachePath, body, pw, streamErr) + file, err := os.CreateTemp(filepath.Dir(cachePath), config.BinaryName+"-agent-*.tmp") if err != nil { - return + _, copyErr := io.Copy(pw, body) + return copyErr } + tmpPath := file.Name() success := false closed := false @@ -363,18 +351,18 @@ func (s *HTTPDownloadSource) streamAndCache( } }() - if !s.writeToFile(file, body, pw, streamErr) { - return + if err := s.writeToFile(file, body, pw); err != nil { + return err } closeErr := file.Close() closed = true if closeErr != nil { - *streamErr = closeErr - return + return closeErr } success = s.finalizeCache(arch, tmpPath, cachePath) + return nil } func (s *HTTPDownloadSource) finalizeCache(arch, tmpPath, cachePath string) bool { @@ -387,43 +375,19 @@ func (s *HTTPDownloadSource) finalizeCache(arch, tmpPath, cachePath string) bool return true } -func (s *HTTPDownloadSource) createTempFile( - cachePath string, - body io.ReadCloser, - pw *io.PipeWriter, - streamErr *error, -) (*os.File, string, error) { - file, err := os.CreateTemp(filepath.Dir(cachePath), config.BinaryName+"-agent-*.tmp") - if err != nil { - if _, copyErr := io.Copy(pw, body); copyErr != nil { - *streamErr = copyErr - } - return nil, "", err - } - return file, file.Name(), nil -} - func (s *HTTPDownloadSource) writeToFile( file *os.File, body io.ReadCloser, pw *io.PipeWriter, - streamErr *error, -) bool { +) error { mw := io.MultiWriter(file, pw) if _, err := io.Copy(mw, body); err != nil { - *streamErr = err - return false + return err } if err := file.Chmod(0o755); err != nil { - *streamErr = err - return false - } - - if err := file.Sync(); err != nil { - *streamErr = err - return false + return err } - return true + return file.Sync() } diff --git a/pkg/agent/binary_cache_test.go b/pkg/agent/binary_cache_test.go new file mode 100644 index 0000000000..eb05336589 --- /dev/null +++ b/pkg/agent/binary_cache_test.go @@ -0,0 +1,102 @@ +package agent + +import ( + "context" + "errors" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + "testing/iotest" + + "github.com/stretchr/testify/require" +) + +func TestHTTPDownloadSourceStreamsAndCaches(t *testing.T) { + const payload = "agent binary contents" + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, payload) + })) + defer server.Close() + + cache := &BinaryCache{BaseDir: t.TempDir()} + source := &HTTPDownloadSource{BaseURL: server.URL, Cache: cache, Version: "v1"} + binary, err := source.GetBinary(context.Background(), "amd64") + require.NoError(t, err) + defer func() { require.NoError(t, binary.Close()) }() + + data, err := io.ReadAll(binary) + require.NoError(t, err) + require.Equal(t, payload, string(data)) + + cached, err := cache.Get("amd64") + require.NoError(t, err) + defer func() { require.NoError(t, cached.Close()) }() + cachedData, err := io.ReadAll(cached) + require.NoError(t, err) + require.Equal(t, payload, string(cachedData)) + require.Equal(t, "v1", cache.ReadVersion("amd64")) +} + +func TestHTTPDownloadSourceStreamsWithoutCacheDirectory(t *testing.T) { + const payload = "agent binary contents" + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, payload) + })) + defer server.Close() + + blockingPath := filepath.Join(t.TempDir(), "file") + require.NoError(t, os.WriteFile(blockingPath, nil, 0o600)) + source := &HTTPDownloadSource{ + BaseURL: server.URL, + Cache: &BinaryCache{BaseDir: filepath.Join(blockingPath, "cache")}, + } + binary, err := source.GetBinary(context.Background(), "amd64") + require.NoError(t, err) + defer func() { require.NoError(t, binary.Close()) }() + + data, err := io.ReadAll(binary) + require.NoError(t, err) + require.Equal(t, payload, string(data)) +} + +func TestHTTPDownloadSourceRemovesPartialCacheOnStreamFailure(t *testing.T) { + streamErr := errors.New("stream failed") + cache := &BinaryCache{BaseDir: t.TempDir()} + source := &HTTPDownloadSource{Cache: cache, Version: "v1"} + body := io.NopCloser(io.MultiReader(strings.NewReader("partial"), iotest.ErrReader(streamErr))) + + binary, err := source.cacheAndReturn("amd64", body) + require.NoError(t, err) + defer func() { require.NoError(t, binary.Close()) }() + data, err := io.ReadAll(binary) + require.ErrorIs(t, err, streamErr) + require.Equal(t, "partial", string(data)) + + _, err = cache.Get("amd64") + require.ErrorIs(t, err, os.ErrNotExist) + require.Empty(t, cache.ReadVersion("amd64")) + entries, err := os.ReadDir(cache.BaseDir) + require.NoError(t, err) + require.Empty(t, entries) +} + +func TestHTTPDownloadSourceFallbackPreservesStreamError(t *testing.T) { + blockingPath := filepath.Join(t.TempDir(), "file") + require.NoError(t, os.WriteFile(blockingPath, nil, 0o600)) + source := &HTTPDownloadSource{ + Cache: &BinaryCache{BaseDir: filepath.Join(blockingPath, "cache")}, + } + streamErr := errors.New("source disconnected") + body := io.NopCloser(io.MultiReader(strings.NewReader("partial"), iotest.ErrReader(streamErr))) + + binary, err := source.cacheAndReturn("amd64", body) + require.NoError(t, err) + defer func() { require.NoError(t, binary.Close()) }() + data, err := io.ReadAll(binary) + require.ErrorIs(t, err, streamErr) + require.Equal(t, "partial", string(data)) +} diff --git a/pkg/agent/delivery/exec_stream_cancellation_unix_test.go b/pkg/agent/delivery/exec_stream_cancellation_unix_test.go index 0a419a0cc3..cf6836fe09 100644 --- a/pkg/agent/delivery/exec_stream_cancellation_unix_test.go +++ b/pkg/agent/delivery/exec_stream_cancellation_unix_test.go @@ -171,13 +171,33 @@ func startCancellationDelivery( outer, "/tmp/owned-delivery-never-written", PostStartOptions{ - Arch: "amd64", SkipVersionCheck: true, BinarySource: sources.acquire, + Arch: "amd64", SkipVersionCheck: true, + BinarySource: func(ctx context.Context, arch string) (io.ReadCloser, error) { + return acquireCancellationSource(ctx, arch, delivery, sources) + }, }, ) }() return outer, call } +func acquireCancellationSource( + ctx context.Context, + arch string, + delivery *KubernetesDelivery, + sources *cancellationBinarySource, +) (io.ReadCloser, error) { + binary, err := sources.acquire(ctx, arch) + if err != nil { + return nil, err + } + delivery.execStreamIdleTimeout = 0 + if binary.(*cancellationBinary).closer != nil { + delivery.execStreamIdleTimeout = 300 * time.Millisecond + } + return binary, nil +} + func awaitDeliveryRead(t *testing.T, sources *cancellationBinarySource) { t.Helper() select { @@ -238,9 +258,10 @@ func TestExecStreamAttemptCancellationOwnsSource(t *testing.T) { } canceled := make(chan error, execStreamMaxAttempts) delivery := &KubernetesDelivery{ - execStreamIdleTimeout: 300 * time.Millisecond, - execStreamCompletionTimeout: 300 * time.Millisecond, - Exec: cancellationDeliveryExecutor(t, runtime, canceled), + Exec: cancellationDeliveryExecutor(t, runtime, canceled), + } + if testCase.blockCompletion { + delivery.execStreamCompletionTimeout = 300 * time.Millisecond } outer, call := startCancellationDelivery(t, delivery, sources) awaitDeliveryRead(t, sources) diff --git a/pkg/agent/delivery/kubernetes.go b/pkg/agent/delivery/kubernetes.go index 4ee83e4022..24dc0618fe 100644 --- a/pkg/agent/delivery/kubernetes.go +++ b/pkg/agent/delivery/kubernetes.go @@ -509,7 +509,8 @@ type execStreamProgressMonitor struct { func (m *execStreamProgressMonitor) run() { defer close(m.done) - ticker := time.NewTicker(max(m.idleTimeout/2, time.Nanosecond)) + interval := min(m.idleTimeout, m.completionTimeout) / 2 + ticker := time.NewTicker(max(interval, time.Nanosecond)) defer ticker.Stop() for { select { diff --git a/pkg/compose/helper.go b/pkg/compose/helper.go index 496e7ac9e3..8666f2f5ab 100644 --- a/pkg/compose/helper.go +++ b/pkg/compose/helper.go @@ -29,6 +29,12 @@ const ( projectNameFlag = "--project-name" ) +var ( + legacyProjectNamePattern = regexp.MustCompile("[^a-z0-9]") + projectNamePattern = regexp.MustCompile("[^-_a-z0-9]") + composeVersionPattern = regexp.MustCompile(`(\d+\.\d+\.\d+)`) +) + func LoadDockerComposeProject( ctx context.Context, paths []string, @@ -299,19 +305,8 @@ func (h *ComposeHelper) Stop(ctx context.Context, projectName string, args []str buildArgs = append(buildArgs, args...) buildArgs = append(buildArgs, "stop") - out, stderr, err := runCmdCapture(h.buildCmd(ctx, buildArgs...)) - if len(stderr) > 0 { - log.Warnf( - "%s: %s", - strings.TrimSpace(string(stderr)), - strings.TrimSpace(string(out)), - ) - } - if err != nil { - return fmt.Errorf("%s: %w", strings.TrimSpace(string(stderr)), err) - } - - return nil + _, err := runComposeCmd(h.buildCmd(ctx, buildArgs...)) + return err } func (h *ComposeHelper) Remove( @@ -327,19 +322,8 @@ func (h *ComposeHelper) Remove( buildArgs = append(buildArgs, "--volumes") } - out, stderr, err := runCmdCapture(h.buildCmd(ctx, buildArgs...)) - if len(stderr) > 0 { - log.Warnf( - "%s: %s", - strings.TrimSpace(string(stderr)), - strings.TrimSpace(string(out)), - ) - } - if err != nil { - return fmt.Errorf("%s: %w", strings.TrimSpace(string(stderr)), err) - } - - return nil + _, err := runComposeCmd(h.buildCmd(ctx, buildArgs...)) + return err } func (h *ComposeHelper) GetDefaultImage(projectName, serviceName string) (string, error) { @@ -367,16 +351,9 @@ func (h *ComposeHelper) FindProjectFiles( buildArgs := []string{projectNameFlag, projectName} buildArgs = append(buildArgs, "ls", "-a", "--filter", "name="+projectName, "--format", "json") - rawOut, stderr, err := runCmdCapture(h.buildCmd(ctx, buildArgs...)) - if len(stderr) > 0 { - log.Warnf( - "%s: %s", - strings.TrimSpace(string(stderr)), - strings.TrimSpace(string(rawOut)), - ) - } + rawOut, err := runComposeCmd(h.buildCmd(ctx, buildArgs...)) if err != nil { - return nil, fmt.Errorf("%s: %w", strings.TrimSpace(string(stderr)), err) + return nil, err } type composeOutput struct { @@ -417,10 +394,21 @@ func (h *ComposeHelper) SanitizeProjectName(name string) string { func (h *ComposeHelper) toProjectName(projectName string) string { useNewProjectNameFormat, _ := h.useNewProjectName() if !useNewProjectNameFormat { - return regexp.MustCompile("[^a-z0-9]").ReplaceAllString(strings.ToLower(projectName), "") + return legacyProjectNamePattern.ReplaceAllString(strings.ToLower(projectName), "") } - return regexp.MustCompile("[^-_a-z0-9]").ReplaceAllString(strings.ToLower(projectName), "") + return projectNamePattern.ReplaceAllString(strings.ToLower(projectName), "") +} + +func runComposeCmd(cmd *exec.Cmd) ([]byte, error) { + out, stderr, err := runCmdCapture(cmd) + if len(stderr) > 0 { + log.Warnf("%s: %s", strings.TrimSpace(string(stderr)), strings.TrimSpace(string(out))) + } + if err != nil { + return out, fmt.Errorf("%s: %w", strings.TrimSpace(string(stderr)), err) + } + return out, nil } func (h *ComposeHelper) buildCmd(ctx context.Context, args ...string) *exec.Cmd { @@ -454,8 +442,7 @@ func runCmdCapture(cmd *exec.Cmd) ([]byte, []byte, error) { // and desktop versions (2.40.3-desktop.1) by extracting only major.minor.patch. func parseVersion(version string) (semver.Version, error) { version = strings.TrimPrefix(version, "v") - re := regexp.MustCompile(`(\d+\.\d+\.\d+)`) - matches := re.FindStringSubmatch(strings.TrimSpace(version)) + matches := composeVersionPattern.FindStringSubmatch(strings.TrimSpace(version)) if len(matches) < 2 { return semver.Version{}, fmt.Errorf("invalid version format: %s", version) } diff --git a/pkg/credentials/github_test.go b/pkg/credentials/github_test.go index 06178012f7..c1467e28f0 100644 --- a/pkg/credentials/github_test.go +++ b/pkg/credentials/github_test.go @@ -34,7 +34,7 @@ func (c *githubCredentialsClient) Ping( func TestReadinessRejectsDeadTransportWithoutCredentialLookup(t *testing.T) { client := &githubCredentialsClient{code: codes.Unavailable} - h := newPreparedHandler(context.Background(), client, "vscode", readyFixture()) + h := newPreparedHandler(client, "vscode", readyFixture()) w := httptest.NewRecorder() h.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "http://localhost/ready", nil)) require.Equal(t, http.StatusServiceUnavailable, w.Code) @@ -44,7 +44,7 @@ func TestReadinessRejectsDeadTransportWithoutCredentialLookup(t *testing.T) { func TestCredentialPostPinsVerifiedHostAndInstanceBeforeRPC(t *testing.T) { client := &githubCredentialsClient{} identity := readyFixture() - h := newPreparedHandler(context.Background(), client, identity.Owner, identity) + h := newPreparedHandler(client, identity.Owner, identity) for _, pair := range [][2]string{{"", ""}, {"old-instance", identity.HostOwner}, {identity.Instance, "other-host"}} { r := httptest.NewRequest(http.MethodPost, "http://localhost/github-credentials", nil) r.Header.Set(HeaderCredentialsInstance, pair[0]) @@ -91,7 +91,7 @@ func TestGitHubHTTPBoundaryMethodsStatusesAndHeaders(t *testing.T) { } { t.Run(tc.want, func(t *testing.T) { client := &githubCredentialsClient{code: tc.code} - h := newCredentialsHandler(context.Background(), client, "guest") + h := newCredentialsHandler(client, "guest") get := httptest.NewRecorder() h.ServeHTTP( get, @@ -116,7 +116,7 @@ func TestGitHubHTTPBoundaryMethodsStatusesAndHeaders(t *testing.T) { } func TestGitHubHTTPMissingOptionalMethod(t *testing.T) { - h := newCredentialsHandler(context.Background(), &mockCredentialsClient{}, "guest") + h := newCredentialsHandler(&mockCredentialsClient{}, "guest") w := httptest.NewRecorder() h.ServeHTTP(w, httptest.NewRequest(http.MethodPost, "http://localhost/github-credentials", nil)) require.JSONEq(t, `{"status":"rpc_unavailable"}`, w.Body.String()) diff --git a/pkg/credentials/host_test.go b/pkg/credentials/host_test.go index dd3ab4609d..5e35d53ed1 100644 --- a/pkg/credentials/host_test.go +++ b/pkg/credentials/host_test.go @@ -34,7 +34,7 @@ func TestCredentialsRejectNonLoopbackHostBeforeDispatch(t *testing.T) { t.Run(host, func(t *testing.T) { client := &hostGuardClient{} identity := readyFixture() - handler := newPreparedHandler(t.Context(), client, identity.Owner, identity) + handler := newPreparedHandler(client, identity.Owner, identity) for _, path := range []string{"/ready", ownerPath, "/github-credentials", "/git-credentials"} { request := httptest.NewRequest(http.MethodPost, "http://localhost"+path, nil) if path == "/ready" || path == ownerPath { @@ -60,7 +60,7 @@ func TestCredentialsAcceptLoopbackHosts(t *testing.T) { } { t.Run(host, func(t *testing.T) { client := &hostGuardClient{} - handler := newPreparedHandler(t.Context(), client, "guest", readyFixture()) + handler := newPreparedHandler(client, "guest", readyFixture()) request := httptest.NewRequest(http.MethodGet, "http://localhost/ready", nil) request.Host = host response := httptest.NewRecorder() diff --git a/pkg/credentials/readiness_test.go b/pkg/credentials/readiness_test.go index 2822072fbd..90a7f316d6 100644 --- a/pkg/credentials/readiness_test.go +++ b/pkg/credentials/readiness_test.go @@ -48,7 +48,7 @@ func TestReadinessLoopbackFamiliesPinIdentityWithoutProxy(t *testing.T) { t, family.network, family.address, - newPreparedHandler(context.Background(), nil, "vscode", readyFixture()), + newPreparedHandler(nil, "vscode", readyFixture()), ) port := s.Listener.Addr().(*net.TCPAddr).Port got, err := ProbeReadiness(context.Background(), port, readyFixture()) @@ -90,7 +90,7 @@ func TestReadinessRejectsOldOccupiedMismatchedAndUnboundedListeners(t *testing.T t, "tcp4", "127.0.0.1:0", - newPreparedHandler(context.Background(), nil, "vscode", other), + newPreparedHandler(nil, "vscode", other), ) _, err := ProbeReadiness( context.Background(), diff --git a/pkg/credentials/server.go b/pkg/credentials/server.go index da70f61eff..9f8b4f9046 100644 --- a/pkg/credentials/server.go +++ b/pkg/credentials/server.go @@ -87,7 +87,8 @@ func runCredentialsServer( status Readiness, ) error { srv := &http.Server{ - Handler: newPreparedHandler(ctx, client, status.Owner, status), + Handler: newPreparedHandler(client, status.Owner, status), + BaseContext: func(net.Listener) context.Context { return ctx }, ReadHeaderTimeout: 10 * time.Second, ReadTimeout: 30 * time.Second, IdleTimeout: 120 * time.Second, @@ -126,15 +127,13 @@ const ownerPath = "/owner" // Root is a readiness probe (see waitForServer); it must return 200 so the // server is detected as up. Unknown paths still 404 below. func newCredentialsHandler( - ctx context.Context, client CredentialsClient, owner string, ) http.Handler { - return newPreparedHandler(ctx, client, owner, Readiness{}) + return newPreparedHandler(client, owner, Readiness{}) } func newPreparedHandler( - ctx context.Context, client CredentialsClient, owner string, status Readiness, @@ -186,7 +185,7 @@ func newPreparedHandler( http.NotFound(writer, request) return } - if err := handler(ctx, writer, request, client); err != nil { + if err := handler(request.Context(), writer, request, client); err != nil { http.Error(writer, err.Error(), http.StatusInternalServerError) } }) diff --git a/pkg/credentials/server_test.go b/pkg/credentials/server_test.go index e45ac6ecab..e0250d05d0 100644 --- a/pkg/credentials/server_test.go +++ b/pkg/credentials/server_test.go @@ -10,6 +10,7 @@ import ( "net/http/httptest" "strings" "testing" + "time" "github.com/devsy-org/devsy/pkg/agent/tunnel" "github.com/stretchr/testify/assert" @@ -105,7 +106,7 @@ func TestHandleGitSSHSignature_GRPCSuccess_ReturnsJSON200(t *testing.T) { func TestOwnerEndpoint_ReturnsConfiguredOwner(t *testing.T) { mock := &mockCredentialsClient{} - handler := newCredentialsHandler(context.Background(), mock, "alice") + handler := newCredentialsHandler(mock, "alice") req := httptest.NewRequest(http.MethodGet, "http://localhost"+ownerPath, nil) w := httptest.NewRecorder() @@ -184,3 +185,79 @@ func TestFetchOwner_CapsResponseSize(t *testing.T) { require.NoError(t, err) assert.LessOrEqual(t, len(owner), maxOwnerResponseSize) } + +func TestCredentialsServerCancelsBackendContext(t *testing.T) { + type contextKey struct{} + for _, trigger := range []string{"disconnect", "server shutdown"} { + t.Run(trigger, func(t *testing.T) { + started := make(chan context.Context, 1) + release := make(chan struct{}) + finished := make(chan struct{}) + client := &mockCredentialsClient{ + gitSSHSignatureFunc: func(ctx context.Context, _ *tunnel.Message) (*tunnel.Message, error) { + started <- ctx + defer close(finished) + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-release: + return nil, fmt.Errorf("test cleanup") + } + }, + } + ln, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + ctx, cancel := context.WithCancel( + context.WithValue(context.Background(), contextKey{}, "value"), + ) + done := make(chan error, 1) + go func() { done <- RunCredentialsServerWithListener(ctx, ln, client, "owner") }() + t.Cleanup(func() { + close(release) + cancel() + select { + case <-done: + case <-time.After(2 * time.Second): + t.Error("server did not stop") + } + }) + conn, err := net.Dial("tcp", ln.Addr().String()) + require.NoError(t, err) + t.Cleanup(func() { _ = conn.Close() }) + _, err = fmt.Fprint( + conn, + "POST /git-ssh-signature HTTP/1.1\r\nHost: localhost\r\nContent-Length: 0\r\n\r\n", + ) + require.NoError(t, err) + backendCtx := awaitCredentialBackend(t, started) + require.Equal(t, "value", backendCtx.Value(contextKey{})) + if trigger == "disconnect" { + require.NoError(t, conn.Close()) + } else { + cancel() + } + awaitCredentialBackendCanceled(t, finished, backendCtx) + }) + } +} + +func awaitCredentialBackend(t *testing.T, started <-chan context.Context) context.Context { + t.Helper() + select { + case ctx := <-started: + return ctx + case <-time.After(2 * time.Second): + t.Fatal("backend was not called") + return nil + } +} + +func awaitCredentialBackendCanceled(t *testing.T, finished <-chan struct{}, ctx context.Context) { + t.Helper() + select { + case <-finished: + require.ErrorIs(t, ctx.Err(), context.Canceled) + case <-time.After(2 * time.Second): + t.Fatal("backend context was not canceled") + } +} diff --git a/pkg/daemon/platform/local_server.go b/pkg/daemon/platform/local_server.go index 72f98010d5..5942524599 100644 --- a/pkg/daemon/platform/local_server.go +++ b/pkg/daemon/platform/local_server.go @@ -336,26 +336,37 @@ func (l *localServer) updateUserProfile( return writeJSON(w, updatedProfile) } -func (l *localServer) projects(w http.ResponseWriter, r *http.Request) error { +func (l *localServer) accessibleProjects( + ctx context.Context, +) (kube.Interface, []managementv1.Project, error) { managementClient, err := l.pc.Management() if err != nil { - return err + return nil, nil, err } projectList, err := managementClient.Devsy(). ManagementV1(). Projects(). - List(r.Context(), metav1.ListOptions{}) + List(ctx, metav1.ListOptions{}) if err != nil { - return fmt.Errorf("list projects: %w", err) + return nil, nil, fmt.Errorf("list projects: %w", err) } else if len(projectList.Items) == 0 { err := fmt.Errorf( "you don't have access to any projects, make sure you have at least access to 1 project", ) - return forbidden(err) + return nil, nil, forbidden(err) + } + + return managementClient, projectList.Items, nil +} + +func (l *localServer) projects(w http.ResponseWriter, r *http.Request) error { + _, projects, err := l.accessibleProjects(r.Context()) + if err != nil { + return err } - return writeJSON(w, projectList.Items) + return writeJSON(w, projects) } func (l *localServer) projectTemplates( @@ -460,26 +471,13 @@ func (l *localServer) listWorkspace( ownerFilter.filter = platform.OwnerFilter(ownerParam) } - managementClient, err := l.pc.Management() + managementClient, projects, err := l.accessibleProjects(r.Context()) if err != nil { return err } - projectList, err := managementClient.Devsy(). - ManagementV1(). - Projects(). - List(r.Context(), metav1.ListOptions{}) - if err != nil { - return fmt.Errorf("list projects: %w", err) - } else if len(projectList.Items) == 0 { - err := fmt.Errorf( - "you don't have access to any projects, make sure you have at least access to 1 project", - ) - return forbidden(err) - } - instances := []managementv1.DevsyWorkspaceInstance{} - for _, p := range projectList.Items { + for _, p := range projects { projectInstances, err := collectProjectWorkspaces( r.Context(), managementClient, p, ownerFilter, ) diff --git a/pkg/devcontainer/feature/extend.go b/pkg/devcontainer/feature/extend.go index e887359b56..76f5472c98 100644 --- a/pkg/devcontainer/feature/extend.go +++ b/pkg/devcontainer/feature/extend.go @@ -673,7 +673,7 @@ func (r *featureDependencyResolver) findByConfigID(configID string) (string, *co return "", nil } -func (r *featureDependencyResolver) resolveFeatureDependency( //nolint:cyclop +func (r *featureDependencyResolver) resolveFeatureDependency( featureID string, featureSet *config.FeatureSet, ) error { @@ -689,27 +689,12 @@ func (r *featureDependencyResolver) resolveFeatureDependency( //nolint:cyclop defer func() { r.visiting[featureID] = false }() for depID, depOptions := range featureSet.Config.DependsOn { - normalizedDepID := normalizeFeatureID(depID) - resolvedKey, depFeatureSet := r.findByConfigID(normalizedDepID) - if depFeatureSet == nil { - if currentID, legacyMatch := r.legacyMap[normalizedDepID]; legacyMatch { - log.Debugf("resolved legacy ID %s to current feature %s", depID, currentID) - resolvedKey, depFeatureSet = r.findByConfigID(currentID) - } - } - if depFeatureSet == nil { - log.Debugf("installing dependency feature %s", depID) - var err error - depFeatureSet, err = r.processor.processFeature(r.processor.ctx, depID, depOptions) - if err != nil { - return fmt.Errorf("failed to resolve dependency %s: %w", depID, err) - } - resolvedKey = featureDeduplicationKey(depFeatureSet.ConfigID, depFeatureSet.Version) - r.features[resolvedKey] = depFeatureSet - r.rebuildLegacyMap() + resolvedKey, depFeatureSet, err := r.findOrInstallDependency(depID, depOptions) + if err != nil { + return err } - err := r.resolveFeatureDependency(resolvedKey, depFeatureSet) + err = r.resolveFeatureDependency(resolvedKey, depFeatureSet) if err != nil { return err } @@ -719,6 +704,32 @@ func (r *featureDependencyResolver) resolveFeatureDependency( //nolint:cyclop return nil } +func (r *featureDependencyResolver) findOrInstallDependency( + depID string, + depOptions any, +) (string, *config.FeatureSet, error) { + normalizedDepID := normalizeFeatureID(depID) + resolvedKey, depFeatureSet := r.findByConfigID(normalizedDepID) + if depFeatureSet == nil { + if currentID, legacyMatch := r.legacyMap[normalizedDepID]; legacyMatch { + log.Debugf("resolved legacy ID %s to current feature %s", depID, currentID) + resolvedKey, depFeatureSet = r.findByConfigID(currentID) + } + } + if depFeatureSet == nil { + log.Debugf("installing dependency feature %s", depID) + var err error + depFeatureSet, err = r.processor.processFeature(r.processor.ctx, depID, depOptions) + if err != nil { + return "", nil, fmt.Errorf("failed to resolve dependency %s: %w", depID, err) + } + resolvedKey = featureDeduplicationKey(depFeatureSet.ConfigID, depFeatureSet.Version) + r.features[resolvedKey] = depFeatureSet + r.rebuildLegacyMap() + } + return resolvedKey, depFeatureSet, nil +} + func (r *featureDependencyResolver) rebuildLegacyMap() { r.legacyMap = buildLegacyIDMap(r.features) } diff --git a/pkg/devcontainer/graph/graph.go b/pkg/devcontainer/graph/graph.go index 2fac49fe88..dd0832b707 100644 --- a/pkg/devcontainer/graph/graph.go +++ b/pkg/devcontainer/graph/graph.go @@ -186,25 +186,7 @@ func (g *Graph[T]) RemoveChildren(id string) error { } func (g *Graph[T]) IsReachable(from, to string) bool { - if from == to { - return true - } - visited := make(map[string]bool) - queue := []string{from} - for len(queue) > 0 { - current := queue[0] - queue = queue[1:] - for _, neighbor := range g.edges[current] { - if neighbor == to { - return true - } - if !visited[neighbor] { - visited[neighbor] = true - queue = append(queue, neighbor) - } - } - } - return false + return g.isReachable(from, to, false) } func (g *Graph[T]) MarkEdgeHard(from, to string) { @@ -215,6 +197,10 @@ func (g *Graph[T]) MarkEdgeHard(from, to string) { } func (g *Graph[T]) IsReachableViaHardEdges(from, to string) bool { + return g.isReachable(from, to, true) +} + +func (g *Graph[T]) isReachable(from, to string, hardOnly bool) bool { if from == to { return true } @@ -224,7 +210,7 @@ func (g *Graph[T]) IsReachableViaHardEdges(from, to string) bool { current := queue[0] queue = queue[1:] for _, neighbor := range g.edges[current] { - if !g.hardEdges[current][neighbor] { + if hardOnly && !g.hardEdges[current][neighbor] { continue } if neighbor == to { diff --git a/pkg/devcontainer/graph/graph_test.go b/pkg/devcontainer/graph/graph_test.go index d87ce3e053..eb2225da28 100644 --- a/pkg/devcontainer/graph/graph_test.go +++ b/pkg/devcontainer/graph/graph_test.go @@ -473,6 +473,29 @@ func (suite *GraphTestSuite) TestIsReachable() { suite.True(suite.graph.IsReachable("A", "A")) } +func (suite *GraphTestSuite) TestReachabilityWithHardEdgesAndCycles() { + for _, id := range []string{"A", "B", "C", "D", "E"} { + suite.Require().NoError(suite.graph.AddNode(id, id)) + } + for _, edge := range [][2]string{{"A", "B"}, {"B", "C"}, {"C", "A"}, {"C", "D"}} { + suite.Require().NoError(suite.graph.AddEdge(edge[0], edge[1])) + } + for _, edge := range [][2]string{{"A", "B"}, {"B", "C"}, {"C", "A"}} { + suite.graph.MarkEdgeHard(edge[0], edge[1]) + } + + suite.True(suite.graph.IsReachableViaHardEdges("A", "C")) + suite.True(suite.graph.IsReachableViaHardEdges("C", "B")) + suite.True(suite.graph.IsReachable("A", "D")) + suite.False(suite.graph.IsReachableViaHardEdges("A", "D")) + suite.False(suite.graph.IsReachable("A", "E")) + suite.False(suite.graph.IsReachableViaHardEdges("A", "E")) + suite.True(suite.graph.IsReachable("missing", "missing")) + suite.True(suite.graph.IsReachableViaHardEdges("missing", "missing")) + suite.False(suite.graph.IsReachable("missing", "A")) + suite.False(suite.graph.IsReachableViaHardEdges("A", "missing")) +} + func (suite *GraphTestSuite) TestLargeGraph() { nodeCount := 100 diff --git a/pkg/devcontainer/metadata/metadata.go b/pkg/devcontainer/metadata/metadata.go index f395edc832..3f373a72d8 100644 --- a/pkg/devcontainer/metadata/metadata.go +++ b/pkg/devcontainer/metadata/metadata.go @@ -159,28 +159,10 @@ func GetImageMetadataFromContainer( return &config.ImageMetadataConfig{}, nil } - imageMetadataConfig := &config.ImageMetadataConfig{} - multiple := []*config.ImageMetadata{} - err := json.Unmarshal([]byte(containerDetails.Config.Labels[ImageMetadataLabel]), &multiple) - if err != nil { - single := &config.ImageMetadata{} - err = json.Unmarshal([]byte(containerDetails.Config.Labels[ImageMetadataLabel]), single) - if err != nil { - log.Warnf("Error parsing image metadata: %v", err) - return &config.ImageMetadataConfig{}, nil - } - - imageMetadataConfig.Raw = []*config.ImageMetadata{single} - } else { - imageMetadataConfig.Raw = multiple - } - - err = substituteConfig(imageMetadataConfig, substituteContext) - if err != nil { - return nil, err - } - - return imageMetadataConfig, nil + return decodeImageMetadata( + containerDetails.Config.Labels[ImageMetadataLabel], + substituteContext, + ) } func GetImageMetadata( @@ -195,12 +177,19 @@ func GetImageMetadata( return &config.ImageMetadataConfig{}, nil } + return decodeImageMetadata(imageDetails.Config.Labels[ImageMetadataLabel], substituteContext) +} + +func decodeImageMetadata( + label string, + substituteContext *config.SubstitutionContext, +) (*config.ImageMetadataConfig, error) { imageMetadataConfig := &config.ImageMetadataConfig{} multiple := []*config.ImageMetadata{} - err := json.Unmarshal([]byte(imageDetails.Config.Labels[ImageMetadataLabel]), &multiple) + err := json.Unmarshal([]byte(label), &multiple) if err != nil { single := &config.ImageMetadata{} - err = json.Unmarshal([]byte(imageDetails.Config.Labels[ImageMetadataLabel]), single) + err = json.Unmarshal([]byte(label), single) if err != nil { log.Warnf("Error parsing image metadata: %v", err) return &config.ImageMetadataConfig{}, nil diff --git a/pkg/docker/helper.go b/pkg/docker/helper.go index 6747968de4..a2df3403a4 100644 --- a/pkg/docker/helper.go +++ b/pkg/docker/helper.go @@ -36,6 +36,7 @@ var ( containerRunningPollInterval = 500 * time.Millisecond containerRunningTimeout = 30 * time.Second containerExitGrace = 2 * time.Second + inspectDiagnosticGrace = 250 * time.Millisecond // podmanMachineStartTimeout is the maximum time to wait for a Podman machine to start. podmanMachineStartTimeout = 90 * time.Second @@ -537,7 +538,7 @@ func (r *DockerHelper) WaitContainerRunning(ctx context.Context, containerID str // daemon error can still be captured for the final diagnostic. diagnosticCtx, diagnosticCancel := context.WithTimeout( context.WithoutCancel(ctx), - 250*time.Millisecond, + inspectDiagnosticGrace, ) details, err = r.InspectContainers(diagnosticCtx, []string{containerID}) diagnosticCancel() @@ -575,7 +576,7 @@ func inspectionDiagnosticContext(ctx context.Context) (context.Context, context. if !ok || time.Until(deadline) > 100*time.Millisecond { return ctx, func() {} } - return context.WithTimeout(context.WithoutCancel(ctx), 250*time.Millisecond) + return context.WithTimeout(context.WithoutCancel(ctx), inspectDiagnosticGrace) } func (r *DockerHelper) GetImageTag(ctx context.Context, imageID string) (string, error) { diff --git a/pkg/docker/helper_test.go b/pkg/docker/helper_test.go index da12161b97..07e393d96f 100644 --- a/pkg/docker/helper_test.go +++ b/pkg/docker/helper_test.go @@ -552,6 +552,9 @@ func TestWaitContainerRunning_PreservesDeadlineExceededWithInspectError(t *testi original := containerRunningTimeout containerRunningTimeout = 50 * time.Millisecond t.Cleanup(func() { containerRunningTimeout = original }) + originalGrace := inspectDiagnosticGrace + inspectDiagnosticGrace = 10 * time.Second + t.Cleanup(func() { inspectDiagnosticGrace = originalGrace }) bin := writeScript(t, t.TempDir(), "docker-fake", `#!/bin/sh case "$1" in diff --git a/pkg/dockercredentials/dockercredentials.go b/pkg/dockercredentials/dockercredentials.go index 4a52ac84ac..882a174706 100644 --- a/pkg/dockercredentials/dockercredentials.go +++ b/pkg/dockercredentials/dockercredentials.go @@ -172,39 +172,14 @@ func buildHelperContent(binaryPath, shebang string, port int) []byte { } func ConfigureCredentialsDockerless(targetFolder string, port int) (string, error) { - dockerConfigDir := newDockerCredentialsDir(targetFolder) - - if err := preserveDockerConfig(dockerConfigDir); err != nil { - _ = os.RemoveAll(dockerConfigDir) - return "", err - } - - err := configureCredentials("", port, credentialLayout{ - shebang: "#!/.dockerless/bin/sh", - targetDir: dockerConfigDir, - configDir: dockerConfigDir, - }) - if err != nil { - _ = os.RemoveAll(dockerConfigDir) - return "", err - } - - err = os.Setenv("DOCKER_CONFIG", dockerConfigDir) - if err != nil { - _ = os.RemoveAll(dockerConfigDir) - return "", err - } - - err = appendToPath(dockerConfigDir) - if err != nil { - _ = os.RemoveAll(dockerConfigDir) - return "", err - } - - return dockerConfigDir, nil + return configureCredentialsInDir(targetFolder, port, "#!/.dockerless/bin/sh") } func ConfigureCredentialsMachine(targetFolder string, port int) (string, error) { + return configureCredentialsInDir(targetFolder, port, "#!/bin/sh") +} + +func configureCredentialsInDir(targetFolder string, port int, shebang string) (string, error) { dockerConfigDir := newDockerCredentialsDir(targetFolder) if err := preserveDockerConfig(dockerConfigDir); err != nil { @@ -213,7 +188,7 @@ func ConfigureCredentialsMachine(targetFolder string, port int) (string, error) } err := configureCredentials("", port, credentialLayout{ - shebang: "#!/bin/sh", + shebang: shebang, targetDir: dockerConfigDir, configDir: dockerConfigDir, }) diff --git a/pkg/dockercredentials/helper.go b/pkg/dockercredentials/helper.go index ed02fb32cc..2ea2bf0bca 100644 --- a/pkg/dockercredentials/helper.go +++ b/pkg/dockercredentials/helper.go @@ -99,29 +99,8 @@ func (h *Helper) List() (map[string]string, error) { } func (h *Helper) getFromCredentialsServer(serverURL string) (string, string, error) { - requestBody, err := json.Marshal(&Request{ServerURL: serverURL}) - if err != nil { - return "", "", err - } - - client := &http.Client{Timeout: credentialsTimeout} endpoint := fmt.Sprintf("http://localhost:%d/docker-credentials", h.port) - resp, err := client.Post(endpoint, "application/json", bytes.NewReader(requestBody)) - if err != nil { - return "", "", err - } - defer func() { _ = resp.Body.Close() }() - - if resp.StatusCode != http.StatusOK { - return "", "", fmt.Errorf("status %d", resp.StatusCode) - } - - var creds Credentials - if err := json.NewDecoder(resp.Body).Decode(&creds); err != nil { - return "", "", err - } - - return creds.Username, creds.Secret, nil + return getFromEndpoint(endpoint, serverURL) } func (h *Helper) getFromWorkspaceServer(serverURL string) (string, string, error) { @@ -129,14 +108,17 @@ func (h *Helper) getFromWorkspaceServer(serverURL string) (string, string, error if workspacePort == "" { return "", "", fmt.Errorf("no workspace port") } + endpoint := fmt.Sprintf("http://localhost:%s/docker-credentials", workspacePort) + return getFromEndpoint(endpoint, serverURL) +} +func getFromEndpoint(endpoint, serverURL string) (string, string, error) { requestBody, err := json.Marshal(&Request{ServerURL: serverURL}) if err != nil { return "", "", err } client := &http.Client{Timeout: credentialsTimeout} - endpoint := fmt.Sprintf("http://localhost:%s/docker-credentials", workspacePort) //nolint:gosec // endpoint is always loopback; only the port comes from the agent environment resp, err := client.Post(endpoint, "application/json", bytes.NewReader(requestBody)) if err != nil { diff --git a/pkg/dockerinstall/executor.go b/pkg/dockerinstall/executor.go index 13ba07f51f..cb5d03b109 100644 --- a/pkg/dockerinstall/executor.go +++ b/pkg/dockerinstall/executor.go @@ -27,18 +27,26 @@ func (e *Executor) Run(ctx context.Context, shC, cmdStr string) error { return nil } + cmd := shellCommand(ctx, shC, cmdStr) + if cmd == nil { + return nil + } + return e.runCommand(cmd) +} + +func shellCommand(ctx context.Context, shC, cmdStr string) *exec.Cmd { switch { case strings.HasPrefix(shC, "sudo"): //nolint:gosec // G204: cmdStr built internally from constants and opts, not external input - return e.runCommand(exec.CommandContext(ctx, "sudo", "-E", "sh", "-c", cmdStr)) + return exec.CommandContext(ctx, "sudo", "-E", "sh", "-c", cmdStr) case strings.HasPrefix(shC, "su"): //nolint:gosec // G204: cmdStr built internally from constants and opts, not external input - return e.runCommand(exec.CommandContext(ctx, "su", "-c", cmdStr)) + return exec.CommandContext(ctx, "su", "-c", cmdStr) case shC == ShellEcho: return nil default: //nolint:gosec // G204: cmdStr built internally from constants and opts, not external input - return e.runCommand(exec.CommandContext(ctx, "sh", "-c", cmdStr)) + return exec.CommandContext(ctx, "sh", "-c", cmdStr) } } @@ -124,19 +132,9 @@ func (e *Executor) runWithStderrCapture( return nil } - var cmd *exec.Cmd - switch { - case strings.HasPrefix(shC, "sudo"): - //nolint:gosec // G204: cmdStr built internally from constants and opts, not external input - cmd = exec.CommandContext(ctx, "sudo", "-E", "sh", "-c", cmdStr) - case strings.HasPrefix(shC, "su"): - //nolint:gosec // G204: cmdStr built internally from constants and opts, not external input - cmd = exec.CommandContext(ctx, "su", "-c", cmdStr) - case shC == ShellEcho: + cmd := shellCommand(ctx, shC, cmdStr) + if cmd == nil { return nil - default: - //nolint:gosec // G204: cmdStr built internally from constants and opts, not external input - cmd = exec.CommandContext(ctx, "sh", "-c", cmdStr) } cmd.Stdout = e.opts.stdout diff --git a/pkg/dotfiles/dotfiles.go b/pkg/dotfiles/dotfiles.go index b7e2e428d7..cd568161f3 100644 --- a/pkg/dotfiles/dotfiles.go +++ b/pkg/dotfiles/dotfiles.go @@ -193,9 +193,9 @@ func buildDotCmd(p buildDotCmdParams) (*exec.Cmd, error) { func extractKeysFromEnvKeyValuePairs(envKeyValuePairs []string) []string { keys := []string{} for _, env := range envKeyValuePairs { - keyValue := strings.SplitN(env, "=", 2) - if len(keyValue) == 2 { - keys = append(keys, keyValue[0]) + key, _, found := strings.Cut(env, "=") + if found { + keys = append(keys, key) } } return keys diff --git a/pkg/driver/apple/build.go b/pkg/driver/apple/build.go index b9d7163fb7..25808e2505 100644 --- a/pkg/driver/apple/build.go +++ b/pkg/driver/apple/build.go @@ -62,15 +62,7 @@ func (d *appleDriver) BuildDevContainer( return nil, fmt.Errorf("get image details: %w", err) } - return &config.BuildInfo{ - ImageDetails: imageDetails, - ImageMetadata: req.ExtendedBuildInfo.MetadataConfig, - ImageName: imageName, - PrebuildHash: req.PrebuildHash, - RegistryCache: req.Options.RegistryCache, - Tags: req.Options.Tag, - BuiltLocally: true, - }, nil + return newBuildInfo(imageDetails, imageName, &req), nil } func (d *appleDriver) resolveExistingImage( @@ -89,6 +81,14 @@ func (d *appleDriver) resolveExistingImage( log.Debugf("found existing local image %s", imageName) recordImageReused(ctx) + return newBuildInfo(imageDetails, imageName, &req), true +} + +func newBuildInfo( + imageDetails *config.ImageDetails, + imageName string, + req *driver.BuildRequest, +) *config.BuildInfo { return &config.BuildInfo{ ImageDetails: imageDetails, ImageMetadata: req.ExtendedBuildInfo.MetadataConfig, @@ -97,7 +97,7 @@ func (d *appleDriver) resolveExistingImage( RegistryCache: req.Options.RegistryCache, Tags: req.Options.Tag, BuiltLocally: true, - }, true + } } func (d *appleDriver) executeBuild( diff --git a/pkg/driver/kubernetes/helper.go b/pkg/driver/kubernetes/helper.go index 5a39ad1f7b..0ed58aac8d 100644 --- a/pkg/driver/kubernetes/helper.go +++ b/pkg/driver/kubernetes/helper.go @@ -25,29 +25,24 @@ func parseResources(resourceString string) corev1.ResourceRequirements { for _, resourceName := range resourcesSplitted { resourceName = strings.TrimSpace(resourceName) - // requests + var destination corev1.ResourceList + var strippedResource string if after, ok := strings.CutPrefix(resourceName, requestsPrefix); ok { - strippedResource := after - name, quantity, err := parseResource(strippedResource) - if err != nil { - log.Error(err.Error()) - continue - } - - requests[corev1.ResourceName(name)] = quantity + destination = requests + strippedResource = after + } else if after, ok := strings.CutPrefix(resourceName, limitsPrefix); ok { + destination = limits + strippedResource = after + } else { + continue } - // limits - if after, ok := strings.CutPrefix(resourceName, limitsPrefix); ok { - strippedResource := after - name, quantity, err := parseResource(strippedResource) - if err != nil { - log.Error(err.Error()) - continue - } - - limits[corev1.ResourceName(name)] = quantity + name, quantity, err := parseResource(strippedResource) + if err != nil { + log.Error(err.Error()) + continue } + destination[corev1.ResourceName(name)] = quantity } return corev1.ResourceRequirements{ @@ -103,27 +98,27 @@ func parseLabels(str string) (map[string]string, error) { retMap := map[string]string{} for _, label := range labels { label = strings.TrimSpace(label) - splitted := strings.SplitN(label, "=", 2) - if len(splitted) != 2 { + key, value, ok := strings.Cut(label, "=") + if !ok { return nil, fmt.Errorf("invalid label %q, expected format label=value", label) } - retMap[splitted[0]] = splitted[1] + retMap[key] = value } return retMap, nil } func parseResource(resourceName string) (string, resource.Quantity, error) { - splittedResource := strings.SplitN(resourceName, "=", 2) - if len(splittedResource) != 2 { + name, value, ok := strings.Cut(resourceName, "=") + if !ok { return "", resource.Quantity{}, fmt.Errorf( "error parsing resource %s: expected form resource=quantity", resourceName, ) } - quantity, err := resource.ParseQuantity(splittedResource[1]) + quantity, err := resource.ParseQuantity(value) if err != nil { return "", resource.Quantity{}, fmt.Errorf( "error parsing resource %s: %w", @@ -132,7 +127,7 @@ func parseResource(resourceName string) (string, resource.Quantity, error) { ) } - return splittedResource[0], quantity, nil + return name, quantity, nil } func parseSecurityContext(raw string) (*corev1.SecurityContext, error) { diff --git a/pkg/driver/kubernetes/pod_lifecycle_test.go b/pkg/driver/kubernetes/pod_lifecycle_test.go index bf540af146..e68cba9aac 100644 --- a/pkg/driver/kubernetes/pod_lifecycle_test.go +++ b/pkg/driver/kubernetes/pod_lifecycle_test.go @@ -250,6 +250,31 @@ func TestReconcileReusesPodWhenOnlyImageConfigFileChanged(t *testing.T) { assert.Zero(t, c.deleteCalls()) } +func TestReconcileReusesPodWhenOnlyConnectionOptionsChanged(t *testing.T) { + c := newFakeCluster(t) + c.putPod(t, c.pod(t, podSpec{ + uid: "u1", + phase: corev1.PodRunning, + options: &provider2.ProviderKubernetesDriverConfig{ + DiskSize: testDiskSize, + KubernetesContext: "previous-context", + KubernetesConfig: "/previous/config", + KubernetesNamespace: "previous-namespace", + PodTimeout: "1m", + }, + devsy: &corev1.ContainerStatus{ + State: corev1.ContainerState{Running: &corev1.ContainerStateRunning{}}, + }, + })) + + reused, err := c.reconcile(context.Background()) + + require.NoError(t, err) + assert.True(t, reused) + assert.Zero(t, c.deleteCalls()) + assert.Equal(t, "2s", c.k.options.PodTimeout) +} + func TestWithoutLocalOptionsDropsImageConfigFile(t *testing.T) { options := &provider2.ProviderKubernetesDriverConfig{ DiskSize: testDiskSize, diff --git a/pkg/driver/kubernetes/run.go b/pkg/driver/kubernetes/run.go index df9da2d9a1..5d2cbac257 100644 --- a/pkg/driver/kubernetes/run.go +++ b/pkg/driver/kubernetes/run.go @@ -763,19 +763,18 @@ func getDaemonSecretName(workspaceID string) string { } func optionsEqual(a, b *provider2.ProviderKubernetesDriverConfig) bool { - // copy a and b and the compare them without the context, config, namespace and podTimeout - aCopy := withoutLocalOptions(a) - aCopy.KubernetesContext = "" - aCopy.KubernetesConfig = "" - aCopy.KubernetesNamespace = "" - aCopy.PodTimeout = "" - - bCopy := withoutLocalOptions(b) - bCopy.KubernetesContext = "" - bCopy.KubernetesConfig = "" - bCopy.KubernetesNamespace = "" - bCopy.PodTimeout = "" - return aCopy == bCopy + return comparableOptions(a) == comparableOptions(b) +} + +func comparableOptions( + options *provider2.ProviderKubernetesDriverConfig, +) provider2.ProviderKubernetesDriverConfig { + comparable := withoutLocalOptions(options) + comparable.KubernetesContext = "" + comparable.KubernetesConfig = "" + comparable.KubernetesNamespace = "" + comparable.PodTimeout = "" + return comparable } func withoutLocalOptions( diff --git a/pkg/envfile/envfile.go b/pkg/envfile/envfile.go index efbeabd7b3..a170196965 100644 --- a/pkg/envfile/envfile.go +++ b/pkg/envfile/envfile.go @@ -16,19 +16,8 @@ type EnvFile struct { } func Apply() { - out, err := os.ReadFile(location) - if err != nil { - if !os.IsNotExist(err) { - log.Debugf("Error reading envfile: %v", err) - } - - return - } - - envFile := &EnvFile{} - err = json.Unmarshal(out, envFile) - if err != nil { - log.Debugf("Error parsing envfile: %v", err) + envFile, ok := readEnvFile() + if !ok { return } @@ -37,24 +26,22 @@ func Apply() { } } -// readEnvFile reads and parses the envfile from disk. -// Returns an empty EnvFile if the file does not exist, or nil on read/parse errors. -func readEnvFile() *EnvFile { +func readEnvFile() (EnvFile, bool) { out, err := os.ReadFile(location) if err != nil { if !os.IsNotExist(err) { log.Debugf("Error reading envfile: %v", err) - return nil + return EnvFile{}, false } - return &EnvFile{} + return EnvFile{}, true } - envFile := &EnvFile{} - if err := json.Unmarshal(out, envFile); err != nil { + var envFile EnvFile + if err := json.Unmarshal(out, &envFile); err != nil { log.Debugf("Error parsing envfile: %v", err) - return nil + return EnvFile{}, false } - return envFile + return envFile, true } func MergeAndApply(env map[string]string) { @@ -62,8 +49,8 @@ func MergeAndApply(env map[string]string) { return } - envFile := readEnvFile() - if envFile == nil { + envFile, ok := readEnvFile() + if !ok { return } diff --git a/pkg/ide/opener/browser_tunnel.go b/pkg/ide/opener/browser_tunnel.go index 978a7d0863..0ca1ea20ab 100644 --- a/pkg/ide/opener/browser_tunnel.go +++ b/pkg/ide/opener/browser_tunnel.go @@ -288,6 +288,7 @@ func spawnTunnelHelper(opts spawnHelperOpts) (int, string, error) { devNull, err := os.OpenFile(os.DevNull, os.O_RDWR, 0) if err != nil { + setup.Cleanup() return 0, "", fmt.Errorf("open %s: %w", os.DevNull, err) } defer func() { _ = devNull.Close() }() diff --git a/pkg/ide/opener/browser_tunnel_fd_unix_test.go b/pkg/ide/opener/browser_tunnel_fd_unix_test.go new file mode 100644 index 0000000000..c19a3310c7 --- /dev/null +++ b/pkg/ide/opener/browser_tunnel_fd_unix_test.go @@ -0,0 +1,93 @@ +//go:build darwin || linux + +package opener + +import ( + "net" + "os" + "strings" + "testing" + + "github.com/devsy-org/devsy/pkg/tunnel" + "github.com/stretchr/testify/require" + "golang.org/x/sys/unix" +) + +func TestSpawnTunnelHelperClosesListenersWhenDevNullOpenFails(t *testing.T) { + setupTempHome(t) + listener, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + addr := listener.Addr().String() + require.NoError(t, listener.Close()) + + lowerNoFileSoftLimit(t) + pressure := exhaustTunnelFDs(t) + pid, _, spawnErr := spawnTunnelHelper(spawnHelperOpts{ + ContextName: "fd-test", + WorkspaceID: "fd-test", + TunnelParams: tunnel.BrowserTunnelParams{ + ExtraPorts: []string{addr + ":80"}, + }, + }) + releaseTunnelFDs(pressure) + assertTunnelFDResult(t, addr, pid, spawnErr) +} + +func lowerNoFileSoftLimit(t *testing.T) { + t.Helper() + var original unix.Rlimit + require.NoError(t, unix.Getrlimit(unix.RLIMIT_NOFILE, &original)) + t.Cleanup(func() { + require.NoError(t, unix.Setrlimit(unix.RLIMIT_NOFILE, &original)) + }) + lowered := original + lowered.Cur = min(original.Cur, 128) + require.NoError(t, unix.Setrlimit(unix.RLIMIT_NOFILE, &lowered)) +} + +func exhaustTunnelFDs(t *testing.T) []*os.File { + t.Helper() + var pressure []*os.File + t.Cleanup(func() { releaseTunnelFDs(pressure) }) + for { + f, err := os.OpenFile(os.DevNull, os.O_RDWR, 0) + if err != nil { + require.ErrorIs(t, err, unix.EMFILE, "exhaust descriptors") + break + } + pressure = append(pressure, f) + } + require.GreaterOrEqual(t, len(pressure), 2, "not enough descriptors to prepare a listener") + for range 2 { + last := len(pressure) - 1 + require.NoError(t, pressure[last].Close()) + pressure = pressure[:last] + } + return pressure +} + +func releaseTunnelFDs(pressure []*os.File) { + for _, f := range pressure { + _ = f.Close() + } +} + +func assertTunnelFDResult(t *testing.T, addr string, pid int, spawnErr error) { + t.Helper() + if spawnErr == nil { + if process, err := os.FindProcess(pid); err == nil { + _ = process.Kill() + _, _ = process.Wait() + } + } + require.ErrorIs(t, spawnErr, unix.EMFILE) + require.True( + t, + strings.HasPrefix(spawnErr.Error(), "open "+os.DevNull+":"), + "unexpected failure: %v", + spawnErr, + ) + listener, err := net.Listen("tcp", addr) + require.NoError(t, err, "rebind %s after spawn failure", addr) + require.NoError(t, listener.Close()) +} diff --git a/pkg/ide/opener/opener.go b/pkg/ide/opener/opener.go index 457ca7bd2c..eee8277e8e 100644 --- a/pkg/ide/opener/opener.go +++ b/pkg/ide/opener/opener.go @@ -250,43 +250,23 @@ func openJetBrains( folder := params.Result.SubstitutionContext.ContainerWorkspaceFolder sshHost := resolveSSHHost(params.Client) user := params.User - type jetbrainsFactory func() interface{ OpenGateway(string, string) error } + type jetbrainsFactory func(string, map[string]config.OptionValue) *jetbrains.GenericJetBrainsServer jetbrainsMap := map[string]jetbrainsFactory{ - string(config.IDERustRover): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewRustRoverServer(user, ideOptions) - }, - string(config.IDEGoland): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewGolandServer(user, ideOptions) - }, - string(config.IDEPyCharm): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewPyCharmServer(user, ideOptions) - }, - string(config.IDEPhpStorm): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewPhpStorm(user, ideOptions) - }, - string(config.IDEIntellij): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewIntellij(user, ideOptions) - }, - string(config.IDECLion): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewCLionServer(user, ideOptions) - }, - string(config.IDERider): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewRiderServer(user, ideOptions) - }, - string(config.IDERubyMine): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewRubyMineServer(user, ideOptions) - }, - string(config.IDEWebStorm): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewWebStormServer(user, ideOptions) - }, - string(config.IDEDataSpell): func() interface{ OpenGateway(string, string) error } { - return jetbrains.NewDataSpellServer(user, ideOptions) - }, + string(config.IDERustRover): jetbrains.NewRustRoverServer, + string(config.IDEGoland): jetbrains.NewGolandServer, + string(config.IDEPyCharm): jetbrains.NewPyCharmServer, + string(config.IDEPhpStorm): jetbrains.NewPhpStorm, + string(config.IDEIntellij): jetbrains.NewIntellij, + string(config.IDECLion): jetbrains.NewCLionServer, + string(config.IDERider): jetbrains.NewRiderServer, + string(config.IDERubyMine): jetbrains.NewRubyMineServer, + string(config.IDEWebStorm): jetbrains.NewWebStormServer, + string(config.IDEDataSpell): jetbrains.NewDataSpellServer, } if factory, ok := jetbrainsMap[ideName]; ok { - return factory().OpenGateway(folder, sshHost) + return factory(user, ideOptions).OpenGateway(folder, sshHost) } return fmt.Errorf("unknown JetBrains IDE: %s", ideName) } diff --git a/pkg/log/streamer.go b/pkg/log/streamer.go index 427caa18c0..29abfc406e 100644 --- a/pkg/log/streamer.go +++ b/pkg/log/streamer.go @@ -245,18 +245,11 @@ func extractLevelPrefix(line string) (bool, zapcore.Level) { return false, 0 } - switch strings.ToLower(parts[1]) { - case "trace", "debug": - return true, zapcore.DebugLevel - case infoLevelName: - return true, zapcore.InfoLevel - case "warning", "warn": - return true, zapcore.WarnLevel - case "error", "panic", "fatal": - return true, zapcore.ErrorLevel - default: + level, recognized := normalizeZapLevel(parts[1]) + if !recognized { return false, 0 } + return true, level } func logAtZapLevel(level zapcore.Level, message string) { diff --git a/pkg/open/open.go b/pkg/open/open.go index ce82bd0338..6ef440c5d5 100644 --- a/pkg/open/open.go +++ b/pkg/open/open.go @@ -24,27 +24,21 @@ func Run(url string) error { // Open opens the given url in the default application, retrying every second until the context is done. func Open(ctx context.Context, url string) error { - for { - select { - case <-ctx.Done(): - return nil - case <-time.After(time.Second): - err := tryOpen(ctx, url, Run) - if err == nil { - return nil - } - } - } + return openWithRetry(ctx, url, Run) } // JLabDesktop opens the given url in the JLab desktop application, retrying every second until the context is done. func JLabDesktop(ctx context.Context, url string) error { + return openWithRetry(ctx, url, jlabOpen) +} + +func openWithRetry(ctx context.Context, url string, fn func(string) error) error { for { select { case <-ctx.Done(): return nil case <-time.After(time.Second): - err := tryOpen(ctx, url, jlabOpen) + err := tryOpen(ctx, url, fn) if err == nil { return nil } diff --git a/pkg/platform/kubeconfig.go b/pkg/platform/kubeconfig.go index 41bac9c8e9..844816566e 100644 --- a/pkg/platform/kubeconfig.go +++ b/pkg/platform/kubeconfig.go @@ -175,18 +175,9 @@ type directClusterEndpointForSpaceParams struct { func directClusterEndpointKubeConfigForSpace( p directClusterEndpointForSpaceParams, ) (*clientcmdapi.Config, error) { - tok := &managementv1.DirectClusterEndpointToken{ - Spec: managementv1.DirectClusterEndpointTokenSpec{ - Scope: p.scope, - TTL: p.ttl, - }, - } - directClusterEndpointToken, err := p.managementClient.Devsy(). - ManagementV1(). - DirectClusterEndpointTokens(). - Create(p.ctx, tok, metav1.CreateOptions{}) + token, err := createDirectClusterEndpointToken(p.ctx, p.managementClient, p.scope, p.ttl) if err != nil { - return nil, fmt.Errorf("create direct cluster endpoint token: %w", err) + return nil, err } directClusterEndpoint := p.hostCluster.GetAnnotations()[annotations.DirectClusterEndpoint] @@ -199,7 +190,7 @@ func directClusterEndpointKubeConfigForSpace( return newKubeConfig( host, - directClusterEndpointToken.Status.Token, + token, p.spaceInstance.Spec.ClusterRef.Namespace, ), nil } @@ -419,18 +410,14 @@ func directClusterEndpointKubeConfig( req vClusterKubeConfigRequest, hostCluster managementv1.Cluster, ) (*clientcmdapi.Config, error) { - tok := &managementv1.DirectClusterEndpointToken{ - Spec: managementv1.DirectClusterEndpointTokenSpec{ - Scope: req.scope, - TTL: req.ttl, - }, - } - directClusterEndpointToken, err := req.managementClient.Devsy(). - ManagementV1(). - DirectClusterEndpointTokens(). - Create(req.ctx, tok, metav1.CreateOptions{}) + token, err := createDirectClusterEndpointToken( + req.ctx, + req.managementClient, + req.scope, + req.ttl, + ) if err != nil { - return nil, fmt.Errorf("create direct cluster endpoint token: %w", err) + return nil, err } directClusterEndpoint := hostCluster.GetAnnotations()[annotations.DirectClusterEndpoint] @@ -443,11 +430,33 @@ func directClusterEndpointKubeConfig( return newKubeConfig( host, - directClusterEndpointToken.Status.Token, + token, req.instance.Spec.ClusterRef.Namespace, ), nil } +func createDirectClusterEndpointToken( + ctx context.Context, + managementClient kube.Interface, + scope *storagev1.AccessKeyScope, + ttl int64, +) (string, error) { + tok := &managementv1.DirectClusterEndpointToken{ + Spec: managementv1.DirectClusterEndpointTokenSpec{ + Scope: scope, + TTL: ttl, + }, + } + created, err := managementClient.Devsy(). + ManagementV1(). + DirectClusterEndpointTokens(). + Create(ctx, tok, metav1.CreateOptions{}) + if err != nil { + return "", fmt.Errorf("create direct cluster endpoint token: %w", err) + } + return created.Status.Token, nil +} + func findHostCluster( ctx context.Context, baseClient client.Client, diff --git a/pkg/platform/version.go b/pkg/platform/version.go index c40796c21d..843458cbec 100644 --- a/pkg/platform/version.go +++ b/pkg/platform/version.go @@ -27,7 +27,10 @@ func GetPlatformVersion(url string) (*VersionObject, error) { resp, err := http.GetHTTPClient().Get(url + "/version") if err != nil { return nil, fmt.Errorf("get %s: %w", url, err) - } else if resp.StatusCode != 200 { + } + defer func() { _ = resp.Body.Close() }() + + if resp.StatusCode != 200 { out, _ := io.ReadAll(resp.Body) return nil, fmt.Errorf("get %s: %s (Status: %d)", url, string(out), resp.StatusCode) } diff --git a/pkg/platform/version_test.go b/pkg/platform/version_test.go index e420b57c87..d3dc7f7821 100644 --- a/pkg/platform/version_test.go +++ b/pkg/platform/version_test.go @@ -1,13 +1,84 @@ package platform import ( + "errors" + "io" "net/http" "net/http/httptest" + "strings" "testing" + devsyhttp "github.com/devsy-org/devsy/pkg/http" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) +type versionRoundTripper func(*http.Request) (*http.Response, error) + +func (f versionRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { + return f(req) +} + +type versionBody struct { + io.Reader + closed bool +} + +func (b *versionBody) Close() error { + b.closed = true + return nil +} + +type versionFailReader struct{} + +func (versionFailReader) Read([]byte) (int, error) { + return 0, errors.New("body read failed") +} + +func TestGetPlatformVersionClosesBody(t *testing.T) { + client := devsyhttp.GetHTTPClient() + originalTransport := client.Transport + t.Cleanup(func() { client.Transport = originalTransport }) + + tests := []struct { + name string + status int + reader io.Reader + wantErr bool + }{ + {name: "success", status: http.StatusOK, reader: strings.NewReader(`{"version":"1.2.3"}`)}, + { + name: "status", + status: http.StatusForbidden, + reader: strings.NewReader("nope"), + wantErr: true, + }, + {name: "read", status: http.StatusOK, reader: versionFailReader{}, wantErr: true}, + {name: "parse", status: http.StatusOK, reader: strings.NewReader("invalid"), wantErr: true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + body := &versionBody{Reader: tt.reader} + client.Transport = versionRoundTripper( + func(*http.Request) (*http.Response, error) { + return &http.Response{ + StatusCode: tt.status, + Body: body, + Header: make(http.Header), + }, nil + }, + ) + _, err := GetPlatformVersion("http://example.test") + if tt.wantErr { + require.Error(t, err) + } else { + require.NoError(t, err) + } + require.True(t, body.closed, "response body was not closed") + }) + } +} + type versionSuite struct { suite.Suite } diff --git a/pkg/pty/ptytest/ptytest_windows.go b/pkg/pty/ptytest/ptytest_windows.go index d57460ff21..457c64bb16 100644 --- a/pkg/pty/ptytest/ptytest_windows.go +++ b/pkg/pty/ptytest/ptytest_windows.go @@ -73,17 +73,10 @@ func (p *testPTY) Close() error { p.closed = true var firstErr error - if err := p.outputWriter.Close(); err != nil && firstErr == nil { - firstErr = err - } - if err := p.outputReader.Close(); err != nil && firstErr == nil { - firstErr = err - } - if err := p.inputWriter.Close(); err != nil && firstErr == nil { - firstErr = err - } - if err := p.inputReader.Close(); err != nil && firstErr == nil { - firstErr = err + for _, pipe := range []*os.File{p.outputWriter, p.outputReader, p.inputWriter, p.inputReader} { + if err := pipe.Close(); err != nil && firstErr == nil { + firstErr = err + } } return firstErr } diff --git a/pkg/secrets/local_store.go b/pkg/secrets/local_store.go index a2f23c04d0..1434bd5dc4 100644 --- a/pkg/secrets/local_store.go +++ b/pkg/secrets/local_store.go @@ -276,22 +276,7 @@ func deletionBackendKinds( if meta.Backend != "" { return []Backend{meta.Backend}, nil } - - var kinds []Backend - for _, kind := range []Backend{BackendKeyring, BackendFile} { - present, conclusive := s.backends.Probe(kind, idx, key) - if !conclusive { - return nil, fmt.Errorf( - "cannot safely delete unowned secret because secrets backend %q could not be probed; "+ - "restore access to that backend or set the secret again", - kind, - ) - } - if present { - kinds = append(kinds, kind) - } - } - return kinds, nil + return s.probeDeletionBackends(idx, key) } func removeSnapshots(snapshots []backendValueSnapshot) error { @@ -466,21 +451,29 @@ func (s *localStore) provenOwner(idx *index, key string) (Backend, bool) { return found[0], true } -func (s *localStore) removeFromProbeableBackends(idx *index, key string) error { - var present []Backend +func (s *localStore) probeDeletionBackends(idx *index, key string) ([]Backend, error) { + var kinds []Backend for _, kind := range []Backend{BackendKeyring, BackendFile} { - found, conclusive := s.backends.Probe(kind, idx, key) + present, conclusive := s.backends.Probe(kind, idx, key) if !conclusive { - return fmt.Errorf( + return nil, fmt.Errorf( "cannot safely delete unowned secret because secrets backend %q could not be probed; "+ "restore access to that backend or set the secret again", kind, ) } - if found { - present = append(present, kind) + if present { + kinds = append(kinds, kind) } } + return kinds, nil +} + +func (s *localStore) removeFromProbeableBackends(idx *index, key string) error { + present, err := s.probeDeletionBackends(idx, key) + if err != nil { + return err + } for _, kind := range present { b, err := s.backends.Open(kind, idx, BackendOpenExisting) if err != nil { diff --git a/pkg/secrets/store_internal_test.go b/pkg/secrets/store_internal_test.go index 62fd860ce7..d0fd808a54 100644 --- a/pkg/secrets/store_internal_test.go +++ b/pkg/secrets/store_internal_test.go @@ -841,6 +841,35 @@ func TestStore_DeleteUnownedFailsWhenBackendUnprobeable(t *testing.T) { require.NoError(t, err) } +func TestStore_UnownedRemovalFailsWhenSecondBackendUnprobeable(t *testing.T) { + key := backendKey(testContext, "LEGACY") + for _, remove := range []struct { + name string + run func(*localStore) error + }{ + {"delete", func(s *localStore) error { return s.Delete(testContext, "LEGACY") }}, + {"remove sensitive", func(s *localStore) error { return s.removeFromProbeableBackends(nil, key) }}, + } { + t.Run(remove.name, func(t *testing.T) { + keyring := newMapBackend() + keyring.values[key] = "sensitive" + s := newLocalStoreWithRegistry( + BackendKeyring, + writeLegacyIndex( + t, + " LEGACY:\n name: LEGACY\n context: default\n kind: secret\n", + ), + mapBackendRegistry{backends: map[Backend]*mapBackend{BackendKeyring: keyring}}, + ) + + err := remove.run(s) + require.ErrorContains(t, err, `backend "file" could not be probed`) + require.Equal(t, 0, keyring.removeCalls) + require.Equal(t, "sensitive", keyring.values[key]) + }) + } +} + // legacyIndexData models the catalog schema used by older installed CLIs. type legacyIndexData struct { SchemaVersion int `json:"schemaVersion,omitempty"` diff --git a/pkg/ssh/keys.go b/pkg/ssh/keys.go index 0732798bda..3fce615bc2 100644 --- a/pkg/ssh/keys.go +++ b/pkg/ssh/keys.go @@ -128,14 +128,11 @@ func GetHostKey(context, workspaceID string) (string, error) { return GetHostKeyBase(workspaceDir) } -func GetPrivateKeyRawBase(dir string) ([]byte, error) { - keyLock.Lock() - defer keyLock.Unlock() - +func prepareSSHKeyPair(dir string) (string, string, error) { // #nosec G301 -- TODO Consider using a more secure permission setting and ownership if needed. err := os.MkdirAll(dir, 0o755) if err != nil { - return nil, err + return "", "", err } // check if key pair exists @@ -145,21 +142,33 @@ func GetPrivateKeyRawBase(dir string) ([]byte, error) { if err != nil { pubKey, privateKey, err := makeSSHKeyPair() if err != nil { - return nil, fmt.Errorf("generate key pair: %w", err) + return "", "", fmt.Errorf("generate key pair: %w", err) } // #nosec G306 -- TODO Consider using a more secure permission setting and ownership if needed. err = os.WriteFile(publicKeyFile, []byte(pubKey), 0o644) if err != nil { - return nil, fmt.Errorf("write public ssh key: %w", err) + return "", "", fmt.Errorf("write public ssh key: %w", err) } err = os.WriteFile(privateKeyFile, []byte(privateKey), 0o600) if err != nil { - return nil, fmt.Errorf("write private ssh key: %w", err) + return "", "", fmt.Errorf("write private ssh key: %w", err) } } + return privateKeyFile, publicKeyFile, nil +} + +func GetPrivateKeyRawBase(dir string) ([]byte, error) { + keyLock.Lock() + defer keyLock.Unlock() + + privateKeyFile, _, err := prepareSSHKeyPair(dir) + if err != nil { + return nil, err + } + // read private key //nolint:gosec // path is a user key file chosen by config out, err := os.ReadFile(privateKeyFile) @@ -209,34 +218,11 @@ func GetPublicKeyBase(dir string) (string, error) { keyLock.Lock() defer keyLock.Unlock() - // #nosec G301 -- TODO Consider using a more secure permission setting and ownership if needed. - err := os.MkdirAll(dir, 0o755) + _, publicKeyFile, err := prepareSSHKeyPair(dir) if err != nil { return "", err } - // check if key pair exists - privateKeyFile := filepath.Join(dir, DevsySSHPrivateKeyFile) - publicKeyFile := filepath.Join(dir, DevsySSHPublicKeyFile) - _, err = os.Stat(privateKeyFile) - if err != nil { - pubKey, privateKey, err := makeSSHKeyPair() - if err != nil { - return "", fmt.Errorf("generate key pair: %w", err) - } - - // #nosec G306 -- TODO Consider using a more secure permission setting and ownership if needed. - err = os.WriteFile(publicKeyFile, []byte(pubKey), 0o644) - if err != nil { - return "", fmt.Errorf("write public ssh key: %w", err) - } - - err = os.WriteFile(privateKeyFile, []byte(privateKey), 0o600) - if err != nil { - return "", fmt.Errorf("write private ssh key: %w", err) - } - } - // read public key //nolint:gosec // path is a user key file chosen by config out, err := os.ReadFile(publicKeyFile) diff --git a/pkg/stdio/listener.go b/pkg/stdio/listener.go index 6b95424717..61eea20c47 100644 --- a/pkg/stdio/listener.go +++ b/pkg/stdio/listener.go @@ -51,12 +51,7 @@ func (lis *StdioListener) Accept() (net.Conn, error) { // Close closes the listener and its stdio connection. func (lis *StdioListener) Close() error { - lis.once.Do(func() { - lis.mu.Lock() - lis.closed = true - close(lis.closedCh) - lis.mu.Unlock() - }) + lis.markClosed() if lis.conn != nil { _ = lis.conn.Close() diff --git a/pkg/task/task.go b/pkg/task/task.go index 2fd3afd6da..08b46f5dec 100644 --- a/pkg/task/task.go +++ b/pkg/task/task.go @@ -602,12 +602,12 @@ func (r taskReporter) Report(e status.Event) { if s.Status.Terminal() || s.CancelRequested { return } + s.Phase = redactor.Redact(string(e.Phase)) + s.Step = redactor.Redact(e.Step) + s.OperationID = redactor.Redact(e.OperationID) + s.ParentOperationID = redactor.Redact(e.ParentOperationID) if e.State == status.StateFailed { s.Status = StatusFailed - s.Phase = redactor.Redact(string(e.Phase)) - s.Step = redactor.Redact(e.Step) - s.OperationID = redactor.Redact(e.OperationID) - s.ParentOperationID = redactor.Redact(e.ParentOperationID) s.DurationMs = e.Duration.Milliseconds() if e.Error != nil { s.Error = redactor.Redact(e.Error.Message) @@ -626,10 +626,6 @@ func (r taskReporter) Report(e status.Event) { if s.Status == StatusPending { s.Status = StatusRunning } - s.Phase = redactor.Redact(string(e.Phase)) - s.Step = redactor.Redact(e.Step) - s.OperationID = redactor.Redact(e.OperationID) - s.ParentOperationID = redactor.Redact(e.ParentOperationID) }) } From 1a5b8eb8dbe8241a5be398b6fed794bf14fefd39 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 4 Nov 2026 09:36:29 -0600 Subject: [PATCH 2/3] fix(kubernetes): rename local that shadows the comparable builtin --- pkg/driver/kubernetes/run.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pkg/driver/kubernetes/run.go b/pkg/driver/kubernetes/run.go index 5d2cbac257..068fefcea8 100644 --- a/pkg/driver/kubernetes/run.go +++ b/pkg/driver/kubernetes/run.go @@ -769,12 +769,12 @@ func optionsEqual(a, b *provider2.ProviderKubernetesDriverConfig) bool { func comparableOptions( options *provider2.ProviderKubernetesDriverConfig, ) provider2.ProviderKubernetesDriverConfig { - comparable := withoutLocalOptions(options) - comparable.KubernetesContext = "" - comparable.KubernetesConfig = "" - comparable.KubernetesNamespace = "" - comparable.PodTimeout = "" - return comparable + normalized := withoutLocalOptions(options) + normalized.KubernetesContext = "" + normalized.KubernetesConfig = "" + normalized.KubernetesNamespace = "" + normalized.PodTimeout = "" + return normalized } func withoutLocalOptions( From 267b627d4e04ffe5ff89eedd8bb4d22e1d11f5ae Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 4 Nov 2026 14:35:25 -0600 Subject: [PATCH 3/3] test(opener): inject the dev null open failure instead of exhausting descriptors --- CONTRIBUTING.md | 8 +- pkg/ide/opener/browser_tunnel.go | 6 +- pkg/ide/opener/browser_tunnel_fd_unix_test.go | 82 +++++++------------ 3 files changed, 37 insertions(+), 59 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b70cc056a4..9535d4688f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -171,10 +171,10 @@ Run affected packages with `go test -race -short -count=1`, then run `mise run cli:lint:ci`. Resource cleanup changes need coverage of failure paths as well as successful calls. -The browser tunnel regression in `pkg/ide/opener` exhausts file descriptors in -an isolated subprocess on Linux and macOS. It checks that a failed helper launch -releases its reserved port. Platform reachability tests in `cmd/pro` use local -HTTP servers to check connection cleanup between probes. +The browser tunnel regression in `pkg/ide/opener` injects a failing `/dev/null` +open on Linux and macOS. It checks that a failed helper launch releases its +reserved port. Platform reachability tests in `cmd/pro` use local HTTP servers +to check connection cleanup between probes. Cross-compilation checks platform buildability, not runtime behavior. Windows PTY tests run through the `windows-pty` step in `hack/ci/suites.yaml`. diff --git a/pkg/ide/opener/browser_tunnel.go b/pkg/ide/opener/browser_tunnel.go index 0ca1ea20ab..62ed3e48d8 100644 --- a/pkg/ide/opener/browser_tunnel.go +++ b/pkg/ide/opener/browser_tunnel.go @@ -258,6 +258,10 @@ type spawnHelperOpts struct { OpenBrowser bool } +var openDevNull = func() (*os.File, error) { + return os.OpenFile(os.DevNull, os.O_RDWR, 0) +} + // spawnTunnelHelper locates the current executable, builds the helper // argument list, pre-binds host listeners (where supported), spawns the // detached helper process, and records its PID in the tunnel state file. @@ -286,7 +290,7 @@ func spawnTunnelHelper(opts spawnHelperOpts) (int, string, error) { setDetachedProcAttrs(cmd) cmd.ExtraFiles = setup.Files - devNull, err := os.OpenFile(os.DevNull, os.O_RDWR, 0) + devNull, err := openDevNull() if err != nil { setup.Cleanup() return 0, "", fmt.Errorf("open %s: %w", os.DevNull, err) diff --git a/pkg/ide/opener/browser_tunnel_fd_unix_test.go b/pkg/ide/opener/browser_tunnel_fd_unix_test.go index c19a3310c7..52f6fc349b 100644 --- a/pkg/ide/opener/browser_tunnel_fd_unix_test.go +++ b/pkg/ide/opener/browser_tunnel_fd_unix_test.go @@ -15,13 +15,9 @@ import ( func TestSpawnTunnelHelperClosesListenersWhenDevNullOpenFails(t *testing.T) { setupTempHome(t) - listener, err := net.Listen("tcp", "127.0.0.1:0") - require.NoError(t, err) - addr := listener.Addr().String() - require.NoError(t, listener.Close()) + addr := reserveLoopbackAddr(t) + failDevNullOpen(t) - lowerNoFileSoftLimit(t) - pressure := exhaustTunnelFDs(t) pid, _, spawnErr := spawnTunnelHelper(spawnHelperOpts{ ContextName: "fd-test", WorkspaceID: "fd-test", @@ -29,56 +25,9 @@ func TestSpawnTunnelHelperClosesListenersWhenDevNullOpenFails(t *testing.T) { ExtraPorts: []string{addr + ":80"}, }, }) - releaseTunnelFDs(pressure) - assertTunnelFDResult(t, addr, pid, spawnErr) -} - -func lowerNoFileSoftLimit(t *testing.T) { - t.Helper() - var original unix.Rlimit - require.NoError(t, unix.Getrlimit(unix.RLIMIT_NOFILE, &original)) - t.Cleanup(func() { - require.NoError(t, unix.Setrlimit(unix.RLIMIT_NOFILE, &original)) - }) - lowered := original - lowered.Cur = min(original.Cur, 128) - require.NoError(t, unix.Setrlimit(unix.RLIMIT_NOFILE, &lowered)) -} - -func exhaustTunnelFDs(t *testing.T) []*os.File { - t.Helper() - var pressure []*os.File - t.Cleanup(func() { releaseTunnelFDs(pressure) }) - for { - f, err := os.OpenFile(os.DevNull, os.O_RDWR, 0) - if err != nil { - require.ErrorIs(t, err, unix.EMFILE, "exhaust descriptors") - break - } - pressure = append(pressure, f) - } - require.GreaterOrEqual(t, len(pressure), 2, "not enough descriptors to prepare a listener") - for range 2 { - last := len(pressure) - 1 - require.NoError(t, pressure[last].Close()) - pressure = pressure[:last] - } - return pressure -} - -func releaseTunnelFDs(pressure []*os.File) { - for _, f := range pressure { - _ = f.Close() - } -} -func assertTunnelFDResult(t *testing.T, addr string, pid int, spawnErr error) { - t.Helper() if spawnErr == nil { - if process, err := os.FindProcess(pid); err == nil { - _ = process.Kill() - _, _ = process.Wait() - } + killTunnelHelper(pid) } require.ErrorIs(t, spawnErr, unix.EMFILE) require.True( @@ -91,3 +40,28 @@ func assertTunnelFDResult(t *testing.T, addr string, pid int, spawnErr error) { require.NoError(t, err, "rebind %s after spawn failure", addr) require.NoError(t, listener.Close()) } + +func reserveLoopbackAddr(t *testing.T) string { + t.Helper() + listener, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + addr := listener.Addr().String() + require.NoError(t, listener.Close()) + return addr +} + +func failDevNullOpen(t *testing.T) { + t.Helper() + original := openDevNull + t.Cleanup(func() { openDevNull = original }) + openDevNull = func() (*os.File, error) { + return nil, &os.PathError{Op: "open", Path: os.DevNull, Err: unix.EMFILE} + } +} + +func killTunnelHelper(pid int) { + if process, err := os.FindProcess(pid); err == nil { + _ = process.Kill() + _, _ = process.Wait() + } +}