apply same enhancements to FlashCertificates func

Author: umbynos

cli/certificates/flash.go

@@ -142,11 +142,10 @@ func run(cmd *cobra.Command, args []string) {
 	}
 
 	// Flash loader Sketch
-	flashOut := new(bytes.Buffer)
-	flashErr := new(bytes.Buffer)
-	// var err error
+	programmerOut := new(bytes.Buffer)
+	programmerErr := new(bytes.Buffer)
 	if feedback.GetFormat() == feedback.JSON {
-		err = programmer.Flash(commandLine, flashOut, flashErr)
+		err = programmer.Flash(commandLine, programmerOut, programmerErr)
 	} else {
 		err = programmer.Flash(commandLine, os.Stdout, os.Stderr)
 	}
@@ -175,9 +174,52 @@ func run(cmd *cobra.Command, args []string) {
 	}
 	defer f.Close()
 
+	// now flash the certificate
+	flasherOut := new(bytes.Buffer)
+	flasherErr := new(bytes.Buffer)
 	certFileList := paths.NewPathList(certificatePaths...)
-	if err := f.FlashCertificates(&certFileList, certificateURLs); err != nil {
+	if feedback.GetFormat() == feedback.JSON {
+		err = f.FlashCertificates(&certFileList, certificateURLs, flasherOut)
+	} else {
+		err = f.FlashCertificates(&certFileList, certificateURLs, os.Stdout)
+	}
+	if err != nil {
 		feedback.Errorf("Error during certificates flashing: %s", err)
+		flasherErr.Write([]byte(fmt.Sprintf("Error during certificates flashing: %s", err)))
+	}
+
+	// Print the results
+	feedback.PrintResult(&flashResult{
+		Programmer: (&ExecOutput{
+			Stdout: programmerOut.String(),
+			Stderr: programmerErr.String(),
+		}),
+		Flasher: (&ExecOutput{
+			Stdout: flasherOut.String(),
+			Stderr: flasherErr.String(),
+		}),
+	})
+	// Exit if something went wrong but after printing
+	if err != nil {
 		os.Exit(errorcodes.ErrGeneric)
 	}
 }
+
+type flashResult struct {
+	Programmer *ExecOutput `json:"programmer"`
+	Flasher    *ExecOutput `json:"flasher"`
+}
+
+type ExecOutput struct {
+	Stdout string `json:"stdout"`
+	Stderr string `json:"stderr"`
+}
+
+func (r *flashResult) Data() interface{} {
+	return r
+}
+
+func (r *flashResult) String() string {
+	// The output is already printed via os.Stdout/os.Stdin
+	return ""
+}

flasher/flasher.go

@@ -50,7 +50,7 @@ func (e FlasherError) Error() string {
 
 type Flasher interface {
 	FlashFirmware(firmwareFile *paths.Path, flasherOut io.Writer) error
-	FlashCertificates(certificatePaths *paths.PathList, URLs []string) error
+	FlashCertificates(certificatePaths *paths.PathList, URLs []string, flasherOut io.Writer) error
 	Close() error
 
 	hello() error

flasher/nina.go

@@ -99,10 +99,12 @@ func (f *NinaFlasher) FlashFirmware(firmwareFile *paths.Path, flasherOut io.Writ
 	return err //should be nil
 }
 
-func (f *NinaFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs []string) error {
+func (f *NinaFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs []string, flasherOut io.Writer) error {
 	var certificatesData []byte
 	for _, certPath := range *certificatePaths {
 		logrus.Infof("Converting and flashing certificate %s", certPath)
+		flasherOut.Write([]byte(fmt.Sprintf("Converting and flashing certificate %s", certPath)))
+		flasherOut.Write([]byte(fmt.Sprintln()))
 
 		data, err := f.certificateFromFile(certPath)
 		if err != nil {
@@ -113,6 +115,8 @@ func (f *NinaFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs [
 
 	for _, URL := range URLs {
 		logrus.Infof("Converting and flashing certificate from %s", URL)
+		flasherOut.Write([]byte(fmt.Sprintf("Converting and flashing certificate from %s", URL)))
+		flasherOut.Write([]byte(fmt.Sprintln()))
 		data, err := f.certificateFromURL(URL)
 		if err != nil {
 			return err
@@ -133,7 +137,14 @@ func (f *NinaFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs [
 	}
 
 	certificatesOffset := 0x10000
-	return f.flashChunk(certificatesOffset, certificatesData)
+	if err := f.flashChunk(certificatesOffset, certificatesData); err != nil {
+		logrus.Error(err)
+		return err
+	}
+	logrus.Infof("Flashed all the things")
+	flasherOut.Write([]byte("Flashed all the things"))
+	flasherOut.Write([]byte(fmt.Sprintln()))
+	return nil
 }
 
 func (f *NinaFlasher) certificateFromFile(certificateFile *paths.Path) ([]byte, error) {

flasher/sara.go

@@ -110,7 +110,7 @@ func (f *SaraFlasher) FlashFirmware(firmwareFile *paths.Path, flasherOut io.Writ
 	return err //should be nil
 }
 
-func (f *SaraFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs []string) error {
+func (f *SaraFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs []string, _ io.Writer) error {
 	return fmt.Errorf("not supported by SaraFlasher")
 }
 

flasher/winc.go

@@ -80,11 +80,13 @@ func (f *WincFlasher) FlashFirmware(firmwareFile *paths.Path, flasherOut io.Writ
 	return err //should be nil
 }
 
-func (f *WincFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs []string) error {
+func (f *WincFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs []string, flasherOut io.Writer) error {
 	var certificatesData []byte
 	certificatesNumber := 0
 	for _, certPath := range *certificatePaths {
 		logrus.Infof("Converting and flashing certificate %s", certPath)
+		flasherOut.Write([]byte(fmt.Sprintf("Converting and flashing certificate %s", certPath)))
+		flasherOut.Write([]byte(fmt.Sprintln()))
 
 		data, err := f.certificateFromFile(certPath)
 		if err != nil {
@@ -96,6 +98,8 @@ func (f *WincFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs [
 
 	for _, URL := range URLs {
 		logrus.Infof("Converting and flashing certificate from %s", URL)
+		flasherOut.Write([]byte(fmt.Sprintf("Converting and flashing certificate from %s", URL)))
+		flasherOut.Write([]byte(fmt.Sprintln()))
 		data, err := f.certificateFromURL(URL)
 		if err != nil {
 			return err
@@ -105,7 +109,14 @@ func (f *WincFlasher) FlashCertificates(certificatePaths *paths.PathList, URLs [
 	}
 
 	certificatesOffset := 0x4000
-	return f.flashChunk(certificatesOffset, certificatesData)
+	if err := f.flashChunk(certificatesOffset, certificatesData); err != nil {
+		logrus.Error(err)
+		return err
+	}
+	logrus.Infof("Flashed all the things")
+	flasherOut.Write([]byte("Flashed all the things"))
+	flasherOut.Write([]byte(fmt.Sprintln()))
+	return nil
 }
 
 func (f *WincFlasher) certificateFromFile(certificateFile *paths.Path) ([]byte, error) {