Пример #1
0
// probe calls the supplied vcs function to probe a variety of url constructions.
// If vcs returns non nil, it is assumed that the url is not a valid repo.
func probe(vcs func(*url.URL) error, url *url.URL, insecure bool, schemes ...string) (string, error) {
	var unsuccessful []string
	for _, scheme := range schemes {

		// make copy of url and apply scheme
		url := *url
		url.Scheme = scheme

		switch url.Scheme {
		case "https", "ssh":
			if err := vcs(&url); err == nil {
				return url.String(), nil
			}
		case "http", "git":
			if !insecure {
				gb.Infof("skipping insecure protocol: %s", url.String())
				continue
			}
			if err := vcs(&url); err == nil {
				return url.String(), nil
			}
		default:
			return "", fmt.Errorf("unsupported scheme: %v", url.Scheme)
		}
		unsuccessful = append(unsuccessful, url.String())
	}
	return "", fmt.Errorf("vcs probe failed, tried: %s", strings.Join(unsuccessful, ","))
}
Пример #2
0
func fetchMetadata(scheme, path string, insecure bool) (io.ReadCloser, error) {
	url := fmt.Sprintf("%s://%s?go-get=1", scheme, path)
	switch scheme {
	case "https":
		resp, err := http.Get(url)
		if err == nil {
			return resp.Body, nil
		}
	case "http":
		if !insecure {
			gb.Infof("skipping insecure protocol: %v", url)
		} else {
			resp, err := http.Get(url)
			if err == nil {
				return resp.Body, nil
			}
		}
	}

	return nil, fmt.Errorf("unknown remote protocol scheme: %q", scheme)
}
Пример #3
0
Файл: repo.go Проект: gpaul/gb
func probeHgUrl(schemes []string, host, path string, insecure bool) (string, error) {
	for _, scheme := range schemes {
		switch scheme {
		case "https":
			url := scheme + "://" + host + "/" + path
			if _, err := run("hg", "identify", url); err == nil {
				return url, nil
			}
		case "http", "git":
			url := scheme + "://" + host + "/" + path
			if !insecure {
				gb.Infof("skipping insecure protocol: %v", url)
			} else {
				if _, err := run("hg", "identify", url); err == nil {
					return url, nil
				}
			}
		}
	}
	return "", fmt.Errorf("unable to determine remote protocol")
}
Пример #4
0
Файл: repo.go Проект: gpaul/gb
func probeGitUrl(schemes []string, host, path string, insecure bool) (string, error) {
	for _, scheme := range schemes {
		switch scheme {
		case "https":
			url := scheme + "://" + host + "/" + path
			out, err := run("git", "ls-remote", url, "HEAD")
			if err == nil && bytes.Contains(out, []byte("HEAD")) {
				return url, nil
			}
		case "http", "git":
			url := scheme + "://" + host + "/" + path
			if !insecure {
				gb.Infof("skipping insecure protocol: %v", url)
			} else {
				out, err := run("git", "ls-remote", url, "HEAD")
				if err == nil && bytes.Contains(out, []byte("HEAD")) {
					return url, nil
				}
			}
		}
	}
	return "", fmt.Errorf("unable to determine remote protocol")
}
Пример #5
0
func fetch(ctx *gb.Context, path string, recurse bool) error {
	m, err := vendor.ReadManifest(manifestFile(ctx))
	if err != nil {
		return fmt.Errorf("could not load manifest: %v", err)
	}

	repo, extra, err := vendor.DeduceRemoteRepo(path, insecure)
	if err != nil {
		return err
	}

	if m.HasImportpath(path) {
		return fmt.Errorf("%s is already vendored", path)
	}

	wc, err := repo.Checkout(branch, tag, revision)
	if err != nil {
		return err
	}

	rev, err := wc.Revision()
	if err != nil {
		return err
	}

	branch, err := wc.Branch()
	if err != nil {
		return err
	}

	dep := vendor.Dependency{
		Importpath: path,
		Repository: repo.URL(),
		Revision:   rev,
		Branch:     branch,
		Path:       extra,
	}

	if err := m.AddDependency(dep); err != nil {
		return err
	}

	dst := filepath.Join(ctx.Projectdir(), "vendor", "src", dep.Importpath)
	src := filepath.Join(wc.Dir(), dep.Path)

	if err := vendor.Copypath(dst, src); err != nil {
		return err
	}

	if err := vendor.WriteManifest(manifestFile(ctx), m); err != nil {
		return err
	}

	if err := wc.Destroy(); err != nil {
		return err
	}

	if !recurse {
		return nil
	}

	for done := false; !done; {

		paths := []struct {
			Root, Prefix string
		}{
			{filepath.Join(runtime.GOROOT(), "src"), ""},
			{filepath.Join(ctx.Projectdir(), "src"), ""},
		}
		m, err := vendor.ReadManifest(filepath.Join("vendor", "manifest"))
		if err != nil {
			return err
		}
		for _, d := range m.Dependencies {
			paths = append(paths, struct{ Root, Prefix string }{filepath.Join(ctx.Projectdir(), "vendor", "src", filepath.FromSlash(d.Importpath)), filepath.FromSlash(d.Importpath)})
		}

		dsm, err := vendor.LoadPaths(paths...)
		if err != nil {
			return err
		}

		is, ok := dsm[filepath.Join(ctx.Projectdir(), "vendor", "src", path)]
		if !ok {
			return fmt.Errorf("unable to locate depset for %q", path)
		}

		missing := findMissing(pkgs(is.Pkgs), dsm)
		switch len(missing) {
		case 0:
			done = true
		default:

			// sort keys in ascending order, so the shortest missing import path
			// with be fetched first.
			keys := keys(missing)
			sort.Strings(keys)
			pkg := keys[0]
			gb.Infof("fetching recursive dependency %s", pkg)
			if err := fetch(ctx, pkg, false); err != nil {
				return err
			}
		}
	}

	return nil
}