Attempt build even if fetching of build flags fails (#800)

Attempts to build the tools with local detection have heretofore
required the build system to determine build flags on the local
platform. This needlessly complicates the process.

The present changeset removes that requirement. Now the build system
will always attempt a build even if it cannot determine build flags.

This also removes the baked-in assumption that locally-detected Linux
versions are Ubuntu 18.04. Now the build system runs `lsb_release` to
determine the Linux distribution’s name & release version.

Author: FGasper

buildscript/build.go

@@ -102,20 +102,12 @@ func TestAWSAuth(ctx *task.Context) error {
 // buildToolBinary builds the tool with the specified name, putting
 // the resulting binary into outDir.
 func buildToolBinary(ctx *task.Context, tool string, outDir string) error {
-	pf, err := getPlatform()
-	if err != nil {
-		return err
-	}
-
-	outPath := filepath.Join(outDir, tool+pf.BinaryExt)
+	outPath := filepath.Join(outDir, tool+platform.GetLocalBinaryExt())
 	_ = sh.Remove(ctx, outPath)
 
 	mainFile := filepath.Join(tool, "main", fmt.Sprintf("%s.go", tool))
 
-	buildFlags, err := getBuildFlags(ctx, false)
-	if err != nil {
-		return fmt.Errorf("failed to get build flags: %w", err)
-	}
+	buildFlags := getBuildFlags(ctx, false)
 
 	args := []string{
 		"build",
@@ -125,8 +117,9 @@ func buildToolBinary(ctx *task.Context, tool string, outDir string) error {
 	args = append(args, mainFile)
 
 	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Stderr = os.Stderr
 	sh.LogCmd(ctx, cmd)
-	output, err := cmd.CombinedOutput()
+	output, err := cmd.Output()
 
 	if len(output) > 0 {
 		_, _ = ctx.Write(output)
@@ -147,10 +140,7 @@ func runTests(ctx *task.Context, pkgs []string, testType string) error {
 		}
 		defer outFile.Close()
 
-		buildFlags, err := getBuildFlags(ctx, true)
-		if err != nil {
-			return fmt.Errorf("failed to get build flags: %w", err)
-		}
+		buildFlags := getBuildFlags(ctx, true)
 
 		// Use the recursive wildcard (...) to run all tests
 		// of the provided testType for the current pkg.
@@ -223,38 +213,39 @@ func getLdflags(ctx *task.Context) (string, error) {
 
 // getBuildFlags gets all the build flags that should be used when
 // building the tools on the current platform, including tags and ldflags.
-func getBuildFlags(ctx *task.Context, forTests bool) ([]string, error) {
+func getBuildFlags(ctx *task.Context, forTests bool) []string {
+	flags := []string{}
+
 	ldflags, err := getLdflags(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get ldflags: %w", err)
+	if err == nil {
+		flags = append(flags, "-ldflags", ldflags)
+	} else {
+		ctx.Logf("failed to get ldflags (error: %v); will still attempt build\n", err)
 	}
 
 	tags, err := getTags(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get tags: %w", err)
-	}
-
-	flags := []string{
-		"-ldflags", ldflags,
-		"-tags", strings.Join(tags, " "),
+	if err == nil {
+		flags = append(flags, "-tags", strings.Join(tags, " "))
+	} else {
+		ctx.Logf("failed to get tags (error: %v); will still attempt build\n", err)
 	}
 
 	pf, err := getPlatform()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get platform: %w", err)
-	}
-
-	if pf.OS == platform.OSLinux {
-		// We don't want to enable -buildmode=pie for tests. This interferes with enabling the race
-		// detector.
-		if !forTests {
-			flags = append(flags, "-buildmode=pie")
+	if err == nil {
+		if pf.OS == platform.OSLinux {
+			// We don't want to enable -buildmode=pie for tests. This interferes with enabling the race
+			// detector.
+			if !forTests {
+				flags = append(flags, "-buildmode=pie")
+			}
+		} else if pf.OS == platform.OSWindows {
+			flags = append(flags, "-buildmode=exe")
 		}
-	} else if pf.OS == platform.OSWindows {
-		flags = append(flags, "-buildmode=exe")
+	} else {
+		ctx.Logf("failed to get platform (error: %v); will still attempt build\n", err)
 	}
 
-	return flags, nil
+	return flags
 }
 
 // runCmd runs the command with the provided name and arguments, and

release/platform/platform.go

@@ -1,16 +1,20 @@
 package platform
 
 import (
+	"bytes"
 	"cmp"
 	"fmt"
+	"os"
 	"os/exec"
 	"regexp"
+	"runtime"
 	"sort"
 	"strings"
 
 	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/mongodb/mongo-tools/release/env"
 	"github.com/mongodb/mongo-tools/release/version"
+	"github.com/samber/lo"
 )
 
 type OS string
@@ -63,7 +67,6 @@ type Platform struct {
 	Pkg                Pkg
 	Repos              []Repo
 	BuildTags          []string
-	BinaryExt          string
 	SkipForJSONFeed    bool
 	ServerVariantNames mapset.Set[string]
 	ServerPlatform     string
@@ -104,6 +107,7 @@ func GetFromEnv() (Platform, error) {
 func DetectLocal() (Platform, error) {
 
 	cmd := exec.Command("uname", "-sm")
+	cmd.Stderr = os.Stderr
 	out, err := cmd.Output()
 	if err != nil {
 		return Platform{}, fmt.Errorf("failed to run uname: %w", err)
@@ -118,30 +122,72 @@ func DetectLocal() (Platform, error) {
 	kernelName := pieces[0]
 	archName := Arch(pieces[1])
 
+	var os string
+	var pf Platform
+	var foundPf bool
+
 	if strings.HasPrefix(kernelName, "CYGWIN") || strings.HasPrefix(kernelName, "MSYS_NT") {
-		pf, ok := GetByVariant("windows")
-		if !ok {
-			panic("windows platform name changed")
+		os = "windows"
+		pf, foundPf = GetByVariant("windows")
+	} else {
+		switch kernelName {
+		case "Linux":
+			var version string
+
+			os, version, err = GetLinuxDistroAndVersion()
+			if err != nil {
+				return Platform{}, fmt.Errorf(
+					"detecting local Linux distro/version: %w",
+					err,
+				)
+			}
+
+			os = strings.ToLower(os)
+			version = strings.ReplaceAll(version, ".", "")
+
+			os += version
+		case "Darwin":
+			os = "macos"
+		default:
+			return Platform{}, fmt.Errorf("failed to detect local platform from kernel name %q", kernelName)
 		}
-		return pf, nil
+
+		pf, foundPf = GetByOsAndArch(os, archName)
 	}
 
-	switch kernelName {
-	case "Linux":
-		pf, ok := GetByOsAndArch("ubuntu1804", archName)
-		if !ok {
-			panic("ubuntu1804 platform name changed")
-		}
-		return pf, nil
-	case "Darwin":
-		pf, ok := GetByOsAndArch("macos", archName)
-		if !ok {
-			panic("macos platform name changed")
-		}
-		return pf, nil
+	if !foundPf {
+		return Platform{}, fmt.Errorf(
+			"no platform %s/%s found; did %s’s platform name change?",
+			os,
+			archName,
+			os,
+		)
+	}
+
+	return pf, nil
+}
+
+func GetLinuxDistroAndVersion() (string, string, error) {
+	cmd := exec.Command("lsb_release", "--short", "--id")
+	cmd.Stderr = os.Stderr
+	distro, err := cmd.Output()
+
+	if err != nil {
+		return "", "", fmt.Errorf("fetching Linux distro name: %w", err)
 	}
 
-	return Platform{}, fmt.Errorf("failed to detect local platform from kernel name %q", kernelName)
+	cmd = exec.Command("lsb_release", "--short", "--release")
+	cmd.Stderr = os.Stderr
+	version, err := cmd.Output()
+
+	if err != nil {
+		return "", "", fmt.Errorf("fetching %#q version: %w", distro, err)
+	}
+
+	distroStr := string(bytes.TrimSpace(distro))
+	versionStr := string(bytes.TrimSpace(version))
+
+	return distroStr, versionStr, nil
 }
 
 func GetByVariant(variant string) (Platform, bool) {
@@ -255,9 +301,9 @@ func (p Platform) asGolangString() string {
 		}
 	}
 
-	var binaryExt string
-	if p.BinaryExt != "" {
-		binaryExt = indentGolangField("BinaryExt", fmt.Sprintf(`"%s"`, p.BinaryExt))
+	binaryExt := GetLocalBinaryExt()
+	if binaryExt != "" {
+		binaryExt = indentGolangField("BinaryExt", fmt.Sprintf(`"%s"`, binaryExt))
 	}
 
 	return fmt.Sprintf(
@@ -272,6 +318,14 @@ func (p Platform) asGolangString() string {
 	)
 }
 
+func GetLocalBinaryExt() string {
+	return lo.Ternary(
+		runtime.GOOS == "windows",
+		".exe",
+		"",
+	)
+}
+
 var canonicalTarget = map[string]string{
 	"rhel80": "rhel8",
 }
@@ -684,7 +738,6 @@ var platforms = []Platform{
 		Arch:               ArchX86_64,
 		OS:                 OSWindows,
 		BuildTags:          defaultBuildTags,
-		BinaryExt:          ".exe",
 		ServerVariantNames: mapset.NewSet("enterprise-windows"),
 	},
 }

release/release.go

@@ -79,7 +79,7 @@ func main() {
 				Action: func(cCtx *cli.Context) error {
 					v, err := version.GetCurrent()
 					if err != nil {
-						return fmt.Errorf("Failed to get current version: %v", err)
+						return fmt.Errorf("Failed to get current version: %w", err)
 					}
 					fmt.Println(v.StringWithCommit())
 					return nil

release/version/version.go

@@ -2,6 +2,7 @@ package version
 
 import (
 	"fmt"
+	"os"
 	"os/exec"
 	"regexp"
 	"strconv"
@@ -143,6 +144,7 @@ func git(args ...string) (string, error) {
 	}
 
 	cmd := exec.Command("git", args...)
+	cmd.Stderr = os.Stderr
 	out, err := cmd.Output()
 	if err != nil {
 		if exerr, ok := err.(*exec.ExitError); ok {