improve parsing

Author: lucarin91

internal/updater/flasher.go

@@ -16,11 +16,9 @@
 package updater
 
 import (
-	"bufio"
 	"context"
 	"encoding/hex"
 	"fmt"
-	"log/slog"
 	"runtime"
 	"strconv"
 	"strings"
@@ -96,18 +94,18 @@ func Flash(ctx context.Context, imagePath *paths.Path, version string, forceYes
 	return FlashBoard(ctx, imagePath.String(), version, preserveUser, nil)
 }
 
-type TypeEvent int
+type EventType int
 
 const (
-	EventWaiting TypeEvent = 3
-	EventFlashed TypeEvent = 4
+	EventLog EventType = iota
+	EventProgress
 )
 
 type FlashEvent struct {
-	Type        TypeEvent
-	Progress    int
-	MaxProgress int
-	Log         string
+	Type     EventType
+	Log      string
+	Progress int
+	Total    int
 }
 
 type FlahsCallback func(FlashEvent)
@@ -197,25 +195,21 @@ func FlashBoard(ctx context.Context, downloadedImagePath string, version string,
 	if callback != nil {
 		progress := 0
 		w = helper.NewCallbackWriter(func(line string) {
-			parsedLine, err := parseQdlLogLine(line)
-			if err != nil {
-				slog.Warn("could not parse qdl log line", "error", err, "line", line)
-				return
-			}
+			parsedLine := parseQdlLogLine(line)
 
 			switch parsedLine.Op {
-			case Waiting:
+			case Flashed:
+				progress++
 				callback(FlashEvent{
-					Type: EventWaiting,
-					Log:  line,
+					Type:     EventProgress,
+					Log:      line,
+					Progress: progress,
+					Total:    totalPartitions,
 				})
-			case Flasherd:
-				progress++
+			default:
 				callback(FlashEvent{
-					Type:        EventFlashed,
-					Log:         line,
-					Progress:    progress,
-					MaxProgress: totalPartitions,
+					Type: EventLog,
+					Log:  line,
 				})
 			}
 		})
@@ -278,52 +272,3 @@ func checkBoardGPTTable(ctx context.Context, qdlPath, flashDir *paths.Path) erro
 
 	return nil
 }
-
-type Op int
-
-const (
-	Waiting  Op = 1
-	Flasherd Op = 2
-)
-
-type QDLLogLine struct {
-	Op  Op
-	Log string
-}
-
-func parseQdlLogLine(line string) (QDLLogLine, error) {
-	line = strings.ToLower(line)
-	if strings.HasPrefix(line, "waiting for") {
-		return QDLLogLine{
-			Op:  Waiting,
-			Log: line,
-		}, nil
-	}
-
-	if strings.HasPrefix(line, "flashed") {
-		return QDLLogLine{
-			Op:  Flasherd,
-			Log: line,
-		}, nil
-	}
-
-	return QDLLogLine{}, fmt.Errorf("line %q does not match known operations", line)
-}
-
-func getTotalPartition(path *paths.Path) (int, error) {
-	f, err := path.Open()
-	if err != nil {
-		return 0, err
-	}
-
-	r := bufio.NewScanner(f)
-	var total int
-	for r.Scan() {
-		c := strings.Count(r.Text(), "<program")
-		total += c
-	}
-	if err := r.Err(); err != nil {
-		return 0, err
-	}
-	return total, nil
-}

internal/updater/parseqdl.go

@@ -0,0 +1,61 @@
+package updater
+
+import (
+	"bufio"
+	"strings"
+
+	"github.com/arduino/go-paths-helper"
+)
+
+type Op int
+
+const (
+	Waiting Op = iota
+	Flashed
+	Unknown
+)
+
+type QDLLogLine struct {
+	Op  Op
+	Log string
+}
+
+func parseQdlLogLine(line string) QDLLogLine {
+	lower := strings.ToLower(line)
+
+	switch {
+	case strings.HasPrefix(lower, "waiting for"):
+		return QDLLogLine{
+			Op:  Waiting,
+			Log: line,
+		}
+	case strings.HasPrefix(lower, "flashed"):
+		return QDLLogLine{
+			Op:  Flashed,
+			Log: line,
+		}
+	default:
+		return QDLLogLine{
+			Op:  Unknown,
+			Log: line,
+		}
+	}
+}
+
+func getTotalPartition(path *paths.Path) (int, error) {
+	f, err := path.Open()
+	if err != nil {
+		return 0, err
+	}
+
+	r := bufio.NewScanner(f)
+	var total int
+	for r.Scan() {
+		c := strings.Count(r.Text(), "<program")
+		total += c
+	}
+	if err := r.Err(); err != nil {
+		return 0, err
+	}
+	return total, nil
+}

internal/updater/parseqdl_test.go

@@ -0,0 +1,72 @@
+package updater
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseQdlLogLine(t *testing.T) {
+	tests := []struct {
+		line    string
+		want    QDLLogLine
+		wantErr bool
+	}{
+		{
+			line: "Waiting for EDL device...",
+			want: QDLLogLine{
+				Op:  Waiting,
+				Log: "Waiting for EDL device...",
+			},
+		},
+		{
+			line: "waiting for programmer...",
+			want: QDLLogLine{
+				Op:  Waiting,
+				Log: "waiting for programmer...",
+			},
+		},
+		{
+			line: `flashed "xbl_a" successfully`,
+			want: QDLLogLine{
+				Op:  Flashed,
+				Log: `flashed "xbl_a" successfully`,
+			},
+		},
+		{
+			line: `flashed "rootfs" successfully at 65058kB/s`,
+			want: QDLLogLine{
+				Op:  Flashed,
+				Log: `flashed "rootfs" successfully at 65058kB/s`,
+			},
+		},
+		{
+
+			line: "13 patches applied",
+			want: QDLLogLine{
+				Op:  Unknown,
+				Log: "13 patches applied",
+			},
+		},
+		{
+			line: "partition 0 is now bootable",
+			want: QDLLogLine{
+				Op:  Unknown,
+				Log: "partition 0 is now bootable",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.line, func(t *testing.T) {
+			result, err := parseQdlLogLine(tt.line)
+			if tt.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, result)
+			}
+
+		})
+	}
+}

service/service_flash.go

@@ -129,12 +129,20 @@ func (s *flasherServerImpl) Flash(req *flasher.FlashRequest, stream flasher.Flas
 
 	flashCB(&flasher.TaskProgress{Name: "flash", Message: "Starting"})
 	if err := updater.FlashBoard(ctx, imagePath.String(), rel.Version, req.GetPreserveUser(), func(fe updater.FlashEvent) {
-		flashCB(&flasher.TaskProgress{
-			Name:     "flash",
-			Message:  fe.Log,
-			Progress: int64(fe.Progress),
-			Total:    int64(fe.MaxProgress),
-		})
+		switch fe.Type {
+		case updater.EventLog:
+			flashCB(&flasher.TaskProgress{
+				Name:    "flash",
+				Message: fe.Log,
+			})
+		case updater.EventProgress:
+			flashCB(&flasher.TaskProgress{
+				Name:     "flash",
+				Message:  fe.Log,
+				Progress: int64(fe.Progress),
+				Total:    int64(fe.Total),
+			})
+		}
 
 	}); err != nil {
 		return err