feat(cli): deploy command

cli/cmd/deploy/cmd.go

@@ -0,0 +1,87 @@
+package deploy
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+
+	"numerous/cli/internal/app"
+	"numerous/cli/internal/gql"
+
+	"github.com/spf13/cobra"
+)
+
+var DeployCmd = &cobra.Command{
+	Use:   "deploy [app directory]",
+	Run:   run,
+	Short: "Deploy an app to an organization.",
+	Long: `Deploys an application to an organization on the Numerous platform.
+
+An apps deployment is identified with the <name> and <organization> identifier.
+Deploying an app to a given <name> and <organization> combination, will override
+the existing version.
+
+The <name> must contain only lower-case alphanumeric characters and dashes.
+
+After deployment the deployed version of the app is available in the
+organization's apps page.
+
+If no [app directory] is specified, the current working directory is used.`,
+	Example: `
+If an app has been initialized in the current working directory, and it should
+be pushed to the organization "organization-slug-a3ecfh2b", and the app name
+"my-app", the following command can be used:
+
+	numerous deploy --organization "organization-slug-a3ecfh2b" --name "my-app"
+	`,
+	Args: func(cmd *cobra.Command, args []string) error {
+		if len(args) > 1 {
+			fn := cmd.HelpFunc()
+			fn(cmd, args)
+
+			return fmt.Errorf("accepts only an optional [app directory] as a positional argument, you provided %d arguments", len(args))
+		}
+
+		if len(args) == 1 {
+			appDir = args[0]
+		}
+
+		return nil
+	},
+}
+
+var (
+	slug       string
+	appName    string
+	verbose    bool
+	appDir     string = "."
+	projectDir string = "."
+)
+
+func run(cmd *cobra.Command, args []string) {
+	sc := gql.NewSubscriptionClient().WithSyncMode(true)
+	service := app.New(gql.NewClient(), sc, http.DefaultClient)
+	err := Deploy(cmd.Context(), service, appDir, projectDir, slug, appName, verbose)
+
+	if err != nil {
+		os.Exit(1)
+	} else {
+		os.Exit(0)
+	}
+}
+
+func init() {
+	flags := DeployCmd.Flags()
+	flags.StringVarP(&slug, "organization", "o", "", "The organization slug identifier. List available organizations with 'numerous organization list'.")
+	flags.StringVarP(&appName, "name", "n", "", "A unique name for the application to deploy.")
+	flags.BoolVarP(&verbose, "verbose", "v", false, "Display detailed information about the app deployment.")
+	flags.StringVarP(&projectDir, "project-dir", "p", "", "The project directory, which is the build context if using a custom Dockerfile.")
+
+	if err := DeployCmd.MarkFlagRequired("organization"); err != nil {
+		panic(err.Error())
+	}
+
+	if err := DeployCmd.MarkFlagRequired("name"); err != nil {
+		panic(err.Error())
+	}
+}

cli/cmd/deploy/deploy.go

