Add label of scaffolded middleware version to function image

go.mod

@@ -11,6 +11,7 @@ replace knative.dev/pkg => knative.dev/pkg v0.0.0-20250716115900-19d3cc2da0b9
 
 require (
 	github.com/AlecAivazis/survey/v2 v2.3.7
+	github.com/BurntSushi/toml v1.5.0
 	github.com/Masterminds/semver v1.5.0
 	github.com/Microsoft/go-winio v0.6.2
 	github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2
@@ -55,6 +56,7 @@ require (
 	github.com/tektoncd/pipeline v0.65.1
 	gitlab.com/gitlab-org/api/client-go v0.150.0
 	golang.org/x/crypto v0.44.0
+	golang.org/x/mod v0.30.0
 	golang.org/x/net v0.47.0
 	golang.org/x/oauth2 v0.30.0
 	golang.org/x/sync v0.18.0
@@ -90,7 +92,6 @@ require (
 	github.com/Azure/go-autorest/autorest/date v0.3.1 // indirect
 	github.com/Azure/go-autorest/logger v0.2.2 // indirect
 	github.com/Azure/go-autorest/tracing v0.6.1 // indirect
-	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/GoogleContainerTools/kaniko v1.24.0 // indirect
 	github.com/Masterminds/semver/v3 v3.2.1 // indirect
 	github.com/Microsoft/hcsshim v0.13.0 // indirect
@@ -285,7 +286,6 @@ require (
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect
-	golang.org/x/mod v0.30.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
 	golang.org/x/time v0.12.0 // indirect
 	gomodules.xyz/jsonpatch/v2 v2.5.0 // indirect

pkg/functions/function_labels.go

@@ -8,6 +8,10 @@ import (
 	"knative.dev/func/pkg/utils"
 )
 
+const (
+	MiddlewareVersionLabelKey = "middleware-version"
+)
+
 type Label struct {
 	// Key consist of optional prefix part (ended by '/') and name part
 	// Prefix part validation pattern: [a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*

pkg/oci/builder.go

@@ -121,7 +121,7 @@ func (b *Builder) Build(ctx context.Context, f fn.Function, pp []fn.Platform) (e
 		_ = os.Remove(job.pidLink())
 	}()
 
-	if err = scaffold(job); err != nil { // write out the service wrapper
+	if err = scaffold(&job); err != nil { // write out the service wrapper
 		return
 	}
 
@@ -245,18 +245,35 @@ func cleanup(job buildJob) {
 
 // scaffold writes out the process wrapper code which will instantiate the
 // Function and expose it as a service when included in the final container.
-func scaffold(job buildJob) (err error) {
+func scaffold(job *buildJob) (err error) {
 	// extract the embedded filesystem which holds the scaffolding for
 	// the given runtime
 	repo, err := fn.NewRepository("", "")
 	if err != nil {
 		return
 	}
-	return scaffolding.Write(
+	err = scaffolding.Write(
 		job.buildDir(),       // desintation for scaffolding
 		job.function.Root,    // source to be scaffolded
 		job.function.Runtime, // scaffolding language to write
 		job.function.Invoke, repo.FS())
+
+	if err != nil {
+		return
+	}
+
+	// add used scaffolded middleware information
+	middlewareVersion, err := scaffolding.MiddlewareVersion(job.function.Root, job.function.Runtime, job.function.Invoke, repo.FS())
+	if err != nil {
+		return fmt.Errorf("unable to get middleware version: %w", err)
+	}
+
+	if job.labels == nil {
+		job.labels = make(map[string]string)
+	}
+	job.labels[fn.MiddlewareVersionLabelKey] = middlewareVersion
+
+	return nil
 }
 
 // containerize the full service which consists of the scaffolded Function,
@@ -688,7 +705,7 @@ func newConfigFile(job buildJob, p v1.Platform, base v1.Image, imageLayers []ima
 			WorkingDir:   "/func/",
 			StopSignal:   "SIGKILL",
 			User:         fmt.Sprintf("%v:%v", DefaultUid, DefaultGid),
-			// Labels
+			Labels:       job.labels,
 		},
 		// TODO: Create a separate history entry for each layer built for
 		// each language (EmptyLayer=false).
@@ -885,6 +902,7 @@ type buildJob struct {
 	platforms       []v1.Platform   // Platforms to build
 	languageBuilder languageBuilder // build implementation
 	verbose         bool
+	labels          map[string]string // labels for the image
 }
 
 // newBuildJob creates a struct which contains information about the current

pkg/s2i/builder.go

@@ -284,5 +284,17 @@ func scaffold(cfg *api.Config, f fn.Function) (*api.Config, error) {
 	// https://github.com/openshift/source-to-image/issues/1141
 	cfg.ForceCopy = true
 
+	// add used scaffolded middleware information
+	middlewareVersion, err := scaffolding.MiddlewareVersion(f.Root, f.Runtime, f.Invoke, embeddedRepo.FS())
+	if err != nil {
+		return cfg, fmt.Errorf("unable to get middleware version: %w", err)
+	}
+
+	if cfg.Labels == nil {
+		cfg.Labels = make(map[string]string)
+	}
+
+	cfg.Labels[fn.MiddlewareVersionLabelKey] = middlewareVersion
+
 	return cfg, nil
 }

pkg/scaffolding/middleware_version.go

@@ -0,0 +1,249 @@
+package scaffolding
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"regexp"
+
+	"github.com/BurntSushi/toml"
+	"golang.org/x/mod/modfile"
+	"knative.dev/func/pkg/filesystem"
+)
+
+// MiddlewareVersion returns the middleware version for the given function
+//
+//	src:     the path to the source code of the function
+//	runtime: the expected runtime of the target source code "go", "node" etc.
+//	invoke:  the optional invocation hint (default "http")
+//	fs:      filesystem which contains scaffolding at '[runtime]/scaffolding'
+//	         (exclusive with 'repo')
+func MiddlewareVersion(src, runtime, invoke string, fs filesystem.Filesystem) (string, error) {
+	s, err := detectSignature(src, runtime, invoke)
+	if err != nil {
+		return "", fmt.Errorf("failed to detect signature: %w", err)
+	}
+
+	vd, err := getVersionDetector(runtime)
+	if err != nil {
+		return "", fmt.Errorf("failed to get middleware version detector: %w", err)
+	}
+
+	return vd.Detect(fs, s)
+}
+
+type middlewareVersionDetector interface {
+	Detect(fs filesystem.Filesystem, sig Signature) (string, error)
+}
+
+func getVersionDetector(runtime string) (middlewareVersionDetector, error) {
+	switch runtime {
+	case "go":
+		return &golangMiddlewareVersionDetector{}, nil
+	case "python":
+		return &pythonMiddlewareVersionDetector{}, nil
+	case "node":
+		return &nodeMiddlewareVersionDetector{}, nil
+	case "typescript":
+		return &typescriptMiddlewareVersionDetector{}, nil
+	case "quarkus":
+		return &quarkusMiddlewareVersionDetector{}, nil
+	case "java":
+		return &springMiddlewareVersionDetector{}, nil
+	case "rust":
+		return &rustMiddlewareVersionDetector{}, nil
+	default:
+		return nil, fmt.Errorf("unsupported runtime: %s", runtime)
+	}
+}
+
+type golangMiddlewareVersionDetector struct{}
+
+func (d *golangMiddlewareVersionDetector) Detect(fs filesystem.Filesystem, sig Signature) (string, error) {
+	gomodPath := fmt.Sprintf("go/scaffolding/%s/go.mod", sig.String())
+	if _, err := fs.Stat(gomodPath); err != nil {
+		return "", fmt.Errorf("failed to stat scaffolding go.mod: %w", err)
+	}
+
+	gomod, err := fs.Open(gomodPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open scaffolding go.mod: %w", err)
+	}
+	defer gomod.Close()
+
+	content, err := io.ReadAll(gomod)
+	if err != nil {
+		return "", fmt.Errorf("failed to read scaffolding go.mod: %w", err)
+	}
+
+	f, err := modfile.Parse(gomodPath, content, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse scaffolding go.mod: %w", err)
+	}
+
+	for _, req := range f.Require {
+		if req.Mod.Path == "knative.dev/func-go" {
+			return req.Mod.Version, nil
+		}
+	}
+
+	return "", fmt.Errorf("knative.dev/func-go dependency not found in %s", gomodPath)
+}
+
+type pythonMiddlewareVersionDetector struct{}
+
+const funcPythonVersionRegex = `func-python[~^=><!]*([0-9]+\.[0-9]+\.[0-9]+)?`
+
+func (d *pythonMiddlewareVersionDetector) Detect(fs filesystem.Filesystem, sig Signature) (string, error) {
+	pyprojectPath := fmt.Sprintf("python/scaffolding/%s/pyproject.toml", sig.String())
+
+	pyproject, err := fs.Open(pyprojectPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open scaffolding project.toml: %w", err)
+	}
+	defer pyproject.Close()
+
+	content, err := io.ReadAll(pyproject)
+	if err != nil {
+		return "", fmt.Errorf("failed to read scaffolding project.toml: %w", err)
+	}
+
+	var config struct {
+		Project struct {
+			Dependencies []string `toml:"dependencies"`
+		} `toml:"project"`
+	}
+	if err := toml.Unmarshal(content, &config); err != nil {
+		return "", fmt.Errorf("failed to parse scaffolding project.toml: %w", err)
+	}
+
+	re := regexp.MustCompile(funcPythonVersionRegex)
+	for _, dep := range config.Project.Dependencies {
+		matches := re.FindStringSubmatch(dep)
+		if len(matches) < 2 {
+			continue
+		}
+
+		// If no version is specified, return empty string
+		if len(matches[1]) == 0 {
+			return "", nil
+		}
+
+		return matches[1], nil
+	}
+
+	return "", fmt.Errorf("func-python not found in %s", pyprojectPath)
+}
+
+type nodeMiddlewareVersionDetector struct{}
+
+func (d *nodeMiddlewareVersionDetector) Detect(fs filesystem.Filesystem, sig Signature) (string, error) {
+	invoke := "http"
+	if sig == InstancedCloudevents || sig == StaticCloudevents {
+		invoke = "cloudevents"
+	}
+	packageJsonPath := fmt.Sprintf("node/%s/package.json", invoke)
+
+	packageJsonDetector := &packageJsonMiddlewareVersionDetector{}
+	return packageJsonDetector.detect(fs, sig, packageJsonPath)
+}
+
+type typescriptMiddlewareVersionDetector struct{}
+
+func (d *typescriptMiddlewareVersionDetector) Detect(fs filesystem.Filesystem, sig Signature) (string, error) {
+	invoke := "http"
+	if sig == InstancedCloudevents || sig == StaticCloudevents {
+		invoke = "cloudevents"
+	}
+	packageJsonPath := fmt.Sprintf("typescript/%s/package.json", invoke)
+
+	packageJsonDetector := &packageJsonMiddlewareVersionDetector{}
+	return packageJsonDetector.detect(fs, sig, packageJsonPath)
+}
+
+type quarkusMiddlewareVersionDetector struct{}
+
+func (d *quarkusMiddlewareVersionDetector) Detect(fs filesystem.Filesystem, sig Signature) (string, error) {
+	invoke := "http"
+	if sig == InstancedCloudevents || sig == StaticCloudevents {
+		invoke = "cloudevents"
+	}
+	pomXmlPath := fmt.Sprintf("quarkus/%s/pom.xml", invoke)
+
+	pomDetector := &pomMiddlewareVersionDetector{}
+	return pomDetector.detect(fs, sig, pomXmlPath)
+}
+
+type springMiddlewareVersionDetector struct{}
+
+func (d *springMiddlewareVersionDetector) Detect(fs filesystem.Filesystem, sig Signature) (string, error) {
+	invoke := "http"
+	if sig == InstancedCloudevents || sig == StaticCloudevents {
+		invoke = "cloudevents"
+	}
+	pomXmlPath := fmt.Sprintf("springboot/%s/pom.xml", invoke)
+
+	pomDetector := &pomMiddlewareVersionDetector{}
+	return pomDetector.detect(fs, sig, pomXmlPath)
+}
+
+type rustMiddlewareVersionDetector struct{}
+
+func (d *rustMiddlewareVersionDetector) Detect(_ filesystem.Filesystem, _ Signature) (string, error) {
+	// we don't have any rust middleware, so simply return nothing
+	return "", nil
+}
+
+type packageJsonMiddlewareVersionDetector struct{}
+
+func (d *packageJsonMiddlewareVersionDetector) detect(fs filesystem.Filesystem, sig Signature, packageJsonPath string) (string, error) {
+	packageJson, err := fs.Open(packageJsonPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open package.json: %w", err)
+	}
+	defer packageJson.Close()
+
+	content, err := io.ReadAll(packageJson)
+	if err != nil {
+		return "", fmt.Errorf("failed to read package.json: %w", err)
+	}
+
+	var config struct {
+		Dependencies map[string]string `json:"dependencies"`
+	}
+	if err := json.Unmarshal(content, &config); err != nil {
+		return "", fmt.Errorf("failed to parse project.json: %w", err)
+	}
+
+	semverRegex := regexp.MustCompile(`\d+\.\d+\.\d+`)
+	for dep, version := range config.Dependencies {
+		if dep == "faas-js-runtime" {
+			return semverRegex.FindString(version), nil
+		}
+	}
+
+	return "", fmt.Errorf("faas-js-runtime not found in %s", packageJsonPath)
+}
+
+type pomMiddlewareVersionDetector struct{}
+
+func (d *pomMiddlewareVersionDetector) detect(fs filesystem.Filesystem, sig Signature, pomXmlPath string) (string, error) {
+	pomXml, err := fs.Open(pomXmlPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open pom.xml: %w", err)
+	}
+	defer pomXml.Close()
+
+	content, err := io.ReadAll(pomXml)
+	if err != nil {
+		return "", fmt.Errorf("failed to read pom.xml: %w", err)
+	}
+
+	re := regexp.MustCompile(`<quarkus\.platform\.version>(.*?)</quarkus\.platform\.version>`)
+	match := re.FindSubmatch(content)
+	if len(match) == 2 {
+		return string(match[1]), nil
+	}
+
+	return "", fmt.Errorf("quarkus.platform.version property not found in %s", pomXmlPath)
+}