From 586c36388705bbe0ae64c39544bb09e7a6be069c Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sun, 18 Oct 2026 14:17:58 -0600 Subject: [PATCH] refactor(oci): share feature and template publish helpers --- cmd/feature/publish.go | 93 +++---------------------- cmd/feature/publish_test.go | 90 +----------------------- cmd/template/publish.go | 89 +++--------------------- pkg/image/publish.go | 103 ++++++++++++++++++++++++++++ pkg/image/publish_test.go | 132 ++++++++++++++++++++++++++++++++++++ 5 files changed, 256 insertions(+), 251 deletions(-) create mode 100644 pkg/image/publish.go create mode 100644 pkg/image/publish_test.go diff --git a/cmd/feature/publish.go b/cmd/feature/publish.go index 548c448013..421807a630 100644 --- a/cmd/feature/publish.go +++ b/cmd/feature/publish.go @@ -1,27 +1,16 @@ package feature import ( - "bytes" - "encoding/json" "fmt" - "io" "os" "path/filepath" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/devcontainer/config" - "github.com/devsy-org/devsy/pkg/extract" cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/image" "github.com/devsy-org/devsy/pkg/log" - "github.com/google/go-containerregistry/pkg/authn" - "github.com/google/go-containerregistry/pkg/name" - v1 "github.com/google/go-containerregistry/pkg/v1" - "github.com/google/go-containerregistry/pkg/v1/empty" - "github.com/google/go-containerregistry/pkg/v1/mutate" - "github.com/google/go-containerregistry/pkg/v1/remote" - "github.com/google/go-containerregistry/pkg/v1/stream" - "github.com/google/go-containerregistry/pkg/v1/types" "github.com/spf13/cobra" ) @@ -80,46 +69,29 @@ func runPublish(f *PublishFlags) error { return err } - version := featureCfg.Version - if version == "" { - version = "latest" - } + version := image.ResolvePublishVersion(featureCfg.Version) - ref, err := parsePublishRef(f.Registry, f.Namespace, featureCfg.ID, version) + ref, err := image.ParsePublishReference(f.Registry, f.Namespace, featureCfg.ID, version) if err != nil { return err } log.Infof("publishing feature %q to %s", featureCfg.ID, ref.String()) - img, err := buildFeatureImage(target) + img, err := image.BuildPublishImage("feature", target) if err != nil { return err } - if err := remote.Write( - ref, img, remote.WithAuthFromKeychain(authn.DefaultKeychain), - ); err != nil { - return fmt.Errorf("push feature to registry: %w", err) + if err := image.PushPublishImage("feature", ref, img); err != nil { + return err } - log.Infof("feature published successfully: %s", ref.String()) - - metadata := publishedFeatureMetadata{ + return image.WritePublishedMetadata(os.Stdout, publishedFeatureMetadata{ ID: featureCfg.ID, Version: version, Ref: ref.String(), - } - - metadataJSON, err := json.MarshalIndent(metadata, "", " ") - if err != nil { - return fmt.Errorf("marshal published metadata: %w", err) - } - - _, _ = os.Stdout.Write(metadataJSON) - _, _ = os.Stdout.WriteString("\n") - - return nil + }) } type publishedFeatureMetadata struct { @@ -129,13 +101,8 @@ type publishedFeatureMetadata struct { } func validatePublishTarget(target string) (*config.FeatureConfig, error) { - stat, err := os.Stat(target) - if err != nil { - return nil, fmt.Errorf("stat target: %w", err) - } - - if !stat.IsDir() { - return nil, fmt.Errorf("target must be a directory: %s", target) + if err := image.ValidatePublishDir(target); err != nil { + return nil, err } featureCfg, err := config.ParseDevContainerFeature(target) @@ -145,43 +112,3 @@ func validatePublishTarget(target string) (*config.FeatureConfig, error) { return featureCfg, nil } - -func parsePublishRef( - registry, namespace, id, version string, -) (name.Reference, error) { - refStr := buildPublishReference(registry, namespace, id, version) - - ref, err := name.ParseReference(refStr) - if err != nil { - return nil, fmt.Errorf("parse publish reference %q: %w", refStr, err) - } - - return ref, nil -} - -func buildPublishReference(registry, namespace, id, version string) string { - if namespace != "" { - return fmt.Sprintf("%s/%s/%s:%s", registry, namespace, id, version) - } - - return fmt.Sprintf("%s/%s:%s", registry, id, version) -} - -func buildFeatureImage(sourceDir string) (v1.Image, error) { - var buf bytes.Buffer - if err := extract.WriteTar(&buf, sourceDir, true); err != nil { - return nil, fmt.Errorf("create feature archive: %w", err) - } - - layer := stream.NewLayer( - io.NopCloser(bytes.NewReader(buf.Bytes())), - stream.WithMediaType(types.OCILayer), - ) - - img, err := mutate.AppendLayers(empty.Image, layer) - if err != nil { - return nil, fmt.Errorf("build feature image: %w", err) - } - - return img, nil -} diff --git a/cmd/feature/publish_test.go b/cmd/feature/publish_test.go index 7f5050aa8f..07539b91c9 100644 --- a/cmd/feature/publish_test.go +++ b/cmd/feature/publish_test.go @@ -11,9 +11,8 @@ import ( ) const ( - testRegistry = "ghcr.io" - testVersion = "1.0.0" - testFeatureNode = "node" + testRegistry = "ghcr.io" + testVersion = "1.0.0" ) func TestPublishCmd_FlagDefaults(t *testing.T) { @@ -49,56 +48,6 @@ func TestPublishCmd_TargetRequired(t *testing.T) { require.Contains(t, annotations, "cobra_annotation_bash_completion_one_required_flag") } -func TestBuildPublishReference(t *testing.T) { - tests := []struct { - name string - registry string - namespace string - id string - version string - want string - }{ - { - name: "with namespace", - registry: testRegistry, - namespace: "devcontainers/features", - id: "go", - version: testVersion, - want: testRegistry + "/devcontainers/features/go:" + testVersion, - }, - { - name: "without namespace", - registry: testRegistry, - id: "go", - version: testVersion, - want: testRegistry + "/go:" + testVersion, - }, - { - name: "custom registry", - registry: "registry.example.com", - namespace: "my-org/features", - id: testFeatureNode, - version: "2.0.0", - want: "registry.example.com/my-org/features/" + testFeatureNode + ":2.0.0", - }, - { - name: "latest version", - registry: testRegistry, - namespace: "test", - id: "python", - version: "latest", - want: testRegistry + "/test/python:latest", - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := buildPublishReference(tt.registry, tt.namespace, tt.id, tt.version) - assert.Equal(t, tt.want, got) - }) - } -} - func TestValidatePublishTarget_NotADirectory(t *testing.T) { tmpFile := filepath.Join(t.TempDir(), "not-a-dir.txt") require.NoError(t, os.WriteFile(tmpFile, []byte("hello"), 0o600)) @@ -148,38 +97,3 @@ func TestValidatePublishTarget_NonexistentPath(t *testing.T) { require.Error(t, err) assert.Contains(t, err.Error(), "stat target") } - -func TestBuildFeatureImage(t *testing.T) { - tmpDir := t.TempDir() - require.NoError(t, os.WriteFile( - filepath.Join(tmpDir, "devcontainer-feature.json"), - []byte(`{"id": "go", "version": "1.0.0"}`), - 0o600, - )) - // #nosec G306 -- test install script must be executable - require.NoError(t, os.WriteFile( - filepath.Join(tmpDir, "install.sh"), - []byte("#!/bin/bash\necho hello\n"), - 0o750, - )) - - img, err := buildFeatureImage(tmpDir) - require.NoError(t, err) - require.NotNil(t, img) - - layers, err := img.Layers() - require.NoError(t, err) - assert.Len(t, layers, 1) -} - -func TestParsePublishRef_Valid(t *testing.T) { - ref, err := parsePublishRef(testRegistry, "devcontainers/features", "go", testVersion) - require.NoError(t, err) - assert.Contains(t, ref.String(), testRegistry+"/devcontainers/features/go:"+testVersion) -} - -func TestParsePublishRef_Invalid(t *testing.T) { - _, err := parsePublishRef("", "", "INVALID REF!!!", "") - require.Error(t, err) - assert.Contains(t, err.Error(), "parse publish reference") -} diff --git a/cmd/template/publish.go b/cmd/template/publish.go index 49cf624af1..97c9e2ae6a 100644 --- a/cmd/template/publish.go +++ b/cmd/template/publish.go @@ -1,26 +1,15 @@ package template import ( - "bytes" - "encoding/json" "fmt" - "io" "os" "path/filepath" "github.com/devsy-org/devsy/cmd/flags" - "github.com/devsy-org/devsy/pkg/extract" cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/image" "github.com/devsy-org/devsy/pkg/log" - "github.com/google/go-containerregistry/pkg/authn" - "github.com/google/go-containerregistry/pkg/name" - v1 "github.com/google/go-containerregistry/pkg/v1" - "github.com/google/go-containerregistry/pkg/v1/empty" - "github.com/google/go-containerregistry/pkg/v1/mutate" - "github.com/google/go-containerregistry/pkg/v1/remote" - "github.com/google/go-containerregistry/pkg/v1/stream" - "github.com/google/go-containerregistry/pkg/v1/types" "github.com/spf13/cobra" ) @@ -72,50 +61,30 @@ func runPublish(f *PublishFlags) error { return err } - version := metadata.Version - if version == "" { - version = "latest" - } + version := image.ResolvePublishVersion(metadata.Version) - ref, err := parsePublishRef(f.Registry, f.Namespace, metadata.ID, version) + ref, err := image.ParsePublishReference(f.Registry, f.Namespace, metadata.ID, version) if err != nil { return err } log.Infof("publishing template %q to %s", metadata.ID, ref.String()) - img, err := buildTemplateImage(target) + img, err := image.BuildPublishImage("template", target) if err != nil { return err } - if err := remote.Write( - ref, img, remote.WithAuthFromKeychain(authn.DefaultKeychain), - ); err != nil { - return fmt.Errorf("push template to registry: %w", err) - } - - log.Infof("template published successfully: %s", ref.String()) - - metadataJSON, err := json.MarshalIndent(metadata, "", " ") - if err != nil { - return fmt.Errorf("marshal published metadata: %w", err) + if err := image.PushPublishImage("template", ref, img); err != nil { + return err } - _, _ = os.Stdout.Write(metadataJSON) - _, _ = os.Stdout.WriteString("\n") - - return nil + return image.WritePublishedMetadata(os.Stdout, metadata) } func validatePublishTarget(target string) (*TemplateMetadata, error) { - stat, err := os.Stat(target) - if err != nil { - return nil, fmt.Errorf("stat target: %w", err) - } - - if !stat.IsDir() { - return nil, fmt.Errorf("target must be a directory: %s", target) + if err := image.ValidatePublishDir(target); err != nil { + return nil, err } metadata, err := readTemplateMetadata(target) @@ -129,43 +98,3 @@ func validatePublishTarget(target string) (*TemplateMetadata, error) { return metadata, nil } - -func parsePublishRef( - registry, namespace, id, version string, -) (name.Reference, error) { - refStr := buildPublishReference(registry, namespace, id, version) - - ref, err := name.ParseReference(refStr) - if err != nil { - return nil, fmt.Errorf("parse publish reference %q: %w", refStr, err) - } - - return ref, nil -} - -func buildPublishReference(registry, namespace, id, version string) string { - if namespace != "" { - return fmt.Sprintf("%s/%s/%s:%s", registry, namespace, id, version) - } - - return fmt.Sprintf("%s/%s:%s", registry, id, version) -} - -func buildTemplateImage(sourceDir string) (v1.Image, error) { - var buf bytes.Buffer - if err := extract.WriteTar(&buf, sourceDir, true); err != nil { - return nil, fmt.Errorf("create template archive: %w", err) - } - - layer := stream.NewLayer( - io.NopCloser(bytes.NewReader(buf.Bytes())), - stream.WithMediaType(types.OCILayer), - ) - - img, err := mutate.AppendLayers(empty.Image, layer) - if err != nil { - return nil, fmt.Errorf("build template image: %w", err) - } - - return img, nil -} diff --git a/pkg/image/publish.go b/pkg/image/publish.go new file mode 100644 index 0000000000..adea0b43bd --- /dev/null +++ b/pkg/image/publish.go @@ -0,0 +1,103 @@ +package image + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "os" + + "github.com/devsy-org/devsy/pkg/extract" + "github.com/devsy-org/devsy/pkg/log" + "github.com/google/go-containerregistry/pkg/authn" + "github.com/google/go-containerregistry/pkg/name" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/empty" + "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/google/go-containerregistry/pkg/v1/remote" + "github.com/google/go-containerregistry/pkg/v1/stream" + "github.com/google/go-containerregistry/pkg/v1/types" +) + +func ResolvePublishVersion(version string) string { + if version == "" { + return "latest" + } + + return version +} + +func ValidatePublishDir(target string) error { + stat, err := os.Stat(target) + if err != nil { + return fmt.Errorf("stat target: %w", err) + } + + if !stat.IsDir() { + return fmt.Errorf("target must be a directory: %s", target) + } + + return nil +} + +func ParsePublishReference(registry, namespace, id, version string) (name.Reference, error) { + refStr := buildPublishReference(registry, namespace, id, version) + + ref, err := name.ParseReference(refStr) + if err != nil { + return nil, fmt.Errorf("parse publish reference %q: %w", refStr, err) + } + + return ref, nil +} + +func buildPublishReference(registry, namespace, id, version string) string { + if namespace != "" { + return fmt.Sprintf("%s/%s/%s:%s", registry, namespace, id, version) + } + + return fmt.Sprintf("%s/%s:%s", registry, id, version) +} + +func BuildPublishImage(kind, sourceDir string) (v1.Image, error) { + var buf bytes.Buffer + if err := extract.WriteTar(&buf, sourceDir, true); err != nil { + return nil, fmt.Errorf("create %s archive: %w", kind, err) + } + + layer := stream.NewLayer( + io.NopCloser(bytes.NewReader(buf.Bytes())), + stream.WithMediaType(types.OCILayer), + ) + + img, err := mutate.AppendLayers(empty.Image, layer) + if err != nil { + return nil, fmt.Errorf("build %s image: %w", kind, err) + } + + return img, nil +} + +func PushPublishImage(kind string, ref name.Reference, img v1.Image) error { + if err := remote.Write( + ref, img, remote.WithAuthFromKeychain(authn.DefaultKeychain), + ); err != nil { + return fmt.Errorf("push %s to registry: %w", kind, err) + } + + log.Infof("%s published successfully: %s", kind, ref.String()) + + return nil +} + +func WritePublishedMetadata(w io.Writer, metadata any) error { + metadataJSON, err := json.MarshalIndent(metadata, "", " ") + if err != nil { + return fmt.Errorf("marshal published metadata: %w", err) + } + + _, _ = w.Write(metadataJSON) + _, _ = io.WriteString(w, "\n") + + return nil +} diff --git a/pkg/image/publish_test.go b/pkg/image/publish_test.go new file mode 100644 index 0000000000..95fbfefe25 --- /dev/null +++ b/pkg/image/publish_test.go @@ -0,0 +1,132 @@ +package image + +import ( + "bytes" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + testPublishRegistry = "ghcr.io" + testPublishLatest = "latest" +) + +func TestBuildPublishReference(t *testing.T) { + tests := []struct { + name string + registry string + namespace string + id string + version string + want string + }{ + { + name: "with namespace", + registry: testPublishRegistry, + namespace: "devcontainers/features", + id: "go", + version: "1.0.0", + want: "ghcr.io/devcontainers/features/go:1.0.0", + }, + { + name: "without namespace", + registry: testPublishRegistry, + id: "go", + version: "1.0.0", + want: "ghcr.io/go:1.0.0", + }, + { + name: "custom registry", + registry: "registry.example.com", + namespace: "my-org/features", + id: "node", + version: "2.0.0", + want: "registry.example.com/my-org/features/node:2.0.0", + }, + { + name: "latest version", + registry: testPublishRegistry, + namespace: "test", + id: "python", + version: testPublishLatest, + want: "ghcr.io/test/python:latest", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal( + t, + tt.want, + buildPublishReference(tt.registry, tt.namespace, tt.id, tt.version), + ) + }) + } +} + +func TestParsePublishReference_Valid(t *testing.T) { + ref, err := ParsePublishReference(testPublishRegistry, "devcontainers/features", "go", "1.0.0") + require.NoError(t, err) + assert.Equal(t, "ghcr.io/devcontainers/features/go:1.0.0", ref.String()) +} + +func TestParsePublishReference_Invalid(t *testing.T) { + _, err := ParsePublishReference("", "", "INVALID REF!!!", "") + require.Error(t, err) + assert.Contains(t, err.Error(), "parse publish reference") +} + +func TestValidatePublishDir_NotADirectory(t *testing.T) { + tmpFile := filepath.Join(t.TempDir(), "not-a-dir.txt") + require.NoError(t, os.WriteFile(tmpFile, []byte("hello"), 0o600)) + + err := ValidatePublishDir(tmpFile) + require.Error(t, err) + assert.Contains(t, err.Error(), "target must be a directory") +} + +func TestValidatePublishDir_NonexistentPath(t *testing.T) { + err := ValidatePublishDir("/nonexistent/path/that/does/not/exist") + require.Error(t, err) + assert.Contains(t, err.Error(), "stat target") +} + +func TestBuildPublishImage_SingleLayer(t *testing.T) { + tmpDir := t.TempDir() + require.NoError(t, os.WriteFile( + filepath.Join(tmpDir, "devcontainer-feature.json"), + []byte(`{"id": "go", "version": "1.0.0"}`), + 0o600, + )) + // #nosec G306 -- test install script must be executable + require.NoError(t, os.WriteFile( + filepath.Join(tmpDir, "install.sh"), + []byte("#!/bin/bash\necho hello\n"), + 0o750, + )) + + img, err := BuildPublishImage("feature", tmpDir) + require.NoError(t, err) + require.NotNil(t, img) + + layers, err := img.Layers() + require.NoError(t, err) + assert.Len(t, layers, 1) +} + +func TestBuildPublishImage_ErrorNamesArtifactKind(t *testing.T) { + _, err := BuildPublishImage("template", "/nonexistent/path/that/does/not/exist") + require.Error(t, err) + assert.Contains(t, err.Error(), "create template archive") +} + +func TestWritePublishedMetadata_IndentedWithTrailingNewline(t *testing.T) { + var buf bytes.Buffer + require.NoError(t, WritePublishedMetadata(&buf, map[string]string{"id": "go"})) + + assert.Equal(t, "{\n \"id\": \"go\"\n}\n", buf.String()) +}