@@ -0,0 +1,201 @@
+package deploy
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"numerous/cli/cmd/initialize"
+	"numerous/cli/cmd/output"
+	"numerous/cli/cmd/validate"
+	"numerous/cli/dotenv"
+	"numerous/cli/internal/app"
+	"numerous/cli/internal/archive"
+	"numerous/cli/manifest"
+)
+
+type AppService interface {
+	ReadApp(ctx context.Context, input app.ReadAppInput) (app.ReadAppOutput, error)
+	Create(ctx context.Context, input app.CreateAppInput) (app.CreateAppOutput, error)
+	CreateVersion(ctx context.Context, input app.CreateAppVersionInput) (app.CreateAppVersionOutput, error)
+	AppVersionUploadURL(ctx context.Context, input app.AppVersionUploadURLInput) (app.AppVersionUploadURLOutput, error)
+	UploadAppSource(uploadURL string, archive io.Reader) error
+	DeployApp(ctx context.Context, input app.DeployAppInput) (app.DeployAppOutput, error)
+	DeployEvents(ctx context.Context, input app.DeployEventsInput) error
+}
+
+var (
+	ErrInvalidSlug    = errors.New("invalid organization slug")
+	ErrInvalidAppName = errors.New("invalid app name")
+)
+
+func Deploy(ctx context.Context, apps AppService, appDir, projectDir, slug string, appName string, verbose bool) error {
+	if !validate.IsValidIdentifier(slug) {
+		output.PrintError("Error: Invalid organization %q.", "Must contain only lower-case alphanumerical characters and dashes.", slug)
+		return ErrInvalidSlug
+	}
+
+	if !validate.IsValidIdentifier(appName) {
+		output.PrintError("Error: Invalid app name %q.", "Must contain only lower-case alphanumerical characters and dashes.", appName)
+		return ErrInvalidAppName
+	}
+
+	task := output.StartTask("Loading app configuration")
+	manifest, err := manifest.LoadManifest(filepath.Join(appDir, manifest.ManifestPath))
+	if err != nil {
+		task.Error()
+		output.PrintErrorAppNotInitialized(appDir)
+
+		return err
+	}
+
+	secrets := loadSecretsFromEnv(appDir)
+	task.Done()
+
+	task = output.StartTask("Registering new version")
+	appID, err := readOrCreateApp(ctx, apps, slug, appName, manifest, task)
+	if err != nil {
+		return err
+	}
+
+	appVersionInput := app.CreateAppVersionInput{AppID: appID}
+	appVersionOutput, err := apps.CreateVersion(ctx, appVersionInput)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error creating app version remotely", err)
+
+		return err
+	}
+	task.Done()
+
+	task = output.StartTask("Creating app archive")
+	tarSrcDir := appDir
+	if projectDir != "" {
+		tarSrcDir = projectDir
+	}
+	tarPath := path.Join(tarSrcDir, ".tmp_app_archive.tar")
+	err = archive.TarCreate(tarSrcDir, tarPath, manifest.Exclude)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error archiving app source", err)
+
+		return err
+	}
+	defer os.Remove(tarPath)
+
+	archive, err := os.Open(tarPath)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error archiving app source", err)
+
+		return err
+	}
+	defer archive.Close()
+	task.Done()
+
+	task = output.StartTask("Uploading app archive")
+	uploadURLInput := app.AppVersionUploadURLInput(appVersionOutput)
+	uploadURLOutput, err := apps.AppVersionUploadURL(ctx, uploadURLInput)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error creating app version remotely", err)
+
+		return err
+	}
+
+	err = apps.UploadAppSource(uploadURLOutput.UploadURL, archive)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error uploading app source archive", err)
+
+		return err
+	}
+	task.Done()
+
+	task = output.StartTask("Deploying app")
+	deployAppInput := app.DeployAppInput{AppVersionID: appVersionOutput.AppVersionID, Secrets: secrets}
+	deployAppOutput, err := apps.DeployApp(ctx, deployAppInput)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error deploying app", err)
+	}
+
+	input := app.DeployEventsInput{
+		DeploymentVersionID: deployAppOutput.DeploymentVersionID,
+		Handler: func(de app.DeployEvent) error {
+			switch de.Typename {
+			case "AppBuildMessageEvent":
+				for _, l := range strings.Split(de.BuildMessage.Message, "\n") {
+					task.AddLine("Build", l)
+				}
+			case "AppBuildErrorEvent":
+				for _, l := range strings.Split(de.BuildError.Message, "\n") {
+					task.AddLine("Error", l)
+				}
+
+				return fmt.Errorf("build error: %s", de.BuildError.Message)
+			case "AppDeployStatusEvent":
+				task.AddLine("Deploy", "Status: "+de.DeploymentStatus.Status)
+				switch de.DeploymentStatus.Status {
+				case "PENDING", "RUNNING":
+				default:
+					return fmt.Errorf("got status %s while deploying", de.DeploymentStatus.Status)
+				}
+			}
+
+			return nil
+		},
+	}
+	err = apps.DeployEvents(ctx, input)
+	if err != nil {
+		task.Error()
+		output.PrintErrorDetails("Error occurred during deploy", err)
+	} else {
+		task.Done()
+	}
+
+	return nil
+}
+
+func readOrCreateApp(ctx context.Context, apps AppService, slug string, appName string, manifest *manifest.Manifest, task *output.Task) (string, error) {
+	appReadInput := app.ReadAppInput{
+		OrganizationSlug: slug,
+		Name:             appName,
+	}
+	appReadOutput, err := apps.ReadApp(ctx, appReadInput)
+	switch {
+	case err == nil:
+		return appReadOutput.AppID, nil
+	case errors.Is(err, app.ErrAppNotFound):
+		appCreateInput := app.CreateAppInput{
+			OrganizationSlug: slug,
+			Name:             appName,
+			DisplayName:      manifest.Name,
+			Description:      manifest.Description,
+		}
+		appCreateOutput, err := apps.Create(ctx, appCreateInput)
+		if err != nil {
+			task.Error()
+			output.PrintErrorDetails("Error creating app remotely", err)
+
+			return "", err
+		}
+
+		return appCreateOutput.AppID, nil
+	default:
+		output.PrintErrorDetails("Error reading remote app", err)
+		task.Error()
+
+		return "", err
+	}
+}
+
+func loadSecretsFromEnv(appDir string) map[string]string {
+	env, _ := dotenv.Load(path.Join(appDir, initialize.EnvFileName))
+	return env
+}