[chore] Split up cmd/goreleaser/internal/configure.go

cmd/goreleaser/internal/constants.go

@@ -0,0 +1,19 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+const (
+	coreDistro         = "otelcol"
+	contribDistro      = "otelcol-contrib"
+	k8sDistro          = "otelcol-k8s"
+	otlpDistro         = "otelcol-otlp"
+	ebpfProfilerDistro = "otelcol-ebpf-profiler"
+	ocbBinary          = "builder"
+	opampBinary        = "opampsupervisor"
+
+	binaryNamePrefix = "otelcol"
+	imageNamePrefix  = "opentelemetry-collector"
+	projectName      = "opentelemetry-collector-releases"
+	defaultBuildDir  = "_build"
+)

cmd/goreleaser/internal/container.go

@@ -0,0 +1,169 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+import (
+	"fmt"
+	"slices"
+
+	"github.com/goreleaser/goreleaser-pro/v2/pkg/config"
+)
+
+const (
+	armArchitecture = "arm"
+	dockerHubRepo   = "otel"
+	ghcrRepo        = "ghcr.io/open-telemetry/opentelemetry-collector-releases"
+)
+
+var (
+	imageRepositories = []string{dockerHubRepo, ghcrRepo}
+)
+
+// containerImageOptions contains options for container image configuration.
+type containerImageOptions struct {
+	armVersion    string
+	winVersion    string
+	binaryRelease bool
+}
+
+func (o *containerImageOptions) version() string {
+	if o.armVersion != "" {
+		return o.armVersion
+	}
+	return o.winVersion
+}
+
+type osArchInfo struct {
+	os, arch, version string
+}
+
+func (o *osArchInfo) buildPlatform() string {
+	switch o.os {
+	case "linux":
+		switch o.arch {
+		case armArchitecture:
+			return fmt.Sprintf("linux/arm/v%s", o.version)
+		}
+	case "windows":
+		return fmt.Sprintf("windows/%s", o.arch)
+	}
+	return fmt.Sprintf("linux/%s", o.arch)
+}
+
+func (o *osArchInfo) imageTag() string {
+	switch o.os {
+	case "linux":
+		switch o.arch {
+		case armArchitecture:
+			return fmt.Sprintf("armv%s", o.version)
+		}
+	case "windows":
+		return fmt.Sprintf("windows-%s-%s", o.version, o.arch)
+	}
+	return o.arch
+}
+
+// newContainerImages creates container image configurations.
+func newContainerImages(dist string, targetOS string, targetArchs []string, opts containerImageOptions) []config.Docker {
+	var images []config.Docker
+	for _, targetArch := range targetArchs {
+		images = append(images, buildDockerImageWithOS(dist, targetOS, targetArch, opts))
+	}
+	return images
+}
+
+// newContainerImageManifests creates container image manifest configurations.
+func newContainerImageManifests(dist, os string, archs []string, opts containerImageOptions) []config.DockerManifest {
+	tags := []string{`{{ .Version }}`, "{{ .Env.CONTAINER_IMAGE_EPHEMERAL_TAG }}"}
+	if os == "windows" {
+		for i, tag := range tags {
+			tags[i] = fmt.Sprintf("%s-%s-%s", tag, os, opts.winVersion)
+		}
+	}
+
+	var r []config.DockerManifest
+	for _, imageRepo := range imageRepositories {
+		for _, tag := range tags {
+			r = append(r, buildOSDockerManifest(imageRepo, tag, dist, os, archs, opts))
+		}
+	}
+	return r
+}
+
+func buildDockerImageWithOS(dist, os, arch string, opts containerImageOptions) config.Docker {
+	osArch := osArchInfo{os: os, arch: arch, version: opts.version()}
+	var imageTemplates []string
+	for _, prefix := range imageRepositories {
+		imageTemplates = append(
+			imageTemplates,
+			fmt.Sprintf("%s/%s:{{ .Version }}-%s", prefix, imageName(dist, opts), osArch.imageTag()),
+			fmt.Sprintf("%s/%s:{{ .Env.CONTAINER_IMAGE_EPHEMERAL_TAG }}-%s", prefix, imageName(dist, opts), osArch.imageTag()),
+		)
+	}
+
+	label := func(name, template string) string {
+		return fmt.Sprintf("--label=org.opencontainers.image.%s={{%s}}", name, template)
+	}
+	imageConfig := config.Docker{
+		ImageTemplates: imageTemplates,
+		Dockerfile:     "Dockerfile",
+		Use:            "buildx",
+		BuildFlagTemplates: []string{
+			"--pull",
+			fmt.Sprintf("--platform=%s", osArch.buildPlatform()),
+			label("created", ".Date"),
+			label("name", ".ProjectName"),
+			label("revision", ".FullCommit"),
+			label("version", ".Version"),
+			label("source", ".GitURL"),
+			"--label=org.opencontainers.image.licenses=Apache-2.0",
+		},
+		Goos:   os,
+		Goarch: arch,
+	}
+	if arch == armArchitecture {
+		imageConfig.Goarm = opts.armVersion
+	}
+	if os == "windows" {
+		imageConfig.BuildFlagTemplates = slices.Insert(
+			imageConfig.BuildFlagTemplates, 1,
+			fmt.Sprintf("--build-arg=WIN_VERSION=%s", opts.winVersion),
+		)
+		imageConfig.Dockerfile = "Windows.dockerfile"
+		imageConfig.Use = "docker"
+		imageConfig.SkipBuild = "{{ not (eq .Runtime.Goos \"windows\") }}"
+		imageConfig.SkipPush = "{{ not (eq .Runtime.Goos \"windows\") }}"
+	}
+	return imageConfig
+}
+
+func buildOSDockerManifest(prefix, version, dist, os string, archs []string, opts containerImageOptions) config.DockerManifest {
+	var imageTemplates []string
+	for _, arch := range archs {
+		switch arch {
+		case armArchitecture:
+			for _, armVers := range armVersions(dist) {
+				dockerArchTag := (&osArchInfo{os: os, arch: arch, version: armVers}).imageTag()
+				imageTemplates = append(
+					imageTemplates,
+					fmt.Sprintf("%s/%s:%s-%s", prefix, imageName(dist, opts), version, dockerArchTag),
+				)
+			}
+		default:
+			imageTemplates = append(
+				imageTemplates,
+				fmt.Sprintf("%s/%s:%s-%s", prefix, imageName(dist, opts), version, arch),
+			)
+		}
+	}
+
+	manifest := config.DockerManifest{
+		NameTemplate:   fmt.Sprintf("%s/%s:%s", prefix, imageName(dist, opts), version),
+		ImageTemplates: imageTemplates,
+	}
+	if os == "windows" {
+		manifest.SkipPush = "{{ not (eq .Runtime.Goos \"windows\") }}"
+	}
+	return manifest
+}

