fixing Init()

4 files changed, 140 insertions, 61 deletions

diff --git a/gitCheckout.go b/gitCheckout.go
new file mode 100644
index 0000000..1ade5c6
--- /dev/null
+++ b/gitCheckout.go
@@ -0,0 +1,92 @@
+package forgepb
+
+import (
+	"errors"
+
+	"go.wit.com/lib/gui/repostatus"
+	"go.wit.com/log"
+)
+
+func (f *Forge) GitPull() bool {
+	var localonly int
+	var badmap int
+
+	log.Log(FORGEPBWARN, "running git pull everywhere")
+	var failed int = 0
+	loop := f.Repos.SortByGoPath()
+	for loop.Scan() {
+		repo := loop.Next()
+		if out, err := repo.GitPull(); err == nil {
+			log.Log(FORGEPBWARN, "Ran git pull ok", repo.GetGoPath(), out)
+		} else {
+			failed += 1
+			// repo.DumpTags()
+			if errors.Is(repostatus.ErrorGitPullOnLocal, err) {
+				localonly += 1
+				continue
+			}
+			badmap += 1
+			log.Log(FORGEPBWARN, "bad unknown git error", repo.GetGoPath(), out, err)
+		}
+	}
+	log.Log(FORGEPBWARN, "Ran git pull in all repos. failure count =", failed)
+	log.Log(FORGEPBWARN, "Ran git pull in all repos. bad errors =", badmap)
+	if localonly != 0 {
+		log.Log(FORGEPBWARN, "Ran git pull in all repos. ignored local only branches =", localonly)
+	}
+	return true
+}
+
+func (f *Forge) CheckoutDevel() bool {
+	log.Log(FORGEPBWARN, "running git checkout devel everwhere")
+	var failed int = 0
+	var count int = 0
+	loop := f.Repos.SortByGoPath()
+	for loop.Scan() {
+		repo := loop.Next()
+		count += 1
+		if repo.CheckoutDevel() {
+			// checkout ok
+		} else {
+			failed += 1
+		}
+	}
+	log.Log(FORGEPBWARN, "Ran git checkout in", count, "repos. failure count =", failed)
+	return true
+}
+
+func (f *Forge) CheckoutMaster() bool {
+	log.Log(FORGEPBWARN, "running git checkout master everwhere")
+	var failed int = 0
+	var count int = 0
+	loop := f.Repos.SortByGoPath()
+	for loop.Scan() {
+		repo := loop.Next()
+		count += 1
+		if repo.CheckoutMaster() {
+			// checkout ok
+		} else {
+			failed += 1
+		}
+	}
+	log.Log(FORGEPBWARN, "Ran git checkout in", count, "repos. failure count =", failed)
+	return true
+}
+
+func (f *Forge) CheckoutUser() bool {
+	log.Log(FORGEPBWARN, "running git checkout master everwhere")
+	var failed int = 0
+	var count int = 0
+	loop := f.Repos.SortByGoPath()
+	for loop.Scan() {
+		repo := loop.Next()
+		count += 1
+		if repo.CheckoutUser() {
+			// checkout ok
+		} else {
+			failed += 1
+		}
+	}
+	log.Log(FORGEPBWARN, "Ran git checkout in", count, "repos. failure count =", failed)
+	return true
+}
diff --git a/goSrcScan.go b/goSrcScan.go
index 83a6442..2287149 100644
--- a/goSrcScan.go
+++ b/goSrcScan.go
@@ -13,26 +13,36 @@ import (
 )
 
 func (f *Forge) ScanGoSrc() (bool, error) {
-	log.Info("pre  dir walk")
 	dirs, err := gitDirectoriesNew(f.goSrc)
-	log.Info("post dir walk", len(dirs))
 	if err != nil {
 		return false, err
 	}
 
 	var gopaths []string
 	for _, dir := range dirs {
+		// log.Info("forge.ScanGoSrc()", dir)
 		if strings.HasPrefix(dir, f.goSrc) {
 			gopath := strings.TrimPrefix(dir, f.goSrc)
 			gopath = strings.Trim(gopath, "/")
+			if r := f.Repos.FindByGoPath(gopath); r != nil {
+				// log.Info("already have", gopath)
+				continue
+			}
 			gopaths = append(gopaths, gopath)
 		} else {
 			log.Log(FORGEPBWARN, "ScanGoSrc() bad:", dir)
 			return false, errors.New("forgepb.ScanGoSrc() bad dir: " + dir)
 		}
 	}
-	log.Info("pre rill")
-	f.rillScanDirs(gopaths)
+	newcount, err := f.rillScanDirs(gopaths)
+	if err != nil {
+		log.Info("go src dir problem. exit for now?", err)
+		os.Exit(-1)
+	}
+	if newcount != 0 {
+		log.Info("forge go src scan found", newcount, "repos")
+		f.Repos.ConfigSave()
+	}
 	return true, err
 }
 
