fastly · Integralist · Oct 31, 2023 · Sep 19, 2023 · Sep 19, 2023 · Sep 19, 2023
@@ -14,5 +14,8 @@ toolchain_constraint_tinygo = ">= 1.18"    # Go toolchain constraint for use wit
 toolchain_constraint = ">= 1.56.1"
 wasm_wasi_target = "wasm32-wasi"
 
+[wasm-tools]
+ttl = "24h"
+
 [viceroy]
 ttl = "24h"
@@ -152,7 +152,7 @@ jobs:
         shell: bash
         env:
           # NOTE: The following lets us focus the test run while debugging.
-          # TEST_ARGS: "-run TestDeploy ./pkg/commands/compute/..."
+          # TEST_ARGS: "-run TestBuild ./pkg/commands/compute/..."
           TEST_COMPUTE_INIT: true
           TEST_COMPUTE_BUILD: true
           TEST_COMPUTE_DEPLOY: true

@@ -6,13 +6,16 @@ import (
 	"io"
 	"net/http"
 	"os"
-	"strings"
 	"time"
 
+	"github.com/fastly/go-fastly/v8/fastly"
 	"github.com/fatih/color"
 
+	"github.com/fastly/cli/pkg/api"
 	"github.com/fastly/cli/pkg/app"
+	"github.com/fastly/cli/pkg/commands/compute"
 	"github.com/fastly/cli/pkg/config"
+	"github.com/fastly/cli/pkg/env"
 	fsterr "github.com/fastly/cli/pkg/errors"
 	"github.com/fastly/cli/pkg/github"
 	"github.com/fastly/cli/pkg/manifest"
@@ -21,38 +24,34 @@ import (
 )
 
 func main() {
-	// Some configuration options can come from env vars.
-	var env config.Environment
-	env.Read(parseEnv(os.Environ()))
+	// Parse the arguments provided by the user via the command-line interface.
+	args := os.Args[1:]
 
-	// All of the work of building the set of commands and subcommands, wiring
-	// them together, picking which one to call, and executing it, occurs in a
-	// helper function, Run. We parameterize all of the dependencies so we can
-	// test it more easily. Here, we declare all of the dependencies, using
-	// the "real" versions that pull e.g. actual commandline arguments, the
-	// user's real environment, etc.
+	// Define a HTTP client that will be used for making arbitrary HTTP requests.
+	httpClient := &http.Client{Timeout: time.Minute * 2}
+
+	// Define the standard input/output streams.
 	var (
-		args                    = os.Args[1:]
-		clientFactory           = app.FastlyAPIClient
-		httpClient              = &http.Client{Timeout: time.Minute * 2}
-		in            io.Reader = os.Stdin
-		out           io.Writer = sync.NewWriter(color.Output)
+		in  io.Reader = os.Stdin
+    		out io.Writer = sync.NewWriter(color.Output)
 	)
 
-	// We have to manually handle the inclusion of the verbose flag here because
-	// Kingpin doesn't evaluate the provided arguments until app.Run which
-	// happens later in the file and yet we need to know if we should be printing
-	// output related to the application configuration file in this file.
+	// Read relevant configuration options from the user's environment.
+	var e config.Environment
+	e.Read(env.Parse(os.Environ()))
+
+	// Identify verbose flag early (before Kingpin parser has executed) so we can
+	// print additional output related to the CLI configuration.
 	var verboseOutput bool
 	for _, seg := range args {
 		if seg == "-v" || seg == "--verbose" {
 			verboseOutput = true
 		}
 	}
 
-	// Similarly for the --auto-yes/--non-interactive flags, we need access to
-	// these for handling interactive error prompts to the user, in case the CLI
-	// is being run in a CI environment.
+	// Identify auto-yes/non-interactive flag early (before Kingpin parser has
+	// executed) so we can handle the interactive prompts appropriately with
+	// regards to processing the CLI configuration.
 	var autoYes, nonInteractive bool
 	for _, seg := range args {
 		if seg == "-y" || seg == "--auto-yes" {
@@ -63,20 +62,19 @@ func main() {
 		}
 	}
 
-	// Extract a subset of configuration options from the local application directory.
+	// Extract a subset of configuration options from the local app directory.
 	var cfg config.File
 	cfg.SetAutoYes(autoYes)
 	cfg.SetNonInteractive(nonInteractive)
-
 	// The CLI relies on a valid configuration, otherwise we can't continue.
 	err := cfg.Read(config.FilePath, in, out, fsterr.Log, verboseOutput)
 	if err != nil {
 		fsterr.Deduce(err).Print(color.Error)
-
 		// WARNING: os.Exit will exit, and any `defer` calls will not be run.
 		os.Exit(1)
 	}
 
+	// Extract user's project configuration from the fastly.toml manifest.
 	var md manifest.Data
 	md.File.Args = args
 	md.File.SetErrLog(fsterr.Log)
@@ -85,18 +83,25 @@ func main() {
 	// NOTE: We skip handling the error because not all commands relate to Compute.
 	_ = md.File.Read(manifest.Filename)
 
-	// Main is basically just a shim to call Run, so we do that here.
-	opts := app.RunOpts{
-		APIClient:  clientFactory,
-		Args:       args,
-		ConfigFile: cfg,
-		ConfigPath: config.FilePath,
-		Env:        env,
-		ErrLog:     fsterr.Log,
-		HTTPClient: httpClient,
-		Manifest:   &md,
-		Stdin:      in,
-		Stdout:     out,
+	// The `main` function is a shim for calling `app.Run()`.
+	err = app.Run(app.RunOpts{
+		APIClient: func(token, endpoint string, debugMode bool) (api.Interface, error) {
+			client, err := fastly.NewClientForEndpoint(token, endpoint)
+			if debugMode {
+				client.DebugMode = true
+			}
+			return client, err
+		},
+		Args:             args,
+		ConfigFile:       cfg,
+		ConfigPath:       config.FilePath,
+		Env:              e,
+		ErrLog:           fsterr.Log,
+		ExecuteWasmTools: compute.ExecuteWasmTools,
+		HTTPClient:       httpClient,
+		Manifest:         &md,
+		Stdin:            in,
+		Stdout:           out,
 		Versioners: app.Versioners{
 			CLI: github.New(github.Opts{
 				HTTPClient: httpClient,
@@ -111,9 +116,16 @@ func main() {
 				Binary:     "viceroy",
 				Version:    md.File.LocalServer.ViceroyVersion,
 			}),
+			WasmTools: github.New(github.Opts{
+				HTTPClient: httpClient,
+				Org:        "bytecodealliance",
+				Repo:       "wasm-tools",
+				Binary:     "wasm-tools",
+				External:   true,
+				Nested:     true,
+			}),
 		},
-	}
-	err = app.Run(opts)
+	})
 
 	// NOTE: We persist any error log entries to disk before attempting to handle
 	// a possible error response from app.Run as there could be errors recorded
@@ -124,7 +136,6 @@ func main() {
 	if logErr != nil {
 		fsterr.Deduce(logErr).Print(color.Error)
 	}
-
 	if err != nil {
 		text.Break(out)
 		fsterr.Deduce(err).Print(color.Error)
@@ -137,16 +148,3 @@ func main() {
 		os.Exit(1)
 	}
 }
-
-func parseEnv(environ []string) map[string]string {
-	env := map[string]string{}
-	for _, kv := range environ {
-		toks := strings.SplitN(kv, "=", 2)
-		if len(toks) != 2 {
-			continue
-		}
-		k, v := toks[0], toks[1]
-		env[k] = v
-	}
-	return env
-}