jiri-go/go.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The following enables go generate to generate the doc.go file.
//go:generate go run $JIRI_ROOT/release/go/src/v.io/x/lib/cmdline/testdata/gendoc.go -env=CMDLINE_PREFIX=jiri . -help

package main

import (
	"flag"
	"fmt"
	"path/filepath"
	"strings"

	"v.io/jiri"
	"v.io/jiri/profiles/profilescmdline"
	"v.io/jiri/profiles/profilesreader"
	"v.io/jiri/runutil"
	"v.io/jiri/tool"
	"v.io/x/devtools/internal/golib"
	"v.io/x/devtools/tooldata"
	"v.io/x/lib/cmdline"
	"v.io/x/lib/lookpath"
)

// cmdGo represents the "jiri go" command.
var cmdGo = &cmdline.Command{
	Runner: jiri.RunnerFunc(runGo),
	Name:   "go",
	Short:  "Execute the go tool using the vanadium environment",
	Long: `
Wrapper around the 'go' tool that can be used for compilation of
vanadium Go sources. It takes care of vanadium-specific setup, such as
setting up the Go specific environment variables or making sure that
VDL generated files are regenerated before compilation.
`,
	ArgsName: "<arg ...>",
	ArgsLong: "<arg ...> is a list of arguments for the go tool.",
}

var (
	extraLDFlags string
	systemGoFlag bool
	envFlag      bool
	readerFlags  profilescmdline.ReaderFlagValues
)

func init() {
	profilescmdline.RegisterReaderFlags(&cmdGo.Flags, &readerFlags, "v23:base", jiri.ProfilesDBDir)
	flag.BoolVar(&systemGoFlag, "system-go", false, "use the version of go found in $PATH rather than that built by the go profile")
	flag.StringVar(&extraLDFlags, "extra-ldflags", "", golib.ExtraLDFlagsFlagDescription)
	flag.BoolVar(&envFlag, "print-run-env", false, "print detailed info on environment variables and the command line used")
	tool.InitializeRunFlags(&cmdGo.Flags)
}

func runGo(jirix *jiri.X, args []string) error {
	if len(args) == 0 {
		return jirix.UsageErrorf("not enough arguments")
	}
	config, err := tooldata.LoadConfig(jirix)
	if err != nil {
		return err
	}
	rd, err := profilesreader.NewReader(jirix, readerFlags.ProfilesMode, readerFlags.DBFilename)
	if err != nil {
		return err
	}
	profileNames := strings.Split(readerFlags.Profiles, ",")
	if err := rd.ValidateRequestedProfilesAndTarget(profileNames, readerFlags.Target); err != nil {
		return err
	}
	rd.MergeEnvFromProfiles(readerFlags.MergePolicies, readerFlags.Target, profileNames...)
	mp := profilesreader.MergePolicies{
		"GOPATH":  profilesreader.PrependPath,
		"VDLPATH": profilesreader.PrependPath,
	}
	profilesreader.MergeEnv(mp, rd.Vars, []string{config.GoPath(jirix), config.VDLPath(jirix)})
	if !systemGoFlag {
		if len(rd.Get("GOROOT")) > 0 {
			rd.PrependToPATH(filepath.Join(rd.Get("GOROOT"), "bin"))
		}
	}
	if envFlag {
		fmt.Fprintf(jirix.Stdout(), "Merged profiles: %v\n", profileNames)
		fmt.Fprintf(jirix.Stdout(), "Merge policies: %v\n", readerFlags.MergePolicies)
		fmt.Fprintf(jirix.Stdout(), "%v\n", strings.Join(rd.ToSlice(), "\n"))
	}
	envMap := rd.ToMap()
	var installSuffix string
	if readerFlags.Target.OS() == "fnl" {
		installSuffix = "musl"
	}
	newArgs, err := golib.PrepareGo(jirix, envMap, args, extraLDFlags, installSuffix)
	if err != nil {
		return err
	}
	// Don't run go env if PrepareGo stripped off the environment
	// variables that the go tool doesn't understand - e.g. VDLPATH,
	// unless the original command was just 'go env'.
	if len(newArgs) == 1 && newArgs[0] == "env" && !(len(args) == 1 && args[0] == "env") {
		return nil
	}
	// Run the go tool.
	goBin, err := lookpath.Look(envMap, "go")
	if err != nil {
		return err
	}
	if envFlag {
		fmt.Fprintf(jirix.Stdout(), "\n%v %s\n", goBin, strings.Join(newArgs, " "))
	}
	err = jirix.NewSeq().Env(envMap).Capture(jirix.Stdout(), jirix.Stderr()).Last(goBin, newArgs...)
	return runutil.TranslateExitCode(err)
}

func main() {
	cmdline.Main(cmdGo)
}