feat: remote taskfile improvements (cache/expiry)

cmd/task/task.go

@@ -18,7 +18,6 @@ import (
 	"github.com/go-task/task/v3/internal/flags"
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/version"
-	"github.com/go-task/task/v3/taskfile"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
@@ -121,18 +120,9 @@ func run() error {
 		return err
 	}
 
-	// If the download flag is specified, we should stop execution as soon as
-	// taskfile is downloaded
-	if flags.Download {
-		return nil
-	}
-
 	if flags.ClearCache {
-		cache, err := taskfile.NewCache(e.TempDir.Remote)
-		if err != nil {
-			return err
-		}
-		return cache.Clear()
+		cachePath := filepath.Join(e.TempDir.Remote, "remote")
+		return os.RemoveAll(cachePath)
 	}
 
 	listOptions := task.NewListOptions(

cmd/tmp/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func main() {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond)
+	defer cancel()
+	if err := run(ctx); err != nil {
+		fmt.Println(ctx.Err())
+		fmt.Println(err)
+	}
+}
+
+func run(ctx context.Context) error {
+	req, err := http.NewRequest("GET", "https://taskfile.dev/schema.json", nil)
+	if err != nil {
+		fmt.Println(1)
+		return err
+	}
+
+	resp, err := http.DefaultClient.Do(req.WithContext(ctx))
+	if err != nil {
+		if ctx.Err() != nil {
+			fmt.Println(2)
+			return err
+		}
+		fmt.Println(3)
+		return err
+	}
+	defer resp.Body.Close()
+
+	return nil
+}

errors/errors_taskfile.go

@@ -155,19 +155,14 @@ func (err *TaskfileVersionCheckError) Code() int {
 // TaskfileNetworkTimeoutError is returned when the user attempts to use a remote
 // Taskfile but a network connection could not be established within the timeout.
 type TaskfileNetworkTimeoutError struct {
-	URI          string
-	Timeout      time.Duration
-	CheckedCache bool
+	URI     string
+	Timeout time.Duration
 }
 
 func (err *TaskfileNetworkTimeoutError) Error() string {
-	var cacheText string
-	if err.CheckedCache {
-		cacheText = " and no offline copy was found in the cache"
-	}
 	return fmt.Sprintf(
-		`task: Network connection timed out after %s while attempting to download Taskfile %q%s`,
-		err.Timeout, err.URI, cacheText,
+		`task: Network connection timed out after %s while attempting to download Taskfile %q`,
+		err.Timeout, err.URI,
 	)
 }
 

executor.go

@@ -26,26 +26,27 @@ type (
 	// within them.
 	Executor struct {
 		// Flags
-		Dir         string
-		Entrypoint  string
-		TempDir     TempDir
-		Force       bool
-		ForceAll    bool
-		Insecure    bool
-		Download    bool
-		Offline     bool
-		Timeout     time.Duration
-		Watch       bool
-		Verbose     bool
-		Silent      bool
-		AssumeYes   bool
-		AssumeTerm  bool // Used for testing
-		Dry         bool
-		Summary     bool
-		Parallel    bool
-		Color       bool
-		Concurrency int
-		Interval    time.Duration
+		Dir                 string
+		Entrypoint          string
+		TempDir             TempDir
+		Force               bool
+		ForceAll            bool
+		Insecure            bool
+		Download            bool
+		Offline             bool
+		Timeout             time.Duration
+		CacheExpiryDuration time.Duration
+		Watch               bool
+		Verbose             bool
+		Silent              bool
+		AssumeYes           bool
+		AssumeTerm          bool // Used for testing
+		Dry                 bool
+		Summary             bool
+		Parallel            bool
+		Color               bool
+		Concurrency         int
+		Interval            time.Duration
 
 		// I/O
 		Stdin  io.Reader
@@ -238,6 +239,20 @@ func (o *timeoutOption) ApplyToExecutor(e *Executor) {
 	e.Timeout = o.timeout
 }
 
+// WithCacheExpiryDuration sets the duration after which the cache is considered
+// expired. By default, the cache is considered expired after 24 hours.
+func WithCacheExpiryDuration(duration time.Duration) ExecutorOption {
+	return &cacheExpiryDurationOption{duration: duration}
+}
+
+type cacheExpiryDurationOption struct {
+	duration time.Duration
+}
+
+func (o *cacheExpiryDurationOption) ApplyToExecutor(r *Executor) {
+	r.CacheExpiryDuration = o.duration
+}
+
 // WithWatch tells the [Executor] to keep running in the background and watch
 // for changes to the fingerprint of the tasks that are run. When changes are
 // detected, a new task run is triggered.

internal/flags/flags.go

@@ -40,39 +40,40 @@ Options:
 `
 
 var (
-	Version     bool
-	Help        bool
-	Init        bool
-	Completion  string
-	List        bool
-	ListAll     bool
-	ListJson    bool
-	TaskSort    string
-	Status      bool
-	NoStatus    bool
-	Insecure    bool
-	Force       bool
-	ForceAll    bool
-	Watch       bool
-	Verbose     bool
-	Silent      bool
-	AssumeYes   bool
-	Dry         bool
-	Summary     bool
-	ExitCode    bool
-	Parallel    bool
-	Concurrency int
-	Dir         string
-	Entrypoint  string
-	Output      ast.Output
-	Color       bool
-	Interval    time.Duration
-	Global      bool
-	Experiments bool
-	Download    bool
-	Offline     bool
-	ClearCache  bool
-	Timeout     time.Duration
+	Version             bool
+	Help                bool
+	Init                bool
+	Completion          string
+	List                bool
+	ListAll             bool
+	ListJson            bool
+	TaskSort            string
+	Status              bool
+	NoStatus            bool
+	Insecure            bool
+	Force               bool
+	ForceAll            bool
+	Watch               bool
+	Verbose             bool
+	Silent              bool
+	AssumeYes           bool
+	Dry                 bool
+	Summary             bool
+	ExitCode            bool
+	Parallel            bool
+	Concurrency         int
+	Dir                 string
+	Entrypoint          string
+	Output              ast.Output
+	Color               bool
+	Interval            time.Duration
+	Global              bool
+	Experiments         bool
+	Download            bool
+	Offline             bool
+	ClearCache          bool
+	Timeout             time.Duration
+	CacheExpiryDuration time.Duration
 )
 
 func init() {
@@ -131,6 +132,7 @@ func init() {
 		pflag.BoolVar(&Offline, "offline", offline, "Forces Task to only use local or cached Taskfiles.")
 		pflag.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")
 		pflag.BoolVar(&ClearCache, "clear-cache", false, "Clear the remote cache.")
+		pflag.DurationVar(&CacheExpiryDuration, "expiry", 0, "Expiry duration for cached remote Taskfiles.")
 	}
 
 	pflag.Parse()
@@ -212,6 +214,7 @@ func (o *flagsOption) ApplyToExecutor(e *task.Executor) {
 		task.WithDownload(Download),
 		task.WithOffline(Offline),
 		task.WithTimeout(Timeout),
+		task.WithCacheExpiryDuration(CacheExpiryDuration),
 		task.WithWatch(Watch),
 		task.WithVerbose(Verbose),
 		task.WithSilent(Silent),

setup.go

@@ -64,6 +64,8 @@ func (e *Executor) getRootNode() (taskfile.Node, error) {
 }
 
 func (e *Executor) readTaskfile(node taskfile.Node) error {
+	ctx, cf := context.WithTimeout(context.Background(), e.Timeout)
+	defer cf()
 	debugFunc := func(s string) {
 		e.Logger.VerboseOutf(logger.Magenta, s)
 	}
@@ -74,13 +76,16 @@ func (e *Executor) readTaskfile(node taskfile.Node) error {
 		taskfile.WithInsecure(e.Insecure),
 		taskfile.WithDownload(e.Download),
 		taskfile.WithOffline(e.Offline),
-		taskfile.WithTimeout(e.Timeout),
 		taskfile.WithTempDir(e.TempDir.Remote),
+		taskfile.WithCacheExpiryDuration(e.CacheExpiryDuration),
 		taskfile.WithDebugFunc(debugFunc),
 		taskfile.WithPromptFunc(promptFunc),
 	)
-	graph, err := reader.Read(node)
+	graph, err := reader.Read(ctx, node)
 	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) {
+			return &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: e.Timeout}
+		}
 		return err
 	}
 	if e.Taskfile, err = graph.Merge(); err != nil {