record

Signed-off-by: Harper, Jason M <[email protected]>

Author: harp-intel

cmd/config/config.go

@@ -14,6 +14,7 @@ import (
 	"perfspect/internal/report"
 	"perfspect/internal/script"
 	"perfspect/internal/target"
+	"perfspect/internal/util"
 	"slices"
 	"strings"
 
@@ -52,6 +53,22 @@ func runCmd(cmd *cobra.Command, args []string) error {
 	// appContext is the application context that holds common data and resources.
 	appContext := cmd.Parent().Context().Value(common.AppContext{}).(common.AppContext)
 	localTempDir := appContext.LocalTempDir
+	outputDir := appContext.OutputDir
+
+	flagRecord := cmd.Flags().Lookup(flagRecordName).Value.String() == "true"
+	flagNoSummary := cmd.Flags().Lookup(flagNoSummaryName).Value.String() == "true"
+
+	// create output directory if we are recording the configuration
+	if flagRecord {
+		err := util.CreateDirectoryIfNotExists(outputDir, 0755) // #nosec G301
+		if err != nil {
+			err = fmt.Errorf("failed to create output directory: %w", err)
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error(err.Error())
+			cmd.SilenceUsage = true
+			return err
+		}
+	}
 	// get the targets
 	myTargets, targetErrs, err := common.GetTargets(cmd, true, true, localTempDir)
 	if err != nil {
@@ -91,14 +108,40 @@ func runCmd(cmd *cobra.Command, args []string) error {
 		cmd.SilenceUsage = true
 		return err
 	}
-	// print config prior to changes, optionally
-	if !cmd.Flags().Lookup(flagNoSummaryName).Changed {
-		if err := printConfig(myTargets, localTempDir); err != nil {
+	// collect and print and/or record the configuration before making changes
+	if !flagNoSummary || flagRecord {
+		config, err := getConfig(myTargets, localTempDir)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error(err.Error())
+			cmd.SilenceUsage = true
+			return err
+		}
+		reports, err := processConfig(config)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error(err.Error())
+			cmd.SilenceUsage = true
+			return err
+		}
+		filesWritten, err := printConfig(reports, !flagNoSummary, flagRecord, outputDir)
+		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			slog.Error(err.Error())
 			cmd.SilenceUsage = true
 			return err
 		}
+		if len(filesWritten) > 0 {
+			message := "Configuration"
+			if len(filesWritten) > 1 {
+				message = "Configurations"
+			}
+			fmt.Printf("%s recorded:\n", message)
+			for _, fileWritten := range filesWritten {
+				fmt.Printf("  %s\n", fileWritten)
+			}
+			fmt.Println()
+		}
 	}
 	// if no changes were requested, print a message and return
 	var changeRequested bool
@@ -138,9 +181,24 @@ func runCmd(cmd *cobra.Command, args []string) error {
 	}
 	multiSpinner.Finish()
 	fmt.Println() // blank line
-	// print config after making changes
-	if !cmd.Flags().Lookup(flagNoSummaryName).Changed {
-		if err := printConfig(myTargets, localTempDir); err != nil {
+	// collect and print the configuration before making changes
+	if !flagNoSummary {
+		config, err := getConfig(myTargets, localTempDir)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error(err.Error())
+			cmd.SilenceUsage = true
+			return err
+		}
+		reports, err := processConfig(config)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error(err.Error())
+			cmd.SilenceUsage = true
+			return err
+		}
+		_, err = printConfig(reports, !flagNoSummary, false, outputDir) // print, don't record
+		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			slog.Error(err.Error())
 			cmd.SilenceUsage = true
@@ -227,7 +285,8 @@ func setOnTarget(cmd *cobra.Command, myTarget target.Target, flagGroups []flagGr
 	channelError <- nil
 }
 
-func printConfig(myTargets []target.Target, localTempDir string) (err error) {
+// getConfig collects the configuration data from the target(s)
+func getConfig(myTargets []target.Target, localTempDir string) ([]common.TargetScriptOutputs, error) {
 	scriptNames := report.GetScriptNamesForTable(report.ConfigurationTableName)
 	var scriptsToRun []script.ScriptDefinition
 	for _, scriptName := range scriptNames {
@@ -239,10 +298,10 @@ func printConfig(myTargets []target.Target, localTempDir string) (err error) {
 	channelTargetScriptOutputs := make(chan common.TargetScriptOutputs)
 	channelError := make(chan error)
 	for _, myTarget := range myTargets {
-		err = multiSpinner.AddSpinner(myTarget.GetName())
+		err := multiSpinner.AddSpinner(myTarget.GetName())
 		if err != nil {
 			err = fmt.Errorf("failed to add spinner: %v", err)
-			return
+			return nil, err
 		}
 		// run the selected scripts on the target
 		go collectOnTarget(myTarget, scriptsToRun, localTempDir, channelTargetScriptOutputs, channelError, multiSpinner.Status)
@@ -269,28 +328,55 @@ func printConfig(myTargets []target.Target, localTempDir string) (err error) {
 		}
 	}
 	multiSpinner.Finish()
-	// process and print the table for each target
-	for _, targetScriptOutputs := range orderedTargetScriptOutputs {
+	return orderedTargetScriptOutputs, nil
+}
+
+// processConfig processes the collected configuration data and creates text reports
+func processConfig(targetScriptOutputs []common.TargetScriptOutputs) (map[string][]byte, error) {
+	reports := make(map[string][]byte)
+	var err error
+	for _, targetScriptOutput := range targetScriptOutputs {
 		// process the tables, i.e., get field values from raw script output
 		tableNames := []string{report.ConfigurationTableName}
 		var tableValues []report.TableValues
-		if tableValues, err = report.ProcessTables(tableNames, targetScriptOutputs.ScriptOutputs); err != nil {
+		if tableValues, err = report.ProcessTables(tableNames, targetScriptOutput.ScriptOutputs); err != nil {
 			err = fmt.Errorf("failed to process collected data: %v", err)
-			return
+			return nil, err
 		}
 		// create the report for this single table
 		var reportBytes []byte
-		if reportBytes, err = report.Create("txt", tableValues, targetScriptOutputs.TargetName); err != nil {
+		if reportBytes, err = report.Create("txt", tableValues, targetScriptOutput.TargetName); err != nil {
 			err = fmt.Errorf("failed to create report: %v", err)
-			return
+			return nil, err
 		}
-		// print the report
-		if len(orderedTargetScriptOutputs) > 1 {
-			fmt.Printf("%s\n", targetScriptOutputs.TargetName)
+		// append the report to the list
+		reports[targetScriptOutput.TargetName] = reportBytes
+	}
+	return reports, nil
+}
+
+// printConfig prints and/or saves the configuration reports
+func printConfig(reports map[string][]byte, toStdout bool, toFile bool, outputDir string) ([]string, error) {
+	filesWriten := []string{}
+	for targetName, reportBytes := range reports {
+		if toStdout {
+			// print the report to stdout
+			if len(reports) > 1 {
+				fmt.Printf("%s\n", targetName)
+			}
+			fmt.Print(string(reportBytes))
+		}
+		if toFile {
+			outputFilePath := fmt.Sprintf("%s/config_%s.txt", outputDir, targetName)
+			err := os.WriteFile(outputFilePath, reportBytes, 0644) // #nosec G306
+			if err != nil {
+				err = fmt.Errorf("failed to write configuration report to file: %v", err)
+				return filesWriten, err
+			}
+			filesWriten = append(filesWriten, outputFilePath)
 		}
-		fmt.Print(string(reportBytes))
 	}
-	return
+	return filesWriten, nil
 }
 
 // collectOnTarget runs the scripts on the target and sends the results to the appropriate channels

cmd/config/flag_groups.go

@@ -66,6 +66,8 @@ const (
 // other flag names
 const (
 	flagNoSummaryName = "no-summary"
+	flagRecordName    = "record"
+	flagRestoreName   = "restore"
 )
 
 // governorOptions - list of valid governor options
@@ -237,6 +239,12 @@ func initializeFlags(cmd *cobra.Command) {
 	group.flags = append(group.flags,
 		newBoolFlag(cmd, flagNoSummaryName, false, nil, "do not print configuration summary", "", nil),
 	)
+	group.flags = append(group.flags,
+		newBoolFlag(cmd, flagRecordName, false, nil, "record the current configuration to a file to be restored later", "", nil),
+	)
+	group.flags = append(group.flags,
+		newStringFlag(cmd, flagRestoreName, "", nil, "restore a previously recorded configuration from the specified file", "", nil),
+	)
 	flagGroups = append(flagGroups, group)
 
 	common.AddTargetFlags(Cmd)