"encoding/xml"
"fmt"
"io"
"strings"
"bytes"
"errors"
"fmt"
"internal/godebug"
"internal/lazyregexp"
"internal/singleflight"
"io/fs"
"log"
urlpkg "net/url"
"os"
"os/exec"
"path/filepath"
"regexp"
"strconv"
"strings"
"sync"
"time"
"cmd/go/internal/base"
"cmd/go/internal/cfg"
"cmd/go/internal/search"
"cmd/go/internal/str"
"cmd/go/internal/web"
"cmd/internal/pathcache"
"golang.org/x/mod/module"
const IgnoreMod ModuleMode = iotaconst PreferModVCSTestHosts is the set of hosts supported by the vcs-test server.
var VCSTestHosts []stringVCSTestIsLocalHost reports whether the given URL refers to a local (loopback) host, such as "localhost" or "127.0.0.1:8080".
var VCSTestIsLocalHost func(*urlpkg.URL) boolVCSTestRepoURL is the URL of the HTTP server that serves the repos for vcs-test.golang.org. In tests, this is set to the URL of an httptest.Server hosting a cmd/go/internal/vcweb.Server.
var VCSTestRepoURL stringvar allowmultiplevcs = *ast.CallExprdefaultGOVCS is the default setting for GOVCS. Setting GOVCS adds entries ahead of these but does not remove them. (They are appended to the parsed GOVCS setting.) The rationale behind allowing only Git and Mercurial is that these two systems have had the most attention to issues of being run as clients of untrusted servers. In contrast, Bazaar, Fossil, and Subversion have primarily been used in trusted, authenticated environments and are not as well scrutinized as attack surfaces. See golang.org/issue/41730 for details.
var defaultGOVCS = govcsConfig{...}var defaultSecureScheme = map[string]bool{...}var errFossilInfo = *ast.CallExprvar errUnknownSite = *ast.CallExprvar fetchCache = map[string]fetchResult{...}var fetchCacheMu sync.Mutexvar fetchGroup singleflight.GroupfossilRepoName is the name go get associates with a fossil repository. In the real world the file can be named anything.
const fossilRepoName = ".fossil"var govcs govcsConfigvar govcsErr errorvar govcsOnce sync.OncescpSyntaxRe matches the SCP-like addresses used by Git to access repositories by SSH.
var scpSyntaxRe = *ast.CallExprvcsBzr describes how to use Bazaar.
var vcsBzr = *ast.UnaryExprvcsFossil describes how to use Fossil (fossil-scm.org)
var vcsFossil = *ast.UnaryExprvcsGit describes how to use Git.
var vcsGit = *ast.UnaryExprvcsHg describes how to use Mercurial.
var vcsHg = *ast.UnaryExprvcsList lists the known version control systems
var vcsList = []*Cmd{...}vcsMod is a stub for the "mod" scheme. It's returned by repoRootForImportPathDynamic, but is otherwise not treated as a VCS command.
var vcsMod = *ast.UnaryExprvcsPaths defines the meaning of import paths referring to commonly-used VCS hosting sites (github.com/user/dir) and import paths referring to a fully-qualified importPath containing a VCS type (foo.com/repo.git/dir)
var vcsPaths = []*vcsPath{...}vcsPathsAfterDynamic gives additional vcsPaths entries to try after the dynamic HTML check. This gives those sites a chance to introduce tags as part of a graceful transition away from the hard-coded logic.
var vcsPathsAfterDynamic = []*vcsPath{...}vcsSvn describes how to use Subversion.
var vcsSvn = *ast.UnaryExprModuleMode specifies whether to prefer modules when looking up code sources.
type ModuleMode intA govcsConfig is a full GOVCS configuration.
type govcsConfig []govcsRuleA Cmd describes how to use a version control system like Mercurial, Git, or Subversion.
type Cmd struct {
Name string
Cmd string
Env []string
RootNames []rootName
CreateCmd []string
DownloadCmd []string
TagCmd []tagCmd
TagLookupCmd []tagCmd
TagSyncCmd []string
TagSyncDefault []string
Scheme []string
PingCmd string
RemoteRepo func(v *Cmd, rootDir string) (remoteRepo string, err error)
ResolveRepo func(v *Cmd, rootDir string, remoteRepo string) (realRepo string, err error)
Status func(v *Cmd, rootDir string) (Status, error)
}An ImportMismatchError is returned where metaImport/s are present but none match our import path.
type ImportMismatchError struct {
importPath string
mismatches []string
}RepoRoot describes the repository root for a tree of source code.
type RepoRoot struct {
Repo string
Root string
IsCustom bool
VCS *Cmd
}Status is the current state of a local repository.
type Status struct {
Revision string
CommitTime time.Time
Uncommitted bool
}type fetchResult struct {
url *urlpkg.URL
imports []metaImport
err error
}A govcsRule is a single GOVCS rule like private:hg|svn.
type govcsRule struct {
pattern string
allowed []string
}importError is a copy of load.importError, made to avoid a dependency cycle on cmd/go/internal/load. It just needs to satisfy load.ImportPathError.
type importError struct {
importPath string
err error
}metaImport represents the parsed tags from HTML files.
type metaImport struct {
Prefix string
VCS string
RepoRoot string
}type rootName struct {
filename string
isDir bool
}A tagCmd describes a command to list available tags that can be passed to tagSyncCmd.
type tagCmd struct {
cmd string
pattern string
}type vcsNotFoundError struct {
dir string
}A vcsPath describes how to convert an import path into a version control system and repository name.
type vcsPath struct {
pathPrefix string
regexp *lazyregexp.Regexp
repo string
vcs string
check func(match map[string]string) error
schemelessRepo bool
}Create creates a new copy of repo in dir. The parent of dir must exist; dir must not.
func (v *Cmd) Create(dir string, repo string) errorDownload downloads any new changes for the repo in dir.
func (v *Cmd) Download(dir string) errorfunc (e *vcsNotFoundError) Error() stringfunc (e *importError) Error() stringfunc (m ImportMismatchError) Error() stringFromDir inspects dir and its parents to determine the version control system and code repository to use. If no repository is found, FromDir returns an error equivalent to os.ErrNotExist.
func FromDir(dir string, srcRoot string) (repoDir string, vcsCmd *Cmd, err error)func (e *importError) ImportPath() stringfunc (e *vcsNotFoundError) Is(err error) boolfunc (v *Cmd) IsSecure(repo string) boolPing pings to determine scheme to use.
func (v *Cmd) Ping(scheme string, repo string) errorRepoRootForImportPath analyzes importPath to determine the version control system, and code repository to use.
func RepoRootForImportPath(importPath string, mod ModuleMode, security web.SecurityMode) (*RepoRoot, error)func (v *Cmd) String() stringTagSync syncs the repo in dir to the named tag, which either is a tag returned by tags or is v.tagDefault.
func (v *Cmd) TagSync(dir string, tag string) errorTags returns the list of available tags for the repo in dir.
func (v *Cmd) Tags(dir string) ([]string, error)func (e *importError) Unwrap() errorfunc (c *govcsConfig) allow(path string, private bool, vcs string) boolattrValue returns the attribute value for the case-insensitive key `name`, or the empty string if nothing is found.
func attrValue(attrs []xml.Attr, name string) stringfunc bzrRemoteRepo(vcsBzr *Cmd, rootDir string) (remoteRepo string, err error)func bzrResolveRepo(vcsBzr *Cmd, rootDir string, remoteRepo string) (realRepo string, err error)func bzrStatus(vcsBzr *Cmd, rootDir string) (Status, error)charsetReader returns a reader that converts from the given charset to UTF-8. Currently it only supports UTF-8 and ASCII. Otherwise, it returns a meaningful error which is printed by go get, so the user can find why the package wasn't downloaded if the encoding is not supported. Note that, in order to reduce potential errors, ASCII is treated as UTF-8 (i.e. characters greater than 0x7f are not rejected).
func charsetReader(charset string, input io.Reader) (io.Reader, error)checkGOVCS checks whether the policy defined by the environment variable GOVCS allows the given vcs command to be used with the given repository root path. Note that root may not be a real package or module path; it's the same as the root path in the go-import meta tag.
func checkGOVCS(vcs *Cmd, root string) errorexpand rewrites s to replace {k} with match[k] for each key k in match.
func expand(match map[string]string, s string) stringfunc fossilRemoteRepo(vcsFossil *Cmd, rootDir string) (remoteRepo string, err error)func fossilStatus(vcsFossil *Cmd, rootDir string) (Status, error)func gitRemoteRepo(vcsGit *Cmd, rootDir string) (remoteRepo string, err error)func gitStatus(vcsGit *Cmd, rootDir string) (Status, error)func hgRemoteRepo(vcsHg *Cmd, rootDir string) (remoteRepo string, err error)func hgStatus(vcsHg *Cmd, rootDir string) (Status, error)func httpPrefix(s string) stringfunc importErrorf(path string, format string, args ...any) errorfunc interceptVCSTest(repo string, vcs *Cmd, security web.SecurityMode) (repoURL string, ok bool)func (v *Cmd) isSecureScheme(scheme string) boolisVCSRoot identifies a VCS root by checking whether the directory contains any of the listed root names.
func isVCSRoot(dir string, rootNames []rootName) boollaunchpadVCS solves the ambiguity for "lp.net/project/foo". In this case, "foo" could be a series name registered in Launchpad with its own branch, and it could also be the name of a directory within the main project branch one level up.
func launchpadVCS(match map[string]string) errormatchGoImport returns the metaImport from imports matching importPath. An error is returned if there are multiple matches. An ImportMismatchError is returned if none match.
func matchGoImport(imports []metaImport, importPath string) (metaImport, error)metaImportsForPrefix takes a package's root import path as declared in a tag and returns its HTML discovery URL and the parsed metaImport lines found on the page. The importPath is of the form "golang.org/x/tools". It is an error if no imports are found. url will still be valid if err != nil. The returned url will be of the form "https://golang.org/x/tools?go-get=1"
func metaImportsForPrefix(importPrefix string, mod ModuleMode, security web.SecurityMode) (*urlpkg.URL, []metaImport, error)noVCSSuffix checks that the repository name does not end in .foo for any version control system foo. The usual culprit is ".git".
func noVCSSuffix(match map[string]string) errorfunc parseGOVCS(s string) (govcsConfig, error)parseMetaGoImports returns meta imports from the HTML in r. Parsing ends at the end of the
section or the beginning of the .func parseMetaGoImports(r io.Reader, mod ModuleMode) ([]metaImport, error)parseRevTime parses commit details in "revision:seconds" format.
func parseRevTime(out []byte) (string, time.Time, error)repoRootForImportDynamic finds a *RepoRoot for a custom domain that's not statically known by repoRootFromVCSPaths. This handles custom import paths like "name.tld/pkg/foo" or just "name.tld".
func repoRootForImportDynamic(importPath string, mod ModuleMode, security web.SecurityMode) (*RepoRoot, error)repoRootFromVCSPaths attempts to map importPath to a repoRoot using the mappings defined in vcsPaths.
func repoRootFromVCSPaths(importPath string, security web.SecurityMode, vcsPaths []*vcsPath) (*RepoRoot, error)run runs the command line cmd in the given directory. keyval is a list of key, value pairs. run expands instances of {key} in cmd into value, but only after splitting cmd into individual arguments. If an error occurs, run prints the command line and the command's combined stdout+stderr to standard error. Otherwise run discards the command's output.
func (v *Cmd) run(dir string, cmd string, keyval ...string) errorrun1 is the generalized implementation of run and runOutput.
func (v *Cmd) run1(dir string, cmdline string, keyval []string, verbose bool) ([]byte, error)runOutput is like run but returns the output of the command.
func (v *Cmd) runOutput(dir string, cmd string, keyval ...string) ([]byte, error)runOutputVerboseOnly is like runOutput but only generates error output to standard error in verbose mode.
func (v *Cmd) runOutputVerboseOnly(dir string, cmd string, keyval ...string) ([]byte, error)runVerboseOnly is like run but only generates error output to standard error in verbose mode.
func (v *Cmd) runVerboseOnly(dir string, cmd string, keyval ...string) errorfunc svnRemoteRepo(vcsSvn *Cmd, rootDir string) (remoteRepo string, err error)urlForImportPath returns a partially-populated URL for the given Go import path. The URL leaves the Scheme field blank so that web.Get will try any scheme allowed by the selected security mode.
func urlForImportPath(importPath string) (*urlpkg.URL, error)validateRepoRoot returns an error if repoRoot does not seem to be a valid URL with scheme.
func validateRepoRoot(repoRoot string) errorvcsByCmd returns the version control system for the given command name (hg, git, svn, bzr).
func vcsByCmd(cmd string) *CmdGenerated with Arrow