289 lines
9.2 KiB
Go
289 lines
9.2 KiB
Go
// This is a simple example
|
|
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
"go.wit.com/lib/gui/shell"
|
|
"go.wit.com/log"
|
|
)
|
|
|
|
func doRelease() bool {
|
|
log.Info("doRelease() on", me.current.GetGoPath())
|
|
if !findOk {
|
|
log.Info("doRelease() immediately end something went wrong last time. findOk == false")
|
|
return false
|
|
}
|
|
// double check release version logic
|
|
if me.release.releaseVersionB.String() != "release version "+me.release.version.String() {
|
|
log.Warn("something went wrong with the release.version:", me.release.version.String())
|
|
return false
|
|
}
|
|
|
|
if strings.HasPrefix(me.release.version.String(), "v") {
|
|
log.Warn("everything is ok. version starts with v.", me.release.version.String())
|
|
} else {
|
|
log.Warn("version does not start with v.", me.release.version.String())
|
|
return false
|
|
}
|
|
|
|
if shell.Exists("go.mod") {
|
|
log.Info("go.mod exists ok")
|
|
} else {
|
|
pwd, _ := os.Getwd()
|
|
log.Info("go.mod missing in working dir", pwd)
|
|
return false
|
|
}
|
|
|
|
curName := me.current.GetCurrentBranchName()
|
|
mName := me.current.GetMasterBranchName()
|
|
if curName != mName {
|
|
log.Info("\trepo is not working from main branch", curName, "!=", mName)
|
|
return false
|
|
}
|
|
|
|
check := me.forge.FindByGoPath(me.current.GetGoPath())
|
|
if check == nil {
|
|
log.Info("boo, you didn't git clone", me.current.GetGoPath())
|
|
return false
|
|
}
|
|
if alreadyDone(check) {
|
|
// means it was already published
|
|
// protects against logic errors that might result
|
|
// in an infinite loop
|
|
log.Info("doRelease() WARNING. should have never gotten here. return true. already done", check.GetGoPath())
|
|
log.Info("doRelease() WARNING. should have never gotten here. return true. already done", check.GetGoPath())
|
|
log.Info("doRelease() WARNING. should have never gotten here. return true. already done", check.GetGoPath())
|
|
log.Sleep(5)
|
|
return true
|
|
}
|
|
me.done = append(me.done, me.current.GetGoPath())
|
|
if !me.forge.FinalGoDepsCheckOk(check, true) {
|
|
msg := fmt.Sprint("the go.mod file is wrong. fix it here?", check.GetGoPath())
|
|
badExit(errors.New(msg))
|
|
return false
|
|
}
|
|
if check.GetGoPath() == me.startRepo.GetGoPath() {
|
|
log.Info("CAN NOT SELF UPDATE.", check.GetGoPath(), "is the same as os.Getwd()")
|
|
log.Info("go get must be run from somewhere else other than startRepo")
|
|
log.Info("chdir to autotypist if it exists")
|
|
msg := fmt.Sprint("CAN NOT SELF UPDATE.", check.GetGoPath(), "is the same as os.Getwd()")
|
|
badExit(errors.New(msg))
|
|
}
|
|
if !me.startRepo.Exists("go.mod") {
|
|
log.Info("go.sum missing in", me.startRepo.GetGoPath())
|
|
log.Info("pick a different repo here")
|
|
log.Info("todo: error out earlier knowing this will upgrade")
|
|
log.Info("versions", me.startRepo.GetTargetVersion(), me.startRepo.GetMasterVersion())
|
|
panic("redo go.sum")
|
|
}
|
|
|
|
log.Info("\ttag and push", curName, me.release.version.String(), me.releaseReasonS)
|
|
|
|
if err := check.ValidGoSum(); err != nil {
|
|
log.Info("ValidGoSum() error", check.GetGoPath(), err)
|
|
msg := fmt.Sprint("ValidGoSum() error", check.GetGoPath(), err)
|
|
badExit(errors.New(msg))
|
|
}
|
|
|
|
var all [][]string
|
|
var autogen []string
|
|
all = append(all, []string{"git", "add", "-f", "go.mod"})
|
|
autogen = append(autogen, "go.mod")
|
|
if check.GoInfo.GoPrimitive {
|
|
// don't add go.sum here. TODO: check for go.sum file and fail
|
|
} else {
|
|
all = append(all, []string{"git", "add", "-f", "go.sum"})
|
|
autogen = append(autogen, "go.sum")
|
|
}
|
|
if ok, compiled, err := me.current.IsProtobuf(); ok {
|
|
log.Info("\tIsProtobuf() == true")
|
|
if err != nil {
|
|
log.Info("\tERROR: There are protobuf files, but they are not compiled")
|
|
log.Info("\tERROR: can not continue")
|
|
msg := fmt.Sprint("ERROR: There are protobuf files, but they are not compiled")
|
|
badExit(errors.New(msg))
|
|
}
|
|
log.Info("\tshould add the protobuf files here")
|
|
log.Info("\tcompiled files found:", compiled)
|
|
for _, s := range compiled {
|
|
log.Info("\tcompiled file found:", s)
|
|
all = append(all, []string{"git", "add", "-f", s})
|
|
autogen = append(autogen, s)
|
|
}
|
|
} else {
|
|
log.Info("\tIsProtobuf() == false")
|
|
}
|
|
all = append(all, []string{"git", "commit", "-m", me.releaseReasonS})
|
|
all = append(all, []string{"git", "push"})
|
|
all = append(all, []string{"git", "tag", "-m", me.releaseReasonS, me.release.version.String()})
|
|
all = append(all, []string{"git", "push", "origin", me.release.version.String()})
|
|
|
|
// save the autogenerated files in git metadata (aka: notes)
|
|
cname := check.GetCurrentBranchName()
|
|
if err := check.AutogenSave(autogen, cname, true); err != nil {
|
|
log.Info("AutogenSave() error", err)
|
|
msg := fmt.Sprint("AutogenSave() error", err)
|
|
badExit(errors.New(msg))
|
|
}
|
|
|
|
if !me.current.RunAll(all) {
|
|
log.Info("failed to make new release", me.release.version.String())
|
|
findOk = false
|
|
return false
|
|
}
|
|
log.Info("RELEASE OK")
|
|
|
|
// 'publish' the version to the golang package versioning system
|
|
if !doPublishVersion() {
|
|
time.Sleep(3 * time.Second)
|
|
// this can fail to update, try it again after sleep(3s)
|
|
if !doPublishVersion() {
|
|
log.Info("PUBLISH FAILED")
|
|
findOk = false
|
|
return false
|
|
}
|
|
}
|
|
|
|
log.Info("PUBLISH OK")
|
|
// me.current.SetGoState("RELEASED")
|
|
|
|
// unwind and re-tag. Now that the go.mod and go.sum are published, revert
|
|
// to the development branch
|
|
if !me.current.RevertMasterToDevel() {
|
|
log.Info("Revert Failed")
|
|
findOk = false
|
|
return false
|
|
}
|
|
|
|
// update tag
|
|
var retag [][]string
|
|
retag = append(retag, []string{"git", "tag", "--delete", me.release.version.String()})
|
|
retag = append(retag, []string{"git", "push", "--delete", "origin", me.release.version.String()})
|
|
retag = append(retag, []string{"git", "tag", "-m", me.releaseReasonS, me.release.version.String()})
|
|
retag = append(retag, []string{"git", "push", "origin", me.release.version.String()})
|
|
|
|
if err := check.AutogenRestore(cname); err != nil {
|
|
log.Info("AutogenRestore() failed", err)
|
|
} else {
|
|
cmd := []string{"git", "push", "origin", "refs/notes/*:refs/notes/*"}
|
|
check.Run(cmd)
|
|
}
|
|
|
|
if !me.current.RunAll(retag) {
|
|
log.Info("retag failed")
|
|
findOk = false
|
|
return false
|
|
}
|
|
log.Info("EVERYTHING OK. RERELEASED", me.current.GetGoPath())
|
|
|
|
// save autogen files under the tag version (for example: "v0.2.3")
|
|
newtag := me.release.version.String()
|
|
if err := check.AutogenSave(autogen, newtag, true); err != nil {
|
|
log.Info("AutogenSave() error", err)
|
|
msg := fmt.Sprint("AutogenSave() error", err)
|
|
badExit(errors.New(msg))
|
|
}
|
|
|
|
printDone()
|
|
log.Info("sleep 2, then Reload()", check.GetGoPath())
|
|
time.Sleep(2 * time.Second) // notsure
|
|
check.Reload()
|
|
|
|
// run this each time something gets published successfully
|
|
rePrepareRelease()
|
|
|
|
// attempt to find another repo to release
|
|
if !doReleaseFindNext() {
|
|
log.Info("doReleaseFindNext() could not find a new", findCounter)
|
|
log.Info("THIS PROBABLY MEANS THAT ACTUALLY WE ARE TOTALLY DONE?", findCounter)
|
|
count := me.forge.PrintReleaseReport(me.found)
|
|
log.Info("count =", count)
|
|
os.Setenv("FindNextDone", "true")
|
|
printDone()
|
|
return false
|
|
}
|
|
log.Info("GOOD TO RUN ANOTHER DAY ON:", me.current.GetGoPath())
|
|
printDone()
|
|
return true
|
|
}
|
|
|
|
// try to figure out if there is another package to update
|
|
// returns true if it finds something
|
|
func doReleaseFindNext() bool {
|
|
// scan for new repo
|
|
if findNext() {
|
|
log.Info("findNext() found something")
|
|
} else {
|
|
// this means findNext() didn't find anything but there are
|
|
// still packages to release. start trying to fix the go.sum files
|
|
if findCounter != 0 {
|
|
findFix = true
|
|
}
|
|
log.Info("findNext() could not find anything")
|
|
return false
|
|
}
|
|
check := me.forge.FindByGoPath(me.current.GetGoPath())
|
|
if check == nil {
|
|
log.Info("boo, you didn't git clone", me.current.GetGoPath())
|
|
return false
|
|
}
|
|
if findFix {
|
|
fixGodeps(check)
|
|
}
|
|
if me.forge.FinalGoDepsCheckOk(check, false) {
|
|
// the go.sum file is ok to release
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// this pulls the new tag from the golang package repository
|
|
// to insert the new version
|
|
func doPublishVersion() bool {
|
|
gopath := me.current.GetGoPath()
|
|
docmd := []string{"go", "get", "-v", gopath + "@" + me.release.version.String()}
|
|
log.Info("SHOULD RUN cmd HERE:", docmd)
|
|
|
|
if me.forge.Config.IsPrivate(me.current.GetGoPath()) {
|
|
// do not self update private repos
|
|
log.Info("This is a private repo and can not be self checked")
|
|
return true
|
|
}
|
|
|
|
// try to pull from google
|
|
if gopath == me.startRepo.GetGoPath() {
|
|
log.Info("CAN NOT SELF UPDATE. cmd =", docmd)
|
|
log.Info("go get must be run from somewhere else other than startRepo")
|
|
log.Info("chdir to autotypist if it exists")
|
|
msg := fmt.Sprint("CAN NOT SELF UPDATE. cmd =", docmd)
|
|
badExit(errors.New(msg))
|
|
}
|
|
// publish go.mod & go.sum for use with go
|
|
os.Unsetenv("GO111MODULE")
|
|
log.Info("TRYING TO SELF UPDATE HERE. cmd =", docmd)
|
|
result := me.startRepo.Run(docmd)
|
|
|
|
if result.Error != nil {
|
|
log.Info("SELF UPDATE FAILED. error =", result.Error)
|
|
log.Info("SELF UPDATE FAILED. exit =", result.Exit)
|
|
log.Info("SELF UPDATE FAILED. out =", result.Stdout)
|
|
log.Info("SELF UPDATE FAILED")
|
|
return false
|
|
}
|
|
if result.Exit != 0 {
|
|
log.Info("SELF UPDATE FAILED. error =", result.Error)
|
|
log.Info("SELF UPDATE FAILED. exit =", result.Exit)
|
|
log.Info("SELF UPDATE FAILED. out =", result.Stdout)
|
|
log.Info("SELF UPDATE FAILED")
|
|
return false
|
|
}
|
|
log.Info("SELF UPDATE OK. out =", strings.Join(result.Stdout, "\n"))
|
|
log.Info("SELF UPDATE WORKED")
|
|
return true
|
|
}
|