Merge pull request karmada-io#5395 from hulizhe/karmadactlattach

add new command karmadactl attach

pkg/karmadactl/attach/attach.go

@@ -0,0 +1,124 @@
+/*
+Copyright 2024 The Karmada Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package attach
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/spf13/cobra"
+	"k8s.io/cli-runtime/pkg/genericiooptions"
+	kubectlattach "k8s.io/kubectl/pkg/cmd/attach"
+	cmdutil "k8s.io/kubectl/pkg/cmd/util"
+	"k8s.io/kubectl/pkg/util/completion"
+	"k8s.io/kubectl/pkg/util/templates"
+
+	"github.com/karmada-io/karmada/pkg/karmadactl/options"
+	"github.com/karmada-io/karmada/pkg/karmadactl/util"
+)
+
+var (
+	attachExample = templates.Examples(`
+		# Get output from running pod mypod in cluster(member1); use the 'kubectl.kubernetes.io/default-container' annotation
+		# for selecting the container to be attached or the first container in the pod will be chosen
+		%[1]s attach mypod --cluster=member1
+
+		# Get output from ruby-container from pod mypod in cluster(member1)
+		%[1]s attach mypod -c ruby-container --cluster=member1
+
+		# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container from pod mypod in Karmada control plane
+		# and sends stdout/stderr from 'bash' back to the client
+		%[1]s attach mypod -c ruby-container -i -t
+
+		# Get output from the first pod of a replica set named nginx in cluster(member1)
+		%[1]s attach rs/nginx --cluster=member1
+		`)
+)
+
+const (
+	defaultPodAttachTimeout = 60 * time.Second
+)
+
+// NewCmdAttach new attach command.
+func NewCmdAttach(f util.Factory, parentCommand string, streams genericiooptions.IOStreams) *cobra.Command {
+	var o CommandAttachOptions
+	o.AttachOptions = kubectlattach.NewAttachOptions(streams)
+
+	cmd := &cobra.Command{
+		Use:                   "attach (POD | TYPE/NAME) -c CONTAINER",
+		DisableFlagsInUseLine: true,
+		Short:                 "Attach to a running container",
+		Long:                  "Attach to a process that is already running inside an existing container.",
+		Example:               fmt.Sprintf(attachExample, parentCommand),
+		ValidArgsFunction:     completion.PodResourceNameCompletionFunc(f),
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.CheckErr(o.Complete(f, cmd, args))
+			cmdutil.CheckErr(o.Validate())
+			cmdutil.CheckErr(o.Run())
+		},
+	}
+
+	cmdutil.AddPodRunningTimeoutFlag(cmd, defaultPodAttachTimeout)
+	cmdutil.AddContainerVarFlags(cmd, &o.ContainerName, o.ContainerName)
+	options.AddKubeConfigFlags(cmd.Flags())
+	o.OperationScope = options.KarmadaControlPlane
+	cmd.Flags().BoolVarP(&o.Stdin, "stdin", "i", o.Stdin, "Pass stdin to the container")
+	cmd.Flags().BoolVarP(&o.TTY, "tty", "t", o.TTY, "Stdin is a TTY")
+	cmd.Flags().BoolVarP(&o.Quiet, "quiet", "q", o.Quiet, "Only print output from the remote session")
+	cmd.Flags().StringVarP(options.DefaultConfigFlags.Namespace, "namespace", "n", *options.DefaultConfigFlags.Namespace, "If present, the namespace scope for this CLI request")
+	cmd.Flags().Var(&o.OperationScope, "operation-scope", "Used to control the operation scope of the command. The optional values are karmada and members. Defaults to karmada.")
+	cmd.Flags().StringVar(&o.Cluster, "cluster", "", "Used to specify a target member cluster and only takes effect when the command's operation scope is members, for example: --operation-scope=members --cluster=member1")
+	return cmd
+}
+
+// CommandAttachOptions declare the arguments accepted by the attach command
+type CommandAttachOptions struct {
+	// flags specific to attach
+	*kubectlattach.AttachOptions
+	Cluster        string
+	OperationScope options.OperationScope
+}
+
+// Complete verifies command line arguments and loads data from the command environment
+func (o *CommandAttachOptions) Complete(f util.Factory, cmd *cobra.Command, args []string) error {
+	var attachFactory cmdutil.Factory = f
+	if o.OperationScope == options.Members && len(o.Cluster) != 0 {
+		memberFactory, err := f.FactoryForMemberCluster(o.Cluster)
+		if err != nil {
+			return err
+		}
+		attachFactory = memberFactory
+	}
+	return o.AttachOptions.Complete(attachFactory, cmd, args)
+}
+
+// Validate checks that the provided attach options are specified.
+func (o *CommandAttachOptions) Validate() error {
+	err := options.VerifyOperationScopeFlags(o.OperationScope, options.KarmadaControlPlane, options.Members)
+	if err != nil {
+		return err
+	}
+	if o.OperationScope == options.Members && len(o.Cluster) == 0 {
+		return fmt.Errorf("must specify a member cluster")
+	}
+	return o.AttachOptions.Validate()
+}
+
+// Run executes a validated remote execution against a pod.
+func (o *CommandAttachOptions) Run() error {
+	return o.AttachOptions.Run()
+}

pkg/karmadactl/karmadactl.go

@@ -30,6 +30,7 @@ import (
 
 	"github.com/karmada-io/karmada/pkg/karmadactl/addons"
 	"github.com/karmada-io/karmada/pkg/karmadactl/apply"
+	"github.com/karmada-io/karmada/pkg/karmadactl/attach"
 	"github.com/karmada-io/karmada/pkg/karmadactl/cmdinit"
 	"github.com/karmada-io/karmada/pkg/karmadactl/cordon"
 	"github.com/karmada-io/karmada/pkg/karmadactl/create"
@@ -114,6 +115,7 @@ func NewKarmadaCtlCommand(cmdUse, parentCommand string) *cobra.Command {
 		{
 			Message: "Troubleshooting and Debugging Commands:",
 			Commands: []*cobra.Command{
+				attach.NewCmdAttach(f, parentCommand, ioStreams),
 				logs.NewCmdLogs(f, parentCommand, ioStreams),
 				exec.NewCmdExec(f, parentCommand, ioStreams),
 				describe.NewCmdDescribe(f, parentCommand, ioStreams),