Provide a standalone command-line tool (#610)

* Draft command-line tool support

Try it by running `make && ./terraform-provider-iterative --help`

* Add list command and underlying methods

* Polish rough edges and allow script on task.yaml

* Sanitize identifier generation

* Improve code structure

* Use main.tf as the configuration format

* Restyled by gofmt

* Restyled by gofmt

* Improve name experience

* Allow deterministic names and improve viper errors

* Print created task identifier to standard output

* Bind stop command 🤦

* Fix log prefixes

* Run go mod tidy

* Apply suggestions from code review

Co-authored-by: Restyled.io <commits@restyled.io>
Co-authored-by: DavidGOrtega <g.ortega.david@gmail.com>

Author: 3 people

cmd/create/create.go

@@ -0,0 +1,132 @@
+package create
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/alessio/shellescape"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
+	"terraform-provider-iterative/task"
+	"terraform-provider-iterative/task/common"
+)
+
+type Options struct {
+	Environment   map[string]string
+	Image         string
+	Machine       string
+	Name          string
+	Output        string
+	Parallelism   int
+	PermissionSet string
+	Script        string
+	Spot          bool
+	Storage       int
+	Tags          map[string]string
+	Timeout       int
+	Workdir       string
+}
+
+func New(cloud *common.Cloud) *cobra.Command {
+	o := Options{}
+
+	cmd := &cobra.Command{
+		Use:   "create [command...]",
+		Short: "Create a task",
+		Long:  ``,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return o.Run(cmd, args, cloud)
+		},
+	}
+
+	cmd.Flags().StringToStringVar(&o.Environment, "environment", map[string]string{}, "environment variables")
+	cmd.Flags().StringVar(&o.Image, "image", "ubuntu", "machine image")
+	cmd.Flags().StringVar(&o.Machine, "machine", "m", "machine type")
+	cmd.Flags().StringVar(&o.Name, "name", "", "deterministic name")
+	cmd.Flags().StringVar(&o.Output, "output", "", "output directory to download")
+	cmd.Flags().IntVar(&o.Parallelism, "parallelism", 1, "parallelism")
+	cmd.Flags().StringVar(&o.PermissionSet, "permission-set", "", "permission set")
+	cmd.Flags().StringVar(&o.Script, "script", "", "script to run")
+	cmd.Flags().BoolVar(&o.Spot, "spot", false, "use spot instances")
+	cmd.Flags().IntVar(&o.Storage, "disk-size", -1, "disk size in gigabytes")
+	cmd.Flags().StringToStringVar(&o.Tags, "tags", map[string]string{}, "resource tags")
+	cmd.Flags().IntVar(&o.Timeout, "timeout", 24*60*60, "timeout")
+	cmd.Flags().StringVar(&o.Workdir, "workdir", ".", "working directory to upload")
+
+	return cmd
+}
+
+func (o *Options) Run(cmd *cobra.Command, args []string, cloud *common.Cloud) error {
+	variables := make(map[string]*string)
+	for name, value := range o.Environment {
+		variables[name] = nil
+		if value != "" {
+			variables[name] = &value
+		}
+	}
+
+	script := o.Script
+	if !strings.HasPrefix(script, "#!") {
+		script = "#!/bin/sh\n" + script
+	}
+	script += "\n" + shellescape.QuoteCommand(args)
+
+	cfg := common.Task{
+		Size: common.Size{
+			Machine: o.Machine,
+			Storage: o.Storage,
+		},
+		Environment: common.Environment{
+			Image:        o.Image,
+			Script:       script,
+			Variables:    variables,
+			Directory:    o.Workdir,
+			DirectoryOut: o.Output,
+			Timeout:      time.Duration(o.Timeout) * time.Second,
+		},
+		Firewall: common.Firewall{
+			Ingress: common.FirewallRule{
+				Ports: &[]uint16{22},
+			},
+		},
+		Parallelism: uint16(1),
+	}
+
+	cfg.Spot = common.Spot(common.SpotDisabled)
+	if o.Spot {
+		cfg.Spot = common.Spot(common.SpotEnabled)
+	}
+
+	id := common.NewRandomIdentifier()
+
+	if o.Name != "" {
+		id = common.NewIdentifier(o.Name)
+		if identifier, err := common.ParseIdentifier(o.Name); err == nil {
+			id = identifier
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cloud.Timeouts.Create)
+	defer cancel()
+
+	tsk, err := task.New(ctx, *cloud, id, cfg)
+	if err != nil {
+		return err
+	}
+
+	if err := tsk.Create(ctx); err != nil {
+		logrus.Errorf("Failed to create a new task: %v", err)
+		logrus.Warn("Attempting to delete residual resources...")
+		if err := tsk.Delete(ctx); err != nil {
+			logrus.Errorf("Failed to delete residual resources")
+			return err
+		}
+		return err
+	}
+
+	fmt.Println(id.Long())
+	return nil
+}

cmd/delete/delete.go

@@ -0,0 +1,58 @@
+package delete
+
+import (
+	"context"
+
+	"github.com/spf13/cobra"
+
+	"terraform-provider-iterative/task"
+	"terraform-provider-iterative/task/common"
+)
+
+type Options struct {
+	Workdir string
+	Output  string
+}
+
+func New(cloud *common.Cloud) *cobra.Command {
+	o := Options{}
+
+	cmd := &cobra.Command{
+		Use:   "delete <name>",
+		Short: "Delete a task",
+		Long:  ``,
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return o.Run(cmd, args, cloud)
+		},
+	}
+
+	cmd.Flags().StringVar(&o.Output, "output", "", "output directory, relative to workdir")
+	cmd.Flags().StringVar(&o.Workdir, "workdir", ".", "working directory")
+
+	return cmd
+}
+
+func (o *Options) Run(cmd *cobra.Command, args []string, cloud *common.Cloud) error {
+	cfg := common.Task{
+		Environment: common.Environment{
+			Directory:    o.Workdir,
+			DirectoryOut: o.Output,
+		},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cloud.Timeouts.Delete)
+	defer cancel()
+
+	id, err := common.ParseIdentifier(args[0])
+	if err != nil {
+		return err
+	}
+
+	tsk, err := task.New(ctx, *cloud, id, cfg)
+	if err != nil {
+		return err
+	}
+
+	return tsk.Delete(ctx)
+}

