gitpb/rill.go

package gitpb

// runs git, parses output
// types faster than you can

import (
	"errors"
	"strings"
	sync "sync"

	"github.com/destel/rill"
	"github.com/go-cmd/cmd"
	"go.wit.com/log"
)

var ErrorMissingGitConfig error = errors.New("missing .git/config")
var ErrorGitPullOnLocal error = errors.New("git pull on local only branch")
var ErrorGitPullOnDirty error = errors.New("cannot git pull on dirty repo")

func (repo *Repo) GitPull() cmd.Status {
	currentName := repo.GetCurrentBranchName()
	if repo.IsOnlyLocalTag(currentName) {
		var result cmd.Status
		result.Exit = 21
		result.Error = ErrorGitPullOnLocal
		// log.Info("git pull skipped on local only branch", repo.GetGoPath())
		return result
	}
	var cmd []string
	cmd = append(cmd, "git", "pull")
	r := repo.Run(cmd)
	// output := strings.Join(r.Stdout, "\n")
	/* notsure why I had this. I think from a long time ago
	if r.Error != nil {
		output = "git error_,,,_a_,,,_b_,,,c"
	}
	*/
	/*
		if r.Error == nil {
			if r.Exit == 0 {
				log.Log(GITPBWARN, "git pull ran  ", repo.GetGoPath())
				// log.Log(GITPBWARN, "git pull output", output)
				return r
			} else {
				log.Log(GITPBWARN, "git pull error", repo.GetGoPath(), strings.Join(r.Stderr, "\n"))
				return r
			}
		}
		log.Log(GITPBWARN, "git pull error", repo.GetGoPath(), r.Error)
	*/
	return r
}

// rill is awesome. long live rill
// attempt scan with rill
func (all *Repos) RillGitPull(part1 int, part2 int) map[*Repo]cmd.Status {
	var lock sync.Mutex
	var allerr map[*Repo]cmd.Status
	allerr = make(map[*Repo]cmd.Status)

	// Convert a slice of user IDs into a channel
	ids := rill.FromSlice(all.Repos, nil)

	var counter int
	// Read users from the API.
	// Concurrency = 20
	dirs := rill.Map(ids, part1, func(id *Repo) (*Repo, error) {
		return id, nil
	})

	rill.ForEach(dirs, part2, func(repo *Repo) error {
		counter += 1
		if repo.CheckDirty() {
			// log.Info("git pull skipped on dirty repo", repo.GoPath)
			var result cmd.Status
			result.Error = ErrorGitPullOnDirty
			lock.Lock()
			defer lock.Unlock()
			allerr[repo] = result
		} else {
			// todo: sort out what the hell is wrong with my code
			// something seems to be trampling things
			/*
				var dur time.Duration
				dur = time.Duration((1+rand.Intn(50))*20) * time.Millisecond
				time.Sleep(dur)
			*/
			var result cmd.Status
			result = repo.GitPull()
			log.Info("git pull", strings.Join(result.Stdout, " "), repo.GetGoPath())
			lock.Lock()
			defer lock.Unlock()
			allerr[repo] = result

		}
		return nil
	})

	//	for r, err := range allerr {
	//		log.Info("git pull error:", r.GoPath, err)
	//	}

	return allerr
}

func (repo *Repo) GitPullRealtime() cmd.Status {
	currentName := repo.GetCurrentBranchName()
	if repo.IsOnlyLocalTag(currentName) {
		var result cmd.Status
		result.Exit = 21
		result.Error = ErrorGitPullOnLocal
		// log.Info("git pull skipped on local only branch", repo.GoPath)
		return result
	}
	var cmd []string
	cmd = append(cmd, "git", "pull")
	r := repo.RunRealtime(cmd)
	return r
}