libgo: update to go1.9

[official-gcc.git] / libgo / go / cmd / go / internal / get / get.go

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

// Package get implements the ``go get'' command.
package get

import (
        "fmt"
        "go/build"
        "os"
        "path/filepath"
        "runtime"
        "strings"

        "cmd/go/internal/base"
        "cmd/go/internal/cfg"
        "cmd/go/internal/load"
        "cmd/go/internal/str"
        "cmd/go/internal/web"
        "cmd/go/internal/work"
)

var CmdGet = &base.Command{
        UsageLine: "get [-d] [-f] [-fix] [-insecure] [-t] [-u] [build flags] [packages]",
        Short:     "download and install packages and dependencies",
        Long: `
Get downloads the packages named by the import paths, along with their
dependencies. It then installs the named packages, like 'go install'.

The -d flag instructs get to stop after downloading the packages; that is,
it instructs get not to install the packages.

The -f flag, valid only when -u is set, forces get -u not to verify that
each package has been checked out from the source control repository
implied by its import path. This can be useful if the source is a local fork
of the original.

The -fix flag instructs get to run the fix tool on the downloaded packages
before resolving dependencies or building the code.

The -insecure flag permits fetching from repositories and resolving
custom domains using insecure schemes such as HTTP. Use with caution.

The -t flag instructs get to also download the packages required to build
the tests for the specified packages.

The -u flag instructs get to use the network to update the named packages
and their dependencies. By default, get uses the network to check out
missing packages but does not use it to look for updates to existing packages.

The -v flag enables verbose progress and debug output.

Get also accepts build flags to control the installation. See 'go help build'.

When checking out a new package, get creates the target directory
GOPATH/src/<import-path>. If the GOPATH contains multiple entries,
get uses the first one. For more details see: 'go help gopath'.

When checking out or updating a package, get looks for a branch or tag
that matches the locally installed version of Go. The most important
rule is that if the local installation is running version "go1", get
searches for a branch or tag named "go1". If no such version exists
it retrieves the default branch of the package.

When go get checks out or updates a Git repository,
it also updates any git submodules referenced by the repository.

Get never checks out or updates code stored in vendor directories.

For more about specifying packages, see 'go help packages'.

For more about how 'go get' finds source code to
download, see 'go help importpath'.

See also: go build, go install, go clean.
        `,
}

var getD = CmdGet.Flag.Bool("d", false, "")
var getF = CmdGet.Flag.Bool("f", false, "")
var getT = CmdGet.Flag.Bool("t", false, "")
var getU = CmdGet.Flag.Bool("u", false, "")
var getFix = CmdGet.Flag.Bool("fix", false, "")
var getInsecure = CmdGet.Flag.Bool("insecure", false, "")

func init() {
        work.AddBuildFlags(CmdGet)
        CmdGet.Run = runGet // break init loop
}

func runGet(cmd *base.Command, args []string) {
        work.InstrumentInit()
        work.BuildModeInit()

        if *getF && !*getU {
                base.Fatalf("go get: cannot use -f flag without -u")
        }

        // Disable any prompting for passwords by Git.
        // Only has an effect for 2.3.0 or later, but avoiding
        // the prompt in earlier versions is just too hard.
        // If user has explicitly set GIT_TERMINAL_PROMPT=1, keep
        // prompting.
        // See golang.org/issue/9341 and golang.org/issue/12706.
        if os.Getenv("GIT_TERMINAL_PROMPT") == "" {
                os.Setenv("GIT_TERMINAL_PROMPT", "0")
        }

        // Disable any ssh connection pooling by Git.
        // If a Git subprocess forks a child into the background to cache a new connection,
        // that child keeps stdout/stderr open. After the Git subprocess exits,
        // os /exec expects to be able to read from the stdout/stderr pipe
        // until EOF to get all the data that the Git subprocess wrote before exiting.
        // The EOF doesn't come until the child exits too, because the child
        // is holding the write end of the pipe.
        // This is unfortunate, but it has come up at least twice
        // (see golang.org/issue/13453 and golang.org/issue/16104)
        // and confuses users when it does.
        // If the user has explicitly set GIT_SSH or GIT_SSH_COMMAND,
        // assume they know what they are doing and don't step on it.
        // But default to turning off ControlMaster.
        if os.Getenv("GIT_SSH") == "" && os.Getenv("GIT_SSH_COMMAND") == "" {
                os.Setenv("GIT_SSH_COMMAND", "ssh -o ControlMaster=no")
        }

        // Phase 1. Download/update.
        var stk load.ImportStack
        mode := 0
        if *getT {
                mode |= load.GetTestDeps
        }
        args = downloadPaths(args)
        for _, arg := range args {
                download(arg, nil, &stk, mode)
        }
        base.ExitIfErrors()

        // Phase 2. Rescan packages and re-evaluate args list.

        // Code we downloaded and all code that depends on it
        // needs to be evicted from the package cache so that
        // the information will be recomputed. Instead of keeping
        // track of the reverse dependency information, evict
        // everything.
        load.ClearPackageCache()

        // In order to rebuild packages information completely,
        // we need to clear commands cache. Command packages are
        // referring to evicted packages from the package cache.
        // This leads to duplicated loads of the standard packages.
        load.ClearCmdCache()

        args = load.ImportPaths(args)
        load.PackagesForBuild(args)

        // Phase 3. Install.
        if *getD {
                // Download only.
                // Check delayed until now so that importPaths
                // and packagesForBuild have a chance to print errors.
                return
        }

        work.InstallPackages(args, true)
}

