guireleaser/doRelease.go

// This is a simple example
package main

import (
	"os"
	"strings"

	"go.wit.com/log"
)

func doRelease() bool {
	if release.releaseVersionB.String() != "release version "+release.version.String() {
		log.Warn("something went wrong with the release.version:", release.version.String())
		return false
	}
	if strings.HasPrefix(release.version.String(), "v") {
		log.Warn("everything is ok. version starts with v.", release.version.String())
	} else {
		log.Warn("version does not start with v.", release.version.String())
		return false
	}
	switch release.status.String() {
	case "PRIMATIVE":
		log.Warn("can do PRIMATIVE", release.version.String())
	case "GOOD":
		log.Warn("GOOD. lots of go.sum checks passed", release.version.String())
	case "manually chosen":
		log.Warn("attempting manual release", release.version.String())
	case "NOT READY":
		log.Warn("attempting to release. TODO: recheck go.sum here", release.version.String())
		log.Warn("Sleep 10")
		log.Sleep(10)
	case "UNRELEASED":
		log.Warn("attempting to release. TODO: dig deep on go.sum here", release.version.String())
		log.Warn("Sleep 10")
		log.Sleep(10)
	default:
		log.Warn("what is this?", release.version.String(), release.status.String())
		return false
	}

	if release.current.status.ReadOnly() {
		log.Info("sorry, it's read-only")
		return true
	}
	if release.current.status.CheckDirty() {
		log.Info("sorry, it's still dirty")
		return false
	}

	curName := release.current.status.GetCurrentBranchName()
	mName := release.current.status.GetMasterBranchName()
	if curName != mName {
		log.Info("\trepo is not working from main branch", curName, "!=", mName)
		return false
	}

	log.Info("\ttag and push", curName, release.version.String(), me.releaseReasonS)

	var all [][]string
	all = append(all, []string{"git", "add", "-f", "go.mod"})
	if release.current.status.CheckPrimativeGoMod() {
		// don't add go.sum here. TODO: check for go.sum file and fail
	} else {
		all = append(all, []string{"git", "add", "-f", "go.sum"})
	}
	all = append(all, []string{"git", "commit", "-m", me.releaseReasonS})
	all = append(all, []string{"git", "push"})
	all = append(all, []string{"git", "tag", "-m", me.releaseReasonS, release.version.String()})
	all = append(all, []string{"git", "push", "origin", release.version.String()})

	if doAll(release.current, all) {
		log.Info("EVERYTHING OK")

		gopath := release.current.String()
		cmd := []string{"go", "get", "-v", gopath + "@" + release.version.String()}
		log.Info("SHOULD RUN cmd HERE:", cmd)

		if release.guireleaser == nil {
			log.Info("CAN NOT SELF UPDATE HERE. cmd =", cmd)
			return false
		} else {
			os.Unsetenv("GO111MODULE")
			log.Info("TRYING TO SELF UPDATE HERE. cmd =", cmd)
			err, out := release.guireleaser.status.RunCmd(cmd)
			if gopath == "go.wit.com/apps/guireleaser" {
				// ignore errors on updating myself
				log.Info("IGNORE SELF UPDATE ERROR. cmd =", cmd)
				err = nil
			}
			if err == nil {
				log.Info("SELF UPDATE OK. out =", out)
				log.Info("SELF UPDATE WORKED")
				release.current.setGoSumStatus("RELEASED")

				release.current.status.UpdateCurrent()
				// repo.newScan()
				cbname := release.current.status.GetCurrentBranchName()
				cbversion := release.current.status.GetCurrentBranchVersion()
				lasttag := release.current.status.GetLastTagVersion()
				release.current.lastTag.SetLabel(lasttag)
				release.current.vLabel.SetLabel(cbname + " " + cbversion)

				// scan for new repo
				if findNextDirty("") {
					log.Info("findNextDirty() found something")
				} else {
					log.Info("findNextDirty() could not find anything")
					return false
				}
				release.current.status.CheckSafeGoSumRemake()
				if release.current.status.MakeRedomod() {
					log.Info("Redo mod ok")
				} else {
					log.Info("go mod tidy not ok")
					return false
				}
				if ok, _ := release.current.status.CheckGoSum(); ok {
					log.Info("repo has go.sum requirements that are clean")
					// release.current.setGoSumStatus("CLEAN")
					release.status.SetValue("GOOD")
					release.notes.SetValue("CheckGoSum() does not seem to lie")
					return true
				} else {
					return false
				}
			} else {
				log.Info("SELF UPDATE FAILED err =", err)
				log.Info("SELF UPDATE FAILED out =", out)
				return false
			}
		}
	}
	log.Info("doAll() failed")
	return false
}