| // Copyright 2017 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 dep |
| |
| import ( |
| "log" |
| "os" |
| "path/filepath" |
| "runtime" |
| "sort" |
| "time" |
| |
| "github.com/golang/dep/gps" |
| "github.com/golang/dep/gps/paths" |
| "github.com/golang/dep/gps/pkgtree" |
| "github.com/golang/dep/gps/verify" |
| "github.com/golang/dep/internal/fs" |
| "github.com/pkg/errors" |
| ) |
| |
| // Ctx defines the supporting context of dep. |
| // |
| // A properly initialized Ctx has a GOPATH containing the project root and non-nil Loggers. |
| // |
| // ctx := &dep.Ctx{ |
| // WorkingDir: GOPATH + "/src/project/root", |
| // GOPATH: GOPATH, |
| // Out: log.New(os.Stdout, "", 0), |
| // Err: log.New(os.Stderr, "", 0), |
| // } |
| // |
| // Ctx.DetectProjectGOPATH() helps with setting the containing GOPATH. |
| // |
| // ctx.GOPATH, err := Ctx.DetectProjectGOPATH(project) |
| // if err != nil { |
| // // Could not determine which GOPATH to use for the project. |
| // } |
| // |
| type Ctx struct { |
| WorkingDir string // Where to execute. |
| GOPATH string // Selected Go path, containing WorkingDir. |
| GOPATHs []string // Other Go paths. |
| ExplicitRoot string // An explicitly-set path to use as the project root. |
| Out, Err *log.Logger // Required loggers. |
| Verbose bool // Enables more verbose logging. |
| DisableLocking bool // When set, no lock file will be created to protect against simultaneous dep processes. |
| Cachedir string // Cache directory loaded from environment. |
| CacheAge time.Duration // Maximum valid age of cached source data. <=0: Don't cache. |
| } |
| |
| // SetPaths sets the WorkingDir and GOPATHs fields. If GOPATHs is empty, then |
| // the GOPATH environment variable (or the default GOPATH) is used instead. |
| func (c *Ctx) SetPaths(wd string, GOPATHs ...string) error { |
| if wd == "" { |
| return errors.New("cannot set Ctx.WorkingDir to an empty path") |
| } |
| c.WorkingDir = wd |
| |
| if len(GOPATHs) == 0 { |
| GOPATH := os.Getenv("GOPATH") |
| if GOPATH == "" { |
| GOPATH = defaultGOPATH() |
| } |
| GOPATHs = filepath.SplitList(GOPATH) |
| } |
| |
| c.GOPATHs = append(c.GOPATHs, GOPATHs...) |
| |
| c.ExplicitRoot = os.Getenv("DEPPROJECTROOT") |
| |
| return nil |
| } |
| |
| // defaultGOPATH gets the default GOPATH that was added in 1.8 |
| // copied from go/build/build.go |
| func defaultGOPATH() string { |
| env := "HOME" |
| if runtime.GOOS == "windows" { |
| env = "USERPROFILE" |
| } else if runtime.GOOS == "plan9" { |
| env = "home" |
| } |
| if home := os.Getenv(env); home != "" { |
| def := filepath.Join(home, "go") |
| if def == runtime.GOROOT() { |
| // Don't set the default GOPATH to GOROOT, |
| // as that will trigger warnings from the go tool. |
| return "" |
| } |
| return def |
| } |
| return "" |
| } |
| |
| // SourceManager produces an instance of gps's built-in SourceManager |
| // initialized to log to the receiver's logger. |
| func (c *Ctx) SourceManager() (*gps.SourceMgr, error) { |
| cachedir := c.Cachedir |
| if cachedir == "" { |
| // When `DEPCACHEDIR` isn't set in the env, use the default - `$GOPATH/pkg/dep`. |
| cachedir = filepath.Join(c.GOPATH, "pkg", "dep") |
| // Create the default cachedir if it does not exist. |
| if err := os.MkdirAll(cachedir, 0777); err != nil { |
| return nil, errors.Wrap(err, "failed to create default cache directory") |
| } |
| } |
| |
| return gps.NewSourceManager(gps.SourceManagerConfig{ |
| CacheAge: c.CacheAge, |
| Cachedir: cachedir, |
| Logger: c.Out, |
| DisableLocking: c.DisableLocking, |
| }) |
| } |
| |
| // LoadProject starts from the current working directory and searches up the |
| // directory tree for a project root. The search stops when a file with the name |
| // ManifestName (Gopkg.toml, by default) is located. |
| // |
| // The Project contains the parsed manifest as well as a parsed lock file, if |
| // present. The import path is calculated as the remaining path segment |
| // below Ctx.GOPATH/src. |
| func (c *Ctx) LoadProject() (*Project, error) { |
| root, err := findProjectRoot(c.WorkingDir) |
| if err != nil { |
| return nil, err |
| } |
| |
| err = checkGopkgFilenames(root) |
| if err != nil { |
| return nil, err |
| } |
| |
| p := new(Project) |
| |
| if err = p.SetRoot(root); err != nil { |
| return nil, err |
| } |
| |
| c.GOPATH, err = c.DetectProjectGOPATH(p) |
| if err != nil { |
| return nil, err |
| } |
| |
| if c.ExplicitRoot != "" { |
| p.ImportRoot = gps.ProjectRoot(c.ExplicitRoot) |
| } else { |
| ip, err := c.ImportForAbs(p.AbsRoot) |
| if err != nil { |
| return nil, errors.Wrap(err, "root project import") |
| } |
| p.ImportRoot = gps.ProjectRoot(ip) |
| } |
| |
| mp := filepath.Join(p.AbsRoot, ManifestName) |
| mf, err := os.Open(mp) |
| if err != nil { |
| if os.IsNotExist(err) { |
| // TODO: list possible solutions? (dep init, cd $project) |
| return nil, errors.Errorf("no %v found in project root %v", ManifestName, p.AbsRoot) |
| } |
| // Unable to read the manifest file |
| return nil, err |
| } |
| defer mf.Close() |
| |
| var warns []error |
| p.Manifest, warns, err = readManifest(mf) |
| for _, warn := range warns { |
| c.Err.Printf("dep: WARNING: %v\n", warn) |
| } |
| if err != nil { |
| return nil, errors.Wrapf(err, "error while parsing %s", mp) |
| } |
| |
| // Parse in the root package tree. |
| ptree, err := p.parseRootPackageTree() |
| if err != nil { |
| return nil, err |
| } |
| |
| lp := filepath.Join(p.AbsRoot, LockName) |
| lf, err := os.Open(lp) |
| if err == nil { |
| defer lf.Close() |
| |
| p.Lock, err = readLock(lf) |
| if err != nil { |
| return nil, errors.Wrapf(err, "error while parsing %s", lp) |
| } |
| |
| // If there's a current Lock, apply the input and pruneopt changes that we |
| // can know without solving. |
| if p.Lock != nil { |
| p.ChangedLock = p.Lock.dup() |
| p.ChangedLock.SolveMeta.InputImports = externalImportList(ptree, p.Manifest) |
| |
| for k, lp := range p.ChangedLock.Projects() { |
| vp := lp.(verify.VerifiableProject) |
| vp.PruneOpts = p.Manifest.PruneOptions.PruneOptionsFor(lp.Ident().ProjectRoot) |
| p.ChangedLock.P[k] = vp |
| } |
| } |
| |
| } else if !os.IsNotExist(err) { |
| // It's fine for the lock not to exist, but if a file does exist and we |
| // can't open it, that's a problem. |
| return nil, errors.Wrapf(err, "could not open %s", lp) |
| } |
| |
| return p, nil |
| } |
| |
| func externalImportList(rpt pkgtree.PackageTree, m gps.RootManifest) []string { |
| rm, _ := rpt.ToReachMap(true, true, false, m.IgnoredPackages()) |
| reach := rm.FlattenFn(paths.IsStandardImportPath) |
| req := m.RequiredPackages() |
| |
| // If there are any requires, slide them into the reach list, as well. |
| if len(req) > 0 { |
| // Make a map of imports that are both in the import path list and the |
| // required list to avoid duplication. |
| skip := make(map[string]bool, len(req)) |
| for _, r := range reach { |
| if req[r] { |
| skip[r] = true |
| } |
| } |
| |
| for r := range req { |
| if !skip[r] { |
| reach = append(reach, r) |
| } |
| } |
| } |
| |
| sort.Strings(reach) |
| return reach |
| } |
| |
| // DetectProjectGOPATH attempt to find the GOPATH containing the project. |
| // |
| // If p.AbsRoot is not a symlink and is within a GOPATH, the GOPATH containing p.AbsRoot is returned. |
| // If p.AbsRoot is a symlink and is not within any known GOPATH, the GOPATH containing p.ResolvedAbsRoot is returned. |
| // |
| // p.AbsRoot is assumed to be a symlink if it is not the same as p.ResolvedAbsRoot. |
| // |
| // DetectProjectGOPATH will return an error in the following cases: |
| // |
| // If p.AbsRoot is not a symlink and is not within any known GOPATH. |
| // If neither p.AbsRoot nor p.ResolvedAbsRoot are within a known GOPATH. |
| // If both p.AbsRoot and p.ResolvedAbsRoot are within the same GOPATH. |
| // If p.AbsRoot and p.ResolvedAbsRoot are each within a different GOPATH. |
| func (c *Ctx) DetectProjectGOPATH(p *Project) (string, error) { |
| if p.AbsRoot == "" || p.ResolvedAbsRoot == "" { |
| return "", errors.New("project AbsRoot and ResolvedAbsRoot must be set to detect GOPATH") |
| } |
| |
| if c.ExplicitRoot != "" { |
| // If an explicit root is set, just use the first GOPATH in the list. |
| return c.GOPATHs[0], nil |
| } |
| |
| pGOPATH, perr := c.detectGOPATH(p.AbsRoot) |
| |
| // If p.AbsRoot is a not a symlink, attempt to detect GOPATH for p.AbsRoot only. |
| if equal, _ := fs.EquivalentPaths(p.AbsRoot, p.ResolvedAbsRoot); equal { |
| return pGOPATH, perr |
| } |
| |
| rGOPATH, rerr := c.detectGOPATH(p.ResolvedAbsRoot) |
| |
| // If detectGOPATH() failed for both p.AbsRoot and p.ResolvedAbsRoot, then both are not within any known GOPATHs. |
| if perr != nil && rerr != nil { |
| return "", errors.Errorf("both %s and %s are not within any known GOPATH", p.AbsRoot, p.ResolvedAbsRoot) |
| } |
| |
| // If pGOPATH equals rGOPATH, then both are within the same GOPATH. |
| if equal, _ := fs.EquivalentPaths(pGOPATH, rGOPATH); equal { |
| return "", errors.Errorf("both %s and %s are in the same GOPATH %s", p.AbsRoot, p.ResolvedAbsRoot, pGOPATH) |
| } |
| |
| if pGOPATH != "" && rGOPATH != "" { |
| return "", errors.Errorf("%s and %s are both in different GOPATHs", p.AbsRoot, p.ResolvedAbsRoot) |
| } |
| |
| // Otherwise, either the p.AbsRoot or p.ResolvedAbsRoot is within a GOPATH. |
| if pGOPATH == "" { |
| return rGOPATH, nil |
| } |
| |
| return pGOPATH, nil |
| } |
| |
| // detectGOPATH detects the GOPATH for a given path from ctx.GOPATHs. |
| func (c *Ctx) detectGOPATH(path string) (string, error) { |
| for _, gp := range c.GOPATHs { |
| isPrefix, err := fs.HasFilepathPrefix(path, gp) |
| if err != nil { |
| return "", errors.Wrap(err, "failed to detect GOPATH") |
| } |
| if isPrefix { |
| return filepath.Clean(gp), nil |
| } |
| } |
| return "", errors.Errorf("%s is not within a known GOPATH/src", path) |
| } |
| |
| // ImportForAbs returns the import path for an absolute project path by trimming the |
| // `$GOPATH/src/` prefix. Returns an error for paths equal to, or without this prefix. |
| func (c *Ctx) ImportForAbs(path string) (string, error) { |
| srcprefix := filepath.Join(c.GOPATH, "src") + string(filepath.Separator) |
| isPrefix, err := fs.HasFilepathPrefix(path, srcprefix) |
| if err != nil { |
| return "", errors.Wrap(err, "failed to find import path") |
| } |
| if isPrefix { |
| if len(path) <= len(srcprefix) { |
| return "", errors.New("dep does not currently support using GOPATH/src as the project root") |
| } |
| |
| // filepath.ToSlash because we're dealing with an import path now, |
| // not an fs path |
| return filepath.ToSlash(path[len(srcprefix):]), nil |
| } |
| |
| return "", errors.Errorf("%s is not within any GOPATH/src", path) |
| } |
| |
| // AbsForImport returns the absolute path for the project root |
| // including the $GOPATH. This will not work with stdlib packages and the |
| // package directory needs to exist. |
| func (c *Ctx) AbsForImport(path string) (string, error) { |
| posspath := filepath.Join(c.GOPATH, "src", path) |
| dirOK, err := fs.IsDir(posspath) |
| if err != nil { |
| return "", errors.Wrapf(err, "checking if %s is a directory", posspath) |
| } |
| if !dirOK { |
| return "", errors.Errorf("%s does not exist", posspath) |
| } |
| return posspath, nil |
| } |
| |
| // ValidateParams ensure that solving can be completed with the specified params. |
| func (c *Ctx) ValidateParams(sm gps.SourceManager, params gps.SolveParameters) error { |
| err := gps.ValidateParams(params, sm) |
| if err != nil { |
| if deduceErrs, ok := err.(gps.DeductionErrs); ok { |
| c.Err.Println("The following errors occurred while deducing packages:") |
| for ip, dErr := range deduceErrs { |
| c.Err.Printf(" * \"%s\": %s", ip, dErr) |
| } |
| c.Err.Println() |
| } |
| } |
| |
| return errors.Wrap(err, "validateParams") |
| } |
