add middleware version as image label (#3410)

Co-authored-by: David Fridrich <fridrich.david19@gmail.com>

Author: knative-prow-robot

pkg/builders/middleware_labels_int_test.go

@@ -0,0 +1,105 @@
+//go:build integration
+
+package builders_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/docker/docker/client"
+
+	"knative.dev/func/pkg/buildpacks"
+	fn "knative.dev/func/pkg/functions"
+	"knative.dev/func/pkg/s2i"
+)
+
+// Scaffolder scaffolds a function for building
+type Scaffolder interface {
+	Scaffold(ctx context.Context, f fn.Function, path string) error
+}
+
+// Builder builds a function image
+type Builder interface {
+	Build(ctx context.Context, f fn.Function, platforms []fn.Platform) error
+}
+
+// TestInt_MiddlewareLabels verifies that the middleware-version label is set
+// on function images built by each builder type.
+func TestInt_MiddlewareLabels(t *testing.T) {
+	tests := []struct {
+		name       string
+		timeout    time.Duration
+		scaffolder Scaffolder
+		builder    Builder
+	}{
+		{
+			name:       "s2i",
+			timeout:    5 * time.Minute,
+			scaffolder: s2i.NewScaffolder(true),
+			builder:    s2i.NewBuilder(s2i.WithVerbose(true)),
+		},
+		{
+			name:       "buildpacks",
+			timeout:    10 * time.Minute,
+			scaffolder: buildpacks.NewScaffolder(true),
+			builder:    buildpacks.NewBuilder(buildpacks.WithVerbose(true)),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := initFunction(t, "test-"+tt.name+"-labels")
+			ctx, cancel := context.WithTimeout(context.Background(), tt.timeout)
+			defer cancel()
+
+			if err := tt.scaffolder.Scaffold(ctx, f, ""); err != nil {
+				t.Fatal(err)
+			}
+			if err := tt.builder.Build(ctx, f, nil); err != nil {
+				t.Fatal(err)
+			}
+
+			assertMiddlewareLabel(t, ctx, f.Build.Image)
+		})
+	}
+}
+
+func initFunction(t *testing.T, name string) fn.Function {
+	t.Helper()
+	f := fn.Function{
+		Name:     name,
+		Root:     t.TempDir(),
+		Runtime:  "go",
+		Registry: "localhost:50000",
+	}
+	f, err := fn.New().Init(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Build.Image = "localhost:50000/" + name + ":latest"
+	return f
+}
+
+func assertMiddlewareLabel(t *testing.T, ctx context.Context, image string) {
+	t.Helper()
+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer cli.Close()
+
+	inspect, _, err := cli.ImageInspectWithRaw(ctx, image)
+	if err != nil {
+		t.Fatalf("failed to inspect image %s: %v", image, err)
+	}
+
+	middlewareVersion, ok := inspect.Config.Labels[fn.MiddlewareVersionLabelKey]
+	if !ok {
+		t.Fatalf("label %q not found in image. Labels: %v", fn.MiddlewareVersionLabelKey, inspect.Config.Labels)
+	}
+	if middlewareVersion == "" {
+		t.Fatalf("label %q is empty", fn.MiddlewareVersionLabelKey)
+	}
+	t.Logf("middleware-version label: %s", middlewareVersion)
+}

pkg/buildpacks/builder.go

@@ -23,6 +23,7 @@ import (
 	"knative.dev/func/pkg/builders"
 	"knative.dev/func/pkg/docker"
 	fn "knative.dev/func/pkg/functions"
+	"knative.dev/func/pkg/scaffolding"
 )
 
 // DefaultName when no WithName option is provided to NewBuilder
@@ -191,6 +192,15 @@ func (b *Builder) Build(ctx context.Context, f fn.Function, platforms []fn.Platf
 		opts.Env["BP_GO_WORKDIR"] = ".func/build"
 	}
 
+	// Get middleware version and set as image label via BP_IMAGE_LABELS
+	middlewareVersion, err := scaffolding.MiddlewareVersion(f.Root, f.Runtime, f.Invoke, fn.EmbeddedTemplatesFS)
+	if err != nil {
+		return fmt.Errorf("cannot get middleware version: %w", err)
+	}
+	if middlewareVersion != "" {
+		opts.Env["BP_IMAGE_LABELS"] = fmt.Sprintf("%s=%s", fn.MiddlewareVersionLabelKey, middlewareVersion)
+	}
+
 	var bindings = make([]string, 0, len(f.Build.Mounts))
 	for _, m := range f.Build.Mounts {
 		bindings = append(bindings, fmt.Sprintf("%s:%s", m.Source, m.Destination))

pkg/buildpacks/builder_test.go

@@ -2,6 +2,7 @@ package buildpacks
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -10,6 +11,8 @@ import (
 	pack "github.com/buildpacks/pack/pkg/client"
 	"knative.dev/func/pkg/builders"
 	fn "knative.dev/func/pkg/functions"
+	"knative.dev/func/pkg/scaffolding"
+	. "knative.dev/func/pkg/testing"
 )
 
 // TestBuild_BuilderImageUntrusted ensures that only known builder images
@@ -83,12 +86,21 @@ func TestBuild_BuilderImageDefault(t *testing.T) {
 // defined in-code, but none defined on the function, the defaults will be
 // used.
 func TestBuild_BuildpacksDefault(t *testing.T) {
+	root, done := Mktemp(t)
+	defer done()
+
 	var (
-		i = &mockImpl{}
-		b = NewBuilder(WithImpl(i))
-		f = fn.Function{Runtime: "go"}
+		i   = &mockImpl{}
+		b   = NewBuilder(WithImpl(i))
+		f   = fn.Function{Runtime: "go", Root: root, Registry: "example.com/alice"}
+		err error
 	)
 
+	// Initialize the function to create proper source files
+	if f, err = fn.New().Init(f); err != nil {
+		t.Fatal(err)
+	}
+
 	i.BuildFn = func(ctx context.Context, opts pack.BuildOptions) error {
 		expected := defaultBuildpacks["go"]
 		if !reflect.DeepEqual(expected, opts.Buildpacks) {
@@ -136,23 +148,32 @@ func TestBuild_BuilderImageConfigurable(t *testing.T) {
 // TestBuild_BuilderImageExclude ensures that ignored files are not added to the func
 // image
 func TestBuild_BuilderImageExclude(t *testing.T) {
+	root, done := Mktemp(t)
+	defer done()
+
 	var (
 		i = &mockImpl{} // mock underlying implementation
 		b = NewBuilder( // Func Builder logic
 			WithName(builders.Pack), WithImpl(i))
 		f = fn.Function{
-			Runtime: "go",
+			Runtime:  "go",
+			Root:     root,
+			Registry: "example.com/alice",
 		}
+		err error
 	)
+
+	// Initialize the function to create proper source files
+	if f, err = fn.New().Init(f); err != nil {
+		t.Fatal(err)
+	}
+
 	funcIgnoreContent := []byte(`#testing comments
 hello.txt`)
 	expected := []string{"hello.txt"}
 
-	tempdir := t.TempDir()
-	f.Root = tempdir
-
 	//create a .funcignore file containing the details of the files to be ignored
-	err := os.WriteFile(filepath.Join(f.Root, ".funcignore"), funcIgnoreContent, 0644)
+	err = os.WriteFile(filepath.Join(f.Root, ".funcignore"), funcIgnoreContent, 0644)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -204,6 +225,57 @@ func TestBuild_Envs(t *testing.T) {
 	}
 }
 
+// TestBuild_MiddlewareLabel ensures that the middleware-version label is set
+// on the build options for runtimes that support scaffolding.
+func TestBuild_MiddlewareLabel(t *testing.T) {
+	root, done := Mktemp(t)
+	defer done()
+
+	var (
+		i = &mockImpl{}
+		b = NewBuilder(WithImpl(i))
+		f = fn.Function{
+			Name:     "test-middleware-label",
+			Root:     root,
+			Runtime:  "go",
+			Registry: "example.com/alice",
+		}
+		err error
+	)
+
+	// Initialize the function to create proper source files
+	if f, err = fn.New().Init(f); err != nil {
+		t.Fatal(err)
+	}
+
+	// Get expected middleware version
+	expectedVersion, err := scaffolding.MiddlewareVersion(f.Root, f.Runtime, f.Invoke, fn.EmbeddedTemplatesFS)
+	if err != nil {
+		t.Fatalf("failed to get expected middleware version: %v", err)
+	}
+	if expectedVersion == "" {
+		t.Fatal("expected middleware version to be non-empty for go runtime")
+	}
+
+	expectedLabel := fmt.Sprintf("%s=%s", fn.MiddlewareVersionLabelKey, expectedVersion)
+
+	i.BuildFn = func(ctx context.Context, opts pack.BuildOptions) error {
+		bpLabels, ok := opts.Env["BP_IMAGE_LABELS"]
+		if !ok {
+			t.Fatal("expected BP_IMAGE_LABELS to be set")
+		}
+		if bpLabels != expectedLabel {
+			t.Fatalf("expected BP_IMAGE_LABELS to be %q, got: %q", expectedLabel, bpLabels)
+		}
+		t.Logf("BP_IMAGE_LABELS: %s", bpLabels)
+		return nil
+	}
+
+	if err := b.Build(context.Background(), f, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
 // TestBuild_Errors confirms error scenarios.
 func TestBuild_Errors(t *testing.T) {
 	testCases := []struct {

pkg/s2i/builder.go

@@ -21,6 +21,7 @@ import (
 	"knative.dev/func/pkg/builders"
 	"knative.dev/func/pkg/docker"
 	fn "knative.dev/func/pkg/functions"
+	"knative.dev/func/pkg/scaffolding"
 )
 
 // DefaultName when no WithName option is provided to NewBuilder
@@ -173,6 +174,15 @@ func (b *Builder) Build(ctx context.Context, f fn.Function, platforms []fn.Platf
 		ExcludeRegExp: "(^|/)\\.git|\\.env|\\.func|node_modules(/|$)",
 	}
 
+	// Set middleware version label
+	middlewareVersion, err := scaffolding.MiddlewareVersion(f.Root, f.Runtime, f.Invoke, fn.EmbeddedTemplatesFS)
+	if err != nil {
+		return fmt.Errorf("cannot get middleware version: %w", err)
+	}
+	if middlewareVersion != "" {
+		cfg.Labels = map[string]string{fn.MiddlewareVersionLabelKey: middlewareVersion}
+	}
+
 	// Environment variables
 	// Build Envs have local env var references interpolated then added to the
 	// config as an S2I EnvironmentList struct

pkg/s2i/builder_test.go

@@ -210,6 +210,49 @@ func Test_BuildEnvs(t *testing.T) {
 	}
 }
 
+// Test_MiddlewareLabel ensures that the middleware-version label is set
+// on the S2I build config for runtimes that support scaffolding.
+func Test_MiddlewareLabel(t *testing.T) {
+	root, done := Mktemp(t)
+	defer done()
+
+	f := fn.Function{
+		Name:     "test-middleware-label",
+		Root:     root,
+		Runtime:  "go",
+		Registry: "example.com/alice",
+	}
+
+	var err error
+	if f, err = fn.New().Init(f); err != nil {
+		t.Fatal(err)
+	}
+
+	i := &mockImpl{}
+	c := mockDocker{}
+	b := s2i.NewBuilder(s2i.WithImpl(i), s2i.WithDockerClient(c))
+
+	i.BuildFn = func(cfg *api.Config) (*api.Result, error) {
+		// Verify middleware-version label is set
+		if cfg.Labels == nil {
+			t.Fatal("expected Labels to be set on config")
+		}
+		middlewareVersion, ok := cfg.Labels[fn.MiddlewareVersionLabelKey]
+		if !ok {
+			t.Fatalf("expected label %q to be set", fn.MiddlewareVersionLabelKey)
+		}
+		if middlewareVersion == "" {
+			t.Fatalf("expected label %q to have a non-empty value", fn.MiddlewareVersionLabelKey)
+		}
+		t.Logf("middleware-version label: %s", middlewareVersion)
+		return nil, nil
+	}
+
+	if err := b.Build(context.Background(), f, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestBuildFail(t *testing.T) {
 	cli := mockDocker{
 		inspect: func(ctx context.Context, image string) (typesImage.InspectResponse, []byte, error) {