151 lines
2.8 KiB
Go
151 lines
2.8 KiB
Go
// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
|
|
// Use of this source code is governed by the GPL 3.0
|
|
|
|
package main
|
|
|
|
import (
|
|
"debug/buildinfo"
|
|
"embed"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"plugin"
|
|
"unicode"
|
|
|
|
"go.wit.com/dev/alexflint/arg"
|
|
"go.wit.com/gui"
|
|
"go.wit.com/log"
|
|
)
|
|
|
|
// sent via -ldflags
|
|
var VERSION string
|
|
var BUILDTIME string
|
|
|
|
// used for shell auto completion
|
|
var ARGNAME string = "fixup" // todo: get this from $0 ?
|
|
|
|
//go:embed resources/*
|
|
var resources embed.FS
|
|
|
|
func main() {
|
|
me = new(autoType)
|
|
gui.InitArg()
|
|
me.pp = arg.MustParse(&argv)
|
|
|
|
// check if the binary is being called to test
|
|
// if the plugin can actually loaded. This is a hack
|
|
// around needing a Test() plugin load function in GO
|
|
if gui.IsGoPluginTestHack() {
|
|
gui.CheckPlugin()
|
|
os.Exit(0)
|
|
}
|
|
|
|
if argv.Bash {
|
|
argv.doBash()
|
|
os.Exit(0)
|
|
}
|
|
if len(argv.BashAuto) != 0 {
|
|
argv.doBashAuto()
|
|
os.Exit(0)
|
|
}
|
|
|
|
me.pb = NewBlocks()
|
|
|
|
/*
|
|
if argv.Drives != nil {
|
|
doDrives()
|
|
doDrives2()
|
|
}
|
|
*/
|
|
|
|
go listenForBlockEvents()
|
|
doGui()
|
|
okExit("everything compiled")
|
|
}
|
|
|
|
func doFixup() {
|
|
okExit("list drives")
|
|
}
|
|
|
|
// this is dumb. sync this with go-deb
|
|
func trimNonNumericFromStart(s string) string {
|
|
for i, r := range s {
|
|
if unicode.IsDigit(r) {
|
|
return s[i:]
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func okExit(thing string) {
|
|
if thing != "" {
|
|
log.Info(thing, "ok")
|
|
}
|
|
// log.Info("Finished go-clean on", check.GetGoPath(), "ok")
|
|
os.Exit(0)
|
|
}
|
|
|
|
func badExit(err error) {
|
|
log.Info("go-clean failed: ", err)
|
|
os.Exit(-1)
|
|
}
|
|
|
|
func dumpDebug() {
|
|
// Get absolute path of the currently running binary
|
|
exePath, err := os.Executable()
|
|
if err != nil {
|
|
log.Println("Error getting executable path:", err)
|
|
return
|
|
}
|
|
|
|
// Resolve symlinks if necessary
|
|
exePath, err = filepath.EvalSymlinks(exePath)
|
|
if err != nil {
|
|
log.Println("Error resolving symlink:", err)
|
|
return
|
|
}
|
|
|
|
// Read build info
|
|
bi, err := buildinfo.ReadFile(exePath)
|
|
if err != nil {
|
|
log.Println("Error reading build info:", err)
|
|
return
|
|
}
|
|
|
|
log.Println("Go Version:", bi.GoVersion)
|
|
for _, dep := range bi.Deps {
|
|
log.Printf("Dependency: %s %s\n", dep.Path, dep.Version)
|
|
}
|
|
}
|
|
|
|
func checkPlug(pluginPath string) *plugin.Plugin {
|
|
if err := checkPluginViaSubprocess(pluginPath); err != nil {
|
|
log.Printf("Plugin check failed: %v\n", err)
|
|
return nil
|
|
}
|
|
|
|
p, err := plugin.Open(pluginPath)
|
|
if err != nil {
|
|
log.Fatalf("plugin.Open failed: %v", err)
|
|
}
|
|
|
|
log.Println("Plugin loaded successfully.")
|
|
return p
|
|
}
|
|
|
|
func checkPluginViaSubprocess(path string) error {
|
|
exe, err := os.Executable()
|
|
if err != nil {
|
|
return log.Errorf("failed to get executable path: %w", err)
|
|
}
|
|
resolved, err := filepath.EvalSymlinks(exe)
|
|
if err != nil {
|
|
return log.Errorf("failed to resolve executable symlink: %w", err)
|
|
}
|
|
|
|
cmd := exec.Command(resolved, "--gui-check-plugin", path)
|
|
cmd.Stdout = os.Stdout
|
|
cmd.Stderr = os.Stderr
|
|
return cmd.Run()
|
|
}
|