[deckhouse-cli] fix kubectl signal and rewrite command (#358)

Signed-off-by: Pavel Okhlopkov <pavel.okhlopkov@flant.com>

Author: ldmonster

cmd/commands/kubectl.go

@@ -22,16 +22,20 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/signal"
 	"regexp"
+	"syscall"
 	"time"
 
 	"github.com/spf13/cobra"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"k8s.io/cli-runtime/pkg/genericiooptions"
 	"k8s.io/client-go/kubernetes"
 	cliflag "k8s.io/component-base/cli/flag"
 	"k8s.io/component-base/logs"
 	kubecmd "k8s.io/kubectl/pkg/cmd"
+	"k8s.io/kubectl/pkg/cmd/plugin"
 )
 
 const (
@@ -42,6 +46,33 @@ const (
 
 var d8CommandRegex = regexp.MustCompile("([\"'`])d8 (\\w+)")
 
+// d8KubectlWriter wraps an io.Writer and rewrites kubectl's "d8 <subcmd>"
+// references (matched by d8CommandRegex) to "d8 k <subcmd>" on each Write call.
+//
+// kubectl uses os.Args[0] as the displayed command name in user-facing
+// suggestions (e.g. "You can run `d8 replace -f ...` to try this update again.").
+// Since the binary is invoked as "d8", those suggestions point users to a
+// non-existent top-level command. Wrapping IOStreams.ErrOut with this writer
+// ensures the suggestions are rewritten to the correct "d8 k <subcmd>" form
+// before reaching the terminal.
+type d8KubectlWriter struct {
+	w io.Writer
+}
+
+func newD8KubectlWriter(w io.Writer) *d8KubectlWriter {
+	return &d8KubectlWriter{w: w}
+}
+
+func (d *d8KubectlWriter) Write(p []byte) (int, error) {
+	rewritten := d8CommandRegex.ReplaceAllString(string(p), "${1}d8 k ${2}")
+	if _, err := d.w.Write([]byte(rewritten)); err != nil {
+		return 0, err
+	}
+	// Report the original input length to honor the io.Writer contract even
+	// though the rewritten payload may have a different byte length.
+	return len(p), nil
+}
+
 // wrapRunE wraps all RunE functions in the kubectl command tree to intercept stderr output.
 // This approach is preferred over modifying os.Args[0] because:
 // - It avoids modifying global state (os.Args) which could affect other parts of the system
@@ -126,12 +157,37 @@ func getDebugImage(cmd *cobra.Command) (string, error) {
 }
 
 func NewKubectlCommand() *cobra.Command {
-	kubectlCmd := kubecmd.NewDefaultKubectlCommand()
+	// Build a kubectl command tree with stderr wrapped by d8KubectlWriter so
+	// kubectl's "d8 <subcmd>" command hints are rewritten to "d8 k <subcmd>".
+	//
+	// This must be applied at construction time: kubectl captures os.Stderr
+	// once into IOStreams.ErrOut and stores the reference (see
+	// k8s.io/kubectl/pkg/cmd/cmd.go:NewDefaultKubectlCommand). Code paths that
+	// write via that stored reference (e.g. the post-edit hint
+	// "You can run `d8 replace -f ...`" emitted from editoptions.go) cannot be
+	// intercepted by later swaps of the os.Stderr global.
+	ioStreams := genericiooptions.IOStreams{
+		In:     os.Stdin,
+		Out:    os.Stdout,
+		ErrOut: newD8KubectlWriter(os.Stderr),
+	}
+
+	kubectlCmd := kubecmd.NewDefaultKubectlCommandWithArgs(kubecmd.KubectlOptions{
+		PluginHandler: kubecmd.NewDefaultPluginHandler(plugin.ValidPluginFilenamePrefixes),
+		Arguments:     os.Args,
+		ConfigFlags: genericclioptions.NewConfigFlags(true).
+			WithDeprecatedPasswordFlag().
+			WithDiscoveryBurst(300).
+			WithDiscoveryQPS(50.0).
+			WithWarningPrinter(ioStreams),
+		IOStreams: ioStreams,
+	})
 	kubectlCmd.Use = "k"
 	kubectlCmd.Aliases = []string{"kubectl"}
 	kubectlCmd = ReplaceCommandName("kubectl", "d8 k", kubectlCmd)
 
-	// Wrap RunE to fix error messages
+	// Fallback rewrite for kubectl code paths that write to the global
+	// os.Stderr directly instead of using IOStreams.ErrOut.
 	wrapRunE(kubectlCmd)
 
 	var debugCmd *cobra.Command
@@ -150,6 +206,22 @@ func NewKubectlCommand() *cobra.Command {
 
 	originalPersistentPreRunE := kubectlCmd.PersistentPreRunE
 	kubectlCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
+		// Restore default OS signal handling for the kubectl subtree.
+		//
+		// The d8 root command installs a graceful-termination signal handler
+		// (see graceful.WithTermination in NewDeliveryCommand) that intercepts
+		// SIGINT/SIGTERM, cancels the root context and then resets the signal
+		// handlers. The kubectl subcommands (notably long-running ones such as
+		// `proxy`, `port-forward`, `exec`, `attach`, `logs -f`) do not observe
+		// that context and keep running until a second signal arrives and is
+		// delivered to the default Go handler.
+		//
+		// To match standalone kubectl behavior (single SIGINT/SIGTERM stops the
+		// command), drop our signal interceptor before kubectl starts so the
+		// very first signal is delivered to the default handler and terminates
+		// the process immediately.
+		signal.Reset(syscall.SIGINT, syscall.SIGTERM)
+
 		if cmd.Name() == "debug" || (cmd.Parent() != nil && cmd.Parent().Name() == "debug") {
 			imageFlag := cmd.Flags().Lookup("image")
 			if imageFlag != nil && imageFlag.Value.String() == "" {

cmd/commands/kubectl_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package commands
 
 import (
+	"bytes"
 	"testing"
 )
 
@@ -167,3 +168,47 @@ func TestD8CommandRegexCaptureGroups(t *testing.T) {
 		t.Errorf("Group 2 (command): expected %q, got %q", expectedGroup2, matches[2])
 	}
 }
+
+func TestD8KubectlWriter(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "kubectl edit retry hint with backticks",
+			input:    "You can run `d8 replace -f /tmp/d8-edit-3418513019.yaml` to try this update again.\n",
+			expected: "You can run `d8 k replace -f /tmp/d8-edit-3418513019.yaml` to try this update again.\n",
+		},
+		{
+			name:     "non-matching content passes through unchanged",
+			input:    "error: the server doesn't have a resource type \"foobar\"\n",
+			expected: "error: the server doesn't have a resource type \"foobar\"\n",
+		},
+		{
+			name:     "multiple references on the same line",
+			input:    "Try `d8 get pods` or `d8 describe pod` for details.\n",
+			expected: "Try `d8 k get pods` or `d8 k describe pod` for details.\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			w := newD8KubectlWriter(&buf)
+
+			n, err := w.Write([]byte(tt.input))
+			if err != nil {
+				t.Fatalf("Write returned error: %v", err)
+			}
+
+			if n != len(tt.input) {
+				t.Errorf("Write returned n=%d, want %d (input length)", n, len(tt.input))
+			}
+
+			if got := buf.String(); got != tt.expected {
+				t.Errorf("\nInput:    %q\nExpected: %q\nGot:      %q", tt.input, tt.expected, got)
+			}
+		})
+	}
+}