500 lines
16 KiB
Go
500 lines
16 KiB
Go
// ======================================================================================= go toolbox (mwx'2026)
|
|
package main
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/AlecAivazis/survey/v2"
|
|
"github.com/AlecAivazis/survey/v2/core"
|
|
"github.com/AlecAivazis/survey/v2/terminal"
|
|
"github.com/Masterminds/semver/v3"
|
|
"github.com/eknkc/basex"
|
|
"github.com/fatih/color"
|
|
"github.com/mgutz/ansi"
|
|
"github.com/minio/selfupdate"
|
|
"github.com/spf13/viper"
|
|
"github.com/tidwall/gjson"
|
|
)
|
|
|
|
var tbversion = "0.7.0"
|
|
|
|
var HTTPTIMEOUT = 3 * time.Second // version.txt / checksums.txt - must never stall a build
|
|
var DOWNLOADTIMEOUT = 10 * time.Minute // the binary itself, http.Client.Timeout covers the whole body
|
|
|
|
var CHRS = "VW9IdGJ6eXh1T25DRHdrc2M5MlhOQVNQcEJFWnJhWVY2ZEowaFJLdmoxNUdxVDRJZkZpTTdRZW0zTFc4Z2w="
|
|
var LR = []rune("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
|
|
|
|
func checkforupdate(URL string) { // ----------------------------------------------------- check for new version
|
|
prg := prgname()
|
|
client := &http.Client{Timeout: HTTPTIMEOUT}
|
|
|
|
body, err := fetch(client, URL+"/version.txt", 1<<20) // update server unreachable: never block the build
|
|
if err != nil { return }
|
|
|
|
lversion := strings.TrimSpace(string(body)) // exactly as published - it names the artifact
|
|
sv_version, err := semver.NewVersion(version)
|
|
if err != nil { return }
|
|
sv_lversion, err := semver.NewVersion(lversion)
|
|
if err != nil { return }
|
|
if !sv_lversion.GreaterThan(sv_version) { return }
|
|
|
|
if !Yesno(SF("new '%s' version found (%s -> %s), update now?",prg,sv_version,lversion),true,false) {
|
|
return
|
|
}
|
|
|
|
target := SF("%s_%s_%s_%s",prg,lversion,runtime.GOOS,runtime.GOARCH)
|
|
if runtime.GOOS == "windows" { target += ".exe" }
|
|
|
|
sum, err := getchecksum(client, URL+"/checksums.txt", target) // no checksum -> no update
|
|
if err != nil {
|
|
PE("update aborted", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
|
|
if err := doupdate(&http.Client{Timeout: DOWNLOADTIMEOUT}, URL+"/"+target, sum); err != nil {
|
|
PE("update failed", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
PO("update successful","please run your last command again")
|
|
os.Exit(0)
|
|
}
|
|
|
|
func doupdate(client *http.Client, url string, checksum []byte) error { // --------------------------- do update
|
|
resp, err := client.Get(url)
|
|
if err != nil { return err }
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK { return SE("server returned status: %v", resp.Status) }
|
|
return selfupdate.Apply(resp.Body, selfupdate.Options{Checksum: checksum})
|
|
}
|
|
|
|
func getchecksum(client *http.Client, url string, name string) ([]byte, error) { // -- sha256 of a published file
|
|
body, err := fetch(client, url, 1<<20)
|
|
if err != nil { return nil, SE("no checksums published (%v)", err) }
|
|
|
|
for _, line := range strings.Split(string(body), "\n") {
|
|
f := strings.Fields(line)
|
|
if len(f) == 2 && f[1] == name {
|
|
sum, err := hex.DecodeString(f[0])
|
|
if err != nil { return nil, SE("bad checksum for %s", name) }
|
|
return sum, nil
|
|
}
|
|
}
|
|
return nil, SE("no checksum for %s", name)
|
|
}
|
|
|
|
func fetch(client *http.Client, url string, max int64) ([]byte, error) { // ------------------- fetch a small file
|
|
resp, err := client.Get(url)
|
|
if err != nil { return nil, err }
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK { return nil, SE("server returned status: %v", resp.Status) }
|
|
return io.ReadAll(io.LimitReader(resp.Body, max))
|
|
}
|
|
|
|
func checkaccess(NETS []string) { // ------------------------------------------------- check ip net based access
|
|
match:=0;
|
|
addrs, err := net.InterfaceAddrs()
|
|
if err != nil { PE("Error getting addresses", err.Error()); os.Exit(1) }
|
|
|
|
for _, validnet := range NETS {
|
|
_, ipNet, err := net.ParseCIDR(validnet)
|
|
if err != nil { PE("invalid network", validnet); continue }
|
|
for _, address := range addrs {
|
|
if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
|
|
if ipnet.IP.To4() != nil {
|
|
if (ipNet.Contains(ipnet.IP)) { match++ }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (match==0) { PE("access violation, permission denied"); os.Exit(1) }
|
|
}
|
|
|
|
|
|
func Enc(str string) string { // ----------------------------------------------------------------- encode string
|
|
enc, _ := basex.NewEncoding(Db64(CHRS))
|
|
return enc.Encode([]byte(Rndstr(2) + str))
|
|
}
|
|
|
|
func Dec(str string) string { // ----------------------------------------------------------------- decode string
|
|
enc, err := basex.NewEncoding(Db64(CHRS))
|
|
if err != nil { return "" }
|
|
b, err := enc.Decode(str)
|
|
if err != nil || len(b) < 2 { return "" }
|
|
return string(b[2:])
|
|
}
|
|
|
|
func Db64(txt string) string { // ------------------------------------------------------------- string to base64
|
|
d, _ := base64.StdEncoding.DecodeString(txt)
|
|
return string(d)
|
|
}
|
|
|
|
func Rndstr(n int) string { // ------------------------------------------------------- random string with length
|
|
b := make([]rune, n)
|
|
for i := range b {
|
|
n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(LR))))
|
|
b[i] = LR[n.Int64()]
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func Input(msg string, def string) string { // -------------------------------- AlecAivazis/survey: input string
|
|
tmp := ""
|
|
err := survey.AskOne(&survey.Input{Message: msg, Default: def}, &tmp)
|
|
if err != nil {
|
|
if err == terminal.InterruptErr {
|
|
P(Crb("Interrupted."))
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
return tmp
|
|
}
|
|
|
|
func Inputpw(msg string) string { // ---------------------------------------- AlecAivazis/survey: input password
|
|
tmp := ""
|
|
err := survey.AskOne(&survey.Password{Message: msg}, &tmp)
|
|
if err != nil {
|
|
if err == terminal.InterruptErr {
|
|
P(Crb("Interrupted."))
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
return tmp
|
|
}
|
|
|
|
func Yesno(msg string, def bool, overwrite bool) bool { // -------------------------- AlecAivazis/survey: yes/no
|
|
|
|
if (overwrite) { return true }
|
|
|
|
var err error
|
|
tmp := ""
|
|
if def {
|
|
err = survey.AskOne(&survey.Select{Message: msg, Options: []string{"Yes", "No"}}, &tmp)
|
|
} else {
|
|
err = survey.AskOne(&survey.Select{Message: msg, Options: []string{"No", "Yes"}}, &tmp)
|
|
}
|
|
|
|
if err != nil {
|
|
if err == terminal.InterruptErr {
|
|
P(Crb("Interrupted."))
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
|
|
if tmp == "Yes" {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
func Getid(n int) string { // --------------------------------------------------------- get base62 random string
|
|
const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
|
ret := make([]byte, n)
|
|
for i := 0; i < n; i++ {
|
|
num, _ := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))
|
|
ret[i] = letters[num.Int64()]
|
|
}
|
|
return string(ret)
|
|
}
|
|
|
|
func GETid(n int) string { // --------------------------------------------------------- get base36 random string
|
|
const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
ret := make([]byte, n)
|
|
for i := 0; i < n; i++ {
|
|
num, _ := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))
|
|
ret[i] = letters[num.Int64()]
|
|
}
|
|
return string(ret)
|
|
}
|
|
|
|
func Mytable(rows *sql.Rows) []map[string]interface{} { // ----------------------------- load mysql result table
|
|
defer rows.Close()
|
|
columns, err := rows.Columns()
|
|
if err != nil { return nil }
|
|
count := len(columns)
|
|
tableData := make([]map[string]interface{}, 0)
|
|
values := make([]interface{}, count)
|
|
valuePtrs := make([]interface{}, count)
|
|
for rows.Next() {
|
|
for i := 0; i < count; i++ {
|
|
valuePtrs[i] = &values[i]
|
|
}
|
|
if err := rows.Scan(valuePtrs...); err != nil { break }
|
|
entry := make(map[string]interface{})
|
|
for i, col := range columns {
|
|
var v interface{}
|
|
val := values[i]
|
|
b, ok := val.([]byte)
|
|
if ok {
|
|
v = string(b)
|
|
} else {
|
|
v = val
|
|
}
|
|
entry[col] = v
|
|
}
|
|
tableData = append(tableData, entry)
|
|
}
|
|
return (tableData)
|
|
}
|
|
|
|
func Checkip(network string, ip string) bool { // ---------- check if ip is in range (cidr address or single ip)
|
|
if net.ParseIP(ip) == nil {
|
|
return false
|
|
}
|
|
_, subnet, err := net.ParseCIDR(network)
|
|
if err == nil {
|
|
if subnet.Contains(net.ParseIP(ip)) {
|
|
return true
|
|
}
|
|
} else {
|
|
if network == ip {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func Isflagpassed(name string) bool { // -------------------------------------------------- check if flag is set
|
|
found := false
|
|
flag.Visit(func(f *flag.Flag) {
|
|
if f.Name == name {
|
|
found = true
|
|
}
|
|
})
|
|
return found
|
|
}
|
|
|
|
func Body(r *http.Response) string { // ------------------------------------------------------------ http body
|
|
defer r.Body.Close()
|
|
body, err := io.ReadAll(r.Body)
|
|
if err == nil {
|
|
return string(body)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func Atoi(s string) int { // ------------------------------------------------------------------------------ atoi
|
|
i, err := strconv.Atoi(s)
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
return i
|
|
}
|
|
|
|
func Itoa(i int) string { // ------------------------------------------------------------------------------ itoa
|
|
return strconv.Itoa(i)
|
|
}
|
|
|
|
func GJA(j string, k string) []string { // -------------------------------------------------- convert gjson array
|
|
var ret []string
|
|
for _, c := range gjson.Get(j, k).Array() {
|
|
ret = append(ret, c.String())
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ print simple
|
|
|
|
func P(a ...any) (n int, err error) { return fmt.Fprintln(os.Stdout, a...) }
|
|
func PN(a ...any) (n int, err error) { return fmt.Fprint(os.Stdout, a...) }
|
|
func PF(format string, a ...any) (n int, err error) { return fmt.Fprintf(os.Stdout, format, a...) }
|
|
func SF(format string, a ...any) string { return fmt.Sprintf(format, a...) }
|
|
func SE(format string, a ...any) error { return fmt.Errorf(format, a...) }
|
|
|
|
func PE(msg ...string) (n int, err error) {
|
|
if (len(msg)==0) { return 0, nil }
|
|
if (len(msg)>=2) { return fmt.Fprintf(os.Stdout, "%s: %s (%s)\n", Crb("ERROR"), Cwb(msg[0]),msg[1]) }
|
|
return fmt.Fprintf(os.Stdout, "%s: %s\n", Crb("ERROR"), Cwb(msg[0]))
|
|
}
|
|
func PO(msg ...string) (n int, err error) {
|
|
if (len(msg)==0) { return 0, nil }
|
|
if (len(msg)>=2) { return fmt.Fprintf(os.Stdout, "%s: %s (%s)\n", Cgb("OK"), Cwb(msg[0]),msg[1]) }
|
|
return fmt.Fprintf(os.Stdout, "%s: %s\n", Cgb("OK"), Cwb(msg[0]))
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------ regular expression
|
|
|
|
func ReplaceFirst(re *regexp.Regexp, str, replace string) string {
|
|
loc := re.FindStringIndex(str)
|
|
if loc == nil { return str }
|
|
return str[:loc[0]] + replace + str[loc[1]:]
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------- string functions
|
|
|
|
func Shortstr(s string, length int) string {
|
|
runes := []rune(s)
|
|
if len(runes) <= length {
|
|
return s
|
|
}
|
|
if length <= 2 {
|
|
return ".."
|
|
}
|
|
return string(runes[:length-2]) + ".."
|
|
}
|
|
|
|
func SR(str string, n int) string { return strings.Repeat(str, n) }
|
|
|
|
func RemoveAllMatches(slice []string, target string) []string { // remove matching string from array
|
|
result := make([]string, 0, len(slice)) // never modify the callers slice
|
|
for _, v := range slice {
|
|
if v != target {
|
|
result = append(result, v)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------- system functions
|
|
|
|
func prgname() string { // program name
|
|
exepath, err := os.Executable()
|
|
if err != nil {
|
|
PE(SF("Error getting executable path: %s", err))
|
|
return ""
|
|
}
|
|
exename := filepath.Base(exepath)
|
|
return strings.TrimSuffix(exename, ".exe") // windows: gbld.exe -> gbld
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------ viper abbrevations
|
|
|
|
func VX(key string) bool { return viper.IsSet(key) }
|
|
func VS(key string) string { return viper.GetString(key) }
|
|
func VSS(key string) []string { return viper.GetStringSlice(key) }
|
|
func VB(key string) bool { return viper.GetBool(key) }
|
|
func VI(key string) int { return viper.GetInt(key) }
|
|
|
|
// ------------------------------------------------------------------------------------------------- text colors
|
|
//
|
|
// catppuccin mocha - https://terminalcolors.com/themes/catppuccin/mocha/
|
|
// the palette is emitted as 24 bit color. terminals that do not announce truecolor via COLORTERM
|
|
// fall back to the basic ansi colors, so their own theme keeps deciding. NO_COLOR is honoured.
|
|
|
|
type rgb struct{ r, g, b int }
|
|
|
|
var ( // ------------------------------------------------------------------------- catppuccin mocha palette
|
|
CatRosewater = rgb{0xf5, 0xe0, 0xdc}
|
|
CatFlamingo = rgb{0xf2, 0xcd, 0xcd}
|
|
CatPink = rgb{0xf5, 0xc2, 0xe7}
|
|
CatMauve = rgb{0xcb, 0xa6, 0xf7}
|
|
CatRed = rgb{0xf3, 0x8b, 0xa8}
|
|
CatMaroon = rgb{0xeb, 0xa0, 0xac}
|
|
CatPeach = rgb{0xfa, 0xb3, 0x87}
|
|
CatYellow = rgb{0xf9, 0xe2, 0xaf}
|
|
CatGreen = rgb{0xa6, 0xe3, 0xa1}
|
|
CatTeal = rgb{0x94, 0xe2, 0xd5}
|
|
CatSky = rgb{0x89, 0xdc, 0xeb}
|
|
CatSapphire = rgb{0x74, 0xc7, 0xec}
|
|
CatBlue = rgb{0x89, 0xb4, 0xfa}
|
|
CatLavender = rgb{0xb4, 0xbe, 0xfe}
|
|
CatText = rgb{0xcd, 0xd6, 0xf4}
|
|
CatSubtext1 = rgb{0xba, 0xc2, 0xde}
|
|
CatSubtext0 = rgb{0xa6, 0xad, 0xc8}
|
|
CatOverlay1 = rgb{0x7f, 0x84, 0x9c}
|
|
CatSurface1 = rgb{0x45, 0x47, 0x5a}
|
|
)
|
|
|
|
var catansi = map[string]rgb{ // ------------------------------- how mocha fills the ansi slots (bright = normal)
|
|
"black": CatSurface1,
|
|
"red": CatRed,
|
|
"green": CatGreen,
|
|
"yellow": CatYellow,
|
|
"blue": CatBlue,
|
|
"magenta": CatPink,
|
|
"cyan": CatTeal,
|
|
"white": CatSubtext1,
|
|
"default": CatText,
|
|
}
|
|
|
|
func truecolor() bool { // ------------------------------------------ does the terminal understand 24 bit color
|
|
ct := strings.ToLower(os.Getenv("COLORTERM"))
|
|
return ct == "truecolor" || ct == "24bit"
|
|
}
|
|
|
|
func cfunc(c rgb, fallback color.Attribute, attrs ...color.Attribute) func(...interface{}) string {
|
|
col := color.New(attrs...)
|
|
if truecolor() {
|
|
col.AddRGB(c.r, c.g, c.b)
|
|
} else {
|
|
col.Add(fallback)
|
|
}
|
|
return col.SprintFunc()
|
|
}
|
|
|
|
// mocha maps its ansi slots to red/green/yellow/blue/pink/teal, bright is identical to normal -
|
|
// so the bold variants keep the hue and only add weight, exactly as before.
|
|
|
|
var Cr func(...interface{}) string = cfunc(CatRed, color.FgRed)
|
|
var Cg func(...interface{}) string = cfunc(CatGreen, color.FgGreen)
|
|
var Cy func(...interface{}) string = cfunc(CatYellow, color.FgYellow)
|
|
var Cb func(...interface{}) string = cfunc(CatBlue, color.FgBlue)
|
|
var Cm func(...interface{}) string = cfunc(CatPink, color.FgMagenta)
|
|
var Cc func(...interface{}) string = cfunc(CatTeal, color.FgCyan)
|
|
var Cw func(...interface{}) string = cfunc(CatSubtext1, color.FgWhite)
|
|
|
|
var Crb func(...interface{}) string = cfunc(CatRed, color.FgRed, color.Bold)
|
|
var Cgb func(...interface{}) string = cfunc(CatGreen, color.FgGreen, color.Bold)
|
|
var Cyb func(...interface{}) string = cfunc(CatYellow, color.FgYellow, color.Bold)
|
|
var Cbb func(...interface{}) string = cfunc(CatBlue, color.FgBlue, color.Bold)
|
|
var Cmb func(...interface{}) string = cfunc(CatPink, color.FgMagenta, color.Bold)
|
|
var Ccb func(...interface{}) string = cfunc(CatTeal, color.FgCyan, color.Bold)
|
|
var Cwb func(...interface{}) string = cfunc(CatText, color.FgWhite, color.Bold) // text: the themes foreground
|
|
|
|
// ------------------------------------------------------------------------------------- survey prompt colors
|
|
//
|
|
// survey renders its prompts from templates that call {{color "green+hb"}} and friends, which normally
|
|
// ends up in mgutz/ansi - and that only speaks 16/256 colors. replacing the template function is enough
|
|
// to theme every prompt including its icons. survey computes its layout from a separate color free
|
|
// rendering, so the longer truecolor sequences cannot disturb the cursor placement.
|
|
|
|
func init() { core.TemplateFuncsWithColor["color"] = catcolor } // must run before the first prompt is parsed
|
|
|
|
func catcolor(style string) string { // ------------------------- mgutz/ansi style string -> catppuccin mocha
|
|
if style == "reset" {
|
|
return "\033[0m"
|
|
}
|
|
if !truecolor() || strings.Contains(style, ":") { // background colors stay with the original mapping
|
|
return ansi.ColorCode(style)
|
|
}
|
|
|
|
name, attrs, _ := strings.Cut(style, "+")
|
|
c, ok := catansi[name]
|
|
if !ok {
|
|
return ansi.ColorCode(style)
|
|
}
|
|
|
|
seq := ""
|
|
for _, a := range attrs { // 'h' (bright) is a no-op: mocha uses the same value for both
|
|
switch a {
|
|
case 'b':
|
|
seq += "1;"
|
|
case 'd':
|
|
seq += "2;"
|
|
case 'u':
|
|
seq += "4;"
|
|
case 'i':
|
|
seq += "7;"
|
|
}
|
|
}
|
|
return SF("\033[%s38;2;%d;%d;%dm", seq, c.r, c.g, c.b)
|
|
}
|
|
|
|
// ========================================================================================================= END |