api: start, stop, list, details, logs

Author: alessio-perugini

.gitignore

@@ -30,4 +30,5 @@ build/
 
 **/.cache
 
-arduino-app-cli
+/arduino-app-cli
+/apps

cmd/arduino-app-cli/main.go

@@ -2,13 +2,12 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
 	"log/slog"
 	"net/http"
 	"os"
-	"path"
 	"time"
 
 	dockerClient "github.com/docker/docker/client"
@@ -17,31 +16,10 @@ import (
 
 	"github.com/arduino/arduino-app-cli/internal/api"
 	"github.com/arduino/arduino-app-cli/internal/orchestrator"
+	"github.com/arduino/arduino-app-cli/pkg/httprecover"
 	"github.com/arduino/arduino-app-cli/pkg/parser"
 )
 
-const DockerRegistry = "ghcr.io/bcmi-labs/"
-const DockerPythonImage = "arduino/appslab-python-apps-base:0.0.2"
-
-var pythonImage string
-
-func init() {
-	// Registry base: contains the registry and namespace, common to all Arduino docker images.
-	registryBase := os.Getenv("DOCKER_REGISTRY_BASE")
-	if registryBase == "" {
-		registryBase = DockerRegistry
-	}
-
-	// Python image: image name (repository) and optionally a tag.
-	pythonImageAndTag := os.Getenv("DOCKER_PYTHON_BASE_IMAGE")
-	if pythonImageAndTag == "" {
-		pythonImageAndTag = DockerPythonImage
-	}
-
-	pythonImage = path.Join(registryBase, pythonImageAndTag)
-	fmt.Println("Using pythonImage:", pythonImage)
-}
-
 func main() {
 	docker, err := dockerClient.NewClientWithOpts(
 		dockerClient.FromEnv,
@@ -52,117 +30,199 @@ func main() {
 	}
 	defer docker.Close()
 
-	var parsedApp parser.App
+	var daemonPort string
+	var completionNoDesc bool // Disable completion description for shells that support it
 
 	rootCmd := &cobra.Command{
-		Use:   "app <APP_PATH>",
+		Use:   "arduino-app-cli",
 		Short: "A CLI to manage the Python app",
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
-			if cmd.Name() == "daemon" {
-				return
-			}
-			if len(args) != 1 {
-				_ = cmd.Help()
-				os.Exit(1)
-			}
-			app, err := parser.Load(args[0])
-			if err != nil {
-				log.Panic(err)
+		},
+	}
+
+	completionCommand := &cobra.Command{
+		Use:       "completion [bash|zsh|fish|powershell] [--no-descriptions]",
+		ValidArgs: []string{"bash", "zsh", "fish", "powershell"},
+		Args:      cobra.ExactArgs(1),
+		Short:     "Generates completion scripts",
+		Long:      "Generates completion scripts for various shells",
+		Example: "  " + os.Args[0] + " completion bash > completion.sh\n" +
+			"  " + "source completion.sh",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			switch args[0] {
+			case "bash":
+				return cmd.Root().GenBashCompletionV2(cmd.OutOrStdout(), !completionNoDesc)
+			case "zsh":
+				if completionNoDesc {
+					return cmd.Root().GenZshCompletionNoDesc(cmd.OutOrStdout())
+				} else {
+					return cmd.Root().GenZshCompletion(cmd.OutOrStdout())
+				}
+			case "fish":
+				return cmd.Root().GenFishCompletion(cmd.OutOrStdout(), !completionNoDesc)
+			case "powershell":
+				return cmd.Root().GenPowerShellCompletion(cmd.OutOrStdout())
 			}
-			parsedApp = app
+			return nil
+		},
+	}
+	completionCommand.Flags().BoolVar(&completionNoDesc, "no-descriptions", false, "Disable completion description for shells that support it")
+
+	daemonCmd := &cobra.Command{
+		Use:   "daemon",
+		Short: "Run an HTTP server to expose arduino-app-cli functionality thorough REST API",
+		Run: func(cmd *cobra.Command, args []string) {
+			httpHandler(cmd.Context(), docker, daemonPort)
 		},
 	}
+	daemonCmd.Flags().StringVar(&daemonPort, "port", "8080", "The TCP port the daemon will listen to")
 
 	rootCmd.AddCommand(
 		&cobra.Command{
-			Use:   "stop",
+			Use:   "stop app_path",
 			Short: "Stop the Python app",
-			Run: func(cmd *cobra.Command, args []string) {
-				stopHandler(cmd.Context(), parsedApp)
+			Args:  cobra.MaximumNArgs(1),
+			RunE: func(cmd *cobra.Command, args []string) error {
+				if len(args) == 0 {
+					return cmd.Help()
+				}
+				app, err := parser.Load(args[0])
+				if err != nil {
+					return err
+				}
+				return stopHandler(cmd.Context(), app)
 			},
 		},
 		&cobra.Command{
-			Use:   "start",
+			Use:   "start app_path",
 			Short: "Start the Python app",
-			Run: func(cmd *cobra.Command, args []string) {
-				if parsedApp.MainPythonFile != nil {
-					provisionHandler(cmd.Context(), docker, parsedApp)
+			Args:  cobra.MaximumNArgs(1),
+			RunE: func(cmd *cobra.Command, args []string) error {
+				if len(args) == 0 {
+					return cmd.Help()
 				}
-
-				startHandler(cmd.Context(), parsedApp)
+				app, err := parser.Load(args[0])
+				if err != nil {
+					return err
+				}
+				return startHandler(cmd.Context(), docker, app)
 			},
 		},
 		&cobra.Command{
-			Use:   "logs",
+			Use:   "logs app_path",
 			Short: "Show the logs of the Python app",
-			Run: func(cmd *cobra.Command, args []string) {
-				logsHandler(cmd.Context(), parsedApp)
+			Args:  cobra.MaximumNArgs(1),
+			RunE: func(cmd *cobra.Command, args []string) error {
+				if len(args) == 0 {
+					return cmd.Help()
+				}
+				app, err := parser.Load(args[0])
+				if err != nil {
+					return err
+				}
+				return logsHandler(cmd.Context(), app)
 			},
 		},
 		&cobra.Command{
 			Use:   "list",
 			Short: "List all running Python apps",
-			Run: func(cmd *cobra.Command, args []string) {
-				listHandler(cmd.Context())
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return listHandler(cmd.Context())
 			},
 		},
 		&cobra.Command{
-			Use:   "provision",
+			Use:   "provision app_path",
 			Short: "Makes sure the Python app deps are downloaded and running",
-			Run: func(cmd *cobra.Command, args []string) {
-				provisionHandler(cmd.Context(), docker, parsedApp)
-			},
-		},
-		&cobra.Command{
-			Use:   "daemon",
-			Short: "Run an HTTP server to expose orchestrator functionality thorough REST API",
-			Run: func(cmd *cobra.Command, args []string) {
-				httpHandler(cmd.Context(), docker)
+			Args:  cobra.MaximumNArgs(1),
+			RunE: func(cmd *cobra.Command, args []string) error {
+				if len(args) == 0 {
+					return cmd.Help()
+				}
+				app, err := parser.Load(args[0])
+				if err != nil {
+					return err
+				}
+				return provisionHandler(cmd.Context(), docker, app)
 			},
 		},
+		completionCommand,
+		daemonCmd,
 	)
 
 	ctx := context.Background()
-	ctx, cancel := cleanup.InterruptableContext(ctx)
-	defer cancel()
+	ctx, _ = cleanup.InterruptableContext(ctx)
 	if err := rootCmd.ExecuteContext(ctx); err != nil {
-		log.Panic(err)
+		slog.Error(err.Error())
 	}
 }
 
-func provisionHandler(ctx context.Context, docker *dockerClient.Client, app parser.App) {
-	orchestrator.ProvisionApp(ctx, pythonImage, docker, app)
+func provisionHandler(ctx context.Context, docker *dockerClient.Client, app parser.App) error {
+	if err := orchestrator.ProvisionApp(ctx, docker, app); err != nil {
+		return err
+	}
+	return nil
 }
 
-func startHandler(ctx context.Context, app parser.App) {
-	orchestrator.StartApp(ctx, app)
+func startHandler(ctx context.Context, docker *dockerClient.Client, app parser.App) error {
+	for message := range orchestrator.StartApp(ctx, docker, app) {
+		switch message.GetType() {
+		case orchestrator.ProgressType:
+			slog.Info("progress", slog.Float64("progress", float64(message.GetProgress().Progress)))
+		case orchestrator.InfoType:
+			slog.Info("log", slog.String("message", message.GetData()))
+		case orchestrator.ErrorType:
+			return errors.New(message.GetError().Error())
+		}
+	}
+	return nil
 }
 
-func stopHandler(ctx context.Context, app parser.App) {
-	orchestrator.StopApp(ctx, app)
+func stopHandler(ctx context.Context, app parser.App) error {
+	for message := range orchestrator.StopApp(ctx, app) {
+		switch message.GetType() {
+		case orchestrator.ProgressType:
+			slog.Info("progress", slog.Float64("progress", float64(message.GetProgress().Progress)))
+		case orchestrator.InfoType:
+			slog.Info("log", slog.String("message", message.GetData()))
+		case orchestrator.ErrorType:
+			return errors.New(message.GetError().Error())
+		}
+	}
+	return nil
 }
 
-func logsHandler(ctx context.Context, app parser.App) {
-	orchestrator.AppLogs(ctx, app)
+func logsHandler(ctx context.Context, app parser.App) error {
+	logsIter, err := orchestrator.AppLogs(ctx, app, orchestrator.AppLogsRequest{ShowAppLogs: true, Follow: true})
+	if err != nil {
+		return err
+	}
+	for msg := range logsIter {
+		fmt.Printf("[%s] %s\n", msg.Name, msg.Content)
+	}
+	return nil
 }
 
-func listHandler(ctx context.Context) {
+func listHandler(ctx context.Context) error {
 	res, err := orchestrator.ListApps(ctx)
 	if err != nil {
-		slog.Error(err.Error())
-		return
+		return nil
 	}
-	fmt.Println(string(res.Stdout))
-	if len(res.Stderr) > 0 {
-		fmt.Println(string(res.Stderr))
+
+	resJSON, err := json.Marshal(res)
+	if err != nil {
+		return nil
 	}
+	fmt.Println(string(resJSON))
+	return nil
 }
 
-func httpHandler(ctx context.Context, dockerClient *dockerClient.Client) {
+func httpHandler(ctx context.Context, dockerClient *dockerClient.Client, daemonPort string) {
+	slog.Info("Starting HTTP server", slog.String("address", ":"+daemonPort))
 	apiSrv := api.NewHTTPRouter(dockerClient)
+
 	httpSrv := http.Server{
-		Addr:              ":8080",
-		Handler:           apiSrv,
+		Addr:              ":" + daemonPort,
+		Handler:           httprecover.RecoverPanic(apiSrv),
 		ReadHeaderTimeout: 60 * time.Second,
 	}
 	go func() {
@@ -172,8 +232,10 @@ func httpHandler(ctx context.Context, dockerClient *dockerClient.Client) {
 	}()
 
 	<-ctx.Done()
+	slog.Info("Shutting down HTTP server", slog.String("address", ":"+daemonPort))
 
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	_ = httpSrv.Shutdown(ctx)
 	cancel()
+	slog.Info("HTTP server shut down", slog.String("address", ":"+daemonPort))
 }

internal/api/api.go

@@ -2,18 +2,72 @@ package api
 
 import (
 	"net/http"
+	"strings"
 
 	"github.com/arduino/arduino-app-cli/internal/api/handlers"
+	"github.com/arduino/arduino-app-cli/internal/orchestrator"
 
 	dockerClient "github.com/docker/docker/client"
 )
 
 func NewHTTPRouter(dockerClient *dockerClient.Client) http.Handler {
 	mux := http.NewServeMux()
 
-	mux.Handle("POST /v1/app/start", handlers.HandleAppStart(dockerClient))
-	mux.Handle("POST /v1/app/stop", handlers.HandleAppStop(dockerClient))
-	mux.Handle("GET /v1/app/list", handlers.HandleAppList(dockerClient))
+	mux.Handle("GET /v1/apps", handlers.HandleAppList(dockerClient))
+	mux.Handle("POST /v1/apps", handlers.HandleAppCreate(dockerClient))
+
+	appLogsHandler := handlers.HandleAppLogs(dockerClient)
+	appEventsHandler := handlers.HandleAppEvents(dockerClient)
+	appGetVariablesHandler := handlers.HandleAppGetVariables(dockerClient)
+	appDetailsHandler := handlers.HandleAppDetails(dockerClient)
+	mux.HandleFunc("GET /v1/apps/{path...}", func(w http.ResponseWriter, r *http.Request) {
+		path := r.PathValue("path")
+		switch {
+		case strings.HasSuffix(path, "/logs"):
+			id := strings.TrimSuffix(path, "/logs")
+			appLogsHandler(w, r, orchestrator.ID(id))
+		case strings.HasSuffix(path, "/events"):
+			id := strings.TrimSuffix(path, "/events")
+			appEventsHandler(w, r, orchestrator.ID(id))
+		case strings.HasSuffix(path, "/variables"):
+			id := strings.TrimSuffix(path, "/variables")
+			appGetVariablesHandler(w, r, orchestrator.ID(id))
+		default:
+			appDetailsHandler(w, r, orchestrator.ID(path))
+		}
+	})
+
+	appSetVariablesHandler := handlers.HandleAppSetVariables(dockerClient)
+	mux.HandleFunc("PATCH /v1/apps/{path...}", func(w http.ResponseWriter, r *http.Request) {
+		path := r.PathValue("path")
+		switch {
+		case strings.HasSuffix(path, "/variables"):
+			id := strings.TrimSuffix(path, "/variables")
+			appSetVariablesHandler(w, r, orchestrator.ID(id))
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	})
+
+	startHandler := handlers.HandleAppStart(dockerClient)
+	stopHandler := handlers.HandleAppStop(dockerClient)
+	cloneHandler := handlers.HandleAppClone(dockerClient)
+	mux.HandleFunc("POST /v1/apps/{path...}", func(w http.ResponseWriter, r *http.Request) {
+		path := r.PathValue("path")
+		switch {
+		case strings.HasSuffix(path, "/start"):
+			id := strings.TrimSuffix(path, "/start")
+			startHandler(w, r, orchestrator.ID(id))
+		case strings.HasSuffix(path, "/stop"):
+			id := strings.TrimSuffix(path, "/stop")
+			stopHandler(w, r, orchestrator.ID(id))
+		case strings.HasSuffix(path, "/clone"):
+			id := strings.TrimSuffix(path, "/clone")
+			cloneHandler(w, r, orchestrator.ID(id))
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	})
 
 	return mux
 }