// downloadPaths prepares the list of paths to pass to download.
// It expands ... patterns that can be expanded. If there is no match
// for a particular pattern, downloadPaths leaves it in the result list,
// in the hope that we can figure out the repository from the
// initial ...-free prefix.
func downloadPaths(args []string) []string {
        args = load.ImportPathsNoDotExpansion(args)
        var out []string
        for _, a := range args {
                if strings.Contains(a, "...") {
                        var expand []string
                        // Use matchPackagesInFS to avoid printing
                        // warnings. They will be printed by the
                        // eventual call to importPaths instead.
                        if build.IsLocalImport(a) {
                                expand = load.MatchPackagesInFS(a)
                        } else {
                                expand = load.MatchPackages(a)
                        }
                        if len(expand) > 0 {
                                out = append(out, expand...)
                                continue
                        }
                }
                out = append(out, a)
        }
        return out
}

// downloadCache records the import paths we have already
// considered during the download, to avoid duplicate work when
// there is more than one dependency sequence leading to
// a particular package.
var downloadCache = map[string]bool{}

// downloadRootCache records the version control repository
// root directories we have already considered during the download.
// For example, all the packages in the github.com/google/codesearch repo
// share the same root (the directory for that path), and we only need
// to run the hg commands to consider each repository once.
var downloadRootCache = map[string]bool{}

