launchr - build extra steps (prebuild script) (#42)

Author: iignatevich

app.go

@@ -1,8 +1,10 @@
 package launchr
 
 import (
+	"embed"
 	"errors"
 	"fmt"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -17,6 +19,10 @@ import (
 	_ "github.com/launchrctl/launchr/plugins" // include default plugins
 )
 
+var (
+	errTplAssetsNotFound = "assets not found for requested plugin %s"
+)
+
 // ActionsGroup is a cobra command group definition
 var ActionsGroup = &cobra.Group{
 	ID:    "actions",
@@ -31,17 +37,23 @@ type launchrCfg struct {
 }
 
 type appImpl struct {
-	rootCmd     *cobra.Command
-	streams     cli.Streams
-	workDir     string
-	cfgDir      string
-	services    map[ServiceInfo]Service
-	actionMngr  action.Manager
-	pluginMngr  PluginManager
-	config      Config
-	mFS         []ManagedFS
+	rootCmd       *cobra.Command
+	streams       cli.Streams
+	workDir       string
+	cfgDir        string
+	services      map[ServiceInfo]Service
+	actionMngr    action.Manager
+	pluginMngr    PluginManager
+	config        Config
+	mFS           []ManagedFS
 	skipActions bool   // skipActions to skip loading if not requested.
 	reqCmd      string // reqCmd to search for the requested cobra command.
+	assetsStorage embed.FS
+}
+
+// AppOptions represents the launchr application options.
+type AppOptions struct {
+	AssetsFs embed.FS
 }
 
 // getPluginByType returns specific plugins from the app.
@@ -70,8 +82,8 @@ func getPluginByType[T Plugin](app *appImpl) []T {
 	return res
 }
 
-func newApp() *appImpl {
-	return &appImpl{}
+func newApp(options *AppOptions) *appImpl {
+	return &appImpl{assetsStorage: options.AssetsFs}
 }
 
 func (app *appImpl) Name() string         { return name }
@@ -115,6 +127,27 @@ func (app *appImpl) GetService(v interface{}) {
 	panic(fmt.Sprintf("service %q does not exist", stype))
 }
 
+func (app *appImpl) GetPluginAssets(p Plugin) fs.FS {
+	pluginsMap := app.pluginMngr.All()
+	var packagePath string
+	for pi, plg := range pluginsMap {
+		if plg == p {
+			packagePath = pi.GetPackagePath()
+		}
+	}
+
+	if packagePath == "" {
+		panic(errors.New("trying to get assets for unknown plugin"))
+	}
+
+	subFS, err := fs.Sub(app.assetsStorage, filepath.Join("assets", packagePath))
+	if err != nil {
+		panic(fmt.Errorf(errTplAssetsNotFound, packagePath))
+	}
+
+	return subFS
+}
+
 // init initializes application and plugins.
 func (app *appImpl) init() error {
 	var err error
@@ -285,6 +318,6 @@ func (app *appImpl) Execute() int {
 }
 
 // Run executes launchr application.
-func Run() int {
-	return newApp().Execute()
+func Run(options *AppOptions) int {
+	return newApp(options).Execute()
 }

cmd/launchr/launchr.go

@@ -11,5 +11,5 @@ import (
 )
 
 func main() {
-	os.Exit(launchr.Run())
+	os.Exit(launchr.Run(&launchr.AppOptions{}))
 }

gen.go

@@ -98,7 +98,7 @@ func (app *appImpl) Generate() int {
 
 // Gen generates application specific build files and returns os exit code.
 func Gen() int {
-	return newApp().Generate()
+	return newApp(&AppOptions{}).Generate()
 }
 
 type initTplVars struct {

internal/launchr/types.go

@@ -26,6 +26,8 @@ type App interface {
 	// GetService retrieves a service of type v and assigns it to v.
 	// Panics if a service is not found.
 	GetService(v interface{})
+
+	GetPluginAssets(p Plugin) fs.FS
 	// RegisterFS registers a File System in launchr.
 	// It may be a FS for action discovery, see action.DiscoveryFS.
 	RegisterFS(fs ManagedFS)
@@ -57,6 +59,11 @@ func (p PluginInfo) String() string {
 	return p.pkgPath + "." + p.typeName
 }
 
+// GetPackagePath returns the package path of the PluginInfo.
+func (p PluginInfo) GetPackagePath() string {
+	return p.pkgPath
+}
+
 // InitPluginInfo sets private fields for internal usage only.
 func InitPluginInfo(pi *PluginInfo, p Plugin) {
 	pi.pkgPath, pi.typeName = GetTypePkgPathName(p)

plugins/builder/builder.go

@@ -5,11 +5,14 @@ import (
 	"embed"
 	"fmt"
 	"os"
+	"path"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"text/template"
 
+	"golang.org/x/mod/module"
+
 	"github.com/launchrctl/launchr/internal/launchr"
 	"github.com/launchrctl/launchr/pkg/cli"
 	"github.com/launchrctl/launchr/pkg/log"
@@ -152,6 +155,13 @@ func (b *Builder) Build(ctx context.Context) error {
 		return err
 	}
 
+	// prebuild
+	cli.Println("Executing prebuild scripts")
+	err = b.preBuild(ctx)
+	if err != nil {
+		return err
+	}
+
 	// Build the main go package.
 	cli.Println("Building %s", b.PkgName)
 	err = b.goBuild(ctx)
@@ -210,6 +220,101 @@ func (b *Builder) goBuild(ctx context.Context) error {
 	return nil
 }
 
+func (b *Builder) preBuild(ctx context.Context) error {
+	output, err := b.env.execGoList(ctx)
+	if err != nil {
+		return err
+	}
+
+	pluginVersionMap := make(map[string]string)
+	lines := strings.Split(output, "\n")
+	for _, line := range lines {
+		pv := strings.Split(line, " ")
+		for _, p := range b.BuildOptions.Plugins {
+			if strings.Contains(pv[0], p.Path) {
+				pluginVersionMap[p.Path] = pv[1]
+				continue
+			}
+		}
+	}
+
+	assetsPath := filepath.Join(b.wd, b.env.wd, "assets")
+	buildName := filepath.Base(b.env.wd)
+	err = os.MkdirAll(assetsPath, 0750)
+	if err != nil {
+		return err
+	}
+
+	for pluginName, v := range pluginVersionMap {
+		packagePath, _ := getModulePath(pluginName, v)
+		if _, err = os.Stat(packagePath); os.IsNotExist(err) {
+			log.Debug("you don't have this module/version installed (%s)", packagePath)
+			continue
+		}
+
+		// check if prebuild script exists.
+		prebuildScriptPath := filepath.Join(packagePath, "scripts", "prebuild.go")
+		if _, err = os.Stat(prebuildScriptPath); os.IsNotExist(err) {
+			log.Debug("prebuild script does not exist for %s, skipping", pluginName)
+			continue
+		}
+
+		tmpPath := filepath.Join(os.TempDir(), buildName, filepath.Base(pluginName))
+
+		// clean tmp folder if it existed before.
+		err = os.RemoveAll(tmpPath)
+		if err != nil {
+			return err
+		}
+
+		// prepare tmp folder for assets and force prebuild script to push data there.
+		err = os.MkdirAll(tmpPath, 0750)
+		if err != nil {
+			return err
+		}
+
+		log.Debug("executing prebuild script for plugin %s", pluginName)
+		cmd := b.env.NewCommand(ctx, b.env.Go(), "run", "scripts/prebuild.go", v, tmpPath)
+		cmd.Dir = packagePath
+
+		err = b.env.RunCmd(ctx, cmd)
+		if err != nil {
+			return err
+		}
+
+		// prepare plugin assets folder.
+		pluginAssetsPath := filepath.Join(assetsPath, pluginName)
+		err = os.MkdirAll(pluginAssetsPath, 0750)
+		if err != nil {
+			return err
+		}
+
+		if _, err = os.Stat(pluginAssetsPath); err == nil {
+			err = os.Remove(pluginAssetsPath)
+			if err != nil {
+				return err
+			}
+		}
+
+		// move assets from tmp dir to assets folder.
+		err = os.Rename(tmpPath, pluginAssetsPath)
+		if err != nil {
+			return err
+		}
+	}
+
+	// create empty .info file for embed.
+	// prevent embed error in case of 0 assets in folder.
+	file, err := os.Create(filepath.Clean(filepath.Join(assetsPath, ".info")))
+	if err != nil {
+		fmt.Println(err.Error())
+		os.Exit(2)
+	}
+	defer file.Close()
+
+	return nil
+}
+
 func (b *Builder) runGen(ctx context.Context) error {
 	genArgs := []string{"generate", "./..."}
 	cmd := b.env.NewCommand(ctx, b.env.Go(), genArgs...)
@@ -221,3 +326,22 @@ func (b *Builder) runGen(ctx context.Context) error {
 	cmd.Env = env
 	return b.env.RunCmd(ctx, cmd)
 }
+
+func getModulePath(name, version string) (string, error) {
+	cache, ok := os.LookupEnv("GOMODCACHE")
+	if !ok {
+		cache = path.Join(os.Getenv("GOPATH"), "pkg", "mod")
+	}
+
+	escapedPath, err := module.EscapePath(name)
+	if err != nil {
+		return "", err
+	}
+
+	escapedVersion, err := module.EscapeVersion(version)
+	if err != nil {
+		return "", err
+	}
+
+	return path.Join(cache, escapedPath+"@"+escapedVersion), nil
+}

plugins/builder/environment.go

@@ -4,6 +4,7 @@ package builder
 import (
 	"bytes"
 	"context"
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -173,6 +174,25 @@ func (env *buildEnvironment) execGoGet(ctx context.Context, args ...string) erro
 	return env.RunCmd(ctx, cmd)
 }
 
+func (env *buildEnvironment) execGoList(ctx context.Context, args ...string) (string, error) {
+	cmd := env.NewCommand(ctx, env.Go(), append([]string{"list", "-m", "all"}, args...)...)
+	cmd.Stdout = nil
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return "", err
+	}
+
+	var outputText string
+	go func() {
+		outputBytes, _ := io.ReadAll(stdout)
+		outputText = string(outputBytes)
+	}()
+
+	err = env.RunCmd(ctx, cmd)
+	return outputText, err
+}
+
 func (env *buildEnvironment) RunCmd(ctx context.Context, cmd *exec.Cmd) error {
 	log.Debug("Executing shell: %s", cmd)
 	log.Debug("Shell env variables: %s", cmd.Env)

plugins/builder/tmpl/main.tmpl

@@ -4,6 +4,7 @@ package main
 
 import (
 	"os"
+	"embed"
 
 	"{{.CorePkg.Path}}"
 	_ "{{.PkgName}}/gen"
@@ -12,6 +13,9 @@ import (
 	{{- end}}
 )
 
+//go:embed assets/*
+var assets embed.FS
+
 func main() {
-	os.Exit(launchr.Run())
+	os.Exit(launchr.Run(&launchr.AppOptions{AssetsFs: assets}))
 }