295 lines
8.0 KiB
Go
295 lines
8.0 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"go.wit.com/lib/gui/shell"
|
|
"go.wit.com/lib/protobuf/gitpb"
|
|
"go.wit.com/log"
|
|
)
|
|
|
|
func forceReleaseVersion(repo *gitpb.Repo) {
|
|
if argv.Minor {
|
|
// if v1.2.3 change to v.1.3.0
|
|
repo.IncrementTargetMinor()
|
|
} else {
|
|
// if v1.2.3 change to v.1.2.4
|
|
repo.IncrementTargetRevision()
|
|
}
|
|
}
|
|
|
|
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()
|
|
log.Info("MISSING:", getpath)
|
|
_, err = me.startRepo.RunVerboseOnError([]string{"go", "get", getpath})
|
|
return err
|
|
}
|
|
|
|
var rillcount int
|
|
|
|
func rillPurge(repo *gitpb.Repo) error {
|
|
if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
|
|
return nil
|
|
}
|
|
if me.forge.Config.IsPrivate(repo.GetGoPath()) {
|
|
return nil
|
|
}
|
|
|
|
_, err := repo.RunQuiet([]string{"go-mod-clean", "--purge"})
|
|
rillcount += 1
|
|
if err != nil {
|
|
log.Info("go-mod-clean --smart failed", repo.GetGoPath(), err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func rillRestore(repo *gitpb.Repo) error {
|
|
if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
|
|
return nil
|
|
}
|
|
if me.forge.Config.IsPrivate(repo.GetGoPath()) {
|
|
return nil
|
|
}
|
|
|
|
_, err := repo.RunQuiet([]string{"go-mod-clean", "--smart"})
|
|
rillcount += 1
|
|
if err != nil {
|
|
log.Info("go-mod-clean --smart failed", repo.GetGoPath(), err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func rePrepareRelease() {
|
|
// reload the config
|
|
// me.forge = forgepb.Init()
|
|
me.found = new(gitpb.Repos)
|
|
|
|
log.Printf("rePrepareRelease() START rill go-mod-clean --smart (11 seconds?)")
|
|
rillcount = 0
|
|
now := time.Now()
|
|
me.forge.RillFuncError(rillRestore)
|
|
log.Printf("showRestore() (%d total repos) took:%s\n", rillcount, shell.FormatDuration(time.Since(now)))
|
|
log.Sleep(1)
|
|
all2 := me.forge.Repos.SortByFullPath()
|
|
for all2.Scan() {
|
|
check := all2.Next()
|
|
if me.forge.Config.IsReadOnly(check.GetGoPath()) {
|
|
continue
|
|
}
|
|
if me.forge.Config.IsPrivate(check.GetGoPath()) {
|
|
continue
|
|
}
|
|
// this should be rare? nonexistant?
|
|
if err := checkpkgcache(check); err != nil {
|
|
log.Info("go get checks failed here.", err, check.GetGoPath())
|
|
}
|
|
}
|
|
|
|
all := me.forge.Repos.SortByFullPath()
|
|
for all.Scan() {
|
|
check := all.Next()
|
|
|
|
if alreadyDone(check) {
|
|
// means it was already published
|
|
// protects against logic errors that might result
|
|
// in an infinite loop
|
|
log.Info("WARNING alreadyDone rePrepareRelease()", check.GetGoPath())
|
|
continue
|
|
}
|
|
|
|
if me.forge.Config.IsReadOnly(check.GetGoPath()) {
|
|
// can't release readonly repos
|
|
continue
|
|
}
|
|
|
|
if !me.forge.Config.IsPrivate(check.GetGoPath()) {
|
|
if err := checkPublishedGodeps(check); err != nil {
|
|
// this means the published godeps are no longer up to date
|
|
forceReleaseVersion(check)
|
|
me.found.AppendByGoPath(check)
|
|
log.Info("checkPublishedGodeps failed with err", check.GetGoPath(), err)
|
|
continue
|
|
} else {
|
|
// log.Info("checkPublishedGodeps is ok", check.GetGoPath())
|
|
}
|
|
}
|
|
|
|
// if master != lastTag, always increment
|
|
master := check.GetMasterVersion()
|
|
lastTag := check.GetLastTag()
|
|
if master != lastTag {
|
|
newmhash := check.GetTagHash(master)
|
|
oldlhash := check.GetTagHash(lastTag)
|
|
if newmhash == oldlhash {
|
|
// they are actually equal
|
|
continue
|
|
}
|
|
b1 := check.CountDiffObjects(oldlhash, newmhash)
|
|
b2 := check.CountDiffObjects(newmhash, oldlhash)
|
|
if b1 != 0 {
|
|
log.Printf("HASH ERROR %-50s tag %s < %s\n", check.GetGoPath(), newmhash, oldlhash)
|
|
log.Info("old vs new count", b1, b2, "git merge", oldlhash)
|
|
}
|
|
|
|
if b1 == 0 && b2 == 0 {
|
|
log.Info("got to identical repo", check.GetGoPath(), b1, b2)
|
|
log.Info("got to identical repo", check.GetGoPath(), oldlhash, newmhash)
|
|
// actually identical. do nothing
|
|
continue
|
|
}
|
|
if gitpb.IsGoTagVersionGreater(lastTag, master) {
|
|
// this function is not right really. the hash error above should catch it correctly
|
|
// log.Printf("PROBABLY NOT NEE %-50s tag %s < %s\n", check.GetGoPath(), lastTag, master)
|
|
}
|
|
log.Printf("NEED RELEASE FOR %-50s tag %s != %s\n", check.GetGoPath(), master, lastTag)
|
|
forceReleaseVersion(check)
|
|
me.found.AppendByGoPath(check)
|
|
continue
|
|
}
|
|
|
|
if me.forge.Config.IsPrivate(check.GetGoPath()) {
|
|
// only checks after this are GO dep related which don't matter for private repos
|
|
continue
|
|
}
|
|
|
|
if argv.Quick != nil {
|
|
// if argv has 'quick' don't do anything
|
|
// that doesn't actually have a patch
|
|
if master == lastTag {
|
|
continue
|
|
}
|
|
}
|
|
|
|
if argv.Protobuf && check.GetRepoType() == "protobuf" {
|
|
log.Printf("NEED RELEASE FOR %s err: %v\n", check.GetGoPath(), "because --protobuf")
|
|
// if --protobuf, this will force upgrade each one
|
|
forceReleaseVersion(check)
|
|
me.found.AppendByGoPath(check)
|
|
continue
|
|
}
|
|
|
|
// if the repo is a go binary or plugin for a new release for
|
|
// any library version change
|
|
// if check.GetRepoType() == "binary" || check.GetRepoType() == "plugin" {
|
|
// check if the package dependancies changed, if so, re-publish
|
|
if err := me.forge.FinalGoDepsCheckOk(check, false); err == nil {
|
|
// log.Printf("go.sum is perfect! %s\n", check.GetGoPath())
|
|
continue
|
|
} else {
|
|
log.Printf("NEED RELEASE FOR %-50s err: %v\n", check.GetGoPath(), err)
|
|
forceReleaseVersion(check)
|
|
me.found.AppendByGoPath(check)
|
|
}
|
|
|
|
}
|
|
me.forge.PrintHumanTable(me.found)
|
|
}
|
|
|
|
func printDone() {
|
|
for _, gopath := range me.done {
|
|
log.Info("printDone() THESE WERE PUBLISHED", gopath)
|
|
}
|
|
log.Info("printDone() total finished so far:", len(me.done))
|
|
time.Sleep(time.Second)
|
|
}
|
|
|
|
func alreadyDone(repo *gitpb.Repo) bool {
|
|
for _, gopath := range me.done {
|
|
// log.Info("WARNING already done", gopath, repo.GetGoPath())
|
|
// log.Info("WARNING already done", gopath, repo.GetGoPath())
|
|
// log.Info("WARNING already done", gopath, repo.GetGoPath())
|
|
if repo.GetGoPath() == gopath {
|
|
log.Info("FOUND. RETURN TRUE. already done", gopath, repo.GetGoPath())
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func checkPublishedGodeps(repo *gitpb.Repo) error {
|
|
godepsOld, err := repo.GoSumFromPkgDir()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if godepsOld != nil {
|
|
if err := me.forge.TestGoDepsCheckOk(godepsOld, argv.Verbose); err != nil {
|
|
return err
|
|
}
|
|
/*
|
|
all := godepsOld.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 godep %s which can not be found", repo.GetGoPath(), dep.GoPath)
|
|
}
|
|
if found.GetLastTag() != dep.Version {
|
|
return fmt.Errorf("%s with godep %s version mismatch %s vs %s", repo.GetGoPath(), dep.GoPath, found.GetLastTag(), dep.Version)
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
godepsNew, err := repo.GoSumFromRepo()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if godepsOld == nil {
|
|
if godepsNew == nil {
|
|
log.Printf("%s published godeps == nil && real == nil\n", repo.GetGoPath())
|
|
return nil
|
|
} else {
|
|
return fmt.Errorf("published godeps == nil vs real != nil")
|
|
}
|
|
}
|
|
if err := me.forge.TestGoDepsCheckOk(godepsNew, argv.Verbose); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
/*
|
|
func checkGodeps(repo *gitpb.Repo, godeps *gitpb.GoDeps) error {
|
|
if godeps == nil {
|
|
}
|
|
return nil
|
|
all := 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 godep %s which can not be found", repo.GetGoPath(), dep.GoPath)
|
|
}
|
|
if found.GetLastTag() != dep.Version {
|
|
return fmt.Errorf("%s with godep %s version mismatch %s vs %s", repo.GetGoPath(), dep.GoPath, found.GetLastTag(), dep.Version)
|
|
}
|
|
log.Printf("%s with godep %s version match %s vs %s\n", repo.GetGoPath(), dep.GoPath, found.GetLastTag(), dep.Version)
|
|
}
|
|
return nil
|
|
}
|
|
*/
|