139 lines
3.4 KiB
Go
139 lines
3.4 KiB
Go
package forgepb
|
|
|
|
// for golang repos, this is an attempt to build the package
|
|
// there might be some 'standard' ways to implement a build
|
|
// that make sense.
|
|
|
|
// Additions to 'go build' that are attempted here:
|
|
//
|
|
// * detect packages that are plugins
|
|
// * autogen packages that have .proto protobuf files
|
|
// * define some 'standard' ldflags
|
|
//
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"go.wit.com/lib/protobuf/gitpb"
|
|
"go.wit.com/log"
|
|
)
|
|
|
|
func (f *Forge) Build(repo *gitpb.Repo, userFlags []string) error {
|
|
return f.doBuild(repo, userFlags, "build")
|
|
}
|
|
|
|
func (f *Forge) Install(repo *gitpb.Repo, userFlags []string) error {
|
|
return f.doBuild(repo, userFlags, "install")
|
|
}
|
|
|
|
func (f *Forge) doBuild(repo *gitpb.Repo, userFlags []string, goWhat string) error {
|
|
// always assume all sources have been downloaded
|
|
// todo: detect when in ~/go/src vs go.work mode
|
|
os.Setenv("GO111MODULE", "off")
|
|
defer os.Unsetenv("GO111MODULE")
|
|
|
|
// get the version
|
|
version := repo.GetCurrentBranchVersion()
|
|
|
|
/*
|
|
loop := repo.Tags.SortByRefname()
|
|
for loop.Scan() {
|
|
t := loop.Next()
|
|
log.Info("Build() tag:", t.Refname)
|
|
}
|
|
*/
|
|
|
|
if repo.GoDeps == nil {
|
|
repo.RedoGoMod()
|
|
}
|
|
if repo.GoDeps.Len() == 0 {
|
|
// eh, potentially runs it twice. don't care right now
|
|
log.Info("redo go.mod", repo.GetGoPath())
|
|
repo.RedoGoMod()
|
|
f.Repos.ConfigSave()
|
|
}
|
|
loop1 := repo.GoDeps.SortByGoPath()
|
|
for loop1.Scan() {
|
|
t := loop1.Next()
|
|
found := f.Repos.FindByGoPath(t.GetGoPath())
|
|
if found.RepoType() == "protobuf" {
|
|
if err := f.runAutogenpb(found); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
if repo.CheckDirty() {
|
|
version = version + "-dirty"
|
|
}
|
|
cmd := []string{"go", goWhat, "-v"}
|
|
|
|
// set standard ldflag options
|
|
now := time.Now()
|
|
datestamp := now.UTC().Format("2006/01/02_1504_UTC")
|
|
// log.Info("datestamp =", datestamp)
|
|
// add some standard golang flags
|
|
ldflags := "-X main.VERSION=" + version + " "
|
|
ldflags += "-X main.BUILDTIME=" + datestamp + " "
|
|
ldflags += "-X main.GUIVERSION=" + version + "" // todo: git this from the filesystem
|
|
cmd = append(cmd, "-ldflags", ldflags)
|
|
|
|
// add any flags from the command line
|
|
// this might not actually work
|
|
// todo: test this
|
|
for _, flag := range userFlags {
|
|
cmd = append(cmd, "-ldflags", "-X "+flag)
|
|
}
|
|
|
|
log.Info("running:", cmd)
|
|
result := repo.RunRealtime(cmd)
|
|
if result.Exit == 0 {
|
|
log.Info(strings.Join(result.Stdout, "\n"))
|
|
return nil
|
|
} else {
|
|
log.DaemonMode(true)
|
|
log.Info(strings.Join(result.Stdout, "\n"))
|
|
log.Info(strings.Join(result.Stderr, "\n"))
|
|
log.DaemonMode(false)
|
|
log.Warn("go build failed", cmd)
|
|
return errors.New("go build failed: " + fmt.Sprint(result.Error))
|
|
}
|
|
}
|
|
|
|
func (f *Forge) runAutogenpb(repo *gitpb.Repo) error {
|
|
// log.Info("run autogenpb here:", repo.GetGoPath())
|
|
files, err := repo.GetProtoFiles()
|
|
if err != nil {
|
|
log.Info("gitpb.GetProtoFiles()", err)
|
|
return err
|
|
}
|
|
for _, s := range files {
|
|
_, filename := filepath.Split(s)
|
|
pbfile := strings.TrimSuffix(filename, ".proto") + ".pb.go"
|
|
cmd := []string{"autogenpb", "--proto", filename}
|
|
if repo.Exists(pbfile) {
|
|
// log.Info("skip running:", cmd)
|
|
continue
|
|
}
|
|
log.Info("running:", cmd)
|
|
r := repo.RunRealtime(cmd)
|
|
if r.Error != nil {
|
|
log.Warn("")
|
|
log.Warn("autogenpb error", r.Error)
|
|
log.Warn("")
|
|
log.Warn("You might be missing autogenpb?")
|
|
log.Warn("")
|
|
log.Warn("To install it run: go install go.wit.com/apps/autogenpb@latest")
|
|
log.Warn("")
|
|
log.Sleep(2)
|
|
return r.Error
|
|
}
|
|
}
|
|
return nil
|
|
}
|