feat: artifact push and pull actions

internal/push/push.go

@@ -0,0 +1,159 @@
+package push
+
+import (
+	"archive/zip"
+	"compress/flate"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+
+	"code.geekeey.de/actions/sdk"
+	"code.geekeey.de/actions/sdk/artifact"
+	"code.geekeey.de/actions/sdk/glob"
+)
+
+type Action struct {
+	*sdk.Action
+}
+
+func New(action *sdk.Action) *Action {
+	return &Action{Action: action}
+}
+
+type config struct {
+	Name     string
+	Path     string
+	Patterns []string
+}
+
+func parseConfig(get func(string) string) (*config, error) {
+	name := get("name")
+	if len(name) == 0 {
+		return nil, fmt.Errorf("input 'name': is empty")
+	}
+
+	path := get("path")
+	if len(path) == 0 {
+		return nil, fmt.Errorf("input 'path': is empty")
+	}
+
+	cfg := &config{Name: name, Path: path}
+	for _, pattern := range strings.Split(get("pattern"), "\n") {
+		if len(pattern) == 0 {
+			continue
+		}
+		cfg.Patterns = append(cfg.Patterns, pattern)
+	}
+	return cfg, nil
+}
+
+func (a *Action) Run(ctx context.Context) error {
+	cfg, err := parseConfig(a.GetInput)
+	if err != nil {
+		return err
+	}
+
+	run, job, err := artifact.JobInfo()
+	if err != nil {
+		return fmt.Errorf("unable to get job info: %v", err)
+	}
+
+	client := artifact.NewClientFromEnv(os.Getenv)
+
+	expire := time.Now().Add(20 * time.Hour)
+	create, err := client.CreateArtifact(ctx, artifact.CreateArtifactRequest{
+		RunID:     run,
+		JobRunID:  job,
+		Name:      cfg.Name,
+		Version:   4,
+		ExpiresAt: &expire,
+	})
+	if err != nil {
+		return fmt.Errorf("cannot create artifact: %w", err)
+	}
+	if !create.Ok {
+		return fmt.Errorf("cannot get pre-signed URL")
+	}
+
+	rd, err := createArchive(cfg.Path, cfg.Patterns)
+	if err != nil {
+		return fmt.Errorf("cannot create archive: %w", err)
+	}
+
+	res, err := artifact.PushBlob(ctx, nil, rd, create.SignedUploadUrl, 1024*1024, runtime.NumCPU())
+	if err != nil {
+		return fmt.Errorf("cannot upload artifact: %w", err)
+	}
+
+	finish, err := client.FinalizeArtifact(ctx, artifact.FinalizeArtifactRequest{
+		RunID:    run,
+		JobRunID: job,
+		Name:     cfg.Name,
+		Size:     res.Size,
+		Hash:     res.SHA256Sum,
+	})
+	if err != nil {
+		return fmt.Errorf("cannot finish artifact: %w", err)
+	}
+	if !finish.Ok {
+		return fmt.Errorf("cannot finish artifact upload")
+	}
+
+	a.SetOutput("artifact-id", finish.ArtifactId)
+	a.SetOutput("artifact-digest", res.SHA256Sum)
+	if url := artifactURL(a.Context(), finish.ArtifactId); url != "" {
+		a.SetOutput("artifact-url", url)
+	}
+
+	a.Noticef("created artifact: %s", finish.ArtifactId)
+	return nil
+}
+
+// artifactURL builds the URL of an artifact on the server, following the same
+// scheme as GitHub's upload-artifact output.
+func artifactURL(context *sdk.GitHubContext, artifactID string) string {
+	if context.ServerURL == "" || context.Repository == "" || context.RunID == "" || artifactID == "" {
+		return ""
+	}
+	return fmt.Sprintf("%s/%s/actions/runs/%s/artifacts/%s",
+		strings.TrimRight(context.ServerURL, "/"), context.Repository, context.RunID, artifactID)
+}
+
+// createArchive zips the files in path matching any of the given glob patterns
+// and returns a reader for the resulting archive.
+func createArchive(path string, patterns []string) (io.Reader, error) {
+	stat, err := os.Stat(path)
+	if err != nil {
+		return nil, fmt.Errorf("cannot find directory: %w", err)
+	}
+	if !stat.IsDir() {
+		return nil, fmt.Errorf("source path is not a directory")
+	}
+
+	gfs, err := glob.NewGlobFS(os.DirFS(path), patterns...)
+	if err != nil {
+		return nil, fmt.Errorf("cannot apply glob patterns: %w", err)
+	}
+
+	rd, wr := io.Pipe()
+	go func() {
+		defer wr.Close()
+
+		zw := zip.NewWriter(wr)
+		zw.RegisterCompressor(zip.Deflate, func(w io.Writer) (io.WriteCloser, error) {
+			return flate.NewWriter(w, flate.BestCompression)
+		})
+		if err := zw.AddFS(gfs); err != nil {
+			wr.CloseWithError(err)
+			return
+		}
+		if err := zw.Close(); err != nil {
+			wr.CloseWithError(err)
+		}
+	}()
+	return rd, nil
+}

