Update 8.5.6

.build/actions.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"iter"
+	"log"
+	"time"
+
+	"github.com/google/go-github/v65/github"
+)
+
+func newActions() actions {
+	return actions{}
+}
+
+func (this *actions) init(b *build, _ *flag.FlagSet) {
+	this.build = b
+}
+
+type actions struct {
+	build *build
+}
+
+func (this *actions) Validate() error { return nil }
+
+func (this *actions) workflowByFilename(ctx context.Context, fn string) (*workflow, error) {
+	v, _, err := this.build.client.Actions.GetWorkflowByFileName(ctx, this.build.owner.String(), this.build.name.String(), fn)
+	if err != nil {
+		return nil, fmt.Errorf("cannot retrieve workflow %s from %v: %w", fn, this.build, err)
+	}
+	return &workflow{
+		v,
+		this,
+	}, nil
+}
+
+type workflow struct {
+	*github.Workflow
+
+	parent *actions
+}
+
+func (this *workflow) String() string {
+	return fmt.Sprintf("%s(%d)@%v", *this.Name, *this.ID, this.parent.build.repo)
+}
+
+func (this *workflow) runs(ctx context.Context) iter.Seq2[*workflowRun, error] {
+	return func(yield func(*workflowRun, error) bool) {
+		var opts github.ListWorkflowRunsOptions
+		opts.PerPage = 100
+
+		for {
+			candidates, rsp, err := this.parent.build.client.Actions.ListWorkflowRunsByID(ctx, this.parent.build.owner.String(), this.parent.build.name.String(), *this.ID, &opts)
+			if err != nil {
+				yield(nil, fmt.Errorf("cannot retrieve workflow runs of %v (page: %d): %w", this, opts.Page, err))
+				return
+			}
+			for _, v := range candidates.WorkflowRuns {
+				if !yield(&workflowRun{v, this}, nil) {
+					return
+				}
+			}
+			if rsp.NextPage == 0 {
+				return
+			}
+			opts.Page = rsp.NextPage
+		}
+	}
+}
+
+type workflowRun struct {
+	*github.WorkflowRun
+	parent *workflow
+}
+
+func (this *workflowRun) reload(ctx context.Context) error {
+	v, _, err := this.parent.parent.build.client.Actions.GetWorkflowRunByID(ctx, this.parent.parent.build.owner.String(), this.parent.parent.build.name.String(), *this.ID)
+	if err != nil {
+		return fmt.Errorf("cannot reload workflow run %v: %w", this, err)
+	}
+	this.WorkflowRun = v
+	return nil
+}
+
+func (this *workflowRun) wait(ctx context.Context) error {
+	start := time.Now()
+	for ctx.Err() == nil {
+		if err := this.reload(ctx); err != nil {
+			return err
+		}
+		if this.Status != nil && *this.Status == "completed" {
+			return nil
+		}
+		log.Printf("INFO %v is still running (waiting since %v)...", this, time.Since(start).Truncate(time.Second))
+		time.Sleep(this.parent.parent.build.waitTimeout)
+	}
+	return ctx.Err()
+}
+
+func (this *workflowRun) rerun(ctx context.Context) error {
+	_, err := this.parent.parent.build.client.Actions.RerunWorkflowByID(ctx, this.parent.parent.build.owner.String(), this.parent.parent.build.name.String(), *this.ID)
+	if err != nil {
+		return fmt.Errorf("cannot rerun workflow run %v: %w", this, err)
+	}
+	return nil
+}
+
+func (this workflowRun) String() string {
+	return fmt.Sprintf("%d@%v", *this.ID, this.parent)
+}

