early 'git pull' using rillv0.0.26

1 files changed, 78 insertions, 70 deletions

diff --git a/rill.go b/rill.go
index facc074..142b201 100644
--- a/rill.go
+++ b/rill.go
@@ -5,92 +5,100 @@ package gitpb
 
 import (
 	"errors"
-	"sort"
 	"strings"
-	"time"
+	sync "sync"
 
+	"github.com/destel/rill"
+	"github.com/go-cmd/cmd"
 	"go.wit.com/log"
 )
 
-func (all *GitTags) SortByAge() *GitTagIterator {
-	packs := all.selectAllGitTag()
-
-	sort.Sort(GitTagAge(packs))
-
-	iterator := NewGitTagIterator(packs)
-	return iterator
-}
-
-type GitTagAge []*GitTag
-
-func (a GitTagAge) Len() int { return len(a) }
-
-// sorts in ? order
-func (a GitTagAge) Less(i, j int) bool {
-	if time.Since(a[i].Authordate.AsTime()) < time.Since(a[j].Authordate.AsTime()) {
-		return true
-	}
-	return false
-}
-func (a GitTagAge) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-
-// rill is awesome. long live rill
-// attempt scan with rill
-func (all *Repos) RillGitPull() error {
-	loop := all.SortByGoPath()
-	for loop.Scan() {
-		t := loop.Next()
-		log.Info("repo", t.GoPath)
-	}
-	/*
-		packs := all.SortByGoPath()
-		// Convert a slice of user IDs into a channel
-		ids := rill.FromSlice(packs, nil)
-
-		// Read users from the API.
-		// Concurrency = 20
-		dirs := rill.Map(ids, 20, func(id string) (*Repo, error) {
-			return packs[id], nil
-		})
-
-		// Activate users.
-		// Concurrency = 10
-		err := rill.ForEach(dirs, 10, func(repo *Repo) error {
-			// could do something here
-			// fmt.Printf("Repo found : %s\n", repo.GoPath)
-			// repo.Run([]string{"git", "pull"})
-			return nil
-		})
-	*/
-	return nil
-}
-
 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")
 
-// checks to see if you can do a 'git pull'
-func (repo *Repo) IsOnlyLocalTag(currentName string) bool {
-	log.Warn("IsOnlyLocalTag(currentName string) not re-implemented yet")
-	return false
-}
-
-func (repo *Repo) GitPull() (string, error) {
+func (repo *Repo) GitPull() cmd.Status {
 	currentName := repo.GetCurrentBranchName()
 	if repo.IsOnlyLocalTag(currentName) {
-		return "", ErrorGitPullOnLocal
+		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.Run(cmd)
-	output := strings.Join(r.Stdout, "\n")
+	// 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 {
-		log.Log(GITPBWARN, "git pull ran", repo.GetGoPath())
-		log.Log(GITPBWARN, "git pull output", output)
-	} else {
+	*/
+	/*
+		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 output, 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.GoPath)
+			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
 }