core/pkgs/build-support/go/package.nix

{
  go,
  govers,
  lib,
  fetchgit,
  fetchhg,
  fetchbzr,
  rsync,
  fetchFromGitHub,
  stdenv,
}:

{
  buildInputs ? [ ],
  nativeBuildInputs ? [ ],
  passthru ? { },
  preFixup ? "",
  shellHook ? "",

  # We want parallel builds by default
  enableParallelBuilding ? true,

  # Go import path of the package
  goPackagePath,

  # Go package aliases
  goPackageAliases ? [ ],

  # Extra sources to include in the gopath
  extraSrcs ? [ ],

  # Extra gopaths containing src subfolder
  # with sources to include in the gopath
  extraSrcPaths ? [ ],

  # go2nix dependency file
  goDeps ? null,

  # Whether to delete the vendor folder supplied with the source.
  deleteVendor ? false,

  dontRenameImports ? false,

  # Do not enable this without good reason
  # IE: programs coupled with the compiler
  allowGoReference ? false,

  CGO_ENABLED ? go.CGO_ENABLED,

  ldflags ? [ ],

  GOFLAGS ? [ ],

  # needed for buildFlags{,Array} warning
  buildFlags ? "",
  buildFlagsArray ? "",

  meta ? { },
  ...
}@args:

