func setup(t *testing.T, tmpDir string) {
_, code, err := internal.Capture(tmpDir, nil, "git", "init")
ut.AssertEqual(t, 0, code)
ut.AssertEqual(t, nil, err)
run(t, tmpDir, nil, "config", "user.email", "nobody@localhost")
run(t, tmpDir, nil, "config", "user.name", "nobody")
}
// Capture sets GOPATH and executes a subprocess.
func (o *Options) Capture(r scm.ReadOnlyRepo, args ...string) (string, int, time.Duration, error) {
o.LeaseRunToken()
defer o.ReturnRunToken()
start := time.Now()
out, exitCode, err := internal.Capture(r.Root(), []string{"GOPATH=" + r.GOPATH()}, args...)
return out, exitCode, time.Since(start), err
}
// captureAbs returns an absolute path of whatever a git command returned.
func captureAbs(wd string, args ...string) (string, error) {
out, code, _ := internal.Capture(wd, nil, args...)
if code != 0 {
return "", fmt.Errorf("failed to run \"%s\"", strings.Join(args, " "))
}
out = strings.TrimSpace(out)
if !filepath.IsAbs(out) {
out = filepath.Clean(filepath.Join(wd, out))
}
return out, nil
}
func setup(t *testing.T, td string, files map[string]string) scm.Change {
fooDir := filepath.Join(td, "src", "foo")
ut.AssertEqual(t, nil, os.MkdirAll(fooDir, 0700))
for f, c := range files {
p := filepath.Join(fooDir, f)
ut.AssertEqual(t, nil, os.MkdirAll(filepath.Dir(p), 0700))
ut.AssertEqual(t, nil, ioutil.WriteFile(p, []byte(c), 0600))
}
_, code, err := internal.Capture(fooDir, nil, "git", "init")
ut.AssertEqual(t, 0, code)
ut.AssertEqual(t, nil, err)
// It's important to add the files to the index, otherwise they will be
// ignored.
_, code, err = internal.Capture(fooDir, nil, "git", "add", ".")
ut.AssertEqual(t, 0, code)
ut.AssertEqual(t, nil, err)
repo, err := scm.GetRepo(fooDir, td)
ut.AssertEqual(t, nil, err)
change, err := repo.Between(scm.Current, scm.GitInitialCommit, nil)
ut.AssertEqual(t, nil, err)
ut.AssertEqual(t, true, change != nil)
return change
}
// cmdInstallPrereq installs all the packages needed to run the enabled checks.
func (a *application) cmdInstallPrereq(repo scm.ReadOnlyRepo, modes []checks.Mode, noUpdate bool) error {
var wg sync.WaitGroup
enabledChecks, _ := a.config.EnabledChecks(modes)
number := 0
c := make(chan string, len(enabledChecks))
for _, check := range enabledChecks {
for _, p := range check.GetPrerequisites() {
number++
wg.Add(1)
go func(prereq checks.CheckPrerequisite) {
defer wg.Done()
if !prereq.IsPresent() {
c <- prereq.URL
}
}(p)
}
}
wg.Wait()
log.Printf("Checked for %d prerequisites", number)
loop := true
// Use a map to remove duplicates.
m := map[string]bool{}
for loop {
select {
case url := <-c:
m[url] = true
default:
loop = false
}
}
urls := make([]string, 0, len(m))
for url := range m {
urls = append(urls, url)
}
wd, err := os.Getwd()
if err != nil {
return err
}
sort.Strings(urls)
if len(urls) != 0 {
if noUpdate {
out := "-n is specified but prerequites are missing:\n"
for _, url := range urls {
out += " " + url + "\n"
}
return errors.New(out)
}
fmt.Printf("Installing:\n")
for _, url := range urls {
fmt.Printf(" %s\n", url)
}
out, _, err := internal.Capture(wd, nil, append([]string{"go", "get"}, urls...)...)
if len(out) != 0 {
return fmt.Errorf("prerequisites installation failed: %s", out)
}
if err != nil {
return fmt.Errorf("prerequisites installation failed: %s", err)
}
}
log.Printf("Prerequisites installation succeeded")
return nil
}
func (g *git) captureEnv(env []string, args ...string) (string, int, error) {
out, code, err := internal.Capture(g.root, env, append([]string{"git"}, args...)...)
return strings.TrimRight(out, "\n\r"), code, err
}
// capture sets GOPATH.
func capture(r scm.ReadOnlyRepo, args ...string) (string, int, error) {
return internal.Capture(r.Root(), []string{"GOPATH=" + r.GOPATH()}, args...)
}