chore: remove custom go toolchain

Change-Id: Ic5e4198e3cb42225deea908169b91b157c398815
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

tool/gocross/gocross-wrapper.sh

@@ -9,99 +9,46 @@
 set -euo pipefail
 
 if [[ "${CI:-}" == "true" ]]; then
-    set -x
+  set -x
 fi
 
 # Locate a bootstrap toolchain and (re)build gocross if necessary. We run all of
 # this in a subshell because posix shell semantics make it very easy to
 # accidentally mutate the input environment that will get passed to gocross at
 # the bottom of this script.
 (
-repo_root="${BASH_SOURCE%/*}/../.."
-
-# Figuring out if gocross needs a rebuild, as well as the rebuild itself, need
-# to happen with CWD inside this repo. Since we're in a subshell entirely
-# dedicated to wrangling gocross and toolchains, cd over now before doing
-# anything further so that the rest of this logic works the same if gocross is
-# being invoked from somewhere else.
-cd "$repo_root"
-
-toolchain="$HOME/.cache/tailscale-go"
-
-if [[ -d "$toolchain" ]]; then
-    # A toolchain exists, but is it recent enough to compile gocross? If not,
-    # wipe it out so that the next if block fetches a usable one.
-    want_go_minor=$(grep -E '^go ' "go.mod" | cut -f2 -d'.')
-    have_go_minor=$(head -1 "$toolchain/VERSION" | cut -f2 -d'.')
-    # Shortly before stable releases, we run release candidate
-    # toolchains, which have a non-numeric suffix on the version
-    # number. Remove the rc qualifier, we just care about the minor
-    # version.
-    have_go_minor="${have_go_minor%rc*}"
-    if [[ -z "$have_go_minor" || "$have_go_minor" -lt "$want_go_minor" ]]; then
-        rm -rf "$toolchain" "$toolchain.extracted"
+  repo_root="${BASH_SOURCE%/*}/../.."
+
+  # Figuring out if gocross needs a rebuild, as well as the rebuild itself, need
+  # to happen with CWD inside this repo. Since we're in a subshell entirely
+  # dedicated to wrangling gocross and toolchains, cd over now before doing
+  # anything further so that the rest of this logic works the same if gocross is
+  # being invoked from somewhere else.
+  cd "$repo_root"
+
+  # Binaries run with `gocross run` can reinvoke gocross, resulting in a
+  # potentially fancy build that invokes external linkers, might be
+  # cross-building for other targets, and so forth. In one hilarious
+  # case, cmd/cloner invokes go with GO111MODULE=off at some stage.
+  #
+  # Anyway, build gocross in a stripped down universe.
+  gocross_path="gocross"
+  gocross_ok=0
+  wantver="$(git rev-parse HEAD)"
+  if [[ -x "$gocross_path" ]]; then
+    gotver="$($gocross_path gocross-version 2>/dev/null || echo '')"
+    if [[ "$gotver" == "$wantver" ]]; then
+      gocross_ok=1
     fi
-fi
-if [[ ! -d "$toolchain" ]]; then
-    mkdir -p "$HOME/.cache"
-
-    # We need any Go toolchain to build gocross, but the toolchain also has to
-    # be reasonably recent because we upgrade eagerly and gocross might not
-    # build with Go N-1. So, if we have no cached tailscale toolchain at all,
-    # fetch the initial one in shell. Once gocross is built, it'll manage
-    # updates.
-    read -r REV <go.toolchain.rev
-
-    case "$REV" in
-    /*)
-        toolchain="$REV"
-        ;;
-    *)
-        # This works for linux and darwin, which is sufficient
-        # (we do not build tailscale-go for other targets).
-        HOST_OS=$(uname -s | tr A-Z a-z)
-        HOST_ARCH="$(uname -m)"
-        if [[ "$HOST_ARCH" == "aarch64" ]]; then
-            # Go uses the name "arm64".
-            HOST_ARCH="arm64"
-        elif [[ "$HOST_ARCH" == "x86_64" ]]; then
-            # Go uses the name "amd64".
-            HOST_ARCH="amd64"
-        fi
-
-        rm -rf "$toolchain" "$toolchain.extracted"
-        curl -f -L -o "$toolchain.tar.gz" "https://github.com/tailscale/go/releases/download/build-${REV}/${HOST_OS}-${HOST_ARCH}.tar.gz"
-        mkdir -p "$toolchain"
-        (cd "$toolchain" && tar --strip-components=1 -xf "$toolchain.tar.gz")
-        echo "$REV" >"$toolchain.extracted"
-        rm -f "$toolchain.tar.gz"
-        ;;
-    esac
-fi
-
-# Binaries run with `gocross run` can reinvoke gocross, resulting in a
-# potentially fancy build that invokes external linkers, might be
-# cross-building for other targets, and so forth. In one hilarious
-# case, cmd/cloner invokes go with GO111MODULE=off at some stage.
-#
-# Anyway, build gocross in a stripped down universe.
-gocross_path="gocross"
-gocross_ok=0
-wantver="$(git rev-parse HEAD)"
-if [[ -x "$gocross_path" ]]; then
-	gotver="$($gocross_path gocross-version 2>/dev/null || echo '')"
-	if [[ "$gotver" == "$wantver" ]]; then
-		gocross_ok=1
-	fi
-fi
-if [[ "$gocross_ok" == "0" ]]; then
+  fi
+  if [[ "$gocross_ok" == "0" ]]; then
     unset GOOS
     unset GOARCH
     unset GO111MODULE
     unset GOROOT
     export CGO_ENABLED=0
-    "$toolchain/bin/go" build -o "$gocross_path" -ldflags "-X tailscale.com/version.gitCommitStamp=$wantver" tailscale.com/tool/gocross
-fi
+    go build -o "$gocross_path" -ldflags "-X tailscale.com/version.gitCommitStamp=$wantver" tailscale.com/tool/gocross
+  fi
 ) # End of the subshell execution.
 
 exec "${BASH_SOURCE%/*}/../../gocross" "$@"

tool/gocross/gocross.go

@@ -15,7 +15,7 @@ import (
 	_ "embed"
 	"fmt"
 	"os"
-	"path/filepath"
+	"runtime"
 
 	"tailscale.com/atomicfile"
 	"tailscale.com/version"
@@ -36,23 +36,6 @@ func main() {
 			// regular go binary, so it can be used to detect when `go` is
 			// actually gocross.
 			os.Exit(0)
-		case "make-goroot":
-			_, gorootDir, err := getToolchain()
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "getting toolchain: %v\n", err)
-				os.Exit(1)
-			}
-
-			fmt.Println(gorootDir)
-			os.Exit(0)
-		case "gocross-get-toolchain-go":
-			toolchain, _, err := getToolchain()
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "getting toolchain: %v\n", err)
-				os.Exit(1)
-			}
-			fmt.Println(filepath.Join(toolchain, "bin/go"))
-			os.Exit(0)
 		case "gocross-write-wrapper-script":
 			if len(os.Args) != 3 {
 				fmt.Fprintf(os.Stderr, "usage: gocross write-wrapper-script <path>\n")
@@ -66,26 +49,14 @@ func main() {
 		}
 	}
 
-	toolchain, goroot, err := getToolchain()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "getting toolchain: %v\n", err)
-		os.Exit(1)
-	}
-
 	args := os.Args
 	if os.Getenv("GOCROSS_BYPASS") == "" {
-		newArgv, env, err := Autoflags(os.Args, goroot)
+		newArgv, env, err := Autoflags(os.Args, runtime.GOROOT())
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "computing flags: %v\n", err)
 			os.Exit(1)
 		}
 
-		// Make sure the right version of cmd/go is the first thing in the PATH
-		// for tests that execute `go build` or `go test`.
-		// TODO: if we really need to do this, do it inside Autoflags, not here.
-		path := filepath.Join(toolchain, "bin") + string(os.PathListSeparator) + os.Getenv("PATH")
-		env.Set("PATH", path)
-
 		debug("Input: %s\n", formatArgv(os.Args))
 		debug("Command: %s\n", formatArgv(newArgv))
 		debug("Set the following flags/envvars:\n%s\n", env.Diff())
@@ -98,7 +69,7 @@ func main() {
 
 	}
 
-	doExec(filepath.Join(toolchain, "bin/go"), args, os.Environ())
+	doExec("go", args, os.Environ())
 }
 
 //go:embed gocross-wrapper.sh