64: add entrypoint option allowed to run direct container command

app.go

@@ -35,6 +35,8 @@ type appImpl struct {
 	mFS        []ManagedFS
 }
 
+const versionFlag = "--version"
+
 // getPluginByType returns specific plugins from the app.
 func getPluginByType[T Plugin](app *appImpl) []T {
 	plugins := app.pluginMngr.All()
@@ -143,7 +145,7 @@ func (app *appImpl) init() error {
 	// Skip discover actions if we check version.
 	args := os.Args[1:]
 	for i := 0; i < len(args); i++ {
-		if args[i] == "--version" {
+		if args[i] == versionFlag {
 			return nil
 		}
 	}
@@ -181,7 +183,7 @@ func (app *appImpl) exec() error {
 	var skipActions bool // skipActions to skip loading if not requested.
 	var reqCmd string    // reqCmd to search for the requested cobra command.
 	for i := 0; i < len(args); i++ {
-		if args[i] == "--version" {
+		if args[i] == versionFlag {
 			rootCmd.SetVersionTemplate(Version().Full())
 			skipActions = true
 		}

docs/actions.md

@@ -103,6 +103,8 @@ Global Flags:
 
 ### Container environment flags
 
+ * `--entrypoint`      Entrypoint: Overwrite the default ENTRYPOINT of the image
+ * `--exec`            Exec: Overwrite CMD definition of the container
  * `--no-cache`        No cache: Send command to build container without cache
  * `--remove-image`    Remove Image: Remove an image after execution of action
  * `--use-volume-wd`   Use volume as a WD: Copy the working directory to a container volume and not bind local paths. Usually used with remote environments.

pkg/action/action.go

@@ -41,9 +41,10 @@ type Action struct {
 
 // Input is a container for action input arguments and options.
 type Input struct {
-	Args TypeArgs
-	Opts TypeOpts
-	IO   cli.Streams // @todo should it be in Input?
+	Args    TypeArgs
+	Opts    TypeOpts
+	IO      cli.Streams // @todo should it be in Input?
+	ArgsRaw []string
 }
 
 type (
@@ -145,7 +146,7 @@ func (a *Action) SetInput(input Input) (err error) {
 		return err
 	}
 	// @todo disabled for now until fully tested.
-	//if err = a.ValidateInput(input); err != nil {
+	//if err = a.validateJSONSchema(input); err != nil {
 	//	return err
 	//}
 
@@ -165,6 +166,7 @@ func (a *Action) SetInput(input Input) (err error) {
 	return a.EnsureLoaded()
 }
 
+// validateJSONSchema validates arguments and options according to
 func (a *Action) processOptions(opts TypeOpts) error {
 	for _, optDef := range a.ActionDef().Options {
 		if _, ok := opts[optDef.Name]; !ok {
@@ -233,10 +235,10 @@ func (a *Action) processValue(value interface{}, valueType jsonschema.Type, toAp
 	return newValue, nil
 }
 
-// ValidateInput validates arguments and options according to
+// validateJSONSchema validates arguments and options according to
 // a specified json schema in action definition.
 // @todo move to jsonschema
-func (a *Action) ValidateInput(inp Input) error {
+func (a *Action) validateJSONSchema(inp Input) error {
 	jsch := a.JSONSchema()
 	// @todo cache jsonschema and resources.
 	b, err := json.Marshal(jsch)
@@ -264,6 +266,17 @@ func (a *Action) ValidateInput(inp Input) error {
 	return nil
 }
 
+// ValidateInput validates input arguments in action definition.
+func (a *Action) ValidateInput(args TypeArgs) error {
+	argsInitNum := len(a.ActionDef().Arguments)
+	argsInputNum := len(args)
+	if argsInitNum != argsInputNum {
+		return fmt.Errorf("expected (%d) arg(s), provided (%d) arg(s)", argsInitNum, argsInputNum)
+	}
+
+	return nil
+}
+
 // Execute runs action in the specified environment.
 func (a *Action) Execute(ctx context.Context) error {
 	// @todo maybe it shouldn't be here.

pkg/action/action_test.go

@@ -44,7 +44,7 @@ func Test_Action(t *testing.T) {
 		"optarr": []interface{}{"opt5.1val", "opt5.2val"},
 		"opt6":   "unexpectedOpt",
 	}
-	err = act.SetInput(Input{inputArgs, inputOpts, nil})
+	err = act.SetInput(Input{inputArgs, inputOpts, nil, nil})
 	assert.NoError(err)
 	assert.Equal(inputArgs, act.input.Args)
 	assert.Equal(inputOpts, act.input.Opts)

pkg/action/cobra.go

@@ -23,28 +23,37 @@ func CobraImpl(a *Action, streams cli.Streams) (*cobra.Command, error) {
 	options := make(TypeOpts)
 	runOpts := make(TypeOpts)
 	cmd := &cobra.Command{
-		Use:  use,
-		Args: cobra.ExactArgs(len(argsDef)),
+		Use: use,
+		// Using custom args validation in ValidateInput.
 		// @todo: maybe we need a long template for arguments description
 		Short: getDesc(actConf.Title, actConf.Description),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cmd.SilenceUsage = true // Don't show usage help on a runtime error.
 			// Pass to the run environment its flags.
 			if env, ok := a.env.(RunEnvironmentFlags); ok {
+				runOpts = filterFlags(cmd, runOpts)
 				err := env.UseFlags(derefOpts(runOpts))
 				if err != nil {
 					return err
 				}
 			}
+
 			// Set action input.
-			err := a.SetInput(Input{
-				Args: argsToMap(args, argsDef),
-				Opts: derefOpts(options),
-				IO:   streams,
-			})
-			if err != nil {
+			input := Input{
+				Args:    argsToMap(args, argsDef),
+				Opts:    derefOpts(options),
+				IO:      streams,
+				ArgsRaw: args,
+			}
+			if runEnv, ok := a.env.(RunEnvironmentFlags); ok {
+				if err := runEnv.ValidateInput(a, input.Args); err != nil {
+					return err
+				}
+			}
+			if err := a.SetInput(input); err != nil {
 				return err
 			}
+
 			// @todo can we use action manager here and Manager.Run()
 			return a.Execute(cmd.Context())
 		},
@@ -66,6 +75,17 @@ func CobraImpl(a *Action, streams cli.Streams) (*cobra.Command, error) {
 	return cmd, nil
 }
 
+func filterFlags(cmd *cobra.Command, opts TypeOpts) TypeOpts {
+	filtered := make(TypeOpts)
+	for name, flag := range opts {
+		// Filter options not set.
+		if opts[name] != nil && cmd.Flags().Changed(name) {
+			filtered[name] = flag
+		}
+	}
+	return filtered
+}
+
 func setCobraOptions(cmd *cobra.Command, defs OptionsList, opts TypeOpts) error {
 	for _, opt := range defs {
 		v, err := setFlag(cmd, opt)

pkg/action/env.container.go

@@ -32,6 +32,8 @@ const (
 	containerFlagUseVolumeWD = "use-volume-wd"
 	containerFlagRemoveImage = "remove-image"
 	containerFlagNoCache     = "no-cache"
+	containerFlagEntrypoint  = "entrypoint"
+	containerFlagExec        = "exec"
 )
 
 type containerEnv struct {
@@ -44,9 +46,12 @@ type containerEnv struct {
 	nameprv  ContainerNameProvider
 
 	// Runtime flags
-	useVolWD  bool
-	removeImg bool
-	noCache   bool
+	useVolWD      bool
+	removeImg     bool
+	noCache       bool
+	entrypoint    string
+	entrypointSet bool
+	exec          bool
 }
 
 // ContainerNameProvider provides an ability to generate a random container name
@@ -99,6 +104,20 @@ func (c *containerEnv) FlagsDefinition() OptionsList {
 			Type:        jsonschema.Boolean,
 			Default:     false,
 		},
+		&Option{
+			Name:        containerFlagEntrypoint,
+			Title:       "Image Entrypoint",
+			Description: "Overwrite the default ENTRYPOINT of the image",
+			Type:        jsonschema.String,
+			Default:     "",
+		},
+		&Option{
+			Name:        containerFlagExec,
+			Title:       "Exec command",
+			Description: "Overwrite CMD definition of the container",
+			Type:        jsonschema.Boolean,
+			Default:     false,
+		},
 	}
 }
 
@@ -115,9 +134,25 @@ func (c *containerEnv) UseFlags(flags TypeOpts) error {
 		c.noCache = nc.(bool)
 	}
 
+	if e, ok := flags[containerFlagEntrypoint]; ok {
+		c.entrypointSet = true
+		c.entrypoint = e.(string)
+	}
+
+	if ex, ok := flags[containerFlagExec]; ok {
+		c.exec = ex.(bool)
+	}
+
 	return nil
 }
+func (c *containerEnv) ValidateInput(a *Action, args TypeArgs) error {
+	if c.exec {
+		return nil
+	}
 
+	// Check arguments if no exec flag present.
+	return a.ValidateInput(args)
+}
 func (c *containerEnv) AddImageBuildResolver(r ImageBuildResolver)            { c.imgres = append(c.imgres, r) }
 func (c *containerEnv) SetImageBuildCacheResolver(s *ImageBuildCacheResolver) { c.imgccres = s }
 func (c *containerEnv) SetContainerNameProvider(p ContainerNameProvider)      { c.nameprv = p }
@@ -151,6 +186,12 @@ func (c *containerEnv) Execute(ctx context.Context, a *Action) (err error) {
 		autoRemove = false
 	}
 
+	// Add entrypoint command option.
+	var entrypoint []string
+	if c.entrypointSet {
+		entrypoint = []string{c.entrypoint}
+	}
+
 	// Create container.
 	runConfig := &types.ContainerCreateOptions{
 		ContainerName: name,
@@ -164,6 +205,7 @@ func (c *containerEnv) Execute(ctx context.Context, a *Action) (err error) {
 		Tty:           streams.In().IsTerminal(),
 		Env:           actConf.Env,
 		User:          getCurrentUser(),
+		Entrypoint:    entrypoint,
 	}
 	log.Debug("Creating a container for action %q", a.ID)
 	cid, err := c.containerCreate(ctx, a, runConfig)
@@ -428,6 +470,12 @@ func (c *containerEnv) containerCreate(ctx context.Context, a *Action, opts *typ
 
 	// Create a container
 	actConf := a.ActionDef()
+
+	// Override Cmd with exec command.
+	if c.exec {
+		actConf.Command = a.GetInput().ArgsRaw
+	}
+
 	createOpts := types.ContainerCreateOptions{
 		ContainerName: opts.ContainerName,
 		Image:         actConf.Image,
@@ -444,6 +492,7 @@ func (c *containerEnv) containerCreate(ctx context.Context, a *Action, opts *typ
 		Tty:           opts.Tty,
 		Env:           opts.Env,
 		User:          opts.User,
+		Entrypoint:    opts.Entrypoint,
 	}
 
 	if c.useVolWD {

pkg/action/env.container_test.go

@@ -707,7 +707,7 @@ func Test_ContainerExec(t *testing.T) {
 			resCh, errCh := make(chan types.ContainerWaitResponse, 1), make(chan error, 1)
 			assert, ctrl, d, r := prepareContainerTestSuite(t)
 			a := act.Clone()
-			err := a.SetInput(Input{nil, nil, cli.NoopStreams()})
+			err := a.SetInput(Input{nil, nil, cli.NoopStreams(), nil})
 			assert.NoError(err)
 			defer ctrl.Finish()
 			defer r.Close()

pkg/action/env.go

@@ -40,6 +40,8 @@ type RunEnvironmentFlags interface {
 	FlagsDefinition() OptionsList
 	// UseFlags sets environment configuration.
 	UseFlags(flags TypeOpts) error
+	// ValidateInput validates input arguments in action definition.
+	ValidateInput(a *Action, args TypeArgs) error
 }
 
 // ContainerRunEnvironment is an interface for container run environments.

pkg/action/loader_test.go

@@ -46,7 +46,7 @@ func Test_InputProcessor(t *testing.T) {
 	act := testLoaderAction()
 	ctx := LoadContext{Action: act}
 	proc := inputProcessor{}
-	err := act.SetInput(Input{TypeArgs{"arg1": "arg1"}, TypeOpts{"optStr": "optVal1", "opt-str": "opt-val2"}, nil})
+	err := act.SetInput(Input{TypeArgs{"arg1": "arg1"}, TypeOpts{"optStr": "optVal1", "opt-str": "opt-val2"}, nil, nil})
 	assert.NoError(t, err)
 
 	s := "{{ .arg1 }},{{ .optStr }},{{ .opt_str }}"
@@ -72,7 +72,7 @@ func Test_YamlTplCommentsProcessor(t *testing.T) {
 		escapeYamlTplCommentsProcessor{},
 		inputProcessor{},
 	)
-	err := act.SetInput(Input{TypeArgs{"arg1": "arg1"}, TypeOpts{"optStr": "optVal1"}, nil})
+	err := act.SetInput(Input{TypeArgs{"arg1": "arg1"}, TypeOpts{"optStr": "optVal1"}, nil, nil})
 	assert.NoError(t, err)
 	// Check the commented strings are not considered.
 	s := `
@@ -100,7 +100,7 @@ func Test_PipeProcessor(t *testing.T) {
 	)
 
 	_ = os.Setenv("TEST_ENV1", "VAL1")
-	err := act.SetInput(Input{TypeArgs{"arg1": "arg1"}, TypeOpts{"optStr": "optVal1"}, nil})
+	err := act.SetInput(Input{TypeArgs{"arg1": "arg1"}, TypeOpts{"optStr": "optVal1"}, nil, nil})
 	assert.NoError(t, err)
 	s := "$TEST_ENV1,{{ .arg1 }},{{ .optStr }}"
 	res, err := proc.Process(ctx, []byte(s))

pkg/driver/docker.go

@@ -136,6 +136,7 @@ func (d *dockerDriver) ContainerCreate(ctx context.Context, opts types.Container
 			Env:          opts.Env,
 			User:         opts.User,
 			Volumes:      opts.Volumes,
+			Entrypoint:   opts.Entrypoint,
 		},
 		hostCfg,
 		nil, nil, opts.ContainerName,

pkg/types/container.go

@@ -134,6 +134,7 @@ type ContainerCreateOptions struct {
 	Tty           bool
 	Env           []string
 	User          string
+	Entrypoint    []string
 }
 
 // ContainerStartOptions stores options for starting a container.