cmd/list/list.go

@@ -0,0 +1,45 @@
+package list
+
+import (
+	"context"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
+	"terraform-provider-iterative/task"
+	"terraform-provider-iterative/task/common"
+)
+
+type Options struct {
+}
+
+func New(cloud *common.Cloud) *cobra.Command {
+	o := Options{}
+
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "List tasks",
+		Long:  ``,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return o.Run(cmd, args, cloud)
+		},
+	}
+
+	return cmd
+}
+
+func (o *Options) Run(cmd *cobra.Command, args []string, cloud *common.Cloud) error {
+	ctx, cancel := context.WithTimeout(context.Background(), cloud.Timeouts.Read)
+	defer cancel()
+
+	lst, err := task.List(ctx, *cloud)
+	if err != nil {
+		return err
+	}
+
+	for _, id := range lst {
+		logrus.Info(id.Long())
+	}
+
+	return nil
+}

cmd/read/read.go

@@ -0,0 +1,102 @@
+package read
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
+	"terraform-provider-iterative/task"
+	"terraform-provider-iterative/task/common"
+)
+
+type Options struct {
+	Parallelism   int
+}
+
+func New(cloud *common.Cloud) *cobra.Command {
+	o := Options{}
+
+	cmd := &cobra.Command{
+		Use:   "read <name>",
+		Short: "Read the status of a task",
+		Long:  ``,
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return o.Run(cmd, args, cloud)
+		},
+	}
+
+	cmd.Flags().IntVar(&o.Parallelism, "parallelism", 1, "parallelism")
+
+	return cmd
+}
+
+func (o *Options) Run(cmd *cobra.Command, args []string, cloud *common.Cloud) error {
+	cfg := common.Task{
+		Environment: common.Environment{
+			Image: "ubuntu",
+		},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cloud.Timeouts.Read)
+	defer cancel()
+
+	id, err := common.ParseIdentifier(args[0])
+	if err != nil {
+		return err
+	}
+
+	tsk, err := task.New(ctx, *cloud, id, cfg)
+	if err != nil {
+		return err
+	}
+
+	if err := tsk.Read(ctx); err != nil {
+		return err
+	}
+
+	var events []string
+	for _, event := range tsk.Events(ctx) {
+		events = append(events, fmt.Sprintf(
+			"%s: %s\n%s",
+			event.Time.Format("2006-01-02 15:04:05"),
+			event.Code,
+			strings.Join(event.Description, "\n"),
+		))
+	}
+	logrus.Info(events)
+
+	logs, err := tsk.Logs(ctx)
+	if err != nil {
+		return err
+	}
+
+	for index, log := range logs {
+		for _, line := range strings.Split(strings.Trim(log, "\n"), "\n") {
+			logrus.Infof("\x1b[%dmLOG %d >> %s", 35, index, line)
+		}
+	}
+
+	status, err := tsk.Status(ctx)
+	if err != nil {
+		return err
+	}
+
+	message := fmt.Sprintf("\x1b[%dmStatus: queued \x1b[1m•\x1b[0m", 34)
+
+	if status["succeeded"] >= o.Parallelism {
+		message = fmt.Sprintf("\x1b[%dmStatus: completed successfully \x1b[1m•\x1b[0m", 32)
+	}
+	if status["failed"] > 0 {
+		message = fmt.Sprintf("\x1b[%dmStatus: completed with errors \x1b[1m•\x1b[0m", 31)
+	}
+	if status["running"] >= o.Parallelism {
+		message = fmt.Sprintf("\x1b[%dmStatus: running \x1b[1m•\x1b[0m", 33)
+	}
+
+	logrus.Info(message)
+	return nil
+}