Add support for composite run/debug commands

pkg/component/delete/delete.go

@@ -181,7 +181,7 @@ func (do *DeleteComponentClient) ExecutePreStopEvents(devfileObj parser.DevfileO
 
 	klog.V(4).Infof("Executing %q event commands for component %q", libdevfile.PreStop, componentName)
 	// ignore the failures if any; delete should not fail because preStop events failed to execute
-	err = libdevfile.ExecPreStopEvents(devfileObj, component.NewExecHandler(do.kubeClient, pod.Name, "", false))
+	err = libdevfile.ExecPreStopEvents(devfileObj, component.NewExecHandler(do.kubeClient, appName, componentName, pod.Name, "", false))
 	if err != nil {
 		klog.V(4).Infof("Failed to execute %q event commands for component %q, cause: %v", libdevfile.PreStop, componentName, err.Error())
 	}

pkg/component/delete/delete_test.go

@@ -560,7 +560,7 @@ func TestDeleteComponentClient_ExecutePreStopEvents(t *testing.T) {
 					selector := odolabels.GetSelector(componentName, "app", odolabels.ComponentDevMode)
 					client.EXPECT().GetOnePodFromSelector(selector).Return(odoTestingUtil.CreateFakePod(componentName, "runtime"), nil)
 
-					cmd := []string{"/bin/sh", "-c", "cd /projects/nodejs-starter && echo \"Hello World!\""}
+					cmd := []string{"/bin/sh", "-c", "cd /projects/nodejs-starter && (echo \"Hello World!\") 1>>/proc/1/fd/1 2>>/proc/1/fd/2"}
 					client.EXPECT().ExecCMDInContainer("runtime", "runtime", cmd, gomock.Any(), gomock.Any(), nil, false).Return(nil)
 
 					return client
@@ -598,9 +598,13 @@ func TestDeleteComponentClient_ExecutePreStopEvents(t *testing.T) {
 					client := kclient.NewMockClientInterface(ctrl)
 
 					selector := odolabels.GetSelector(componentName, "app", odolabels.ComponentDevMode)
-					client.EXPECT().GetOnePodFromSelector(selector).Return(odoTestingUtil.CreateFakePod(componentName, "runtime"), nil)
+					fakePod := odoTestingUtil.CreateFakePod(componentName, "runtime")
+					//Expecting this method to be called twice because if the command execution fails, we try to get the pod logs by calling GetOnePodFromSelector again.
+					client.EXPECT().GetOnePodFromSelector(selector).Return(fakePod, nil).Times(2)
+
+					client.EXPECT().GetPodLogs(fakePod.Name, gomock.Any(), gomock.Any()).Return(nil, errors.New("an error"))
 
-					cmd := []string{"/bin/sh", "-c", "cd /projects/nodejs-starter && echo \"Hello World!\""}
+					cmd := []string{"/bin/sh", "-c", "cd /projects/nodejs-starter && (echo \"Hello World!\") 1>>/proc/1/fd/1 2>>/proc/1/fd/2"}
 					client.EXPECT().ExecCMDInContainer("runtime", "runtime", cmd, gomock.Any(), gomock.Any(), nil, false).Return(errors.New("some error"))
 
 					return client

pkg/component/exec_handler.go

@@ -14,20 +14,24 @@ import (
 )
 
 type execHandler struct {
-	kubeClient kclient.ClientInterface
-	podName    string
-	msg        string
-	show       bool
+	kubeClient    kclient.ClientInterface
+	appName       string
+	componentName string
+	podName       string
+	msg           string
+	show          bool
 }
 
 const ShellExecutable string = "/bin/sh"
 
-func NewExecHandler(kubeClient kclient.ClientInterface, podName string, msg string, show bool) *execHandler {
+func NewExecHandler(kubeClient kclient.ClientInterface, appName, cmpName, podName, msg string, show bool) *execHandler {
 	return &execHandler{
-		kubeClient: kubeClient,
-		podName:    podName,
-		msg:        msg,
-		show:       show,
+		kubeClient:    kubeClient,
+		appName:       appName,
+		componentName: cmpName,
+		podName:       podName,
+		msg:           msg,
+		show:          show,
 	}
 }
 
@@ -43,6 +47,8 @@ func (o *execHandler) Execute(command v1alpha2.Command) error {
 	msg := o.msg
 	if msg == "" {
 		msg = fmt.Sprintf("Executing %s command %q on container %q", command.Id, command.Exec.CommandLine, command.Exec.Component)
+	} else {
+		msg += " (command: " + command.Id + ")"
 	}
 	spinner := log.Spinner(msg)
 	defer spinner.End(false)
@@ -56,6 +62,19 @@ func (o *execHandler) Execute(command v1alpha2.Command) error {
 	closeWriterAndWaitForAck(stdoutWriter, stdoutChannel, stderrWriter, stderrChannel)
 
 	spinner.End(err == nil)
+	if err != nil {
+		rd, errLog := Log(o.kubeClient, o.componentName, o.appName, false, command)
+		if errLog != nil {
+			return fmt.Errorf("unable to log error %v: %w", err, errLog)
+		}
+
+		// Use GetStderr in order to make sure that colour output is correct
+		// on non-TTY terminals
+		errLog = util.DisplayLog(false, rd, log.GetStderr(), o.componentName, -1)
+		if errLog != nil {
+			return fmt.Errorf("unable to log error %v: %w", err, errLog)
+		}
+	}
 	return err
 }
 
@@ -71,12 +90,16 @@ func getCmdline(command v1alpha2.Command) []string {
 	}
 
 	// Change to the workdir and execute the command
+	// Redirecting to /proc/1/fd/* allows to redirect the process output to the output streams of PID 1 process inside the container.
+	// This way, returning the container logs with 'odo logs' or 'kubectl logs' would work seamlessly.
+	// See https://stackoverflow.com/questions/58716574/where-exactly-do-the-logs-of-kubernetes-pods-come-from-at-the-container-level
+	redirectString := "1>>/proc/1/fd/1 2>>/proc/1/fd/2"
 	var cmd []string
 	if command.Exec.WorkingDir != "" {
 		// since we are using /bin/sh -c, the command needs to be within a single double quote instance, for example "cd /tmp && pwd"
-		cmd = []string{ShellExecutable, "-c", "cd " + command.Exec.WorkingDir + " && " + cmdLine}
+		cmd = []string{ShellExecutable, "-c", "cd " + command.Exec.WorkingDir + " && (" + cmdLine + ") " + redirectString}
 	} else {
-		cmd = []string{ShellExecutable, "-c", cmdLine}
+		cmd = []string{ShellExecutable, "-c", "(" + cmdLine + ") " + redirectString}
 	}
 	return cmd
 }

pkg/devfile/adapters/kubernetes/component/adapter.go

@@ -8,6 +8,7 @@ import (
 	"k8s.io/utils/pointer"
 
 	"github.com/devfile/library/pkg/devfile/generator"
+	devfileCommon "github.com/devfile/library/pkg/devfile/parser/data/v2/common"
 
 	"github.com/redhat-developer/odo/pkg/component"
 	"github.com/redhat-developer/odo/pkg/devfile"
@@ -298,7 +299,8 @@ func (a Adapter) Push(parameters common.PushParameters) (err error) {
 	// PostStart events from the devfile will only be executed when the component
 	// didn't previously exist
 	if !componentExists && libdevfile.HasPostStartEvents(a.Devfile) {
-		err = libdevfile.ExecPostStartEvents(a.Devfile, component.NewExecHandler(a.kubeClient, a.pod.Name, "", parameters.Show))
+		err = libdevfile.ExecPostStartEvents(a.Devfile,
+			component.NewExecHandler(a.kubeClient, a.AppName, a.ComponentName, a.pod.Name, "", parameters.Show))
 		if err != nil {
 			return err
 		}
@@ -316,20 +318,52 @@ func (a Adapter) Push(parameters common.PushParameters) (err error) {
 
 	cmdHandler := adapterHandler{
 		Adapter:         a,
-		cmdKind:         cmdKind,
 		parameters:      parameters,
 		componentExists: componentExists,
 	}
 
-	running, err := cmdHandler.isRemoteProcessForCommandRunning(cmd)
+	commandType, err := devfileCommon.GetCommandType(cmd)
 	if err != nil {
 		return err
 	}
+	var running bool
+	var isComposite bool
+	if commandType == devfilev1.ExecCommandType {
+		running, err = cmdHandler.isRemoteProcessForCommandRunning(cmd)
+		if err != nil {
+			return err
+		}
+	} else if commandType == devfilev1.CompositeCommandType {
+		//this handler will run each command in this composite command individually,
+		//and will determine whether each command is running or not.
+		isComposite = true
+	} else {
+		return fmt.Errorf("unsupported type %q for Devfile command %s, only exec and composite are handled",
+			commandType, cmd.Id)
+	}
 
 	klog.V(4).Infof("running=%v, execRequired=%v, parameters.RunModeChanged=%v",
 		running, execRequired, parameters.RunModeChanged)
 
-	if !running || execRequired || parameters.RunModeChanged {
+	if isComposite || !running || execRequired || parameters.RunModeChanged {
+		// Invoke the build command once (before calling libdevfile.ExecuteCommandByKind), as, if cmd is a composite command,
+		// the handler we pass will be called for each command in that composite command.
+		doExecuteBuildCommand := func() error {
+			execHandler := component.NewExecHandler(a.kubeClient, a.AppName, a.ComponentName, a.pod.Name,
+				"Building your application in container on cluster", parameters.Show)
+			return libdevfile.Build(a.Devfile, execHandler, true)
+		}
+		if componentExists {
+			if parameters.RunModeChanged || cmd.Exec == nil || !util.SafeGetBool(cmd.Exec.HotReloadCapable) {
+				if err = doExecuteBuildCommand(); err != nil {
+					return err
+				}
+			}
+		} else {
+			if err = doExecuteBuildCommand(); err != nil {
+				return err
+			}
+		}
 		err = libdevfile.ExecuteCommandByKind(a.Devfile, cmdKind, &cmdHandler, false)
 	}
 
@@ -382,7 +416,7 @@ func (a *Adapter) createOrUpdateComponent(componentExists bool, ei envinfo.EnvSp
 		return err
 	}
 
-	containers, err = utils.UpdateContainersEntrypointsIfNeeded(a.Devfile, containers, a.devfileRunCmd, a.devfileDebugCmd)
+	containers, err = utils.UpdateContainersEntrypointsIfNeeded(a.Devfile, containers, a.devfileBuildCmd, a.devfileRunCmd, a.devfileDebugCmd)
 	if err != nil {
 		return err
 	}

pkg/devfile/adapters/kubernetes/component/commandhandler.go

@@ -21,7 +21,6 @@ const numberOfLinesToOutputLog = 100
 
 type adapterHandler struct {
 	Adapter
-	cmdKind         devfilev1.CommandGroupKind
 	parameters      common.PushParameters
 	componentExists bool
 }
@@ -39,71 +38,56 @@ func (a *adapterHandler) ApplyKubernetes(_ devfilev1.Component) error {
 }
 
 func (a *adapterHandler) Execute(devfileCmd devfilev1.Command) error {
-	processName := "devrun"
-	if a.parameters.Debug {
-		processName = "debugrun"
-	}
-
-	doExecuteBuildCommand := func() error {
-		execHandler := component.NewExecHandler(a.kubeClient, a.pod.Name, "Building your application in container on cluster", a.parameters.Show)
-		return libdevfile.Build(a.Devfile, execHandler, true)
-	}
-
 	remoteProcessHandler := remotecmd.NewKubeExecProcessHandler()
 
-	startHandler := func(status remotecmd.RemoteProcessStatus, stdout []string, stderr []string, err error) {
-		switch status {
-		case remotecmd.Starting:
-			_ = log.SpinnerNoSpin("Executing the application")
-		case remotecmd.Stopped:
-			if err != nil {
-				klog.V(2).Infof("error while running background command: %v", err)
+	statusHandlerFunc := func(s *log.Status) remotecmd.CommandOutputHandler {
+		return func(status remotecmd.RemoteProcessStatus, stdout []string, stderr []string, err error) {
+			switch status {
+			case remotecmd.Starting:
+				// Creating with no spin because the command could be long-running, and we cannot determine when it will end.
+				s.Start(fmt.Sprintf("Executing the application (command: %s)", devfileCmd.Id), true)
+			case remotecmd.Stopped, remotecmd.Errored:
+				s.End(status == remotecmd.Stopped)
+				if err != nil {
+					klog.V(2).Infof("error while running background command: %v", err)
+				}
 			}
 		}
 	}
 
+	// Spinner created but not started yet.
+	// It will be displayed when the statusHandlerFunc function is called with the "Starting" state.
+	spinner := log.NewStatus(log.GetStdout())
+
 	// if we need to restart, issue the remote process handler command to stop all running commands first.
 	// We do not need to restart Hot reload capable commands.
 	if a.componentExists {
-		cmd, err := libdevfile.GetDefaultCommand(a.Devfile, a.cmdKind)
-		if err != nil {
-			return err
-		}
-
-		if a.parameters.RunModeChanged || cmd.Exec == nil || !util.SafeGetBool(cmd.Exec.HotReloadCapable) {
-			klog.V(2).Info("restart required for command")
+		if a.parameters.RunModeChanged || devfileCmd.Exec == nil || !util.SafeGetBool(devfileCmd.Exec.HotReloadCapable) {
+			klog.V(2).Infof("restart required for command %s", devfileCmd.Id)
 
 			cmdDef, err := devfileCommandToRemoteCmdDefinition(devfileCmd)
 			if err != nil {
 				return err
 			}
 
-			if err = doExecuteBuildCommand(); err != nil {
-				return err
-			}
-
 			err = remoteProcessHandler.StopProcessForCommand(cmdDef, a.kubeClient, a.pod.Name, devfileCmd.Exec.Component)
 			if err != nil {
 				return err
 			}
 
-			if err = remoteProcessHandler.StartProcessForCommand(cmdDef, a.kubeClient, a.pod.Name, devfileCmd.Exec.Component, startHandler); err != nil {
+			if err = remoteProcessHandler.StartProcessForCommand(cmdDef, a.kubeClient, a.pod.Name, devfileCmd.Exec.Component, statusHandlerFunc(spinner)); err != nil {
 				return err
 			}
 		} else {
-			klog.V(2).Infof("command is hot-reload capable, not restarting %s", processName)
+			klog.V(2).Infof("command is hot-reload capable, not restarting %s", devfileCmd.Id)
 		}
 	} else {
 		cmdDef, err := devfileCommandToRemoteCmdDefinition(devfileCmd)
 		if err != nil {
 			return err
 		}
 
-		if err := doExecuteBuildCommand(); err != nil {
-			return err
-		}
-
-		if err := remoteProcessHandler.StartProcessForCommand(cmdDef, a.kubeClient, a.pod.Name, devfileCmd.Exec.Component, startHandler); err != nil {
+		if err := remoteProcessHandler.StartProcessForCommand(cmdDef, a.kubeClient, a.pod.Name, devfileCmd.Exec.Component, statusHandlerFunc(spinner)); err != nil {
 			return err
 		}
 	}
@@ -120,8 +104,15 @@ func (a *adapterHandler) Execute(devfileCmd devfilev1.Command) error {
 
 	_, err := task.NewRetryable(fmt.Sprintf("process for command %q", devfileCmd.Id), func() (bool, interface{}, error) {
 		klog.V(4).Infof("checking if process for command %q is running", devfileCmd.Id)
-		isRunning, err := a.isRemoteProcessForCommandRunning(devfileCmd)
-		return err == nil && isRunning, isRunning, err
+		remoteProcess, err := remoteProcessHandler.GetProcessInfoForCommand(
+			remotecmd.CommandDefinition{Id: devfileCmd.Id}, a.kubeClient, a.pod.Name, devfileCmd.Exec.Component)
+		if err != nil {
+			return false, nil, err
+		}
+		isRunningOrDone := remoteProcess.Status == remotecmd.Running ||
+			remoteProcess.Status == remotecmd.Stopped ||
+			remoteProcess.Status == remotecmd.Errored
+		return isRunningOrDone, nil, err
 	}).RetryWithSchedule(retrySchedule, false)
 	if err != nil {
 		return err
@@ -165,12 +156,13 @@ func (a *adapterHandler) isRemoteProcessForCommandRunning(command devfilev1.Comm
 // checkRemoteCommandStatus checks if the command is running .
 // if the command is not in a running state, we fetch the last 20 lines of the component's log and display it
 func (a *adapterHandler) checkRemoteCommandStatus(command devfilev1.Command, notRunningMessage string) error {
-	running, err := a.isRemoteProcessForCommandRunning(command)
+	remoteProcessHandler := remotecmd.NewKubeExecProcessHandler()
+	remoteProcess, err := remoteProcessHandler.GetProcessInfoForCommand(remotecmd.CommandDefinition{Id: command.Id}, a.kubeClient, a.pod.Name, command.Exec.Component)
 	if err != nil {
 		return err
 	}
 
-	if !running {
+	if remoteProcess.Status != remotecmd.Running && remoteProcess.Status != remotecmd.Stopped {
 		log.Warningf(notRunningMessage)
 		log.Warningf("Last %d lines of log:", numberOfLinesToOutputLog)