269 lines
7.5 KiB
Go
269 lines
7.5 KiB
Go
// This is a simple example
|
|
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"go.wit.com/log"
|
|
|
|
"go.wit.com/lib/gui/shell"
|
|
"go.wit.com/lib/protobuf/gitpb"
|
|
)
|
|
|
|
var findCounter int
|
|
var findFix bool = false
|
|
var findOk bool = true
|
|
|
|
func checkpkgcache(repo *gitpb.Repo) error {
|
|
homedir, err := os.UserHomeDir()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rver := repo.GetLastTag()
|
|
if rver == "" {
|
|
return errors.New("could not get master version")
|
|
}
|
|
moddir := filepath.Join(homedir, "go/pkg/mod", repo.GetGoPath()+"@"+rver)
|
|
if shell.IsDir(moddir) {
|
|
return nil
|
|
}
|
|
|
|
getpath := repo.GetGoPath() + "@" + repo.GetLastTag()
|
|
_, err = me.startRepo.RunVerbose([]string{"go", "get", getpath})
|
|
return err
|
|
}
|
|
|
|
func rillRestore(repo *gitpb.Repo) error {
|
|
if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
|
|
return nil
|
|
}
|
|
if me.forge.Config.IsPrivate(repo.GetGoPath()) {
|
|
return nil
|
|
}
|
|
if err := checkpkgcache(repo); err != nil {
|
|
return err
|
|
}
|
|
_, err := repo.RunVerboseOnError([]string{"go-mod-clean", "--restore"})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
log.Info("go-mod-clean restore worked ", repo.GetGoPath())
|
|
return nil
|
|
}
|
|
|
|
func slowRestore() error {
|
|
all := me.forge.Repos.All()
|
|
for all.Scan() {
|
|
repo := all.Next()
|
|
if err := rillRestore(repo); err != nil {
|
|
badExit(err)
|
|
}
|
|
if repo.ParseGoSum() {
|
|
log.Info("go-mod-clean and parse worked", repo.GetGoPath())
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkDeps(repo *gitpb.Repo) error {
|
|
if repo.GoDeps == nil {
|
|
return fmt.Errorf("%s has GoDeps == nil", repo.GetGoPath())
|
|
}
|
|
all := repo.GoDeps.All()
|
|
for all.Scan() {
|
|
dep := all.Next()
|
|
// log.Info(repo.GetGoPath(), dep.GoPath, dep.Version)
|
|
|
|
// check if the package in question is waiting for another package to publish
|
|
found := me.forge.FindByGoPath(dep.GoPath)
|
|
if found == nil {
|
|
return fmt.Errorf("%s has dep == nil", repo.GetGoPath(), dep.GoPath)
|
|
}
|
|
all := me.found.SortByFullPath()
|
|
for all.Scan() {
|
|
check := all.Next()
|
|
if found.GetGoPath() == check.GetGoPath() {
|
|
// this package is waiting on other packages to publish
|
|
return fmt.Errorf("%s is waiting on %s", repo.GetGoPath(), found.GetGoPath())
|
|
}
|
|
}
|
|
// found package isn't being published. is the version correct?
|
|
// never check this? we are done?
|
|
/*
|
|
if found.GetLastTag() == dep.Version {
|
|
// everything is normal
|
|
} else {
|
|
return fmt.Errorf("%s version mismatch on %s (%s vs %s)", repo.GetGoPath(), found.GetGoPath(), found.GetLastTag(), dep.Version)
|
|
}
|
|
*/
|
|
}
|
|
// everything might be cool?
|
|
return nil
|
|
}
|
|
|
|
// trys to figure out if there is still something to update
|
|
// todo: redo this logic as it is terrible
|
|
// rename this findNext()
|
|
func findNext() bool {
|
|
findCounter = 0
|
|
all := me.found.SortByFullPath()
|
|
for all.Scan() {
|
|
check := all.Next()
|
|
if err := checkDeps(check); err != nil {
|
|
log.Info("\t", check.GetGoPath(), err)
|
|
continue
|
|
} else {
|
|
log.Info("Might be ok?", check.GetGoPath())
|
|
}
|
|
if check.GetMasterBranchName() != check.GetCurrentBranchName() {
|
|
log.Info("YOU MUST BE ON THE MASTER BRANCHES")
|
|
os.Exit(-1)
|
|
}
|
|
_, err := check.RunVerboseOnError([]string{"go-mod-clean", "--strict"})
|
|
if err != nil {
|
|
os.Exit(-1)
|
|
}
|
|
|
|
if check.IsDirty() {
|
|
log.Info("findNext() skipping dirty")
|
|
continue
|
|
}
|
|
/*
|
|
if findFix {
|
|
log.Info("findFix is true. running fixGoDeps()")
|
|
if fixGodeps(check) {
|
|
log.Info("fixGoDeps() returned true")
|
|
} else {
|
|
log.Info("fixGoDeps() returned false")
|
|
}
|
|
|
|
}
|
|
*/
|
|
findCounter += 1
|
|
if !check.ParseGoSum() {
|
|
log.Info("ParseGoSum() failed")
|
|
log.Info("ParseGoSum() failed")
|
|
log.Info("ParseGoSum() failed")
|
|
continue
|
|
}
|
|
if me.forge.FinalGoDepsCheckOk(check, false) {
|
|
setCurrentRepo(check, "should be good to release", "pretty sure")
|
|
return true
|
|
} else {
|
|
log.Info("FinalGoDepsCheckOk() failed")
|
|
log.Info("FinalGoDepsCheckOk() failed")
|
|
log.Info("FinalGoDepsCheckOk() failed")
|
|
}
|
|
log.Info("findNext() got to the end. repo", check.GetGoPath(), "did not work. trying to find a new one now")
|
|
}
|
|
if findCounter == 0 {
|
|
log.Info("NOTHING TO UPDATE. findCounter =", findCounter)
|
|
} else {
|
|
findFix = true
|
|
log.Info("me.current is nil findCounter =", findCounter, "so set findFix =", findFix)
|
|
}
|
|
log.Info("tried to findNext() but not sure what to do next counter =", findCounter, "findFix =", findFix)
|
|
me.release.status.SetText("ALL DONE?")
|
|
return false
|
|
}
|
|
|
|
func runGoClean(check *gitpb.Repo, myarg string) bool {
|
|
// check if the package dependancies changed, if so, re-publish
|
|
check.GoDeps = nil
|
|
|
|
cmd := []string{"go-mod-clean", myarg}
|
|
// log.Info("Running", cmd, "in", check.GetGoPath())
|
|
result := check.Run(cmd)
|
|
if result.Error != nil {
|
|
/*
|
|
log.Info(cmd, "failed with", result.Error, check.GetGoPath())
|
|
log.Info("STDOUT")
|
|
log.Info(strings.Join(result.Stdout, "\n"))
|
|
log.Info("STDERR")
|
|
log.Info(strings.Join(result.Stderr, "\n"))
|
|
*/
|
|
return false
|
|
}
|
|
if result.Exit != 0 {
|
|
/*
|
|
log.Info(cmd, "failed with", result.Exit, check.GetGoPath())
|
|
log.Info("STDOUT")
|
|
log.Info(strings.Join(result.Stdout, "\n"))
|
|
log.Info("STDERR")
|
|
log.Info(strings.Join(result.Stderr, "\n"))
|
|
*/
|
|
return false
|
|
}
|
|
if check.ParseGoSum() {
|
|
return true
|
|
}
|
|
log.Info("ParseGoSum() failed", check.GetGoPath())
|
|
return false
|
|
}
|
|
|
|
// tries to fix the go.mod and go.sum files
|
|
func fixGodeps(check *gitpb.Repo) bool {
|
|
log.Info("fixGoDeps() START", check.GetGoPath())
|
|
log.Info("fixGoDeps() START", check.GetGoPath())
|
|
log.Info("fixGoDeps() START", check.GetGoPath())
|
|
var good bool = true
|
|
if !runGoClean(check, "--strict") {
|
|
log.Info("fixGoDeps() runGoClean() strict failed", check.GetGoPath())
|
|
log.Info("fixGoDeps() runGoClean() strict failed", check.GetGoPath())
|
|
log.Info("fixGoDeps() runGoClean() strict failed", check.GetGoPath())
|
|
return false
|
|
}
|
|
// skip primative ones
|
|
if check.GetGoPrimitive() {
|
|
if check.Exists("go.sum") {
|
|
log.Info("fixGoDeps() has go.sum but says it is primitive", check.GetGoPath())
|
|
return false
|
|
}
|
|
log.Info("fixGoDeps() skipping primitive", check.GetGoPath())
|
|
return true
|
|
}
|
|
log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
|
|
log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
|
|
log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
|
|
deps := check.GoDeps.SortByGoPath()
|
|
for deps.Scan() {
|
|
depRepo := deps.Next()
|
|
// log.Info("found dep", depRepo.GetGoPath())
|
|
if me.forge.Config.IsReadOnly(depRepo.GetGoPath()) {
|
|
log.Info("IsReadOnly = true", depRepo.GetGoPath())
|
|
continue
|
|
} else {
|
|
// log.Info("IsReadOnly = false", depRepo.GetGoPath())
|
|
}
|
|
found := me.forge.FindByGoPath(depRepo.GetGoPath())
|
|
if found == nil {
|
|
log.Info("not found:", depRepo.GetGoPath())
|
|
continue
|
|
}
|
|
log.Printf("%-48s dep ver=%10s repo ver=%10s target ver=%10s\n", found.GetGoPath(), depRepo.GetVersion(), found.GetMasterVersion(), found.GetTargetVersion())
|
|
if depRepo.GetVersion() != found.GetMasterVersion() {
|
|
log.Printf("%-48s %10s (gitpb depRepo)\n", depRepo.GetGoPath(), depRepo.GetVersion())
|
|
log.Printf("%-48s %10s (gitpb found)\n", found.GetGoPath(), found.GetMasterVersion())
|
|
cmd := []string{"go", "get", depRepo.GetGoPath() + "@latest"}
|
|
check.RunVerbose(cmd)
|
|
}
|
|
}
|
|
return good
|
|
}
|
|
|
|
func setCurrentRepo(check *gitpb.Repo, s string, note string) bool {
|
|
me.release.repo.SetText(check.GetGoPath())
|
|
me.release.status.SetText(s)
|
|
me.release.notes.SetText(note)
|
|
me.current = check
|
|
me.release.version.SetText(check.GetTargetVersion())
|
|
me.release.releaseVersionB.SetText("release version " + check.GetTargetVersion())
|
|
me.release.openrepo.Enable()
|
|
|
|
return true
|
|
}
|