@@ -47,6 +57,13 @@ func gitDirectoriesNew(srcDir string) ([]string, error) {
 			return err
 		}
 
+		if d.IsDir() {
+			// log.Info("path is dir", path)
+		} else {
+			log.Info("warning: you have an untracked file:", path)
+			return nil
+		}
+
 		gitdir := filepath.Join(path, ".git")
 		_, err2 := os.Stat(gitdir)
 		if !os.IsNotExist(err2) {
@@ -118,24 +135,23 @@ func rillAddDirs(gopaths []string) {
 
 // rill is awesome. long live rill
 // attempt scan with rill
-func (f *Forge) rillScanDirs(gopaths []string) error {
+func (f *Forge) rillScanDirs(gopaths []string) (int, error) {
 	// Convert a slice of user IDs into a channel
 	ids := rill.FromSlice(gopaths, nil)
 
 	// Read users from the API.
 	// Concurrency = 20
 	dirs := rill.Map(ids, 20, func(id string) (*gitpb.Repo, error) {
-		return f.Repos.NewGoPath(f.goSrc, id)
+		return f.NewGoPathRepo(id)
 	})
 
+	var counter int
 	// Activate users.
 	// Concurrency = 10
 	err := rill.ForEach(dirs, 10, func(repo *gitpb.Repo) error {
-		// could do something here
-		// fmt.Printf("Repo found : %s\n", repo.GoPath)
-		// repo.Run([]string{"git", "pull"})
+		counter += 1
 		return nil
 	})
 
-	return err
+	return counter, err
 }
diff --git a/repoClone.go b/repoClone.go
index 75dd393..1c1ffa0 100644
--- a/repoClone.go
+++ b/repoClone.go
@@ -80,7 +80,7 @@ func (f *Forge) guessPaths(path string) (string, string, string, bool, error) {
 
 // TODO: make some config file for things like this
 // can be used to work around temporary problems
-func clonePathHack(dirname string, basedir string, gopath string) error {
+func clonePathHack(dirname string, basedir string, gopath string) (string, error) {
 	// newdir = helloworld
 	// basedir = /home/jcarr/go/src/go.wit.com/apps
 	// giturl = https://gitea.wit.com/gui/helloworld
@@ -117,7 +117,7 @@ func clonePathHack(dirname string, basedir string, gopath string) error {
 		return cloneActual(dirname, basedir, "https://"+"go.googlesource.com/appengine")
 	}
 
-	return errors.New("no gopath override here")
+	return "", errors.New("no gopath override here")
 }
 
 // attempt to git clone if the go path doesn't exist
@@ -126,7 +126,7 @@ func clonePathHack(dirname string, basedir string, gopath string) error {
 // gopath  = go.wit.com/apps/helloworld
 func (f *Forge) Clone(gopath string) (*gitpb.Repo, error) {
 	var err error
-	pb, err := f.Repos.NewGoPath(f.goSrc, gopath)
+	pb, err := f.Repos.NewGoPath(f.goSrc, gopath, "")
 	if err == nil {
 		return pb, err
 	}
@@ -142,9 +142,9 @@ func (f *Forge) Clone(gopath string) (*gitpb.Repo, error) {
 
 	// try a direct git clone against the gopath
 	// cloneActual("helloworld", "/home/jcarr/go/src/go.wit.com/apps", "https://go.wit.com/apps/helloworld")
-	if err = cloneActual(dirname, basedir, url); err == nil {
+	if finalurl, err := cloneActual(dirname, basedir, url); err == nil {
 		// git clone worked!
-		return f.Repos.NewGoPath(f.goSrc, gopath)
+		return f.Repos.NewGoPath(f.goSrc, gopath, finalurl)
 	}
 	log.Info("direct attempt at git clone failed", url)
 
@@ -155,9 +155,9 @@ func (f *Forge) Clone(gopath string) (*gitpb.Repo, error) {
 		log.Info("findGoImport() DID NOT WORK", url)
 		log.Info("findGoImport() DID NOT WORK", err)
 	} else {
-		if err := cloneActual(dirname, basedir, url); err == nil {
+		if finalurl, err := cloneActual(dirname, basedir, url); err == nil {
 			// git clone worked!
-			return f.Repos.NewGoPath(f.goSrc, gopath)
+			return f.Repos.NewGoPath(f.goSrc, gopath, finalurl)
 		}
 	}
 	log.Info("git clone from 'go-import' info failed", url)
@@ -167,18 +167,18 @@ func (f *Forge) Clone(gopath string) (*gitpb.Repo, error) {
 	if url, err = runGoList(gopath); err != nil {
 		log.Info("go list failed", err)
 	} else {
-		if err := cloneActual(dirname, basedir, url); err == nil {
+		if finalurl, err := cloneActual(dirname, basedir, url); err == nil {
 			// git clone worked!
-			return f.Repos.NewGoPath(f.goSrc, gopath)
+			return f.Repos.NewGoPath(f.goSrc, gopath, finalurl)
 		}
 	}
 	log.Info("git clone from 'git list' info failed", url)
 
 	// try to parse a redirect
 
-	if err = clonePathHack(dirname, basedir, gopath); err == nil {
+	if finalurl, err := clonePathHack(dirname, basedir, gopath); err == nil {
 		// WTF didn't go-import or go list work?
-		return f.Repos.NewGoPath(f.goSrc, gopath)
+		return f.Repos.NewGoPath(f.goSrc, gopath, finalurl)
 	}
 
 	return nil, errors.New("can not find git sources for gopath " + gopath)
@@ -187,7 +187,7 @@ func (f *Forge) Clone(gopath string) (*gitpb.Repo, error) {
 // newdir = helloworld
 // basedir = /home/jcarr/go/src/go.wit.com/apps
 // giturl = https://gitea.wit.com/gui/helloworld
-func cloneActual(newdir, basedir, giturl string) error {
+func cloneActual(newdir, basedir, giturl string) (string, error) {
 	log.Info("cloneActual() newdir  =", newdir)
 	log.Info("cloneActual() basedir =", basedir)
 	log.Info("cloneActual() giturl  =", giturl)
@@ -197,7 +197,7 @@ func cloneActual(newdir, basedir, giturl string) error {
 	err := os.Chdir(basedir)
 	if err != nil {
 		log.Warn("chdir failed", basedir, err)
-		return err
+		return giturl, err
 	}
 
 	cmd := []string{"git", "clone", "--verbose", "--progress", giturl, newdir}
@@ -205,22 +205,22 @@ func cloneActual(newdir, basedir, giturl string) error {
 	r := shell.PathRunRealtime(basedir, cmd)
 	if r.Error != nil {
 		log.Warn("git clone error", r.Error)
-		return r.Error
+		return giturl, r.Error
 	}
 
 	fullpath := filepath.Join(basedir, newdir)
 	if !IsDirectory(fullpath) {
 		log.Info("git clone failed", giturl)
-		return errors.New("git clone failed " + giturl)
+		return giturl, errors.New("git clone failed " + giturl)
 	}
 	gitdir := filepath.Join(fullpath, ".git")
 	if IsDirectory(gitdir) {
 		log.Info("git cloned worked to", fullpath)
-		return nil
+		return giturl, nil
 	}
 	// git clone didn't really work but did make a directory
 	log.Info("fullpath is probably empty", fullpath)
-	return errors.New("crapnuts. rmdir fullpath here? " + fullpath)
+	return giturl, errors.New("crapnuts. rmdir fullpath here? " + fullpath)
 }
 
 // check the server for the current go path to git url mapping
diff --git a/repoNew.go b/repoNew.go
index f114487..c6cb8be 100644
--- a/repoNew.go
+++ b/repoNew.go
@@ -6,44 +6,15 @@ import (
 	"go.wit.com/lib/protobuf/gitpb"
 )
 
-/*
-func (f *Forge) NewGoPath(gopath string) (*gitpb.Repo, error) {
-	newr, err := f.Repos.NewGoPath(f.goSrc, gopath)
+func (f *Forge) NewGoPathRepo(gopath string) (*gitpb.Repo, error) {
+	repo, err := f.Repos.NewGoPath(f.GetGoSrc(), gopath, "")
 	if err != nil {
-		log.Log(FORGEPBWARN, "init failed", err)
 		return nil, err
 	}
-	log.Info("init worked for", newr.GoPath)
-	// try to guess what the 'master' branch is
-	if newr.IsBranch("guimaster") {
-		newr.SetMasterBranchName("guimaster")
-	} else if newr.IsBranch("master") {
-		newr.SetMasterBranchName("master")
-	} else if newr.IsBranch("main") {
-		newr.SetMasterBranchName("main")
-	} else {
-		newr.SetMasterBranchName("masterFIXME")
-	}
-
-	if newr.IsBranch("guidevel") {
-		newr.SetDevelBranchName("guidevel")
-	} else if newr.IsBranch("devel") {
-		newr.SetDevelBranchName("devel")
-	} else {
-		newr.SetDevelBranchName("develFIXME")
-	}
-
-	usr, _ := user.Current()
-	uname := usr.Username
-	if newr.IsBranch(uname) {
-		newr.SetUserBranchName(uname)
-	} else {
-		newr.SetUserBranchName(uname + "FIXME")
-	}
-	f.Repos.ConfigSave()
-	return newr, err
+	f.VerifyBranchNames(repo)
+	repo.ParseGoSum()
+	return repo, nil
 }
-*/
 
 func (f *Forge) VerifyBranchNames(newr *gitpb.Repo) {
 	// log.Info("init worked for", newr.GoPath)