Add an odo run command to manually execute command during odo dev

cmd/odo/help_test.go

@@ -34,6 +34,7 @@ Examples:
   init         Init bootstraps a new project
   logs         Show logs of all containers of the component
   registry     List all components from the Devfile registry
+  run          Run a specific command in the Dev mode
 
 `
 

pkg/component/component.go

@@ -94,11 +94,7 @@ func Log(platformClient platform.Client, componentName string, appName string, f
 
 	pod, err := platformClient.GetRunningPodFromSelector(odolabels.GetSelector(componentName, appName, odolabels.ComponentDevMode, false))
 	if err != nil {
-		return nil, fmt.Errorf("the component %s doesn't exist on the cluster", componentName)
-	}
-
-	if pod.Status.Phase != corev1.PodRunning {
-		return nil, fmt.Errorf("unable to show logs, component is not in running state. current status=%v", pod.Status.Phase)
+		return nil, fmt.Errorf("a running component %s doesn't exist on the cluster: %w", componentName, err)
 	}
 
 	containerName := command.Exec.Component

pkg/component/delete/delete.go

@@ -212,12 +212,6 @@ func (do *DeleteComponentClient) ExecutePreStopEvents(ctx context.Context, devfi
 		return fmt.Errorf("unable to determine if component %s exists; cause: %v", componentName, err.Error())
 	}
 
-	// do not fail Delete operation if if the pod is not running or if the event execution fails
-	if pod.Status.Phase != corev1.PodRunning {
-		klog.V(4).Infof("unable to execute preStop events, pod for component %q is not running", componentName)
-		return nil
-	}
-
 	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
 	handler := component.NewRunHandler(

pkg/component/delete/delete_test.go

@@ -700,25 +700,6 @@ func TestDeleteComponentClient_ExecutePreStopEvents(t *testing.T) {
 			},
 			wantErr: false,
 		},
-		{
-			name: "did not execute PreStopEvents because the pod is not in the running state",
-			fields: fields{
-				kubeClient: func(ctrl *gomock.Controller) kclient.ClientInterface {
-					client := kclient.NewMockClientInterface(ctrl)
-
-					selector := odolabels.GetSelector(componentName, "app", odolabels.ComponentDevMode, false)
-					pod := odoTestingUtil.CreateFakePod(componentName, "mypod", "runtime")
-					pod.Status.Phase = corev1.PodFailed
-					client.EXPECT().GetRunningPodFromSelector(selector).Return(pod, nil)
-					return client
-				},
-			},
-			args: args{
-				devfileObj: devfileObjWithPreStopEvents,
-				appName:    appName,
-			},
-			wantErr: false,
-		},
 		{
 			name: "failed to execute PreStopEvents because it failed to execute the command inside the container, but no error returned",
 			fields: fields{

pkg/dev/common/run.go

@@ -0,0 +1,53 @@
+package common
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/redhat-developer/odo/pkg/component"
+	"github.com/redhat-developer/odo/pkg/configAutomount"
+	"github.com/redhat-developer/odo/pkg/devfile/image"
+	"github.com/redhat-developer/odo/pkg/exec"
+	"github.com/redhat-developer/odo/pkg/libdevfile"
+	odocontext "github.com/redhat-developer/odo/pkg/odo/context"
+	"github.com/redhat-developer/odo/pkg/platform"
+	"github.com/redhat-developer/odo/pkg/testingutil/filesystem"
+)
+
+func Run(
+	ctx context.Context,
+	commandName string,
+	platformClient platform.Client,
+	execClient exec.Client,
+	configAutomountClient configAutomount.Client,
+	filesystem filesystem.Filesystem,
+) error {
+	var (
+		componentName = odocontext.GetComponentName(ctx)
+		devfileObj    = odocontext.GetEffectiveDevfileObj(ctx)
+		devfilePath   = odocontext.GetDevfilePath(ctx)
+	)
+
+	pod, err := platformClient.GetPodUsingComponentName(componentName)
+	if err != nil {
+		return fmt.Errorf("unable to get pod for component %s: %w. Please check the command 'odo dev' is running", componentName, err)
+	}
+
+	handler := component.NewRunHandler(
+		ctx,
+		platformClient,
+		execClient,
+		configAutomountClient,
+		pod.Name,
+		false,
+		component.GetContainersNames(pod),
+		"Executing command in container",
+
+		filesystem,
+		image.SelectBackend(ctx),
+		*devfileObj,
+		devfilePath,
+	)
+
+	return libdevfile.ExecuteCommandByName(ctx, *devfileObj, commandName, handler, false)
+}

pkg/dev/interface.go

@@ -48,6 +48,11 @@ type Client interface {
 		options StartOptions,
 	) error
 
+	Run(
+		ctx context.Context,
+		commandName string,
+	) error
+
 	// CleanupResources deletes the component created using the context's devfile and writes any outputs to out
 	CleanupResources(ctx context.Context, out io.Writer) error
 }

pkg/dev/kubedev/run.go

@@ -0,0 +1,23 @@
+package kubedev
+
+import (
+	"context"
+
+	"github.com/redhat-developer/odo/pkg/dev/common"
+	"k8s.io/klog"
+)
+
+func (o *DevClient) Run(
+	ctx context.Context,
+	commandName string,
+) error {
+	klog.V(4).Infof("running command %q on cluster", commandName)
+	return common.Run(
+		ctx,
+		commandName,
+		o.kubernetesClient,
+		o.execClient,
+		o.configAutomountClient,
+		o.filesystem,
+	)
+}

pkg/dev/podmandev/run.go

@@ -0,0 +1,23 @@
+package podmandev
+
+import (
+	"context"
+
+	"github.com/redhat-developer/odo/pkg/dev/common"
+	"k8s.io/klog"
+)
+
+func (o *DevClient) Run(
+	ctx context.Context,
+	commandName string,
+) error {
+	klog.V(4).Infof("running command %q on podman", commandName)
+	return common.Run(
+		ctx,
+		commandName,
+		o.podmanClient,
+		o.execClient,
+		nil, // TODO(feloy) set when running on new container is supported on podman
+		o.fs,
+	)
+}

pkg/exec/exec_test.go

@@ -44,6 +44,10 @@ func (o fakePlatform) GetRunningPodFromSelector(selector string) (*corev1.Pod, e
 	panic("not implemented yet")
 }
 
+func (o fakePlatform) GetPodUsingComponentName(componentName string) (*corev1.Pod, error) {
+	panic("not implemented yet")
+}
+
 func TestExecuteCommand(t *testing.T) {
 	for _, tt := range []struct {
 		name               string

pkg/libdevfile/errors.go

@@ -22,6 +22,9 @@ func (e NoCommandFoundError) Error() string {
 	if e.name == "" {
 		return fmt.Sprintf("no %s command found in devfile", e.kind)
 	}
+	if e.kind == "" {
+		return fmt.Sprintf("no command named %q found in devfile", e.name)
+	}
 	return fmt.Sprintf("no %s command with name %q found in Devfile", e.kind, e.name)
 }
 

pkg/libdevfile/libdevfile.go

@@ -66,6 +66,25 @@ func ExecuteCommandByNameAndKind(ctx context.Context, devfileObj parser.DevfileO
 	return executeCommand(ctx, devfileObj, cmd, handler)
 }
 
+// ExecuteCommandByName executes the specified command cmdName in the Devfile.
+// If ignoreCommandNotFound is true, nothing is executed if the command is not found and no error is returned.
+func ExecuteCommandByName(ctx context.Context, devfileObj parser.DevfileObj, cmdName string, handler Handler, ignoreCommandNotFound bool) error {
+	commands, err := devfileObj.Data.GetCommands(
+		common.DevfileOptions{
+			FilterByName: cmdName,
+		},
+	)
+	if err != nil {
+		return err
+	}
+	if len(commands) != 1 {
+		return NewNoCommandFoundError("", cmdName)
+	}
+
+	cmd := commands[0]
+	return executeCommand(ctx, devfileObj, cmd, handler)
+}
+
 // executeCommand executes a specific command of a devfile using handler as backend
 func executeCommand(ctx context.Context, devfileObj parser.DevfileObj, command v1alpha2.Command, handler Handler) error {
 	cmd, err := newCommand(devfileObj, command)

pkg/odo/cli/cli.go

@@ -10,6 +10,7 @@ import (
 	"unicode"
 
 	"github.com/redhat-developer/odo/pkg/odo/cli/logs"
+	"github.com/redhat-developer/odo/pkg/odo/cli/run"
 	"github.com/redhat-developer/odo/pkg/odo/commonflags"
 
 	"github.com/redhat-developer/odo/pkg/log"
@@ -195,6 +196,7 @@ func odoRootCmd(ctx context.Context, name, fullName string) *cobra.Command {
 		set.NewCmdSet(set.RecommendedCommandName, util.GetFullName(fullName, set.RecommendedCommandName)),
 		logs.NewCmdLogs(logs.RecommendedCommandName, util.GetFullName(fullName, logs.RecommendedCommandName)),
 		completion.NewCmdCompletion(completion.RecommendedCommandName, util.GetFullName(fullName, completion.RecommendedCommandName)),
+		run.NewCmdRun(run.RecommendedCommandName, util.GetFullName(fullName, run.RecommendedCommandName)),
 	)
 
 	// Add all subcommands to base commands

pkg/odo/cli/errors/errors.go

@@ -19,6 +19,20 @@ func (o NoCommandInDevfileError) Error() string {
 	return fmt.Sprintf("no command of kind %q found in the devfile", o.command)
 }
 
+type NoCommandNameInDevfileError struct {
+	name string
+}
+
+func NewNoCommandNameInDevfileError(name string) NoCommandNameInDevfileError {
+	return NoCommandNameInDevfileError{
+		name: name,
+	}
+}
+
+func (o NoCommandNameInDevfileError) Error() string {
+	return fmt.Sprintf("no command named %q found in the devfile", o.name)
+}
+
 type Warning struct {
 	msg string
 	err error