Merge pull request #436 from sapcc/concourse-resource-support

Author: SuperSandro2000

README.md

@@ -111,6 +111,17 @@ The `fromPackage` is a Go module path relative to the directory containing the M
 If `installTo` is set for at least one binary, the `install` target is added to the Makefile, and all binaries with `installTo` are installed by it.
 In this case, `example` would be installed as `/usr/bin/example` by default, and `test-helper` would not be installed.
 
+As a special case for building [Concourse resource types](https://concourse-ci.org/docs/resource-types/implementing/),
+setting `installTo: /opt/resource` will have the following effects:
+
+- At build time, the binary will be written to `build/$NAME` as usual.
+  This path will also be symlinked to `build/check`, `build/in` and `build/out`,
+  to allow invoking the binary in one of the three operation modes for Concourse resource types.
+- At install time, the binary will be installed to `/opt/resource/$NAME`.
+  This path will also be symlinked to `/opt/resource/check`, `/opt/resource/in` and `/opt/resource/out`,
+  to make Docker images that were built with `make install` work as a Concourse resource type.
+  See [`dockerfile.enabled`](#dockerfile) below for how to build such images.
+
 ### `controllerGen`
 
 ```yaml

internal/core/config.go

@@ -7,6 +7,7 @@ import (
 	_ "embed"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"slices"
 	"strings"
 	"time"
@@ -335,6 +336,17 @@ func (c *Configuration) Validate() {
 		}
 	}
 
+	// because of the special logic for `installTo: /opt/resource`, only one binary is allowed to install there
+	optResourceBinaryCount := 0
+	for _, bin := range c.Binaries {
+		if filepath.Clean(bin.InstallTo) == "/opt/resource" {
+			optResourceBinaryCount++
+		}
+	}
+	if optResourceBinaryCount > 1 {
+		logg.Fatal("cannot have more than one entry in 'binaries' with `installTo: /opt/resource`")
+	}
+
 	// Validate GolangciLintConfiguration.
 	if len(c.GolangciLint.ErrcheckExcludes) > 0 && !c.GolangciLint.CreateConfig {
 		logg.Fatal("golangciLint.createConfig must be set to 'true' if golangciLint.errcheckExcludes is defined")

internal/dockerfile/Dockerfile.tmpl

@@ -74,7 +74,9 @@ RUN {{ .RunCommands }}
 
 COPY --from=builder /etc/ssl/certs/ /etc/ssl/certs/
 COPY --from=builder /etc/ssl/cert.pem /etc/ssl/cert.pem
-COPY --from=builder /pkg/ /usr/
+{{- range $src := .PathsToCopy | sortedKeys }}
+COPY --from=builder {{ $src }}/ {{ index $.PathsToCopy $src }}/
+{{- end }}
 # make sure all binaries can be executed
 {{- if .RunVersionCommands }}
 RUN set -x \

internal/dockerfile/docker.go

@@ -6,6 +6,7 @@ package dockerfile
 import (
 	_ "embed"
 	"fmt"
+	"path/filepath"
 	"strings"
 
 	"github.com/sapcc/go-bits/logg"
@@ -53,16 +54,28 @@ func RenderConfig(cfg core.Configuration, sr golang.ScanResult) {
 
 	// these commands will be run after `make install` to see that all installed commands can be executed
 	// (e.g. that all required shared libraries can be loaded correctly)
-	var runVersionCommands []string
+	var (
+		runVersionCommands []string
+		pathsToCopy        = make(map[string]string)
+	)
 	for _, binary := range cfg.Binaries {
-		if binary.InstallTo != "" {
+		switch {
+		case binary.InstallTo == "":
+			continue
+		case binary.InstallTo == "bin/":
 			// The binaries need to be in PATH which is only the case if they are installed to bin/
-			if binary.InstallTo != "bin/" {
-				logg.Error("dockerfile: ignoring binary %q with custom install path %q, only 'bin/' is supported at the moment", binary.Name, binary.InstallTo)
-				continue
-			}
-
+			pathsToCopy["/pkg"] = "/usr"
 			runVersionCommands = append(runVersionCommands, binary.Name+" --version 2>/dev/null")
+		case filepath.Clean(binary.InstallTo) == "/opt/resource":
+			// special case: Concourse resource type binaries are accessed through symlinks in /opt/resource that `make install` generates
+			pathsToCopy["/opt/resource"] = "/opt/resource"
+			runVersionCommands = append(runVersionCommands,
+				"/opt/resource/check --version 2>/dev/null",
+				"/opt/resource/in --version 2>/dev/null",
+				"/opt/resource/out --version 2>/dev/null",
+			)
+		default:
+			logg.Error("dockerfile: ignoring binary %q with custom install path %q, only 'bin/' and '/opt/resource' are supported at the moment", binary.Name, binary.InstallTo)
 		}
 	}
 
@@ -90,6 +103,7 @@ func RenderConfig(cfg core.Configuration, sr golang.ScanResult) {
 		"CheckEnv":           cfg.Dockerfile.CheckEnv,
 		"ExtraTestPackages":  extraTestPackages,
 		"Entrypoint":         entrypoint,
+		"PathsToCopy":        pathsToCopy,
 		"ReuseEnabled":       reuseEnabled,
 		"RunCommands":        strings.Join(commands, " \\\n  && "),
 		"RunVersionCommands": strings.Join(runVersionCommands, " \\\n  && "),

internal/makefile/makefile.go

@@ -724,6 +724,20 @@ func buildTargets(binaries []core.BinaryConfiguration, sr golang.ScanResult, run
 
 		result = append(result, r)
 		allPrerequisites = append(allPrerequisites, r.target)
+
+		// special handling for Concourse resource type binaries
+		if filepath.Clean(bin.InstallTo) == "/opt/resource" {
+			for _, alias := range []string{"check", "in", "out"} {
+				r := rule{
+					description: fmt.Sprintf("Build %s.", alias),
+					phony:       true,
+					target:      "build/" + alias,
+					recipe:      []string{fmt.Sprintf("ln -sf %s build/%s", bin.Name, alias)},
+				}
+				result = append(result, r)
+				allPrerequisites = append(allPrerequisites, r.target)
+			}
+		}
 	}
 	result[0].prerequisites = allPrerequisites
 
@@ -761,16 +775,34 @@ endif
 `), cfg.Variable("DESTDIR", ""))
 
 	for _, bin := range binaries {
-		if bin.InstallTo != "" {
-			r.prerequisites = append(r.prerequisites, "build/"+bin.Name)
-			// stupid MacOS does not have -D
-			r.recipe = append(r.recipe, fmt.Sprintf(
-				`install -d -m 0755 "$(DESTDIR)$(PREFIX)/%s"`, filepath.Clean(bin.InstallTo),
-			))
-			r.recipe = append(r.recipe, fmt.Sprintf(
-				`install -m 0755 build/%s "$(DESTDIR)$(PREFIX)/%s/%s"`,
-				bin.Name, filepath.Clean(bin.InstallTo), bin.Name,
-			))
+		if bin.InstallTo == "" {
+			continue
+		}
+		var installPath string
+		if strings.HasPrefix(bin.InstallTo, "/") {
+			installPath = filepath.Clean(bin.InstallTo)
+		} else {
+			installPath = filepath.Join("$(PREFIX)", bin.InstallTo)
+		}
+
+		r.prerequisites = append(r.prerequisites, "build/"+bin.Name)
+		// stupid MacOS does not have -D
+		r.recipe = append(r.recipe, fmt.Sprintf(
+			`install -d -m 0755 "$(DESTDIR)%s"`, installPath,
+		))
+		r.recipe = append(r.recipe, fmt.Sprintf(
+			`install -m 0755 build/%s "$(DESTDIR)%s/%s"`,
+			bin.Name, installPath, bin.Name,
+		))
+
+		// special handling for Concourse resource type binaries
+		if installPath == "/opt/resource" {
+			for _, alias := range []string{"check", "in", "out"} {
+				r.recipe = append(r.recipe, fmt.Sprintf(
+					`ln -sf %s $(DESTDIR)%s/%s`,
+					bin.Name, installPath, alias,
+				))
+			}
 		}
 	}
 	if len(r.recipe) == 0 {

internal/util/template.go

@@ -6,7 +6,9 @@ package util
 import (
 	"bytes"
 	"fmt"
+	"maps"
 	"os"
+	"slices"
 	"strings"
 	"text/template"
 
@@ -23,6 +25,9 @@ func WriteFileFromTemplate(fileName, templateCode string, data map[string]any) e
 		"containsIgnoreCase": func(s, substr string) bool {
 			return strings.Contains(strings.ToLower(s), strings.ToLower(substr))
 		},
+		"sortedKeys": func(m map[string]string) []string {
+			return slices.Sorted(maps.Keys(m))
+		},
 		"trimSpace": strings.TrimSpace,
 	}