cmd/goreleaser/internal/distro_contrib.go

@@ -0,0 +1,62 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+import (
+	"slices"
+
+	"github.com/goreleaser/goreleaser-pro/v2/pkg/config"
+)
+
+var (
+	// contrib distro
+	contribDist = newDistributionBuilder(contribDistro).withConfigFunc(func(d *distribution) {
+		d.BuildConfigs = []buildConfig{
+			&preBuiltBuildConfig{
+				TargetOS:   "linux",
+				TargetArch: baseArchs,
+				PreBuilt: config.PreBuiltOptions{
+					Path: "artifacts/otelcol-contrib-linux_{{ .Target }}/otelcol-contrib",
+				},
+			},
+			&preBuiltBuildConfig{
+				TargetOS:   "darwin",
+				TargetArch: darwinArchs,
+				PreBuilt: config.PreBuiltOptions{
+					Path: "artifacts/otelcol-contrib-darwin_{{ .Target }}/otelcol-contrib",
+				},
+			},
+			&preBuiltBuildConfig{
+				TargetOS:   "windows",
+				TargetArch: winArchs,
+				PreBuilt: config.PreBuiltOptions{
+					Path: "artifacts/otelcol-contrib-windows_{{ .Target }}/otelcol-contrib.exe",
+				},
+			},
+		}
+		d.ContainerImages = slices.Concat(
+			newContainerImages(d.Name, "linux", baseArchs, containerImageOptions{armVersion: "7"}),
+			newContainerImages(d.Name, "windows", winContainerArchs, containerImageOptions{winVersion: "2019"}),
+			newContainerImages(d.Name, "windows", winContainerArchs, containerImageOptions{winVersion: "2022"}),
+		)
+		d.ContainerImageManifests = slices.Concat(
+			newContainerImageManifests(d.Name, "linux", baseArchs, containerImageOptions{}),
+		)
+	}).withPackagingDefaults().withDefaultConfigIncluded().build()
+
+	// contrib build-only project
+	contribBuildOnlyDist = newDistributionBuilder(contribDistro).withConfigFunc(func(d *distribution) {
+		d.BuildConfigs = []buildConfig{
+			&fullBuildConfig{TargetOS: "linux", TargetArch: baseArchs, BuildDir: defaultBuildDir, ArmVersion: []string{"7"}},
+			&fullBuildConfig{TargetOS: "darwin", TargetArch: darwinArchs, BuildDir: defaultBuildDir},
+			&fullBuildConfig{TargetOS: "windows", TargetArch: winArchs, BuildDir: defaultBuildDir},
+		}
+	}).withBinArchive().
+		withDefaultMonorepo().
+		withDefaultEnv().
+		withDefaultPartial().
+		withDefaultRelease().
+		withNightlyConfig().
+		build()
+)

