feat: --tty flag & carriage return fix

Author: FabianKramm

cmd/enter.go

@@ -30,6 +30,7 @@ type EnterCmd struct {
 	Container     string
 	Pod           string
 	Pick          bool
+	TTY           bool
 	Wait          bool
 	Reconnect     bool
 	Screen        bool
@@ -78,6 +79,7 @@ devspace enter bash --image-selector "${runtime.images.app.image}:${runtime.imag
 	enterCmd.Flags().StringVar(&cmd.ImageSelector, "image-selector", "", "The image to search a pod for (e.g. nginx, nginx:latest, ${runtime.images.app}, nginx:${runtime.images.app.tag})")
 	enterCmd.Flags().StringVar(&cmd.WorkingDirectory, "workdir", "", "The working directory where to open the terminal or execute the command")
 
+	enterCmd.Flags().BoolVar(&cmd.TTY, "tty", true, "If to use a tty to start the command")
 	enterCmd.Flags().BoolVar(&cmd.Pick, "pick", true, "Select a pod / container if multiple are found")
 	enterCmd.Flags().BoolVar(&cmd.Wait, "wait", false, "Wait for the pod(s) to start if they are not running")
 	enterCmd.Flags().BoolVar(&cmd.Reconnect, "reconnect", false, "Will reconnect the terminal if an unexpected return code is encountered")
@@ -158,7 +160,7 @@ func (cmd *EnterCmd) Run(f factory.Factory, args []string) error {
 
 	// Start terminal
 	stdout, stderr, stdin := defaultStdStreams(cmd.Stdout, cmd.Stderr, cmd.Stdin)
-	exitCode, err := terminal.StartTerminalFromCMD(ctx, targetselector.NewTargetSelector(selectorOptions), command, cmd.Wait, cmd.Reconnect, cmd.Screen, cmd.ScreenSession, stdout, stderr, stdin)
+	exitCode, err := terminal.StartTerminalFromCMD(ctx, targetselector.NewTargetSelector(selectorOptions), command, cmd.Wait, cmd.Reconnect, cmd.TTY, cmd.Screen, cmd.ScreenSession, stdout, stderr, stdin)
 	if err != nil {
 		return err
 	} else if exitCode != 0 {

docs/hack/functions/main.go

@@ -363,6 +363,14 @@ var Functions = []Function{
 		Return:      reflect.String.String(),
 		Group:       groupOther,
 	},
+	{
+		Name:        "wait_pod",
+		Description: "Waits for a pod to become running",
+		Args:        `[command]`,
+		Handler:     commands.WaitPod,
+		Flags:       commands.WaitPodOptions{},
+		Group:       groupOther,
+	},
 	{
 		Name:        "exec_container",
 		Description: `Executes the command provided as argument inside a container`,

pkg/devspace/config/versions/latest/schema.go

@@ -1234,6 +1234,9 @@ type Terminal struct {
 	// DisableScreen will disable screen which is used by DevSpace by default to preserve
 	// sessions if connections interrupt or the session is lost.
 	DisableScreen bool `yaml:"disableScreen,omitempty" json:"disableScreen,omitempty"`
+
+	// DisableTTY will disable a tty shell for terminal command execution
+	DisableTTY bool `yaml:"disableTTY,omitempty" json:"disableTTY,omitempty"`
 }
 
 // DependencyConfig defines the devspace dependency

pkg/devspace/deploy/deployer/kubectl/kubectl.go

@@ -281,7 +281,7 @@ func (d *DeployConfig) buildManifests(ctx devspacecontext.Context, manifest stri
 		return NewKustomizeBuilder(kustomizePath, d.DeploymentConfig, ctx.Log()).Build(ctx.Context(), ctx.Environ(), ctx.WorkingDir(), manifest)
 	}
 
-	raw, err := ctx.KubeClient().KubeConfigLoader().LoadConfig().RawConfig()
+	raw, err := ctx.KubeClient().KubeConfigLoader().LoadRawConfig()
 	if err != nil {
 		return nil, fmt.Errorf("get raw config")
 	}

pkg/devspace/kubectl/client.go

@@ -108,6 +108,7 @@ func NewClientFromContext(context, namespace string, switchContext bool, kubeLoa
 		return nil, err
 	}
 	restConfig.UserAgent = "DevSpace Version " + upgrade.GetVersion()
+
 	kubeClient, err := kubernetes.NewForConfig(restConfig)
 	if err != nil {
 		return nil, errors.Wrap(err, "new client")

pkg/devspace/server/server.go

@@ -121,7 +121,7 @@ type forward struct {
 }
 
 func newHandler(ctx devspacecontext.Context, path string, pipeline types.Pipeline) (*handler, error) { // Get kube config
-	kubeConfig, err := kubeconfig.NewLoader().LoadConfig().RawConfig()
+	kubeConfig, err := kubeconfig.NewLoader().LoadRawConfig()
 	if err != nil {
 		return nil, errors.Wrap(err, "load kube config")
 	}

pkg/devspace/services/terminal/terminal.go

@@ -27,6 +27,7 @@ func StartTerminalFromCMD(
 	command []string,
 	wait,
 	restart,
+	tty,
 	screen bool,
 	screenSession string,
 	stdout io.Writer,
@@ -41,7 +42,7 @@ func StartTerminalFromCMD(
 	ctx.Log().Infof("Opening shell to pod:container %s:%s", ansi.Color(container.Pod.Name, "white+b"), ansi.Color(container.Container.Name, "white+b"))
 	done := make(chan error)
 	go func() {
-		done <- startTerminal(ctx, command, !screen, screenSession, stdout, stderr, stdin, container)
+		done <- startTerminal(ctx, command, tty, !screen, screenSession, stdout, stderr, stdin, container)
 	}()
 
 	// wait until either client has finished or we got interrupted
@@ -62,14 +63,14 @@ func StartTerminalFromCMD(
 				if restart && IsUnexpectedExitCode(exitError.Code) {
 					ctx.Log().WriteString(logrus.InfoLevel, "\n")
 					ctx.Log().Infof("Restarting because: %s", err)
-					return StartTerminalFromCMD(ctx, selector, command, wait, restart, screen, screenSession, stdout, stderr, stdin)
+					return StartTerminalFromCMD(ctx, selector, command, wait, restart, tty, screen, screenSession, stdout, stderr, stdin)
 				}
 
 				return exitError.Code, nil
 			} else if restart {
 				ctx.Log().WriteString(logrus.InfoLevel, "\n")
 				ctx.Log().Infof("Restarting because: %s", err)
-				return StartTerminalFromCMD(ctx, selector, command, wait, restart, screen, screenSession, stdout, stderr, stdin)
+				return StartTerminalFromCMD(ctx, selector, command, wait, restart, tty, screen, screenSession, stdout, stderr, stdin)
 			}
 
 			return 0, err
@@ -118,7 +119,7 @@ func StartTerminal(
 	ctx.Log().Infof("Opening shell to %s:%s (pod:container)", ansi.Color(container.Container.Name, "white+b"), ansi.Color(container.Pod.Name, "white+b"))
 	errChan := make(chan error)
 	parent.Go(func() error {
-		errChan <- startTerminal(ctx, command, devContainer.Terminal.DisableScreen, "dev", stdout, stderr, stdin, container)
+		errChan <- startTerminal(ctx, command, !devContainer.Terminal.DisableTTY, devContainer.Terminal.DisableScreen, "dev", stdout, stderr, stdin, container)
 		return nil
 	})
 
@@ -158,6 +159,7 @@ func StartTerminal(
 func startTerminal(
 	ctx devspacecontext.Context,
 	command []string,
+	tty bool,
 	disableScreen bool,
 	screenSession string,
 	stdout io.Writer,
@@ -218,7 +220,7 @@ fi`,
 		Pod:         container.Pod,
 		Container:   container.Container.Name,
 		Command:     command,
-		TTY:         true,
+		TTY:         tty,
 		Stdin:       stdin,
 		Stdout:      stdout,
 		Stderr:      stderr,

pkg/util/scanner/scanner.go

@@ -2,12 +2,36 @@ package scanner
 
 import (
 	"bufio"
+	"bytes"
 	"io"
 )
 
 func NewScanner(r io.Reader) *bufio.Scanner {
 	scanner := bufio.NewScanner(r)
 	buf := make([]byte, 0, 64*1024)
 	scanner.Buffer(buf, 1024*1024)
+	scanner.Split(ScanLines)
 	return scanner
 }
+
+// ScanLines is a split function for a Scanner that returns each line of
+// text, stripped of any trailing end-of-line marker. The returned line may
+// be empty. The end-of-line marker is one optional carriage return followed
+// by one mandatory newline. In regular expression notation, it is `\r?\n`.
+// The last non-empty line of input will be returned even if it has no
+// newline.
+func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	if atEOF && len(data) == 0 {
+		return 0, nil, nil
+	}
+	if i := bytes.IndexByte(data, '\n'); i >= 0 {
+		// We have a full newline-terminated line.
+		return i + 1, data[0:i], nil
+	}
+	// If we're at EOF, we have a final, non-terminated line. Return it.
+	if atEOF {
+		return len(data), data, nil
+	}
+	// Request more data.
+	return 0, nil, nil
+}