// download runs the download half of the get command
// for the package named by the argument.
func download(arg string, parent *load.Package, stk *load.ImportStack, mode int) {
        if mode&load.UseVendor != 0 {
                // Caller is responsible for expanding vendor paths.
                panic("internal error: download mode has useVendor set")
        }
        load1 := func(path string, mode int) *load.Package {
                if parent == nil {
                        return load.LoadPackage(path, stk)
                }
                return load.LoadImport(path, parent.Dir, parent, stk, nil, mode)
        }

        p := load1(arg, mode)
        if p.Error != nil && p.Error.Hard {
                base.Errorf("%s", p.Error)
                return
        }

        // loadPackage inferred the canonical ImportPath from arg.
        // Use that in the following to prevent hysteresis effects
        // in e.g. downloadCache and packageCache.
        // This allows invocations such as:
        //   mkdir -p $GOPATH/src/github.com/user
        //   cd $GOPATH/src/github.com/user
        //   go get ./foo
        // see: golang.org/issue/9767
        arg = p.ImportPath

        // There's nothing to do if this is a package in the standard library.
        if p.Standard {
                return
        }

        // Only process each package once.
        // (Unless we're fetching test dependencies for this package,
        // in which case we want to process it again.)
        if downloadCache[arg] && mode&load.GetTestDeps == 0 {
                return
        }
        downloadCache[arg] = true

        pkgs := []*load.Package{p}
        wildcardOkay := len(*stk) == 0
        isWildcard := false

        // Download if the package is missing, or update if we're using -u.
        if p.Dir == "" || *getU {
                // The actual download.
                stk.Push(arg)
                err := downloadPackage(p)
                if err != nil {
                        base.Errorf("%s", &load.PackageError{ImportStack: stk.Copy(), Err: err.Error()})
                        stk.Pop()
                        return
                }
                stk.Pop()

                args := []string{arg}
                // If the argument has a wildcard in it, re-evaluate the wildcard.
                // We delay this until after reloadPackage so that the old entry
                // for p has been replaced in the package cache.
                if wildcardOkay && strings.Contains(arg, "...") {
                        if build.IsLocalImport(arg) {
                                args = load.MatchPackagesInFS(arg)
                        } else {
                                args = load.MatchPackages(arg)
                        }
                        isWildcard = true
                }

                // Clear all relevant package cache entries before
                // doing any new loads.
                load.ClearPackageCachePartial(args)

                pkgs = pkgs[:0]
                for _, arg := range args {
                        // Note: load calls loadPackage or loadImport,
                        // which push arg onto stk already.
                        // Do not push here too, or else stk will say arg imports arg.
                        p := load1(arg, mode)
                        if p.Error != nil {
                                base.Errorf("%s", p.Error)
                                continue
                        }
                        pkgs = append(pkgs, p)
                }
        }

        // Process package, which might now be multiple packages
        // due to wildcard expansion.
        for _, p := range pkgs {
                if *getFix {
                        files := base.FilterDotUnderscoreFiles(base.RelPaths(p.Internal.AllGoFiles))
                        base.Run(cfg.BuildToolexec, str.StringList(base.Tool("fix"), files))

                        // The imports might have changed, so reload again.
                        p = load.ReloadPackage(arg, stk)
                        if p.Error != nil {
                                base.Errorf("%s", p.Error)
                                return
                        }
                }

                if isWildcard {
                        // Report both the real package and the
                        // wildcard in any error message.
                        stk.Push(p.ImportPath)
                }

                // Process dependencies, now that we know what they are.
                imports := p.Imports
                if mode&load.GetTestDeps != 0 {
                        // Process test dependencies when -t is specified.
                        // (But don't get test dependencies for test dependencies:
                        // we always pass mode 0 to the recursive calls below.)
                        imports = str.StringList(imports, p.TestImports, p.XTestImports)
                }
                for i, path := range imports {
                        if path == "C" {
                                continue
                        }
                        // Fail fast on import naming full vendor path.
                        // Otherwise expand path as needed for test imports.
                        // Note that p.Imports can have additional entries beyond p.Internal.Build.Imports.
                        orig := path
                        if i < len(p.Internal.Build.Imports) {
                                orig = p.Internal.Build.Imports[i]
                        }
                        if j, ok := load.FindVendor(orig); ok {
                                stk.Push(path)
                                err := &load.PackageError{
                                        ImportStack: stk.Copy(),
                                        Err:         "must be imported as " + path[j+len("vendor/"):],
                                }
                                stk.Pop()
                                base.Errorf("%s", err)
                                continue
                        }
                        // If this is a test import, apply vendor lookup now.
                        // We cannot pass useVendor to download, because
                        // download does caching based on the value of path,
                        // so it must be the fully qualified path already.
                        if i >= len(p.Imports) {
                                path = load.VendoredImportPath(p, path)
                        }
                        download(path, p, stk, 0)
                }

                if isWildcard {
                        stk.Pop()
                }
        }
}

