Docker Proof-of-Concept

Taskfile.yml

@@ -107,3 +107,14 @@ tasks:
     cmds:
       - echo '{{.GO_PACKAGES}}'
     silent: true
+
+  d:
+    container:
+      image: alpine
+      flags: [--cpus=1]
+    env:
+      MESSAGE: Hello
+    cmds:
+      - echo $MESSAGE 1
+      - echo $MESSAGE 2
+      - echo $MESSAGE 3

internal/container/docker/docker.go

@@ -0,0 +1,53 @@
+package docker
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/go-task/task/v3/internal/execext"
+)
+
+type Docker struct {
+	DockerCli string
+	Image     string
+	Flags     []string
+	Env       map[string]string
+
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+func (d *Docker) Setup() error {
+	if d.DockerCli == "" {
+		d.DockerCli = "docker"
+	}
+	return nil
+}
+
+func (d *Docker) Exec(ctx context.Context, cmd string) error {
+	dockerArgs := []string{"run"}
+
+	for k, v := range d.Env {
+		dockerArgs = append(dockerArgs, "--env", fmt.Sprintf("%s=%s", k, v))
+	}
+
+	dockerArgs = append(dockerArgs, d.Flags...)
+	dockerArgs = append(dockerArgs, d.Image, "sh", "-c", cmd)
+
+	shCmd, err := execext.Build(d.DockerCli, dockerArgs...)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("DOCKER: %s\n", shCmd)
+
+	return execext.RunCommand(ctx, &execext.RunCommandOptions{
+		Command: shCmd,
+		Dir:     "", // TODO(@andreynering): Implement this
+		Stdin:   d.Stdin,
+		Stdout:  d.Stdout,
+		Stderr:  d.Stderr,
+	})
+}

internal/execext/builder.go

@@ -0,0 +1,22 @@
+package execext
+
+import (
+	"fmt"
+	"strings"
+
+	"mvdan.cc/sh/v3/syntax"
+)
+
+func Build(cmd string, args ...string) (string, error) {
+	quotedArgs := make([]string, 0, len(args))
+
+	for _, arg := range args {
+		quoted, err := syntax.Quote(arg, syntax.LangBash)
+		if err != nil {
+			return "", err
+		}
+		quotedArgs = append(quotedArgs, quoted)
+	}
+
+	return fmt.Sprintf("%s %s", cmd, strings.Join(quotedArgs, " ")), nil
+}

task.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/go-task/task/v3/internal/compiler"
+	"github.com/go-task/task/v3/internal/container/docker"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/output"
@@ -127,6 +128,7 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 	if err != nil {
 		return err
 	}
+
 	if !e.Watch && atomic.AddInt32(e.taskCallCount[t.Task], 1) >= MaximumTaskCall {
 		return &MaximumTaskCallExceededError{task: t.Task}
 	}
@@ -251,6 +253,20 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 			return err
 		}
 		return nil
+	case t.Container != nil:
+		d := docker.Docker{
+			Image: t.Container.Image,
+			Env:   t.Env.ToStringMap(),
+			Flags: t.Container.Flags,
+
+			Stdin:  e.Stdin,
+			Stdout: e.Stdout,
+			Stderr: e.Stderr,
+		}
+		if err := d.Setup(); err != nil {
+			return err
+		}
+		return d.Exec(ctx, cmd.Cmd)
 	case cmd.Cmd != "":
 		if e.Verbose || (!cmd.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {
 			e.Logger.Errf(logger.Green, "task: [%s] %s", t.Name(), cmd.Cmd)

taskfile/container.go

@@ -0,0 +1,7 @@
+package taskfile
+
+type Container struct {
+	Type  string
+	Image string
+	Flags []string
+}

taskfile/task.go

@@ -33,6 +33,7 @@ type Task struct {
 	Prefix               string
 	IgnoreError          bool
 	Run                  string
+	Container            *Container
 	IncludeVars          *Vars
 	IncludedTaskfileVars *Vars
 	IncludedTaskfile     *IncludedTaskfile
@@ -90,6 +91,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 			Prefix        string
 			IgnoreError   bool `yaml:"ignore_error"`
 			Run           string
+			Container     *Container
 		}
 		if err := node.Decode(&task); err != nil {
 			return err
@@ -115,6 +117,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 		t.Prefix = task.Prefix
 		t.IgnoreError = task.IgnoreError
 		t.Run = task.Run
+		t.Container = task.Container
 		return nil
 	}
 

taskfile/taskfile.go

@@ -22,6 +22,7 @@ type Taskfile struct {
 	Dotenv     []string
 	Run        string
 	Interval   time.Duration
+	Container  *Container
 }
 
 func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
@@ -41,6 +42,7 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 			Dotenv     []string
 			Run        string
 			Interval   time.Duration
+			Container  *Container
 		}
 		if err := node.Decode(&taskfile); err != nil {
 			return err
@@ -57,6 +59,7 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 		tf.Dotenv = taskfile.Dotenv
 		tf.Run = taskfile.Run
 		tf.Interval = taskfile.Interval
+		tf.Container = taskfile.Container
 		if tf.Expansions <= 0 {
 			tf.Expansions = 2
 		}

taskfile/var.go

@@ -84,6 +84,7 @@ func (vs *Vars) Range(yield func(key string, value Var) error) error {
 // variables
 func (vs *Vars) ToCacheMap() (m map[string]interface{}) {
 	m = make(map[string]interface{}, vs.Len())
+
 	_ = vs.Range(func(k string, v Var) error {
 		if v.Sh != "" {
 			// Dynamic variable is not yet resolved; trigger
@@ -98,6 +99,20 @@ func (vs *Vars) ToCacheMap() (m map[string]interface{}) {
 		}
 		return nil
 	})
+
+	return
+}
+
+func (vs *Vars) ToStringMap() (m map[string]string) {
+	m = make(map[string]string, vs.Len())
+
+	_ = vs.Range(func(k string, v Var) error {
+		if v.Static != "" {
+			m[k] = v.Static
+		}
+		return nil
+	})
+
 	return
 }
 

variables.go

@@ -68,6 +68,7 @@ func (e *Executor) compiledTask(call taskfile.Call, evaluateShVars bool) (*taskf
 		Run:                  r.Replace(origTask.Run),
 		IncludeVars:          origTask.IncludeVars,
 		IncludedTaskfileVars: origTask.IncludedTaskfileVars,
+		Container:            origTask.Container,
 	}
 	new.Dir, err = execext.Expand(new.Dir)
 	if err != nil {