mirror of
https://github.com/go-task/task.git
synced 2024-12-14 10:52:43 +02:00
0608782cfa
Add Preconditions to Tasks
333 lines
7.3 KiB
Go
333 lines
7.3 KiB
Go
package task
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"github.com/go-task/task/v2/internal/compiler"
|
|
compilerv1 "github.com/go-task/task/v2/internal/compiler/v1"
|
|
compilerv2 "github.com/go-task/task/v2/internal/compiler/v2"
|
|
"github.com/go-task/task/v2/internal/execext"
|
|
"github.com/go-task/task/v2/internal/logger"
|
|
"github.com/go-task/task/v2/internal/output"
|
|
"github.com/go-task/task/v2/internal/summary"
|
|
"github.com/go-task/task/v2/internal/taskfile"
|
|
"github.com/go-task/task/v2/internal/taskfile/read"
|
|
"github.com/go-task/task/v2/internal/taskfile/version"
|
|
|
|
"github.com/Masterminds/semver"
|
|
"golang.org/x/sync/errgroup"
|
|
)
|
|
|
|
const (
|
|
// MaximumTaskCall is the max number of times a task can be called.
|
|
// This exists to prevent infinite loops on cyclic dependencies
|
|
MaximumTaskCall = 100
|
|
)
|
|
|
|
// Executor executes a Taskfile
|
|
type Executor struct {
|
|
Taskfile *taskfile.Taskfile
|
|
Dir string
|
|
Force bool
|
|
Watch bool
|
|
Verbose bool
|
|
Silent bool
|
|
Dry bool
|
|
Summary bool
|
|
|
|
Stdin io.Reader
|
|
Stdout io.Writer
|
|
Stderr io.Writer
|
|
|
|
Logger *logger.Logger
|
|
Compiler compiler.Compiler
|
|
Output output.Output
|
|
OutputStyle string
|
|
|
|
taskvars taskfile.Vars
|
|
|
|
taskCallCount map[string]*int32
|
|
mkdirMutexMap map[string]*sync.Mutex
|
|
}
|
|
|
|
// Run runs Task
|
|
func (e *Executor) Run(ctx context.Context, calls ...taskfile.Call) error {
|
|
// check if given tasks exist
|
|
for _, c := range calls {
|
|
if _, ok := e.Taskfile.Tasks[c.Task]; !ok {
|
|
// FIXME: move to the main package
|
|
e.PrintTasksHelp()
|
|
return &taskNotFoundError{taskName: c.Task}
|
|
}
|
|
}
|
|
|
|
if e.Summary {
|
|
summary.PrintTasks(e.Logger, e.Taskfile, calls)
|
|
return nil
|
|
}
|
|
|
|
if e.Watch {
|
|
return e.watchTasks(calls...)
|
|
}
|
|
|
|
for _, c := range calls {
|
|
if err := e.RunTask(ctx, c); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Setup setups Executor's internal state
|
|
func (e *Executor) Setup() error {
|
|
var err error
|
|
e.Taskfile, err = read.Taskfile(e.Dir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
e.taskvars, err = read.Taskvars(e.Dir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
v, err := semver.NewConstraint(e.Taskfile.Version)
|
|
if err != nil {
|
|
return fmt.Errorf(`task: could not parse taskfile version "%s": %v`, e.Taskfile.Version, err)
|
|
}
|
|
|
|
if e.Stdin == nil {
|
|
e.Stdin = os.Stdin
|
|
}
|
|
if e.Stdout == nil {
|
|
e.Stdout = os.Stdout
|
|
}
|
|
if e.Stderr == nil {
|
|
e.Stderr = os.Stderr
|
|
}
|
|
e.Logger = &logger.Logger{
|
|
Stdout: e.Stdout,
|
|
Stderr: e.Stderr,
|
|
Verbose: e.Verbose,
|
|
}
|
|
switch {
|
|
case version.IsV1(v):
|
|
e.Compiler = &compilerv1.CompilerV1{
|
|
Dir: e.Dir,
|
|
Vars: e.taskvars,
|
|
Logger: e.Logger,
|
|
}
|
|
case version.IsV2(v), version.IsV21(v), version.IsV22(v), version.IsV23(v):
|
|
e.Compiler = &compilerv2.CompilerV2{
|
|
Dir: e.Dir,
|
|
Taskvars: e.taskvars,
|
|
TaskfileVars: e.Taskfile.Vars,
|
|
Expansions: e.Taskfile.Expansions,
|
|
Logger: e.Logger,
|
|
}
|
|
|
|
case version.IsV24(v):
|
|
return fmt.Errorf(`task: Taskfile versions greater than v2.4 not implemented in the version of Task`)
|
|
}
|
|
|
|
if !version.IsV21(v) && e.Taskfile.Output != "" {
|
|
return fmt.Errorf(`task: Taskfile option "output" is only available starting on Taskfile version v2.1`)
|
|
}
|
|
if !version.IsV22(v) && len(e.Taskfile.Includes) > 0 {
|
|
return fmt.Errorf(`task: Including Taskfiles is only available starting on Taskfile version v2.2`)
|
|
}
|
|
if e.OutputStyle != "" {
|
|
e.Taskfile.Output = e.OutputStyle
|
|
}
|
|
switch e.Taskfile.Output {
|
|
case "", "interleaved":
|
|
e.Output = output.Interleaved{}
|
|
case "group":
|
|
e.Output = output.Group{}
|
|
case "prefixed":
|
|
e.Output = output.Prefixed{}
|
|
default:
|
|
return fmt.Errorf(`task: output option "%s" not recognized`, e.Taskfile.Output)
|
|
}
|
|
|
|
if !version.IsV21(v) {
|
|
err := fmt.Errorf(`task: Taskfile option "ignore_error" is only available starting on Taskfile version v2.1`)
|
|
|
|
for _, task := range e.Taskfile.Tasks {
|
|
if task.IgnoreError {
|
|
return err
|
|
}
|
|
for _, cmd := range task.Cmds {
|
|
if cmd.IgnoreError {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
e.taskCallCount = make(map[string]*int32, len(e.Taskfile.Tasks))
|
|
e.mkdirMutexMap = make(map[string]*sync.Mutex, len(e.Taskfile.Tasks))
|
|
for k := range e.Taskfile.Tasks {
|
|
e.taskCallCount[k] = new(int32)
|
|
e.mkdirMutexMap[k] = &sync.Mutex{}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RunTask runs a task by its name
|
|
func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
|
|
t, err := e.CompiledTask(call)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !e.Watch && atomic.AddInt32(e.taskCallCount[call.Task], 1) >= MaximumTaskCall {
|
|
return &MaximumTaskCallExceededError{task: call.Task}
|
|
}
|
|
|
|
if err := e.runDeps(ctx, t); err != nil {
|
|
return err
|
|
}
|
|
|
|
if !e.Force {
|
|
preCondMet, err := e.areTaskPreconditionsMet(ctx, t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
upToDate, err := e.isTaskUpToDate(ctx, t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if upToDate && preCondMet {
|
|
if !e.Silent {
|
|
e.Logger.Errf(`task: Task "%s" is up to date`, t.Task)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
if err := e.mkdir(t); err != nil {
|
|
e.Logger.Errf("task: cannot make directory %q: %v", t.Dir, err)
|
|
}
|
|
|
|
for i := range t.Cmds {
|
|
if err := e.runCommand(ctx, t, call, i); err != nil {
|
|
if err2 := e.statusOnError(t); err2 != nil {
|
|
e.Logger.VerboseErrf("task: error cleaning status on error: %v", err2)
|
|
}
|
|
|
|
if execext.IsExitError(err) && t.IgnoreError {
|
|
e.Logger.VerboseErrf("task: task error ignored: %v", err)
|
|
continue
|
|
}
|
|
|
|
return &taskRunError{t.Task, err}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (e *Executor) mkdir(t *taskfile.Task) error {
|
|
if t.Dir == "" {
|
|
return nil
|
|
}
|
|
|
|
mutex := e.mkdirMutexMap[t.Task]
|
|
mutex.Lock()
|
|
defer mutex.Unlock()
|
|
|
|
if _, err := os.Stat(t.Dir); os.IsNotExist(err) {
|
|
if err := os.MkdirAll(t.Dir, 0755); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (e *Executor) runDeps(ctx context.Context, t *taskfile.Task) error {
|
|
g, ctx := errgroup.WithContext(ctx)
|
|
|
|
for _, d := range t.Deps {
|
|
d := d
|
|
|
|
g.Go(func() error {
|
|
err := e.RunTask(ctx, taskfile.Call{Task: d.Task, Vars: d.Vars})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
return g.Wait()
|
|
}
|
|
|
|
func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfile.Call, i int) error {
|
|
cmd := t.Cmds[i]
|
|
|
|
switch {
|
|
case cmd.Task != "":
|
|
err := e.RunTask(ctx, taskfile.Call{Task: cmd.Task, Vars: cmd.Vars})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
case cmd.Cmd != "":
|
|
if e.Verbose || (!cmd.Silent && !t.Silent && !e.Silent) {
|
|
e.Logger.Errf(cmd.Cmd)
|
|
}
|
|
|
|
if e.Dry {
|
|
return nil
|
|
}
|
|
|
|
stdOut := e.Output.WrapWriter(e.Stdout, t.Prefix)
|
|
stdErr := e.Output.WrapWriter(e.Stderr, t.Prefix)
|
|
defer func() {
|
|
if _, ok := stdOut.(*os.File); !ok {
|
|
if closer, ok := stdOut.(io.Closer); ok {
|
|
closer.Close()
|
|
}
|
|
}
|
|
if _, ok := stdErr.(*os.File); !ok {
|
|
if closer, ok := stdErr.(io.Closer); ok {
|
|
closer.Close()
|
|
}
|
|
}
|
|
}()
|
|
|
|
err := execext.RunCommand(ctx, &execext.RunCommandOptions{
|
|
Command: cmd.Cmd,
|
|
Dir: t.Dir,
|
|
Env: getEnviron(t),
|
|
Stdin: e.Stdin,
|
|
Stdout: stdOut,
|
|
Stderr: stdErr,
|
|
})
|
|
if execext.IsExitError(err) && cmd.IgnoreError {
|
|
e.Logger.VerboseErrf("task: command error ignored: %v", err)
|
|
return nil
|
|
}
|
|
return err
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func getEnviron(t *taskfile.Task) []string {
|
|
if t.Env == nil {
|
|
return nil
|
|
}
|
|
|
|
environ := os.Environ()
|
|
for k, v := range t.Env.ToStringMap() {
|
|
environ = append(environ, fmt.Sprintf("%s=%s", k, v))
|
|
}
|
|
return environ
|
|
}
|