let
  dep2src = goDep: {
    inherit (goDep) goPackagePath;
    src =
      if goDep.fetch.type == "git" then
        fetchgit { inherit (goDep.fetch) url rev sha256; }
      else if goDep.fetch.type == "hg" then
        fetchhg { inherit (goDep.fetch) url rev sha256; }
      else if goDep.fetch.type == "bzr" then
        fetchbzr { inherit (goDep.fetch) url rev sha256; }
      else if goDep.fetch.type == "FromGitHub" then
        fetchFromGitHub {
          inherit (goDep.fetch)
            owner
            repo
            rev
            sha256
            ;
        }
      else
        abort "Unrecognized package fetch type: ${goDep.fetch.type}";
  };

  importGodeps = { depsFile }: map dep2src (import depsFile);

  goPath = if goDeps != null then importGodeps { depsFile = goDeps; } ++ extraSrcs else extraSrcs;
  package = stdenv.mkDerivation (
    (builtins.removeAttrs args [
      "goPackageAliases"
      "disabled"
      "extraSrcs"
    ])
    // {

      nativeBuildInputs = [ go ] ++ (lib.optional (!dontRenameImports) govers) ++ nativeBuildInputs;
      buildInputs = buildInputs;

      inherit (go) GOOS GOARCH GO386;

      GOHOSTARCH = go.GOHOSTARCH or null;
      GOHOSTOS = go.GOHOSTOS or null;

      inherit CGO_ENABLED enableParallelBuilding;

      GO111MODULE = "off";
      GOTOOLCHAIN = "local";
      GOFLAGS = GOFLAGS ++ lib.optional (!allowGoReference) "-trimpath";

      GOARM = toString (
        lib.intersectLists [ (stdenv.hostPlatform.parsed.cpu.version or "") ] [
          "5"
          "6"
          "7"
        ]
      );

      # If not set to an explicit value, set the buildid empty for reproducibility.
      ldflags = ldflags ++ lib.optional (!lib.any (lib.hasPrefix "-buildid=") ldflags) "-buildid=";

      configurePhase =
        args.configurePhase or (
          ''
            runHook preConfigure

            # Extract the source
            cd "$NIX_BUILD_TOP"
            mkdir -p "go/src/$(dirname "$goPackagePath")"
            mv "$sourceRoot" "go/src/$goPackagePath"

          ''
          + lib.optionalString deleteVendor ''
            if [ ! -d "go/src/$goPackagePath/vendor" ]; then
              echo "vendor folder does not exist, 'deleteVendor' is not needed"
              exit 10
            else
              rm -rf "go/src/$goPackagePath/vendor"
            fi
          ''
          + lib.optionalString (goDeps != null) ''
            if [ -d "go/src/$goPackagePath/vendor" ]; then
              echo "vendor folder exists, 'goDeps' is not needed"
              exit 10
            fi
          ''
          + lib.flip lib.concatMapStrings goPath (
            { src, goPackagePath }:
            ''
              mkdir goPath
              (cd goPath; unpackFile "${src}")
              mkdir -p "go/src/$(dirname "${goPackagePath}")"
              chmod -R u+w goPath/*
              mv goPath/* "go/src/${goPackagePath}"
              rmdir goPath

            ''
          )
          + (lib.optionalString (extraSrcPaths != [ ]) ''
            ${rsync}/bin/rsync -a ${lib.concatMapStringsSep " " (p: "${p}/src") extraSrcPaths} go

          '')
          + ''
            export GOPATH=$NIX_BUILD_TOP/go:$GOPATH
            export GOCACHE=$TMPDIR/go-cache

            # currently pie is only enabled by default in pkgsMusl
            # this will respect the `hardening{Disable,Enable}` flags if set
            if [[ $NIX_HARDENING_ENABLE =~ "pie" ]]; then
              export GOFLAGS="-buildmode=pie $GOFLAGS"
            fi

            runHook postConfigure
          ''
        );

      renameImports =
        args.renameImports or (
          let
            inputsWithAliases = lib.filter (x: x ? goPackageAliases) (
              buildInputs ++ (args.propagatedBuildInputs or [ ])
            );
            rename = to: from: "echo Renaming '${from}' to '${to}'; govers -d -m ${from} ${to}";
            renames = p: lib.concatMapStringsSep "\n" (rename p.goPackagePath) p.goPackageAliases;
          in
          lib.concatMapStringsSep "\n" renames inputsWithAliases
        );

      buildPhase =
        args.buildPhase or (
          ''
            runHook preBuild

            runHook renameImports

            exclude='\(/_\|examples\|Godeps\|testdata'
            if [[ -n "$excludedPackages" ]]; then
              IFS=' ' read -r -a excludedArr <<<$excludedPackages
              printf -v excludedAlternates '%s\\|' "''${excludedArr[@]}"
              excludedAlternates=''${excludedAlternates%\\|} # drop final \| added by printf
              exclude+='\|'"$excludedAlternates"
            fi
            exclude+='\)'

            buildGoDir() {
              local cmd="$1" dir="$2"

              . $TMPDIR/buildFlagsArray

              declare -a flags
              flags+=($buildFlags "''${buildFlagsArray[@]}")
              flags+=(''${tags:+-tags=''${tags// /,}})
              flags+=(''${ldflags:+-ldflags="$ldflags"})
              flags+=("-p" "$NIX_BUILD_CORES")

              if [ "$cmd" = "test" ]; then
                flags+=(-vet=off)
                flags+=($checkFlags)
              fi

              local OUT
              if ! OUT="$(go $cmd "''${flags[@]}" $dir 2>&1)"; then
                if ! echo "$OUT" | grep -qE '(no( buildable| non-test)?|build constraints exclude all) Go (source )?files'; then
                  echo "$OUT" >&2
                  return 1
                fi
              fi
              if [ -n "$OUT" ]; then
                echo "$OUT" >&2
              fi
              return 0
            }

            getGoDirs() {
              local type;
              type="$1"
              if [ -n "$subPackages" ]; then
                echo "$subPackages" | sed "s,\(^\| \),\1$goPackagePath/,g"
              else
                pushd "$NIX_BUILD_TOP/go/src" >/dev/null
                find "$goPackagePath" -type f -name \*$type.go -exec dirname {} \; | grep -v "/vendor/" | sort | uniq | grep -v "$exclude"
                popd >/dev/null
              fi
            }

            if (( "''${NIX_DEBUG:-0}" >= 1 )); then
              buildFlagsArray+=(-x)
            fi

            if [ ''${#buildFlagsArray[@]} -ne 0 ]; then
              declare -p buildFlagsArray > $TMPDIR/buildFlagsArray
            else
              touch $TMPDIR/buildFlagsArray
            fi
            if [ -z "$enableParallelBuilding" ]; then
                export NIX_BUILD_CORES=1
            fi
            for pkg in $(getGoDirs ""); do
              echo "Building subPackage $pkg"
              buildGoDir install "$pkg"
            done
          ''
          + lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
            # normalize cross-compiled builds w.r.t. native builds
            (
              dir=$NIX_BUILD_TOP/go/bin/${go.GOOS}_${go.GOARCH}
              if [[ -n "$(shopt -s nullglob; echo $dir/*)" ]]; then
                mv $dir/* $dir/..
              fi
              if [[ -d $dir ]]; then
                rmdir $dir
              fi
            )
          ''
          + ''
            runHook postBuild
          ''
        );

      doCheck = args.doCheck or false;
      checkPhase =
        args.checkPhase or ''
          runHook preCheck
          # We do not set trimpath for tests, in case they reference test assets
          export GOFLAGS=''${GOFLAGS//-trimpath/}

          for pkg in $(getGoDirs test); do
            buildGoDir test "$pkg"
          done

          runHook postCheck
        '';

      installPhase =
        args.installPhase or ''
          runHook preInstall

          mkdir -p $out
          dir="$NIX_BUILD_TOP/go/bin"
          [ -e "$dir" ] && cp -r $dir $out

          runHook postInstall
        '';

      strictDeps = true;

      shellHook =
        ''
          d=$(mktemp -d "--suffix=-$name")
        ''
        + toString (
          map (dep: ''
            mkdir -p "$d/src/$(dirname "${dep.goPackagePath}")"
            ln -s "${dep.src}" "$d/src/${dep.goPackagePath}"
          '') goPath
        )
        + ''
          export GOPATH=${lib.concatStringsSep ":" ([ "$d" ] ++ [ "$GOPATH" ] ++ [ "$PWD" ] ++ extraSrcPaths)}
        ''
        + shellHook;

      disallowedReferences =
        lib.optional (!allowGoReference) go
        ++ lib.optional (!dontRenameImports) govers;

      passthru =
        passthru
        // {
          inherit go;
        }
        // lib.optionalAttrs (goPackageAliases != [ ]) { inherit goPackageAliases; };

      meta = {
        # Add default meta information
        homepage = "https://${goPackagePath}";
        platforms = go.meta.platforms or lib.platforms.all;
      } // meta;
    }
  );
in
lib.warnIf (buildFlags != "" || buildFlagsArray != "")
  "Use the `ldflags` and/or `tags` attributes instead of `buildFlags`/`buildFlagsArray`"
  lib.warnIf
  (builtins.elem "-buildid=" ldflags)
  "`-buildid=` is set by default as ldflag by buildGoModule"
  lib.warnIf
  (builtins.elem "-trimpath" GOFLAGS)
  "`-trimpath` is added by default to GOFLAGS by buildGoModule when allowGoReference isn't set to true"
  package