feat: base structure for log level cmd

Author: mirkoCrobu

cmd/arduino-app-cli/app/start.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/spf13/cobra"
 
@@ -34,7 +33,6 @@ func newStartCmd() *cobra.Command {
 }
 
 func startHandler(ctx context.Context, app app.ArduinoApp) error {
-	out, _, getResult := feedback.OutputStreams()
 
 	stream := orchestrator.StartApp(
 		ctx,
@@ -47,19 +45,21 @@ func startHandler(ctx context.Context, app app.ArduinoApp) error {
 	for message := range stream {
 		switch message.GetType() {
 		case orchestrator.ProgressType:
-			fmt.Fprintf(out, "Progress: %.0f%%\n", message.GetProgress().Progress)
+			feedback.Progress(message.GetProgress().Progress)
 		case orchestrator.InfoType:
-			fmt.Fprintln(out, "[INFO]", message.GetData())
+			feedback.Info(message.GetData())
+		case orchestrator.DebugType:
+			feedback.Debug(message.GetData())
+		case orchestrator.WarningType:
+			feedback.Warning(message.GetData())
 		case orchestrator.ErrorType:
 			feedback.Fatal(message.GetError().Error(), feedback.ErrGeneric)
 			return nil
 		}
 	}
-	outputResult := getResult()
 	feedback.PrintResult(results.StartAppResult{
 		AppName: app.Name,
 		Status:  "started",
-		Output:  outputResult,
 	})
 
 	return nil

cmd/arduino-app-cli/main.go

@@ -1,11 +1,10 @@
 package main
 
 import (
-	"cmp"
 	"context"
 	"fmt"
 	"log/slog"
-	"os"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"go.bug.st/cleanup"
@@ -27,31 +26,37 @@ import (
 // Version will be set a build time with -ldflags
 var Version string = "0.0.0-dev"
 var format string
+var logLevel string
 
 func run() error {
 	defer func() { _ = servicelocator.CloseDockerClient() }()
 
-	logLevel, err := ParseLogLevel(cmp.Or(os.Getenv("ARDUINO_APP_CLI__LOG_LEVEL"), "INFO"))
-	if err != nil {
-		return err
-	}
-	slog.SetLogLoggerLevel(logLevel)
-
 	rootCmd := &cobra.Command{
 		Use:   "arduino-app-cli",
 		Short: "A CLI to manage the Python app",
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+
+			level, ok := feedback.ParseLogLevel(logLevel)
+			if !ok {
+				feedback.Fatal(i18n.Tr("Invalid log level : %s", logLevel), feedback.ErrBadArgument)
+			}
+			feedback.SetLogLevel(level)
+
 			format, ok := feedback.ParseOutputFormat(format)
 			if !ok {
 				feedback.Fatal(i18n.Tr("Invalid output format: %s", format), feedback.ErrBadArgument)
 			}
 			feedback.SetFormat(format)
+
+			ConfigureSLogger(logLevel)
+
 		},
 		SilenceUsage:  true,
 		SilenceErrors: true,
 	}
 
 	rootCmd.PersistentFlags().StringVar(&format, "format", "text", "Output format (text, json)")
+	rootCmd.PersistentFlags().StringVar(&logLevel, "log-level", "info", "Set log level (quiet, info, debug/verbose)")
 
 	rootCmd.AddCommand(
 		app.NewAppCmd(),
@@ -88,3 +93,17 @@ func ParseLogLevel(level string) (slog.Level, error) {
 	}
 	return l, nil
 }
+
+func ConfigureSLogger(levelStr string) {
+	var slogLevel slog.Level
+
+	switch strings.ToLower(levelStr) {
+	case "quiet":
+		slogLevel = slog.LevelError
+	case "debug", "verbose":
+		slogLevel = slog.LevelDebug
+	default:
+		slogLevel = slog.LevelInfo
+	}
+	slog.SetLogLoggerLevel(slogLevel)
+}

cmd/arduino-app-cli/results/app_results.go

@@ -87,9 +87,8 @@ func (r CreateAppResult) Data() interface{} {
 }
 
 type StartAppResult struct {
-	AppName string                        `json:"appName"`
-	Status  string                        `json:"status"`
-	Output  *feedback.OutputStreamsResult `json:"output,omitempty"`
+	AppName string `json:"appName"`
+	Status  string `json:"status"`
 }
 
 func (r StartAppResult) String() string {

cmd/feedback/feedback.go

@@ -6,8 +6,7 @@ import (
 	"fmt"
 	"io"
 	"os"
-
-	"github.com/sirupsen/logrus"
+	"strings"
 
 	"github.com/bcmi-labs/orchestrator/cmd/i18n"
 )
@@ -138,16 +137,6 @@ func Print(v string) {
 	fmt.Fprintln(feedbackOut, v)
 }
 
-// Warning outputs a warning message.
-func Warning(msg string) {
-	if format == Text {
-		fmt.Fprintln(feedbackErr, msg)
-	} else {
-		bufferWarnings = append(bufferWarnings, msg)
-	}
-	logrus.Warning(msg)
-}
-
 // FatalError outputs the error and exits with status exitCode.
 func FatalError(err error, exitCode ExitCode) {
 	Fatal(err.Error(), exitCode)
@@ -241,3 +230,85 @@ func PrintResult(res Result) {
 		fmt.Fprintln(stdErr, dataErr)
 	}
 }
+
+type LogLevel int
+
+const (
+	LogLevelQuiet LogLevel = iota
+	LogLevelInfo
+	LogLevelDebug
+)
+
+var logLevel LogLevel = LogLevelInfo
+
+func SetLogLevel(level LogLevel) {
+	logLevel = level
+}
+
+func ParseLogLevel(levelStr string) (LogLevel, bool) {
+	switch strings.ToLower(levelStr) {
+	case "quiet":
+		return LogLevelQuiet, true
+	case "info":
+		return LogLevelInfo, true
+	case "debug", "verbose":
+		return LogLevelDebug, true
+	}
+	return LogLevelInfo, false
+}
+
+func Info(message string) {
+	if logLevel < LogLevelInfo {
+		return
+	}
+	printLogMessage("[INFO]", message)
+}
+
+func Debug(message string) {
+	if logLevel < LogLevelDebug {
+		return
+	}
+	printLogMessage("[DEBUG]", message)
+}
+
+func Warning(message string) {
+	if logLevel < LogLevelInfo {
+		return
+	}
+	printLogMessage("[WARNING]", message)
+}
+
+func printLogMessage(level string, message string) {
+	switch format {
+	case JSON, MinifiedJSON:
+		type logMsg struct {
+			Level   string `json:"level"`
+			Message string `json:"message"`
+		}
+		output, _ := json.Marshal(logMsg{Level: level, Message: message})
+		fmt.Fprintln(feedbackOut, string(output))
+	default: // Text
+		fmt.Fprintf(feedbackErr, "%s %s\n", level, message)
+	}
+}
+
+func Progress(percent float32) {
+	if logLevel < LogLevelInfo {
+		return
+	}
+	switch format {
+	case JSON, MinifiedJSON:
+		type progressMsg struct {
+			Type  string  `json:"type"`
+			Value float32 `json:"value"`
+		}
+		output, _ := json.Marshal(progressMsg{Type: "progress", Value: percent})
+		fmt.Fprintln(feedbackOut, string(output))
+	default: // Text
+
+		fmt.Fprintf(feedbackErr, "\rProgress: %.0f%%", percent*100)
+		if percent >= 1.0 {
+			fmt.Fprintln(feedbackErr)
+		}
+	}
+}

internal/orchestrator/orchestrator.go

@@ -67,10 +67,13 @@ const (
 	UnknownType  MessageType = ""
 	ProgressType MessageType = "progress"
 	InfoType     MessageType = "info"
+	DebugType    MessageType = "debug"
+	WarningType  MessageType = "warning"
 	ErrorType    MessageType = "error"
 )
 
 type StreamMessage struct {
+	Type     MessageType
 	data     string
 	error    error
 	progress *Progress
@@ -81,74 +84,73 @@ type Progress struct {
 	Progress float32
 }
 
-func (p *StreamMessage) IsData() bool           { return p.data != "" }
+func (p *StreamMessage) IsInfo() bool           { return p.Type == InfoType }
+func (p *StreamMessage) IsDebug() bool          { return p.Type == DebugType }
+func (p *StreamMessage) IsWarning() bool        { return p.Type == WarningType }
 func (p *StreamMessage) IsError() bool          { return p.error != nil }
 func (p *StreamMessage) IsProgress() bool       { return p.progress != nil }
 func (p *StreamMessage) GetData() string        { return p.data }
 func (p *StreamMessage) GetError() error        { return p.error }
 func (p *StreamMessage) GetProgress() *Progress { return p.progress }
 func (p *StreamMessage) GetType() MessageType {
-	if p.IsData() {
-		return InfoType
-	}
-	if p.IsError() {
-		return ErrorType
-	}
-	if p.IsProgress() {
-		return ProgressType
-	}
-	return UnknownType
+	return p.Type
 }
 
 func StartApp(ctx context.Context, docker *dockerClient.Client, provisioner *Provision, modelsIndex *modelsindex.ModelsIndex, bricksIndex *bricksindex.BricksIndex, app app.ArduinoApp) iter.Seq[StreamMessage] {
 	return func(yield func(StreamMessage) bool) {
 		ctx, cancel := context.WithCancel(ctx)
 		defer cancel()
 
+		if !yield(StreamMessage{Type: DebugType, data: "Checking for already running apps..."}) {
+			cancel()
+			return
+		}
 		running, err := getRunningApp(ctx, docker)
 		if err != nil {
-			yield(StreamMessage{error: err})
+			yield(StreamMessage{Type: ErrorType, error: err})
 			return
 		}
 		if running != nil {
-			yield(StreamMessage{error: fmt.Errorf("app %q is running", running.Name)})
+			err := fmt.Errorf("app %q is already running", running.Name)
+			yield(StreamMessage{Type: ErrorType, error: err})
 			return
 		}
 
 		callbackWriter := NewCallbackWriter(func(line string) {
-			if !yield(StreamMessage{data: line}) {
+			if !yield(StreamMessage{Type: DebugType, data: line}) {
 				cancel()
 				return
 			}
 		})
 
 		if app.MainSketchPath != nil {
-			if !yield(StreamMessage{data: "compiling and updating sketch..."}) {
+			if !yield(StreamMessage{Type: InfoType, data: "Compiling and updating sketch..."}) {
 				cancel()
 				return
 			}
 			if err := compileUploadSketch(ctx, &app, callbackWriter); err != nil {
-				yield(StreamMessage{error: err})
+				yield(StreamMessage{Type: ErrorType, error: err})
 				return
 			}
 		}
 		if app.MainPythonFile != nil {
-			if !yield(StreamMessage{data: "Provisioning app..."}) {
+			if !yield(StreamMessage{Type: InfoType, data: "Provisioning app..."}) {
 				cancel()
 				return
 			}
 			if err := ProvisionApp(ctx, provisioner, bricksIndex, &app); err != nil {
-				yield(StreamMessage{error: err})
+				yield(StreamMessage{Type: ErrorType, error: err})
 				return
 			}
-			if !yield(StreamMessage{data: "Starting app..."}) {
+
+			if !yield(StreamMessage{Type: InfoType, data: "Starting app..."}) {
 				cancel()
 				return
 			}
 
 			provisioningStateDir, err := getProvisioningStateDir(app)
 			if err != nil {
-				yield(StreamMessage{error: err})
+				yield(StreamMessage{Type: ErrorType, error: err})
 				return
 			}
 
@@ -176,17 +178,17 @@ func StartApp(ctx context.Context, docker *dockerClient.Client, provisioner *Pro
 			commands = append(commands, "up", "-d", "--remove-orphans", "--pull", "missing")
 			process, err := paths.NewProcess(envs, commands...)
 			if err != nil {
-				yield(StreamMessage{error: err})
+				yield(StreamMessage{Type: ErrorType, error: err})
 				return
 			}
 			process.RedirectStderrTo(callbackWriter)
 			process.RedirectStdoutTo(callbackWriter)
 			if err := process.RunWithinContext(ctx); err != nil {
-				yield(StreamMessage{error: err})
+				yield(StreamMessage{Type: ErrorType, error: err})
 				return
 			}
 		}
-		_ = yield(StreamMessage{progress: &Progress{Name: "", Progress: 100.0}})
+		_ = yield(StreamMessage{Type: ProgressType, progress: &Progress{Name: "", Progress: 100.0}})
 	}
 }