internal/push/push_test.go

@@ -0,0 +1,178 @@
+package push
+
+import (
+	"archive/zip"
+	"bytes"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"testing"
+
+	"code.geekeey.de/actions/sdk"
+)
+
+func TestParseConfig(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name    string
+		env     map[string]string
+		want    *config
+		wantErr bool
+	}{
+		{
+			name: "minimal",
+			env:  map[string]string{"name": "foo", "path": "dist"},
+			want: &config{Name: "foo", Path: "dist"},
+		},
+		{
+			name: "patterns",
+			env:  map[string]string{"name": "foo", "path": "dist", "pattern": "**/*.go\n\n!main.go\n"},
+			want: &config{Name: "foo", Path: "dist", Patterns: []string{"**/*.go", "!main.go"}},
+		},
+		{
+			name:    "missing name",
+			env:     map[string]string{"path": "dist"},
+			wantErr: true,
+		},
+		{
+			name:    "missing path",
+			env:     map[string]string{"name": "foo"},
+			wantErr: true,
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := parseConfig(func(k string) string { return tc.env[k] })
+			if tc.wantErr {
+				if err == nil {
+					t.Fatalf("expected error, got %+v", got)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(got, tc.want) {
+				t.Errorf("expected %+v, got %+v", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestCreateArchive(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "a.txt"), "a")
+	writeFile(t, filepath.Join(dir, "sub", "b.txt"), "b")
+	writeFile(t, filepath.Join(dir, "sub", "c.log"), "c")
+
+	rd, err := createArchive(dir, []string{"**/*.txt"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	entries := zipEntries(t, rd)
+	if want := []string{"a.txt", "sub/b.txt"}; !reflect.DeepEqual(entries, want) {
+		t.Errorf("expected entries %v, got %v", want, entries)
+	}
+}
+
+func TestCreateArchive_NotDirectory(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "file.txt")
+	writeFile(t, path, "x")
+
+	if _, err := createArchive(path, []string{"**/*"}); err == nil {
+		t.Fatal("expected error for non-directory path")
+	}
+}
+
+func TestArtifactURL(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name    string
+		context *sdk.GitHubContext
+		id      string
+		want    string
+	}{
+		{
+			name:    "full",
+			context: &sdk.GitHubContext{ServerURL: "https://code.geekeey.de", Repository: "actions/test", RunID: "1"},
+			id:      "1234",
+			want:    "https://code.geekeey.de/actions/test/actions/runs/1/artifacts/1234",
+		},
+		{
+			name:    "trailing slash",
+			context: &sdk.GitHubContext{ServerURL: "https://code.geekeey.de/", Repository: "actions/test", RunID: "1"},
+			id:      "1234",
+			want:    "https://code.geekeey.de/actions/test/actions/runs/1/artifacts/1234",
+		},
+		{
+			name:    "missing run id",
+			context: &sdk.GitHubContext{ServerURL: "https://code.geekeey.de", Repository: "actions/test"},
+			id:      "1234",
+			want:    "",
+		},
+		{
+			name:    "missing id",
+			context: &sdk.GitHubContext{ServerURL: "https://code.geekeey.de", Repository: "actions/test", RunID: "1"},
+			id:      "",
+			want:    "",
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := artifactURL(tc.context, tc.id); got != tc.want {
+				t.Errorf("expected %q, got %q", tc.want, got)
+			}
+		})
+	}
+}
+
+func writeFile(t *testing.T, path, content string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func zipEntries(t *testing.T, r io.Reader) []string {
+	t.Helper()
+
+	data, err := io.ReadAll(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var entries []string
+	for _, f := range zr.File {
+		if f.FileInfo().IsDir() {
+			continue
+		}
+		entries = append(entries, f.Name)
+	}
+	sort.Strings(entries)
+	return entries
+}