// GetRepo retrieves a Masterminds/vcs repo object configured for the root // of the package being retrieved. func (d *Dependency) GetRepo(dest string) (vcs.Repo, error) { // The remote location is either the configured repo or the package // name as an https url. var remote string if len(d.Repository) > 0 { remote = d.Repository } else { remote = "https://" + d.Name } // If the VCS type has a value we try that first. if len(d.VcsType) > 0 && d.VcsType != "None" { switch vcs.Type(d.VcsType) { case vcs.Git: return vcs.NewGitRepo(remote, dest) case vcs.Svn: return vcs.NewSvnRepo(remote, dest) case vcs.Hg: return vcs.NewHgRepo(remote, dest) case vcs.Bzr: return vcs.NewBzrRepo(remote, dest) default: return nil, fmt.Errorf("Unknown VCS type %s set for %s", d.VcsType, d.Name) } } // When no type set we try to autodetect. return vcs.NewRepo(remote, dest) }
// GetAll gets zero or more repos. // // Params: // - packages ([]string): Package names to get. // - verbose (bool): default false // // Returns: // - []*Dependency: A list of constructed dependencies. func GetAll(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) { names := p.Get("packages", []string{}).([]string) cfg := p.Get("conf", nil).(*Config) Info("Preparing to install %d package.", len(names)) deps := []*Dependency{} for _, name := range names { cwd, err := VendorPath(c) if err != nil { return nil, err } root := getRepoRootFromPackage(name) if len(root) == 0 { return nil, fmt.Errorf("Package name is required for %q.", name) } if cfg.HasDependency(root) { Warn("Package %q is already in glide.yaml. Skipping", root) continue } dest := path.Join(cwd, root) repoURL := "https://" + root repo, err := v.NewRepo(repoURL, dest) if err != nil { Error("Could not construct repo for %q: %s", name, err) return false, err } dep := &Dependency{ Name: root, } subpkg := strings.TrimPrefix(name, root) if len(subpkg) > 0 && subpkg != "/" { dep.Subpackages = []string{subpkg} } if err := repo.Get(); err != nil { return dep, err } cfg.Imports = append(cfg.Imports, dep) deps = append(deps, dep) } return deps, nil }
// Get fetches a single package and puts it in vendor/. // // Params: // - package (string): Name of the package to get. // - verbose (bool): default false // // Returns: // - *Dependency: A dependency describing this package. func Get(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) { name := p.Get("package", "").(string) cfg := p.Get("conf", nil).(*Config) cwd, err := VendorPath(c) if err != nil { return nil, err } root := getRepoRootFromPackage(name) if len(root) == 0 { return nil, fmt.Errorf("Package name is required.") } if cfg.HasDependency(root) { return nil, fmt.Errorf("Package '%s' is already in glide.yaml", root) } dest := path.Join(cwd, root) repoUrl := "https://" + root repo, err := v.NewRepo(repoUrl, dest) if err != nil { return false, err } dep := &Dependency{ Name: root, VcsType: string(repo.Vcs()), // Should this assume a remote https root at all times? Repository: repoUrl, } subpkg := strings.TrimPrefix(name, root) if len(subpkg) > 0 && subpkg != "/" { dep.Subpackages = []string{subpkg} } if err := repo.Get(); err != nil { return dep, err } cfg.Imports = append(cfg.Imports, dep) return dep, nil }
func NewPackage(importPath string, goPath string) (*GoPackage, error) { fullPath, err := goPackageDir(importPath, goPath) if err != nil { return nil, err } repoRoot, err := repoRoot(fullPath) if err != nil { return nil, fmt.Errorf("Cannot find repo root for %v: %v", fullPath, err) } pkgRoot := strings.TrimPrefix(repoRoot, goPath+"/src/") if strings.Contains(pkgRoot, "/vendor/") { return nil, nil } repo, err := vcs.NewRepo("", repoRoot) if err != nil { return nil, fmt.Errorf("Error while creating repo for %v: %v", repoRoot, err) } revision, err := repo.Version() if err != nil { return nil, err } updateDate, err := repo.Date() if err != nil { return nil, err } return &GoPackage{ Name: nixName(pkgRoot), ImportPath: pkgRoot, VcsRepo: repo.Remote(), VcsCommand: string(repo.Vcs()), Revision: revision, Hash: calculateHash("file://"+repo.LocalPath(), string(repo.Vcs())), UpdateDate: updateDate, }, nil }
// Clone will clone the repo to a specified location and then checkout the repo at the particular revision. func (m Manager) Clone(url string, revision string, dir string) error { log.Printf("Initializing repo %s into %s\n", url, dir) repo, err := vcs.NewRepo(url, dir) if err != nil { return fmt.Errorf(errorContainer, repoInitFailed, url, revision, dir, err.Error()) } log.Printf("Cloning %s into %s\n", url, dir) err = repo.Get() if err != nil { return fmt.Errorf(errorContainer, repoCloneFailed, url, revision, dir, err.Error()) } if revision != "" { log.Printf("Checking out revision %s for repo %s\n", revision, url) err = repo.UpdateVersion(revision) if err != nil { return fmt.Errorf(errorContainer, repoCheckoutFailed, url, revision, dir, err.Error()) } } else { log.Printf("Assuming default revision for repo %s\n", url) } return nil }
func wizardFindVersions(d *cfg.Dependency) { l, err := cache.Location() if err != nil { msg.Debug("Problem detecting cache location: %s", err) return } var remote string if d.Repository != "" { remote = d.Repository } else { remote = "https://" + d.Name } key, err := cache.Key(remote) if err != nil { msg.Debug("Problem generating cache key for %s: %s", remote, err) return } local := filepath.Join(l, "src", key) repo, err := vcs.NewRepo(remote, local) if err != nil { msg.Debug("Problem getting repo instance: %s", err) return } var useLocal bool if _, err = os.Stat(local); err == nil { useLocal = true } // Git endpoints allow for querying without fetching the codebase locally. // We try that first to avoid fetching right away. Is this premature // optimization? cc := true if !useLocal && repo.Vcs() == vcs.Git { out, err2 := exec.Command("git", "ls-remote", remote).CombinedOutput() if err2 == nil { cache.MemTouch(remote) cc = false lines := strings.Split(string(out), "\n") for _, i := range lines { ti := strings.TrimSpace(i) if found := createGitParseVersion.FindString(ti); found != "" { tg := strings.TrimPrefix(strings.TrimSuffix(found, "^{}"), "tags/") cache.MemPut(remote, tg) if d.Reference != "" && strings.HasPrefix(ti, d.Reference) { cache.MemSetCurrent(remote, tg) } } } } } if cc { cache.Lock(key) cache.MemTouch(remote) if _, err = os.Stat(local); os.IsNotExist(err) { repo.Get() branch := findCurrentBranch(repo) c := cache.RepoInfo{DefaultBranch: branch} err = cache.SaveRepoData(key, c) if err != nil { msg.Debug("Error saving cache repo details: %s", err) } } else { repo.Update() } tgs, err := repo.Tags() if err != nil { msg.Debug("Problem getting tags: %s", err) } else { for _, v := range tgs { cache.MemPut(remote, v) } } if d.Reference != "" && repo.IsReference(d.Reference) { tgs, err = repo.TagsFromCommit(d.Reference) if err != nil { msg.Debug("Problem getting tags for commit: %s", err) } else { if len(tgs) > 0 { for _, v := range tgs { if !(repo.Vcs() == vcs.Hg && v == "tip") { cache.MemSetCurrent(remote, v) } } } } } cache.Unlock(key) } }