// 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)
}
}