// downloadPackage runs the create or download command
// to make the first copy of or update a copy of the given package.
func downloadPackage(p *load.Package) error {
        var (
                vcs            *vcsCmd
                repo, rootPath string
                err            error
        )

        security := web.Secure
        if *getInsecure {
                security = web.Insecure
        }

        if p.Internal.Build.SrcRoot != "" {
                // Directory exists. Look for checkout along path to src.
                vcs, rootPath, err = vcsFromDir(p.Dir, p.Internal.Build.SrcRoot)
                if err != nil {
                        return err
                }
                repo = "<local>" // should be unused; make distinctive

                // Double-check where it came from.
                if *getU && vcs.remoteRepo != nil {
                        dir := filepath.Join(p.Internal.Build.SrcRoot, filepath.FromSlash(rootPath))
                        remote, err := vcs.remoteRepo(vcs, dir)
                        if err != nil {
                                return err
                        }
                        repo = remote
                        if !*getF {
                                if rr, err := repoRootForImportPath(p.ImportPath, security); err == nil {
                                        repo := rr.repo
                                        if rr.vcs.resolveRepo != nil {
                                                resolved, err := rr.vcs.resolveRepo(rr.vcs, dir, repo)
                                                if err == nil {
                                                        repo = resolved
                                                }
                                        }
                                        if remote != repo && rr.isCustom {
                                                return fmt.Errorf("%s is a custom import path for %s, but %s is checked out from %s", rr.root, repo, dir, remote)
                                        }
                                }
                        }
                }
        } else {
                // Analyze the import path to determine the version control system,
                // repository, and the import path for the root of the repository.
                rr, err := repoRootForImportPath(p.ImportPath, security)
                if err != nil {
                        return err
                }
                vcs, repo, rootPath = rr.vcs, rr.repo, rr.root
        }
        if !vcs.isSecure(repo) && !*getInsecure {
                return fmt.Errorf("cannot download, %v uses insecure protocol", repo)
        }

        if p.Internal.Build.SrcRoot == "" {
                // Package not found. Put in first directory of $GOPATH.
                list := filepath.SplitList(cfg.BuildContext.GOPATH)
                if len(list) == 0 {
                        return fmt.Errorf("cannot download, $GOPATH not set. For more details see: 'go help gopath'")
                }
                // Guard against people setting GOPATH=$GOROOT.
                if filepath.Clean(list[0]) == filepath.Clean(cfg.GOROOT) {
                        return fmt.Errorf("cannot download, $GOPATH must not be set to $GOROOT. For more details see: 'go help gopath'")
                }
                if _, err := os.Stat(filepath.Join(list[0], "src/cmd/go/alldocs.go")); err == nil {
                        return fmt.Errorf("cannot download, %s is a GOROOT, not a GOPATH. For more details see: 'go help gopath'", list[0])
                }
                p.Internal.Build.Root = list[0]
                p.Internal.Build.SrcRoot = filepath.Join(list[0], "src")
                p.Internal.Build.PkgRoot = filepath.Join(list[0], "pkg")
        }
        root := filepath.Join(p.Internal.Build.SrcRoot, filepath.FromSlash(rootPath))
        // If we've considered this repository already, don't do it again.
        if downloadRootCache[root] {
                return nil
        }
        downloadRootCache[root] = true

        if cfg.BuildV {
                fmt.Fprintf(os.Stderr, "%s (download)\n", rootPath)
        }

        // Check that this is an appropriate place for the repo to be checked out.
        // The target directory must either not exist or have a repo checked out already.
        meta := filepath.Join(root, "."+vcs.cmd)
        st, err := os.Stat(meta)
        if err == nil && !st.IsDir() {
                return fmt.Errorf("%s exists but is not a directory", meta)
        }
        if err != nil {
                // Metadata directory does not exist. Prepare to checkout new copy.
                // Some version control tools require the target directory not to exist.
                // We require that too, just to avoid stepping on existing work.
                if _, err := os.Stat(root); err == nil {
                        return fmt.Errorf("%s exists but %s does not - stale checkout?", root, meta)
                }

                _, err := os.Stat(p.Internal.Build.Root)
                gopathExisted := err == nil

                // Some version control tools require the parent of the target to exist.
                parent, _ := filepath.Split(root)
                if err = os.MkdirAll(parent, 0777); err != nil {
                        return err
                }
                if cfg.BuildV && !gopathExisted && p.Internal.Build.Root == cfg.BuildContext.GOPATH {
                        fmt.Fprintf(os.Stderr, "created GOPATH=%s; see 'go help gopath'\n", p.Internal.Build.Root)
                }

                if err = vcs.create(root, repo); err != nil {
                        return err
                }
        } else {
                // Metadata directory does exist; download incremental updates.
                if err = vcs.download(root); err != nil {
                        return err
                }
        }

        if cfg.BuildN {
                // Do not show tag sync in -n; it's noise more than anything,
                // and since we're not running commands, no tag will be found.
                // But avoid printing nothing.
                fmt.Fprintf(os.Stderr, "# cd %s; %s sync/update\n", root, vcs.cmd)
                return nil
        }

        // Select and sync to appropriate version of the repository.
        tags, err := vcs.tags(root)
        if err != nil {
                return err
        }
        vers := runtime.Version()
        if i := strings.Index(vers, " "); i >= 0 {
                vers = vers[:i]
        }
        if err := vcs.tagSync(root, selectTag(vers, tags)); err != nil {
                return err
        }

        return nil
}

// selectTag returns the closest matching tag for a given version.
// Closest means the latest one that is not after the current release.
// Version "goX" (or "goX.Y" or "goX.Y.Z") matches tags of the same form.
// Version "release.rN" matches tags of the form "go.rN" (N being a floating-point number).
// Version "weekly.YYYY-MM-DD" matches tags like "go.weekly.YYYY-MM-DD".
//
// NOTE(rsc): Eventually we will need to decide on some logic here.
// For now, there is only "go1". This matches the docs in go help get.
func selectTag(goVersion string, tags []string) (match string) {
        for _, t := range tags {
                if t == "go1" {
                        return "go1"
                }
        }
        return ""
}