Update interface for rwx logs (#267)

Co-authored-by: Dan Manges <[email protected]>

Author: robinaugh

cmd/rwx/logs.go

@@ -12,7 +12,11 @@ import (
 )
 
 var (
-	LogsOutput string
+	LogsOutputDir   string
+	LogsOutputFile  string
+	LogsJson        bool
+	LogsAutoExtract bool
+	LogsOpen        bool
 
 	logsCmd = &cobra.Command{
 		PreRunE: func(cmd *cobra.Command, args []string) error {
@@ -25,27 +29,42 @@ var (
 
 			taskId := args[0]
 
-			outputDir := LogsOutput
-			if outputDir == "" {
-				var err error
-				outputDir, err = getDefaultLogsDir()
-				if err != nil {
-					return errors.Wrap(err, "unable to determine default logs directory")
-				}
+			outputDirSet := cmd.Flags().Changed("output-dir")
+			outputFileSet := cmd.Flags().Changed("output-file")
+			if outputDirSet && outputFileSet {
+				return errors.New("output-dir and output-file cannot be used together")
 			}
 
-			if err := os.MkdirAll(outputDir, 0755); err != nil {
-				return errors.Wrapf(err, "unable to create output directory %s", outputDir)
-			}
+			var absOutputDir string
+			var absOutputFile string
+			var err error
 
-			absOutputDir, err := filepath.Abs(outputDir)
-			if err != nil {
-				return errors.Wrapf(err, "unable to resolve absolute path for %s", outputDir)
+			if LogsOutputFile != "" {
+				absOutputFile, err = filepath.Abs(LogsOutputFile)
+				if err != nil {
+					return errors.Wrapf(err, "unable to resolve absolute path for %s", LogsOutputFile)
+				}
+			} else {
+				outputDir := LogsOutputDir
+				if !outputDirSet {
+					outputDir, err = getDefaultLogsDir()
+					if err != nil {
+						return errors.Wrap(err, "unable to determine default logs directory")
+					}
+				}
+				absOutputDir, err = filepath.Abs(outputDir)
+				if err != nil {
+					return errors.Wrapf(err, "unable to resolve absolute path for %s", outputDir)
+				}
 			}
 
 			err = service.DownloadLogs(cli.DownloadLogsConfig{
-				TaskID:    taskId,
-				OutputDir: absOutputDir,
+				TaskID:      taskId,
+				OutputDir:   absOutputDir,
+				OutputFile:  absOutputFile,
+				Json:        LogsJson,
+				AutoExtract: LogsAutoExtract,
+				Open:        LogsOpen,
 			})
 			if err != nil {
 				return err
@@ -59,7 +78,12 @@ var (
 )
 
 func init() {
-	logsCmd.Flags().StringVarP(&LogsOutput, "output", "o", "", "output directory for the downloaded log file (defaults to Downloads folder)")
+	logsCmd.Flags().StringVar(&LogsOutputDir, "output-dir", "", "output directory for the downloaded log file (defaults to Downloads folder)")
+	logsCmd.Flags().StringVar(&LogsOutputFile, "output-file", "", "output file path for the downloaded log file")
+	logsCmd.MarkFlagsMutuallyExclusive("output-dir", "output-file")
+	logsCmd.Flags().BoolVar(&LogsJson, "json", false, "output file locations as JSON")
+	logsCmd.Flags().BoolVar(&LogsAutoExtract, "auto-extract", false, "automatically extract zip archives")
+	logsCmd.Flags().BoolVar(&LogsOpen, "open", false, "automatically open the downloaded file(s)")
 }
 
 func getDefaultLogsDir() (string, error) {

internal/cli/config.go

@@ -329,13 +329,20 @@ func (c PullImageConfig) Validate() error {
 }
 
 type DownloadLogsConfig struct {
-	TaskID    string
-	OutputDir string
+	TaskID      string
+	OutputDir   string
+	OutputFile  string
+	Json        bool
+	AutoExtract bool
+	Open        bool
 }
 
 func (c DownloadLogsConfig) Validate() error {
 	if c.TaskID == "" {
 		return errors.New("task ID must be provided")
 	}
+	if c.OutputDir != "" && c.OutputFile != "" {
+		return errors.New("output-dir and output-file cannot be used together")
+	}
 	return nil
 }

internal/cli/service.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"archive/zip"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -12,6 +13,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/skratchdot/open-golang/open"
+
 	"github.com/rwx-cloud/cli/internal/accesstoken"
 	"github.com/rwx-cloud/cli/internal/api"
 	"github.com/rwx-cloud/cli/internal/dotenv"
@@ -587,20 +590,139 @@ func (s Service) DownloadLogs(cfg DownloadLogsConfig) error {
 		return errors.Wrap(err, "unable to download logs")
 	}
 
-	outputPath := filepath.Join(cfg.OutputDir, LogDownloadRequest.Filename)
+	var outputPath string
+	if cfg.OutputFile != "" {
+		outputPath = cfg.OutputFile
+	} else {
+		outputPath = filepath.Join(cfg.OutputDir, LogDownloadRequest.Filename)
+	}
+
+	outputDir := filepath.Dir(outputPath)
+	if err := os.MkdirAll(outputDir, 0755); err != nil {
+		return errors.Wrapf(err, "unable to create output directory %s", outputDir)
+	}
 
 	if _, err := os.Stat(outputPath); err == nil {
-		fmt.Fprintf(s.Stdout, "Overwriting existing file at %s\n", outputPath)
+		if !cfg.Json {
+			fmt.Fprintf(s.Stdout, "Overwriting existing file at %s\n", outputPath)
+		}
 	}
 
 	if err := os.WriteFile(outputPath, logBytes, 0644); err != nil {
 		return errors.Wrapf(err, "unable to write log file to %s", outputPath)
 	}
 
-	fmt.Fprintf(s.Stdout, "Logs downloaded to %s\n", outputPath)
+	var outputFiles []string
+	outputFiles = append(outputFiles, outputPath)
+
+	if cfg.AutoExtract && strings.HasSuffix(strings.ToLower(outputPath), ".zip") {
+		// Create a directory named after the zip file (without .zip extension)
+		zipName := filepath.Base(outputPath)
+		extractDirName := strings.TrimSuffix(zipName, filepath.Ext(zipName))
+		extractDir := filepath.Join(filepath.Dir(outputPath), extractDirName)
+
+		if err := os.MkdirAll(extractDir, 0755); err != nil {
+			return errors.Wrapf(err, "unable to create extraction directory %s", extractDir)
+		}
+
+		extractedFiles, err := extractZip(outputPath, extractDir)
+		if err != nil {
+			return errors.Wrapf(err, "unable to extract zip archive %s", outputPath)
+		}
+		outputFiles = extractedFiles
+
+		if !cfg.Json {
+			fmt.Fprintf(s.Stdout, "Extracted %d file(s) from %s to %s\n", len(extractedFiles), outputPath, extractDir)
+		}
+	}
+
+	if cfg.Open {
+		for _, file := range outputFiles {
+			if err := open.Run(file); err != nil {
+				if !cfg.Json {
+					fmt.Fprintf(s.Stderr, "Failed to open %s: %v\n", file, err)
+				}
+			}
+		}
+	}
+
+	if cfg.Json {
+		output := struct {
+			OutputFiles []string `json:"outputFiles"`
+		}{
+			OutputFiles: outputFiles,
+		}
+		if err := json.NewEncoder(s.Stdout).Encode(output); err != nil {
+			return errors.Wrap(err, "unable to encode JSON output")
+		}
+	} else {
+		if len(outputFiles) == 1 {
+			fmt.Fprintf(s.Stdout, "Logs downloaded to %s\n", outputFiles[0])
+		} else {
+			fmt.Fprintf(s.Stdout, "Logs downloaded and extracted:\n")
+			for _, file := range outputFiles {
+				fmt.Fprintf(s.Stdout, "  %s\n", file)
+			}
+		}
+	}
 	return nil
 }
 
+func extractZip(zipPath, destDir string) ([]string, error) {
+	reader, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to open zip file")
+	}
+	defer reader.Close()
+
+	var extractedFiles []string
+
+	for _, file := range reader.File {
+		filePath := filepath.Join(destDir, file.Name)
+		if !strings.HasPrefix(filePath, filepath.Clean(destDir)+string(os.PathSeparator)) {
+			return nil, fmt.Errorf("invalid file path in zip: %s", file.Name)
+		}
+
+		if file.FileInfo().IsDir() {
+			if err := os.MkdirAll(filePath, 0755); err != nil {
+				return nil, errors.Wrapf(err, "unable to create directory %s", filePath)
+			}
+			continue
+		}
+
+		if err := os.MkdirAll(filepath.Dir(filePath), 0755); err != nil {
+			return nil, errors.Wrapf(err, "unable to create directory for %s", filePath)
+		}
+
+		rc, err := file.Open()
+		if err != nil {
+			return nil, errors.Wrapf(err, "unable to open file %s in zip", file.Name)
+		}
+
+		outFile, err := os.Create(filePath)
+		if err != nil {
+			rc.Close()
+			return nil, errors.Wrapf(err, "unable to create file %s", filePath)
+		}
+
+		_, err = io.Copy(outFile, rc)
+		outFile.Close()
+		rc.Close()
+
+		if err != nil {
+			return nil, errors.Wrapf(err, "unable to extract file %s", filePath)
+		}
+
+		if err := os.Chmod(filePath, file.FileInfo().Mode()); err != nil {
+			return nil, errors.Wrapf(err, "unable to set permissions for %s", filePath)
+		}
+
+		extractedFiles = append(extractedFiles, filePath)
+	}
+
+	return extractedFiles, nil
+}
+
 func (s Service) SetSecretsInVault(cfg SetSecretsInVaultConfig) error {
 	defer s.outputLatestVersionMessage()
 	err := cfg.Validate()