.build/build.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/google/go-github/v65/github"
+)
+
+func newBuild() (build, error) {
+	r, err := newRepo()
+	if err != nil {
+		return build{}, err
+	}
+	return build{
+		repo:        r,
+		waitTimeout: time.Second * 3,
+		commands:    make(map[string]command),
+	}, nil
+}
+
+type build struct {
+	repo
+
+	waitTimeout time.Duration
+
+	client *github.Client
+
+	commands map[string]command
+}
+
+type command struct {
+	f     func(context.Context, []string) error
+	usage string
+}
+
+func (this *build) init(fs *flag.FlagSet) {
+	this.client = github.NewClient(nil).
+		WithAuthToken(os.Getenv("GITHUB_TOKEN"))
+
+	fs.DurationVar(&this.waitTimeout, "wait-timeout", this.waitTimeout, "")
+
+	this.repo.init(this, fs)
+}
+
+func (this *build) Validate() error {
+	if err := this.repo.Validate(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (this *build) registerCommand(name, usage string, action func(context.Context, []string) error) {
+	this.commands[name] = command{action, usage}
+}
+
+func (this *build) flagUsage(fs *flag.FlagSet, reasonMsg string, args ...any) {
+	w := fs.Output()
+	_, _ = fmt.Fprint(w, `Usage of .build:
+`)
+	if reasonMsg != "" {
+		_, _ = fmt.Fprintf(w, "Error: %s\n", fmt.Sprintf(reasonMsg, args...))
+	}
+	_, _ = fmt.Fprintf(w, "Syntax: %s [flags] <command> [commandSpecificArgs]\nCommands:\n", fs.Name())
+	for n, c := range this.commands {
+		_, _ = fmt.Fprintf(w, "\t%s %s\n", n, c.usage)
+	}
+	_, _ = fmt.Fprint(w, "Flags:\n")
+	fs.PrintDefaults()
+}

.build/go.mod

@@ -0,0 +1,7 @@
+module github.com/blaubaer/ha-addon/unifi/.build
+
+go 1.23.1
+
+require github.com/google/go-github/v65 v65.0.0
+
+require github.com/google/go-querystring v1.1.0 // indirect

.build/go.sum

@@ -0,0 +1,8 @@
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-github/v65 v65.0.0 h1:pQ7BmO3DZivvFk92geC0jB0q2m3gyn8vnYPgV7GSLhQ=
+github.com/google/go-github/v65 v65.0.0/go.mod h1:DvrqWo5hvsdhJvHd4WyVF9ttANN3BniqjP8uTFMNb60=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

.build/main.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+)
+
+func main() {
+	b, err := newBuild()
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(3)
+	}
+
+	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+	fs.Usage = func() { b.flagUsage(fs, "") }
+	b.init(fs)
+
+	_ = fs.Parse(os.Args[1:])
+
+	if err := b.Validate(); err != nil {
+		b.flagUsage(fs, "ERROR: %v", err)
+		os.Exit(3)
+	}
+
+	err = func() error {
+		args := fs.Args()
+		if len(args) < 1 {
+			return flagFail("command missing")
+		}
+
+		cmd, ok := b.commands[args[0]]
+		if !ok {
+			return flagFail("unknown command: %s", args[0])
+		}
+
+		ctx, cancelFunc := context.WithCancel(context.Background())
+		sigs := make(chan os.Signal, 1)
+		defer close(sigs)
+		signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+		go func() {
+			<-sigs
+			cancelFunc()
+		}()
+
+		return cmd.f(ctx, args[1:])
+	}()
+
+	var fe *flagError
+	if errors.As(err, &fe) {
+		b.flagUsage(fs, "ERROR: %v", err)
+		os.Exit(2)
+	} else if err != nil {
+		w := flag.CommandLine.Output()
+		_, _ = fmt.Fprintf(w, "%s: ERROR %v\n", os.Args[0], err)
+		os.Exit(3)
+	}
+}
+
+func flagFail(msg string, args ...any) *flagError {
+	err := flagError(fmt.Sprintf(msg, args...))
+	return &err
+}
+
+type stringSlice []string
+
+func (this stringSlice) String() string {
+	return strings.Join(this, ",")
+}
+
+func (this *stringSlice) Set(s string) error {
+	var buf stringSlice
+	for _, plain := range strings.Split(s, ",") {
+		plain = strings.TrimSpace(plain)
+		if plain != "" {
+			buf = append(buf, plain)
+		}
+	}
+	*this = buf
+	return nil
+}
+
+type flagError string
+
+func (this flagError) Error() string {
+	return string(this)
+}