feat: --download and --offline flags for remote taskfiles

Author: pd93

cmd/task/task.go

@@ -72,6 +72,8 @@ var flags struct {
 	interval    time.Duration
 	global      bool
 	experiments bool
+	download    bool
+	offline     bool
 }
 
 func main() {
@@ -142,6 +144,12 @@ func run() error {
 		pflag.BoolVarP(&flags.forceAll, "force", "f", false, "Forces execution even when the task is up-to-date.")
 	}
 
+	// Remote Taskfiles experiment will adds the "download" and "offline" flags
+	if experiments.RemoteTaskfiles {
+		pflag.BoolVar(&flags.download, "download", false, "Downloads a cached version of a remote Taskfile.")
+		pflag.BoolVar(&flags.offline, "offline", false, "Forces Task to only use local or cached Taskfiles.")
+	}
+
 	pflag.Parse()
 
 	if flags.version {
@@ -175,6 +183,10 @@ func run() error {
 		return nil
 	}
 
+	if flags.download && flags.offline {
+		return errors.New("task: You can't set both --download and --offline flags")
+	}
+
 	if flags.global && flags.dir != "" {
 		log.Fatal("task: You can't set both --global and --dir")
 		return nil
@@ -219,6 +231,8 @@ func run() error {
 		Force:       flags.force,
 		ForceAll:    flags.forceAll,
 		Insecure:    flags.insecure,
+		Download:    flags.download,
+		Offline:     flags.offline,
 		Watch:       flags.watch,
 		Verbose:     flags.verbose,
 		Silent:      flags.silent,

errors/errors.go

@@ -16,6 +16,7 @@ const (
 	CodeTaskfileFetchFailed
 	CodeTaskfileNotTrusted
 	CodeTaskfileNotSecure
+	CodeTaskfileCacheNotFound
 )
 
 // Task related exit codes

errors/errors_taskfile.go

@@ -103,3 +103,20 @@ func (err *TaskfileNotSecureError) Error() string {
 func (err *TaskfileNotSecureError) Code() int {
 	return CodeTaskfileNotSecure
 }
+
+// TaskfileCacheNotFound is returned when the user attempts to use an offline
+// (cached) Taskfile but the files does not exist in the cache.
+type TaskfileCacheNotFound struct {
+	URI string
+}
+
+func (err *TaskfileCacheNotFound) Error() string {
+	return fmt.Sprintf(
+		`task: Taskfile %q was not found in the cache. Remove the --offline flag to use a remote copy or download it using the --download flag`,
+		err.URI,
+	)
+}
+
+func (err *TaskfileCacheNotFound) Code() int {
+	return CodeTaskfileCacheNotFound
+}

setup.go

@@ -73,10 +73,17 @@ func (e *Executor) setCurrentDir() error {
 
 func (e *Executor) readTaskfile() error {
 	var err error
-	e.Taskfile, err = read.Taskfile(&read.FileNode{
-		Dir:        e.Dir,
-		Entrypoint: e.Entrypoint,
-	}, e.Insecure, e.TempDir, e.Logger)
+	e.Taskfile, err = read.Taskfile(
+		&read.FileNode{
+			Dir:        e.Dir,
+			Entrypoint: e.Entrypoint,
+		},
+		e.Insecure,
+		e.Download,
+		e.Offline,
+		e.TempDir,
+		e.Logger,
+	)
 	if err != nil {
 		return err
 	}

task.go

@@ -52,6 +52,8 @@ type Executor struct {
 	Force       bool
 	ForceAll    bool
 	Insecure    bool
+	Download    bool
+	Offline     bool
 	Watch       bool
 	Verbose     bool
 	Silent      bool

taskfile/read/cache.go

@@ -0,0 +1,58 @@
+package read
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+type Cache struct {
+	dir string
+}
+
+func NewCache(dir string) (*Cache, error) {
+	dir = filepath.Join(dir, "remote")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return nil, err
+	}
+	return &Cache{
+		dir: dir,
+	}, nil
+}
+
+func (c *Cache) checksum(b []byte) string {
+	h := sha256.New()
+	h.Write(b)
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func (c *Cache) write(node Node, b []byte) error {
+	return os.WriteFile(c.cacheFilePath(node), b, 0o644)
+}
+
+func (c *Cache) read(node Node) ([]byte, error) {
+	return os.ReadFile(c.cacheFilePath(node))
+}
+
+func (c *Cache) writeChecksum(node Node, checksum string) error {
+	return os.WriteFile(c.checksumFilePath(node), []byte(checksum), 0o644)
+}
+
+func (c *Cache) readChecksum(node Node) string {
+	b, _ := os.ReadFile(c.checksumFilePath(node))
+	return string(b)
+}
+
+func (c *Cache) key(node Node) string {
+	return base64.StdEncoding.EncodeToString([]byte(node.Location()))
+}
+
+func (c *Cache) cacheFilePath(node Node) string {
+	return filepath.Join(c.dir, fmt.Sprintf("%s.yaml", c.key(node)))
+}
+
+func (c *Cache) checksumFilePath(node Node) string {
+	return filepath.Join(c.dir, fmt.Sprintf("%s.checksum", c.key(node)))
+}

taskfile/read/node.go

@@ -10,13 +10,20 @@ import (
 )
 
 type Node interface {
-	Read() (*taskfile.Taskfile, error)
+	Read() ([]byte, error)
 	Parent() Node
 	Optional() bool
 	Location() string
+	Remote() bool
 }
 
-func NewNodeFromIncludedTaskfile(parent Node, includedTaskfile taskfile.IncludedTaskfile, allowInsecure bool, tempDir string, l *logger.Logger) (Node, error) {
+func NewNodeFromIncludedTaskfile(
+	parent Node,
+	includedTaskfile taskfile.IncludedTaskfile,
+	allowInsecure bool,
+	tempDir string,
+	l *logger.Logger,
+) (Node, error) {
 	// TODO: Remove this condition when the remote taskfiles experiment is complete
 	if !experiments.RemoteTaskfiles {
 		path, err := includedTaskfile.FullTaskfilePath()

taskfile/read/node_file.go

@@ -1,14 +1,11 @@
 package read
 
 import (
+	"io"
 	"os"
 	"path/filepath"
 
-	"gopkg.in/yaml.v3"
-
-	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/taskfile"
 )
 
 // A FileNode is a node that reads a taskfile from the local filesystem.
@@ -38,7 +35,11 @@ func (node *FileNode) Location() string {
 	return filepathext.SmartJoin(node.Dir, node.Entrypoint)
 }
 
-func (node *FileNode) Read() (*taskfile.Taskfile, error) {
+func (node *FileNode) Remote() bool {
+	return false
+}
+
+func (node *FileNode) Read() ([]byte, error) {
 	if node.Dir == "" {
 		d, err := os.Getwd()
 		if err != nil {
@@ -60,11 +61,5 @@ func (node *FileNode) Read() (*taskfile.Taskfile, error) {
 	}
 	defer f.Close()
 
-	var t taskfile.Taskfile
-	if err := yaml.NewDecoder(f).Decode(&t); err != nil {
-		return nil, &errors.TaskfileInvalidError{URI: filepathext.TryAbsToRel(path), Err: err}
-	}
-
-	t.Location = path
-	return &t, nil
+	return io.ReadAll(f)
 }

taskfile/read/node_http.go

@@ -3,18 +3,14 @@ package read
 import (
 	"crypto/sha256"
 	"encoding/base64"
-	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
 
-	"gopkg.in/yaml.v3"
-
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/taskfile"
 )
 
 // An HTTPNode is a node that reads a Taskfile from a remote location via HTTP.
@@ -45,7 +41,11 @@ func (node *HTTPNode) Location() string {
 	return node.URL.String()
 }
 
-func (node *HTTPNode) Read() (*taskfile.Taskfile, error) {
+func (node *HTTPNode) Remote() bool {
+	return true
+}
+
+func (node *HTTPNode) Read() ([]byte, error) {
 	resp, err := http.Get(node.URL.String())
 	if err != nil {
 		return nil, errors.TaskfileFetchFailedError{URI: node.URL.String()}
@@ -65,45 +65,7 @@ func (node *HTTPNode) Read() (*taskfile.Taskfile, error) {
 		return nil, err
 	}
 
-	// Create a hash of the response body
-	h := sha256.New()
-	h.Write(b)
-	hash := base64.URLEncoding.EncodeToString(h.Sum(nil))
-
-	// Get the cached hash
-	cachedHash, err := node.getHashFromCache()
-	if errors.Is(err, os.ErrNotExist) {
-		// If the hash doesn't exist in the cache, prompt the user to continue
-		if cont, err := node.Logger.Prompt(logger.Yellow, fmt.Sprintf("The task you are attempting to run depends on the remote Taskfile at %q.\n--- Make sure you trust the source of this Taskfile before continuing ---\nContinue?", node.URL.String()), "n", "y", "yes"); err != nil {
-			return nil, err
-		} else if !cont {
-			return nil, &errors.TaskfileNotTrustedError{URI: node.URL.String()}
-		}
-	} else if err != nil {
-		return nil, err
-	} else if hash != cachedHash {
-		// If there is a cached hash, but it doesn't match the expected hash, prompt the user to continue
-		if cont, err := node.Logger.Prompt(logger.Yellow, fmt.Sprintf("The Taskfile at %q has changed since you last used it!\n--- Make sure you trust the source of this Taskfile before continuing ---\nContinue?", node.URL.String()), "n", "y", "yes"); err != nil {
-			return nil, err
-		} else if !cont {
-			return nil, &errors.TaskfileNotTrustedError{URI: node.URL.String()}
-		}
-	}
-
-	// If the hash has changed (or is new), store it in the cache
-	if hash != cachedHash {
-		if err := node.toCache([]byte(hash)); err != nil {
-			return nil, err
-		}
-	}
-
-	// Unmarshal the taskfile
-	var t *taskfile.Taskfile
-	if err := yaml.Unmarshal(b, &t); err != nil {
-		return nil, &errors.TaskfileInvalidError{URI: node.URL.String(), Err: err}
-	}
-	t.Location = node.URL.String()
-	return t, nil
+	return b, nil
 }
 
 func (node *HTTPNode) getCachePath() string {