cmd/goreleaser/internal/distro_ebpf_profiler.go

@@ -0,0 +1,39 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+import "slices"
+
+var (
+	ebpfProfilerArchs = []string{"amd64", "arm64"}
+)
+
+var (
+	// ebpf-profiler distro
+	ebpfProfilerDist = newDistributionBuilder(ebpfProfilerDistro).withConfigFunc(func(d *distribution) {
+		d.BuildConfigs = []buildConfig{
+			&fullBuildConfig{TargetOS: "linux", TargetArch: ebpfProfilerArchs, BuildDir: defaultBuildDir},
+		}
+		d.ContainerImages = slices.Concat(
+			newContainerImages(d.Name, "linux", ebpfProfilerArchs, containerImageOptions{}),
+		)
+		d.ContainerImageManifests = slices.Concat(
+			newContainerImageManifests(d.Name, "linux", ebpfProfilerArchs, containerImageOptions{}),
+		)
+		d.Env = append(d.Env, "TARGET_ARCH={{ .Runtime.Goarch }}")
+		d.LdFlags = "-extldflags=-static"
+		d.GoTags = "osusergo,netgo"
+	}).withDefaultArchives().
+		withDefaultChecksum().
+		withDefaultSigns().
+		withDefaultDockerSigns().
+		withDefaultSBOMs().
+		withDefaultMonorepo().
+		withDefaultEnv().
+		withDefaultPartial().
+		withDefaultRelease().
+		withNightlyConfig().
+		withDefaultSnapshot().
+		build()
+)

cmd/goreleaser/internal/distro_k8s.go

@@ -0,0 +1,35 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+import "slices"
+
+var (
+	// k8s distro
+	k8sDist = newDistributionBuilder(k8sDistro).withConfigFunc(func(d *distribution) {
+		d.BuildConfigs = []buildConfig{
+			&fullBuildConfig{TargetOS: "linux", TargetArch: k8sArchs, BuildDir: defaultBuildDir, Ppc64Version: []string{"power8"}},
+			&fullBuildConfig{TargetOS: "windows", TargetArch: winContainerArchs, BuildDir: defaultBuildDir},
+		}
+		d.ContainerImages = slices.Concat(
+			newContainerImages(d.Name, "linux", k8sArchs, containerImageOptions{armVersion: "7"}),
+			newContainerImages(d.Name, "windows", winContainerArchs, containerImageOptions{winVersion: "2019"}),
+			newContainerImages(d.Name, "windows", winContainerArchs, containerImageOptions{winVersion: "2022"}),
+		)
+		d.ContainerImageManifests = slices.Concat(
+			newContainerImageManifests(d.Name, "linux", k8sArchs, containerImageOptions{}),
+		)
+	}).withDefaultArchives().
+		withDefaultChecksum().
+		withDefaultSigns().
+		withDefaultDockerSigns().
+		withDefaultSBOMs().
+		withDefaultMonorepo().
+		withDefaultEnv().
+		withDefaultPartial().
+		withDefaultRelease().
+		withNightlyConfig().
+		withDefaultSnapshot().
+		build()
+)

cmd/goreleaser/internal/distro_ocb.go

@@ -0,0 +1,32 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+import "slices"
+
+const (
+	ocbReleaseHeader = "### Images and binaries for collector distributions here: https://github.com/open-telemetry/opentelemetry-collector-releases/releases/tag/{{ .Tag }}"
+)
+
+var (
+	// OCB binary
+	ocbDist = newDistributionBuilder(ocbBinary).withConfigFunc(func(d *distribution) {
+		d.BuildConfigs = []buildConfig{
+			&fullBuildConfig{TargetOS: "linux", TargetArch: ocbArchs, BinaryName: "ocb"},
+			&fullBuildConfig{TargetOS: "darwin", TargetArch: darwinArchs, BinaryName: "ocb"},
+			&fullBuildConfig{TargetOS: "windows", TargetArch: []string{"amd64"}, BinaryName: "ocb"},
+		}
+		d.ContainerImages = slices.Concat(
+			newContainerImages(d.Name, "linux", ocbArchs, containerImageOptions{binaryRelease: true}),
+		)
+		d.ContainerImageManifests = slices.Concat(
+			newContainerImageManifests(d.Name, "linux", ocbArchs, containerImageOptions{binaryRelease: true}),
+		)
+		d.LdFlags = "-s -w -X go.opentelemetry.io/collector/cmd/builder/internal.version={{ .Version }}"
+	}).withBinaryPackagingDefaults().
+		withBinaryMonorepo(".core/cmd/builder").
+		withDefaultBinaryRelease(ocbReleaseHeader).
+		withNightlyConfig().
+		build()
+)