refac(updater): refactor the updater package

Co-authored-by: MatteoPologruto <m.pologruto@arduino.cc>
Co-authored-by: lucarin91 <lucarin@protonmail.com>

Author: 3 people

cmd/releaser/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+
+	"github.com/arduino/go-updater/releaser"
+)
+
+func main() {
+	var (
+		outputDir string
+		platform  releaser.Platform
+	)
+
+	platform = defaultPlatform()
+
+	flag.StringVar(&outputDir, "o", "public", "Output directory for writing updates")
+	flag.Var(&platform, "platform", "Target platform in the form OS-ARCH. Defaults to running os/arch or the combination of the environment variables GOOS and GOARCH if both are set.")
+	flag.Usage = printUsage
+	flag.Parse()
+
+	if flag.NArg() < 2 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	inputPath := flag.Arg(0)
+	version := flag.Arg(1)
+
+	manifest, err := releaser.CreateRelease(inputPath, platform, version, outputDir)
+	if err != nil {
+		log.Fatalf("could not create release: %v", err)
+	}
+	fmt.Println("Release created successfully!")
+	jsonBytes, err := json.MarshalIndent(manifest, "", "  ")
+	if err != nil {
+		log.Fatalf("could not marshal manifest to JSON: %v", err)
+	}
+	fmt.Println(string(jsonBytes))
+}
+
+func defaultPlatform() releaser.Platform {
+	goos := os.Getenv("GOOS")
+	goarch := os.Getenv("GOARCH")
+	if goos != "" && goarch != "" {
+		return releaser.NewPlatform(goos, goarch)
+	}
+	return releaser.NewPlatform(runtime.GOOS, runtime.GOARCH)
+}
+
+func printUsage() {
+	fmt.Fprintf(os.Stderr, `
+Usage:
+  go-selfupdate [flags] <binary-or-dir> <version>
+
+Positional arguments:
+  <binary-or-dir>   Path to the binary file or directory containing binaries
+  <version>         Version string to embed in the update metadata
+
+Flags:
+`)
+	flag.PrintDefaults()
+	fmt.Fprintln(os.Stderr, `
+Examples:
+  go-selfupdate myapp 1.2.3
+  go-selfupdate -o public -platform linux-amd64 myapp 1.2.3
+  go-selfupdate /tmp/mybinares/ 1.2.3`)
+}

releaser/http_client.go

@@ -0,0 +1,109 @@
+package releaser
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// Client holds the base URL, command name, allows custom HTTP client, and optional headers.
+type Client struct {
+	BaseURL    *url.URL
+	CmdName    string
+	HTTPClient HTTPDoer
+	Headers    map[string]string // Optional headers to add to each request
+}
+
+// HTTPDoer is an interface for http.Client or mocks.
+type HTTPDoer interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+// Option is a functional option for configuring Client.
+type Option func(*Client)
+
+// WithHeaders sets custom headers for the Client.
+func WithHeaders(headers map[string]string) Option {
+	return func(c *Client) {
+		c.Headers = headers
+	}
+}
+
+// WithHTTPClient sets a custom HTTP client for the Client.
+func WithHTTPClient(client HTTPDoer) Option {
+	return func(c *Client) {
+		c.HTTPClient = client
+	}
+}
+
+// NewClient creates a new Client with optional configuration.
+func NewClient(baseURL *url.URL, cmdName string, opts ...Option) *Client {
+	c := &Client{
+		BaseURL:    baseURL,
+		CmdName:    cmdName,
+		HTTPClient: http.DefaultClient,
+		Headers:    nil,
+	}
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c
+}
+
+// addHeaders adds custom headers to the request if present.
+func (c *Client) addHeaders(req *http.Request) {
+	for k, v := range c.Headers {
+		req.Header.Set(k, v)
+	}
+}
+
+// GetManifest fetches and decodes the manifest for the given platform.
+func (c *Client) GetManifest(plat Platform) (Manifest, error) {
+	manifestURL := c.BaseURL.JoinPath(c.CmdName, plat.String()+".json").String()
+	req, err := http.NewRequest("GET", manifestURL, nil)
+	if err != nil {
+		return Manifest{}, fmt.Errorf("failed to create request: %w", err)
+	}
+	c.addHeaders(req)
+	// #nosec G107 -- manifestURL is constructed from trusted config and parameters
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return Manifest{}, fmt.Errorf("failed to GET manifest: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return Manifest{}, fmt.Errorf("bad http status from %s: %v", manifestURL, resp.Status)
+	}
+
+	var res Manifest
+	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
+		return Manifest{}, fmt.Errorf("invalid manifest JSON: %w", err)
+	}
+	if len(res.Sha256) != sha256.Size {
+		return Manifest{}, fmt.Errorf("bad sha256 in manifest: got %d bytes", len(res.Sha256))
+	}
+	return res, nil
+}
+
+// FetchZip fetches the zip for the given version and platform.
+func (c *Client) FetchZip(version string, plat Platform) (io.ReadCloser, error) {
+	zipURL := c.BaseURL.JoinPath(c.CmdName, version, plat.String()+".zip").String()
+	req, err := http.NewRequest("GET", zipURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	c.addHeaders(req)
+	// #nosec G107 -- zipURL is constructed from trusted config and parameters
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to GET zip: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return nil, fmt.Errorf("bad http status from %s: %v", zipURL, resp.Status)
+	}
+	return resp.Body, nil
+}

