add non-wasm version of tplprev

tplprev/data.go

@@ -24,34 +24,43 @@ type LogEntry struct {
 	Level   LogLevel
 }
 
-type LogLevel int
+type LogLevel string
 
 const (
-	PanicLevel LogLevel = iota
-	FatalLevel
-	ErrorLevel
-	WarnLevel
-	InfoLevel
-	DebugLevel
-	TraceLevel
+	TraceLevel LogLevel = "trace"
+	DebugLevel LogLevel = "debug"
+	InfoLevel  LogLevel = "info"
+	WarnLevel  LogLevel = "warning"
+	ErrorLevel LogLevel = "error"
+	FatalLevel LogLevel = "fatal"
+	PanicLevel LogLevel = "panic"
 )
 
-func (level LogLevel) String() string {
-	switch level {
-	case TraceLevel:
-		return "trace"
-	case DebugLevel:
-		return "debug"
-	case InfoLevel:
-		return "info"
-	case WarnLevel:
-		return "warning"
-	case ErrorLevel:
-		return "error"
-	case FatalLevel:
-		return "fatal"
-	case PanicLevel:
-		return "panic"
+func LevelsFromString(str string) []LogLevel {
+	levels := make([]LogLevel, 0, len(str))
+	for _, c := range str {
+		switch c {
+		case 'p':
+			levels = append(levels, PanicLevel)
+		case 'f':
+			levels = append(levels, FatalLevel)
+		case 'e':
+			levels = append(levels, ErrorLevel)
+		case 'w':
+			levels = append(levels, WarnLevel)
+		case 'i':
+			levels = append(levels, InfoLevel)
+		case 'd':
+			levels = append(levels, DebugLevel)
+		case 't':
+			levels = append(levels, TraceLevel)
+		default:
+			continue
+		}
 	}
-	return ""
+	return levels
+}
+
+func (level LogLevel) String() string {
+	return string(level)
 }

tplprev/main.go

@@ -1,89 +1,47 @@
+//go:build !wasm
+
 package main
 
 import (
+	"flag"
 	"fmt"
-	"strings"
-	"text/template"
-	"time"
+	"os"
 
 	"github.com/containrrr/watchtower/internal/meta"
-	"github.com/containrrr/watchtower/pkg/notifications/templates"
-
-	"syscall/js"
 )
 
 func main() {
-	fmt.Println("watchtower/tplprev v" + meta.Version)
+	fmt.Fprintf(os.Stderr, "watchtower/tplprev v%v\n\n", meta.Version)
 
-	js.Global().Set("WATCHTOWER", js.ValueOf(map[string]any{
-		"tplprev": js.FuncOf(tplprev),
-	}))
-	<-make(chan bool)
+	var states string
+	var entries string
 
-}
+	flag.StringVar(&states, "states", "cccuuueeekkktttfff", "sCanned, Updated, failEd, sKipped, sTale, Fresh")
+	flag.StringVar(&entries, "entries", "ewwiiidddd", "Fatal,Error,Warn,Info,Debug,Trace")
 
-func tplprev(this js.Value, args []js.Value) any {
+	flag.Parse()
 
-	rb := ReportBuilder()
-
-	if len(args) < 2 {
-		return "Requires 3 argument passed"
+	if len(flag.Args()) < 1 {
+		fmt.Fprintln(os.Stderr, "Missing required argument TEMPLATE")
+		flag.Usage()
+		os.Exit(1)
+		return
 	}
 
-	input := args[0].String()
-	tpl, err := template.New("").Funcs(templates.Funcs).Parse(input)
+	input, err := os.ReadFile(flag.Arg(0))
 	if err != nil {
-		return "Failed to parse template: " + err.Error()
+
+		fmt.Fprintf(os.Stderr, "Failed to read template file %q: %v\n", flag.Arg(0), err)
+		os.Exit(1)
+		return
 	}
 
-	actionsArg := args[1]
-
-	for i := 0; i < actionsArg.Length(); i++ {
-		action := actionsArg.Index(i)
-		if action.Length() != 2 {
-			return fmt.Sprintf("Invalid size of action tuple, expected 2, got %v", action.Length())
-		}
-		count := action.Index(0).Int()
-		state := State(action.Index(1).String())
-		rb.AddNContainers(count, state)
-	}
-
-	entriesArg := args[2]
-	var entries []*LogEntry
-	for i := 0; i < entriesArg.Length(); i++ {
-		count := entriesArg.Index(i).Int()
-		level := ErrorLevel + LogLevel(i)
-		for m := 0; m < count; m++ {
-			var msg string
-			if level <= WarnLevel {
-				msg = rb.randomEntry(logErrors)
-			} else {
-				msg = rb.randomEntry(logMessages)
-			}
-			entries = append(entries, &LogEntry{
-				Message: msg,
-				Data:    map[string]any{},
-				Time:    time.Now(),
-				Level:   level,
-			})
-		}
-	}
-
-	report := rb.Build()
-	data := Data{
-		Entries: entries,
-		StaticData: StaticData{
-			Title: "Title",
-			Host:  "Host",
-		},
-		Report: report,
-	}
-
-	var buf strings.Builder
-	err = tpl.Execute(&buf, data)
+	result, err := TplPrev(string(input), StatesFromString(states), LevelsFromString(entries))
 	if err != nil {
-		return "Failed to execute template: " + err.Error()
+		fmt.Fprintf(os.Stderr, "Failed to read template file %q: %v\n", flag.Arg(0), err)
+		os.Exit(1)
+		return
 	}
 
-	return buf.String()
+	fmt.Println(result)
 }

tplprev/main_wasm.go

@@ -0,0 +1,60 @@
+//go:build wasm
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/containrrr/watchtower/internal/meta"
+
+	"syscall/js"
+)
+
+func main() {
+	fmt.Println("watchtower/tplprev v" + meta.Version)
+
+	js.Global().Set("WATCHTOWER", js.ValueOf(map[string]any{
+		"tplprev": js.FuncOf(jsTplPrev),
+	}))
+	<-make(chan bool)
+
+}
+
+func jsTplPrev(this js.Value, args []js.Value) any {
+
+	if len(args) < 3 {
+		return "Requires 3 arguments passed"
+	}
+
+	input := args[0].String()
+
+	statesArg := args[1]
+	var states []State
+
+	if statesArg.Type() == js.TypeString {
+		states = StatesFromString(statesArg.String())
+	} else {
+		for i := 0; i < statesArg.Length(); i++ {
+			state := State(statesArg.Index(i).String())
+			states = append(states, state)
+		}
+	}
+
+	levelsArg := args[2]
+	var levels []LogLevel
+
+	if levelsArg.Type() == js.TypeString {
+		levels = LevelsFromString(statesArg.String())
+	} else {
+		for i := 0; i < levelsArg.Length(); i++ {
+			level := LogLevel(levelsArg.Index(i).String())
+			levels = append(levels, level)
+		}
+	}
+
+	result, err := TplPrev(input, states, levels)
+	if err != nil {
+		return "Error: " + err.Error()
+	}
+	return result
+}

tplprev/report.go

@@ -3,7 +3,6 @@ package main
 import (
 	"encoding/hex"
 	"errors"
-	"fmt"
 	"math/rand"
 	"sort"
 	"strconv"
@@ -30,30 +29,27 @@ func (rb *reportBuilder) Build() types.Report {
 	return &rb.report
 }
 
-func (rb *reportBuilder) AddNContainers(n int, state State) {
-	fmt.Printf("Adding %v containers with state %v", n, state)
-	for i := 0; i < n; i++ {
-		cid := types.ContainerID(rb.generateID())
-		old := types.ImageID(rb.generateID())
-		new := types.ImageID(rb.generateID())
-		name := rb.generateName()
-		image := rb.generateImageName(name)
-		var err error
-		if state == FailedState {
-			err = errors.New(rb.randomEntry(errorMessages))
-		} else if state == SkippedState {
-			err = errors.New(rb.randomEntry(skippedMessages))
-		}
-		rb.AddContainer(ContainerStatus{
-			containerID:   cid,
-			oldImage:      old,
-			newImage:      new,
-			containerName: name,
-			imageName:     image,
-			error:         err,
-			state:         state,
-		})
+func (rb *reportBuilder) AddFromState(state State) {
+	cid := types.ContainerID(rb.generateID())
+	old := types.ImageID(rb.generateID())
+	new := types.ImageID(rb.generateID())
+	name := rb.generateName()
+	image := rb.generateImageName(name)
+	var err error
+	if state == FailedState {
+		err = errors.New(rb.randomEntry(errorMessages))
+	} else if state == SkippedState {
+		err = errors.New(rb.randomEntry(skippedMessages))
 	}
+	rb.AddContainer(ContainerStatus{
+		containerID:   cid,
+		oldImage:      old,
+		newImage:      new,
+		containerName: name,
+		imageName:     image,
+		error:         err,
+		state:         state,
+	})
 }
 
 func (rb *reportBuilder) AddContainer(c ContainerStatus) {
@@ -127,6 +123,29 @@ type Report struct {
 	fresh   []types.ContainerReport
 }
 
+func StatesFromString(str string) []State {
+	states := make([]State, 0, len(str))
+	for _, c := range str {
+		switch c {
+		case 'c':
+			states = append(states, ScannedState)
+		case 'u':
+			states = append(states, UpdatedState)
+		case 'e':
+			states = append(states, FailedState)
+		case 'k':
+			states = append(states, SkippedState)
+		case 't':
+			states = append(states, StaleState)
+		case 'f':
+			states = append(states, FreshState)
+		default:
+			continue
+		}
+	}
+	return states
+}
+
 func (r *Report) Scanned() []types.ContainerReport {
 	return r.scanned
 }

tplprev/tplprev.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/containrrr/watchtower/pkg/notifications/templates"
+)
+
+func TplPrev(input string, states []State, loglevels []LogLevel) (string, error) {
+
+	rb := ReportBuilder()
+
+	tpl, err := template.New("").Funcs(templates.Funcs).Parse(input)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse template: %e", err)
+	}
+
+	for _, state := range states {
+		rb.AddFromState(state)
+	}
+
+	var entries []*LogEntry
+	for _, level := range loglevels {
+		var msg string
+		if level <= WarnLevel {
+			msg = rb.randomEntry(logErrors)
+		} else {
+			msg = rb.randomEntry(logMessages)
+		}
+		entries = append(entries, &LogEntry{
+			Message: msg,
+			Data:    map[string]any{},
+			Time:    time.Now(),
+			Level:   level,
+		})
+	}
+
+	report := rb.Build()
+	data := Data{
+		Entries: entries,
+		StaticData: StaticData{
+			Title: "Title",
+			Host:  "Host",
+		},
+		Report: report,
+	}
+
+	var buf strings.Builder
+	err = tpl.Execute(&buf, data)
+	if err != nil {
+		return "", fmt.Errorf("failed to execute template: %e", err)
+	}
+
+	return buf.String(), nil
+}