releaser/platform.go

@@ -0,0 +1,60 @@
+package releaser
+
+import (
+	"errors"
+	"strings"
+)
+
+type Platform struct {
+	OS   string
+	Arch string
+}
+
+func NewPlatform(os string, arch string) Platform {
+	return Platform{
+		OS:   os,
+		Arch: arch,
+	}
+}
+
+// Parse parses a string like "linux-amd64" into a Platform struct.
+func Parse(s string) (Platform, error) {
+	parts := strings.Split(s, "-")
+	if len(parts) != 2 {
+		return Platform{}, errors.New("platform string must be in the form os-arch, e.g. linux-amd64")
+	}
+	os := parts[0]
+	if os == "" {
+		return Platform{}, errors.New("missing OS in platform string")
+	}
+	arch := parts[1]
+	if arch == "" {
+		return Platform{}, errors.New("missing Arch in platform string")
+	}
+	return Platform{OS: os, Arch: arch}, nil
+}
+
+func MustParse(s string) Platform {
+	id, err := Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// String returns the platform as "os-arch"
+func (p Platform) String() string {
+	return p.OS + "-" + p.Arch
+}
+
+// Set parses and sets the platform from a string like "linux-amd64"
+// Used for flag.Value interface
+func (p *Platform) Set(s string) error {
+	platform, err := Parse(s)
+	if err != nil {
+		return err
+	}
+	p.OS = platform.OS
+	p.Arch = platform.Arch
+	return nil
+}

releaser/platform_test.go

@@ -0,0 +1,72 @@
+package releaser
+
+import (
+	"testing"
+)
+
+func TestParsePlatform_Valid(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected Platform
+	}{
+		{"linux-amd64", Platform{"linux", "amd64"}},
+		{"darwin-arm64", Platform{"darwin", "arm64"}},
+		{"windows-386", Platform{"windows", "386"}},
+	}
+
+	for _, tt := range tests {
+		got, err := Parse(tt.input)
+		if err != nil {
+			t.Errorf("ParsePlatform(%q) unexpected error: %v", tt.input, err)
+		}
+		if got != tt.expected {
+			t.Errorf("ParsePlatform(%q) = %+v, want %+v", tt.input, got, tt.expected)
+		}
+	}
+}
+
+func TestParsePlatform_Invalid(t *testing.T) {
+	cases := []struct {
+		name  string
+		input string
+	}{
+		{"Empty", ""},
+		{"Missing Arch", "linux"},
+		{"Missing OS", "-amd64"},
+		{"Extra Parts", "linux-amd64-extra"},
+		{"Just Dash", "-"},
+	}
+
+	for _, c := range cases {
+		_, err := Parse(c.input)
+		if err == nil {
+			t.Errorf("ParsePlatform(%q) expected error, got nil", c.input)
+		}
+	}
+}
+
+func TestPlatform_String(t *testing.T) {
+	p := Platform{"linux", "amd64"}
+	if got := p.String(); got != "linux-amd64" {
+		t.Errorf("Platform.String() = %q, want %q", got, "linux-amd64")
+	}
+}
+
+func TestPlatform_Set(t *testing.T) {
+	var p Platform
+	err := p.Set("darwin-arm64")
+	if err != nil {
+		t.Fatalf("Set returned error: %v", err)
+	}
+	if p.OS != "darwin" || p.Arch != "arm64" {
+		t.Errorf("Set did not set fields correctly: %+v", p)
+	}
+}
+
+func TestPlatform_Set_Invalid(t *testing.T) {
+	var p Platform
+	err := p.Set("badformat")
+	if err == nil {
+		t.Error("Set should return error for bad format")
+	}
+}