cfgenv.go

package main

import (
	"bytes"
	cryrand "crypto/rand"
	"encoding/hex"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"regexp"
	"runtime"
	"strconv"
	"strings"

	rpc "github.com/glycerine/rpc25519"
)

// grab config from env

type TmSeconds int64 // time in seconds since epoch
type Ntm int64       // time in nanoseconds since epoch

func Tmsec2Ntm(t TmSeconds) Ntm {
	return Ntm(t) * 1e9
}
func MaxNtm(a, b Ntm) Ntm {
	if a >= b {
		return a
	}
	return b
}

// data flow:
//
// GOQ_HOME -> $GOQ_HOME/.goq/{clusterid, aes key, stored-disk-config}
type Config struct {
	SendTimeoutMsec     int    // GOQ_SENDTIMEOUT_MSEC
	RecvTimeoutMsec     int    // GOQ_RECVTIMEOUT_MSEC
	JservIP             string // GOQ_JSERV_IP
	JservPublicFacingIP string // make it easy for clients to configure to reach servers behind nat
	Home                string // GOQ_HOME
	Odir                string // GOQ_ODIR
	JservPort           int    // GOQ_JSERV_PORT

	ClusterId string // from GOQ_HOME/.goq/goqclusterid

	NoSshConfig bool       // GOQ_NOSSHCONFIG
	DebugMode   bool       // GOQ_DEBUGMODE
	Cypher      *CypherKey // from GOQ_HOME/.goq/aes
	UseQUIC     bool       // GOQ_USE_QUIC

	// for TestConfig; see NewTestConfig()
	origdir  string
	tempdir  string
	orighome string

	Heartbeat TmSeconds
}

func NewConfig() *Config {
	return &Config{}
}

func CopyConfig(cfg *Config) *Config {
	cp := *cfg
	return &cp
}

// DiskThenEnvConfig: the usual if you want to specify home, else use DefaultCfg()
func DiskThenEnvConfig(home string) (cfg *Config, err error) {
	// let the disk override env

	fallback := GetEnvConfig()
	cfg, _ = GetConfigFromFile(home, fallback) // ignore the error; might not be able to read cid if it isn't there yet.

	key, err := LoadKey(cfg)
	if err != nil {
		err = fmt.Errorf("problem with LoadKey(cfg): %s", err)
	}
	cfg.Cypher = key

	return cfg, err
}

func ErrorCheckedPwd() string {
	pwd, err := os.Getwd()
	if err != nil {
		panic(err)
	}
	return pwd
}

// DefaultCfg
//
//	convenience wrapper, most server creation calls should use this.
func DefaultCfg() *Config {
	pwd := ErrorCheckedPwd()
	cfg, err := DiskThenEnvConfig(pwd)
	if err != nil {
		// ignore errors from DiskThenEnv -- just couldn't find any extant .goqclusterid files.
		//fmt.Printf("cfg = %#v\n", cfg)
	}

	return cfg
}

var regexSplitEnv = regexp.MustCompile(`^([^=]*)[=](.*)$`)

func (cfg *Config) JservAddr() string {
	if cfg.UseQUIC {
		return fmt.Sprintf("udp://%s:%d", WrapWithBrackets(cfg.JservIP), cfg.JservPort)
	}
	return fmt.Sprintf("tcp://%s:%d", cfg.JservIP, cfg.JservPort)
}

func (cfg *Config) JservAddrNoProto() string {
	return fmt.Sprintf("%s:%d", cfg.JservIP, cfg.JservPort)
}

func (cfg *Config) Setenv(env []string) []string {

	e := EnvToMap(env)

	e["GOQ_SENDTIMEOUT_MSEC"] = fmt.Sprintf("%d", cfg.SendTimeoutMsec)
	e["GOQ_RECVTIMEOUT_MSEC"] = fmt.Sprintf("%d", cfg.RecvTimeoutMsec)
	e["GOQ_JSERV_IP"] = cfg.JservIP
	e["GOQ_HOME"] = cfg.Home
	e["GOQ_ODIR"] = cfg.Odir
	e["GOQ_JSERV_PORT"] = fmt.Sprintf("%d", cfg.JservPort)
	if cfg.NoSshConfig {
		e["GOQ_NOSSHCONFIG"] = "true"
	} else {
		e["GOQ_NOSSHCONFIG"] = "false"
	}
	if cfg.DebugMode {
		e["GOQ_DEBUGMODE"] = "true"
	} else {
		e["GOQ_DEBUGMODE"] = "false"
	}
	e["GOQ_HEARTBEAT_SEC"] = fmt.Sprintf("%v", cfg.Heartbeat)

	if cfg.UseQUIC {
		e["GOQ_USE_QUIC"] = "true"
	} else {
		e["GOQ_USE_QUIC"] = "false"
	}
	return MapToEnv(e)
}

func EnvToMap(env []string) map[string]string {
	m := make(map[string]string)

	for _, v := range env {
		match := regexSplitEnv.FindStringSubmatch(v)
		if match != nil {
			//fmt.Printf("match = %#v\n", match)
			if len(match) != 3 {
				panic("regexSplitEnv must return two groups")
			}
			m[match[1]] = match[2]
		}
	}

	return m
}

func MapToEnv(m map[string]string) []string {
	env := make([]string, len(m))
	i := 0
	for k, v := range m {
		env[i] = fmt.Sprintf("%s=%s", k, v)
		i++
	}
	return env
}

func GetEnvConfig() *Config {
	c := &Config{}
	c.SendTimeoutMsec = GetEnvNumber("GOQ_SENDTIMEOUT_MSEC", 0)
	c.RecvTimeoutMsec = GetEnvNumber("GOQ_RECVTIMEOUT_MSEC", 0)

	myip := GetExternalIP()
	c.JservIP = GetEnvString("GOQ_JSERV_IP", myip)
	c.Home = patchHomeForCygwin(os.Getenv("GOQ_HOME"))
	c.Odir = GetEnvString("GOQ_ODIR", "o")
	c.JservPort = GetEnvNumber("GOQ_JSERV_PORT", 1776)
	//c.JservAddr = fmt.Sprintf("tcp://%s:%d", c.JservIP, c.JservPort)
	c.NoSshConfig = GetEnvBool("GOQ_NOSSHCONFIG", false)
	c.DebugMode = GetEnvBool("GOQ_DEBUGMODE", false)
	c.Heartbeat = TmSeconds(GetEnvNumber("GOQ_HEARTBEAT_SEC", 60))
	c.UseQUIC = GetEnvBool("GOQ_USE_QUIC", false) // actually TLS/TCP faster than QUIC.

	//fmt.Printf("GetEnvConfig returning %#v\n", c)
	return c
}

func patchHomeForCygwin(home string) string {
	// problem in cygwin: $HOME and thus $GOQ_HOME can be /cygdrive/c/Users/me
	// but os.Stat and os.Mkdir need C:\Users\me or C:\Users/me
	if runtime.GOOS != "windows" {
		return home
	}
	prefix := "/cygdrive/"
	if strings.Contains(home, prefix) {
		// get drive letter
		noprefix := home[len(prefix):]
		splt := strings.SplitN(noprefix, "/", 2)
		drive := splt[0]
		home = drive + `:\` + splt[1] // the backticks are critical here.
		//vv("new c.Home = '%v'", c.Home) // 'c:\Users/me/'
	}
	return home
}

func GetEnvNumber(envvar string, def int) int {
	to := os.Getenv(envvar)
	if to != "" {
		toi, err := strconv.Atoi(to)
		if err == nil {
			return toi
		}
	}
	return def
}

func GetEnvString(envvar string, def string) string {
	s := os.Getenv(envvar)
	if s != "" {
		return s
	}
	return def
}

func GetEnvBool(envvar string, def bool) bool {
	s := os.Getenv(envvar)
	if s == "" {
		return def
	}
	if s == "true" || s == "TRUE" || s == "True" {
		return true
	}
	return false
}

const IdSz = 64

func RandomClusterId() (rcid string) {

	var by [32]byte
	_, err := cryrand.Read(by[:])
	panicOn(err)

	rcid = hex.EncodeToString(by[:])

	//if AesOff {
	//	fmt.Printf("RandomClusterId generated rcid='%s'\n", rcid)
	//}
	return
}

var validClusterId = regexp.MustCompile(`^[0-9a-f]{40}`)

func ShellOut(cmd string, args ...string) string {
	out, err := exec.Command(cmd, args...).Output()
	if err != nil {
		panic(err)
	}

	return strings.Trim(string(out), " \t\n")
}

func IsValidClusterId(id string) bool {
	if len(id) != IdSz {
		return false
	}
	match := validClusterId.FindStringSubmatch(id)
	if match != nil {
		return true
	}
	return false
}

var validClusterIdFile = regexp.MustCompile(`^goqclusterid$`)

func ClusterIdFileName(cfg *Config) string {
	return "goqclusterid"
}

func GetClusterIdPath(cfg *Config) string {
	if cfg.Home == "" {
		panic("cfg.Home must be set")
	}

	if !DirExists(cfg.Home) {
		panic(fmt.Sprintf("cfg.Home('%s') must be an existing directory", cfg.Home))
	}
	return fixSlash(fmt.Sprintf("%s/.goq/%s", cfg.Home, ClusterIdFileName(cfg)))
}

func LoadLocalClusterId(cfg *Config) (string, error) {
	fn := GetClusterIdPath(cfg)
	cid, err := ReadAndTrimFile(fn)
	if err != nil {
		return "", err
	}
	return cid, nil
}

func ReadAndTrimFile(fn string) (string, error) {
	by, err := ioutil.ReadFile(fixSlash(fn))
	if err != nil {
		return "", err
	}
	return strings.Trim(string(by), " \t\n\r"), nil
}

func SaveLocalClusterId(id string, cfg *Config) {
	fn := GetClusterIdPath(cfg)
	err := MakeDotGoqDir(cfg)
	if err != nil {
		panic(err)
	}
	// keep private, 0600
	f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	n, err := f.Write([]byte(id))
	if err != nil {
		panic(err)
	}
	if n != len(id) {
		panic(fmt.Sprintf("write truncated atempting to write clusterid to file '%s'", fn))
	}
	f.Write([]byte("\n"))
}

func RemoveLocalClusterId(cfg *Config) error {
	fn := GetClusterIdPath(cfg)
	return os.Remove(fn)
}

func GetClusterIdFromFile(cfg *Config) *Config {
	cfg2 := *cfg
	filecid, _ := LoadLocalClusterId(&cfg2)
	if filecid != "" {
		cfg2.ClusterId = filecid
	}
	return &cfg2
}

func InjectHelper(key, val string) {
	var err error
	err = os.Setenv(key, val)
	if err != nil {
		panic(err)
	}
}

// panics on error
func InjectConfigIntoEnv(cfg *Config) {

	InjectHelper(`GOQ_SENDTIMEOUT_MSEC`, fmt.Sprintf("%d", cfg.SendTimeoutMsec))
	InjectHelper(`GOQ_RECVTIMEOUT_MSEC`, fmt.Sprintf("%d", cfg.RecvTimeoutMsec))
	InjectHelper(`GOQ_JSERV_IP`, cfg.JservIP)
	InjectHelper(`GOQ_HOME`, cfg.Home)
	InjectHelper(`GOQ_ODIR`, cfg.Odir)
	InjectHelper(`GOQ_JSERV_PORT`, fmt.Sprintf("%d", cfg.JservPort))
	InjectHelper(`GOQ_NOSSHCONFIG`, BoolToString(cfg.NoSshConfig))
	InjectHelper(`GOQ_DEBUGMODE`, BoolToString(cfg.DebugMode))
	InjectHelper(`GOQ_USE_QUIC`, BoolToString(cfg.UseQUIC))
	InjectHelper(`GOQ_HEARTBEAT_SEC`, fmt.Sprintf("%d", cfg.Heartbeat))
}

func (cfg *Config) InjectConfigIntoMap(addto *map[string]string) {

	MapInjectHelper(addto, `GOQ_SENDTIMEOUT_MSEC`, fmt.Sprintf("%d", cfg.SendTimeoutMsec))
	MapInjectHelper(addto, `GOQ_RECVTIMEOUT_MSEC`, fmt.Sprintf("%d", cfg.RecvTimeoutMsec))
	MapInjectHelper(addto, `GOQ_JSERV_IP`, cfg.JservIP)
	MapInjectHelper(addto, `GOQ_HOME`, cfg.Home)
	MapInjectHelper(addto, `GOQ_ODIR`, cfg.Odir)
	MapInjectHelper(addto, `GOQ_JSERV_PORT`, fmt.Sprintf("%d", cfg.JservPort))
	MapInjectHelper(addto, `GOQ_NOSSHCONFIG`, BoolToString(cfg.NoSshConfig))
	MapInjectHelper(addto, `GOQ_DEBUGMODE`, BoolToString(cfg.DebugMode))
	MapInjectHelper(addto, `GOQ_USE_QUIC`, BoolToString(cfg.UseQUIC))
	MapInjectHelper(addto, `GOQ_HEARTBEAT_SEC`, fmt.Sprintf("%d", cfg.Heartbeat))

}

func MapInjectHelper(m *map[string]string, key, val string) {
	(*m)[key] = val
}

func BoolToString(b bool) string {
	if b {
		return "true"
	}
	return "false"
}

func GetConfigFromFile(home string, defaults *Config) (*Config, error) {

	cfg := *defaults
	cfg.Home = patchHomeForCygwin(home)
	cid, err := LoadLocalClusterId(&cfg)
	if cid != "" {
		cfg.ClusterId = cid
	}

	ReadServerLoc(&cfg)

	return &cfg, err
}

func ServerLocFile(cfg *Config) string {
	return fmt.Sprintf("%s/.goq/serverloc", cfg.Home)
}

func WriteServerLoc(cfg *Config) error {
	fn := ServerLocFile(cfg)
	// keep private, 0600
	file, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	fmt.Fprintf(file, "export GOQ_JSERV_IP=%s\n", cfg.JservIP)
	fmt.Fprintf(file, "## export GOQ_JSERV_IP=%s ## public facing IP\n", cfg.JservPublicFacingIP)
	fmt.Fprintf(file, "export GOQ_JSERV_PORT=%d\n", cfg.JservPort)
	fmt.Fprintf(file, "export GOQ_SENDTIMEOUT_MSEC=%d\n", cfg.SendTimeoutMsec)
	fmt.Fprintf(file, "export GOQ_RECVTIMEOUT_MSEC=%d\n", cfg.RecvTimeoutMsec)
	fmt.Fprintf(file, "export GOQ_HEARTBEAT_SEC=%d\n", cfg.Heartbeat)
	fmt.Fprintf(file, "export GOQ_USE_QUIC=%v\n", cfg.UseQUIC)

	return nil
}

func ReadServerLoc(cfg *Config) error {
	fn := ServerLocFile(cfg)
	by, err := os.ReadFile(fn)
	if err != nil {
		return nil // ignoring errors, I suppose b/c file might be absent?
	}
	lines := strings.Split(string(by), "\n")
	for _, line := range lines {
		ln := strings.TrimSpace(line)
		if len(ln) > 0 && ln[0] == '#' {
			continue // ignore comments
		}
		splt := strings.Split(ln, "#") // ignore end of line comments
		ok := splt[0]
		readme := bytes.NewBuffer([]byte(ok))
		switch {
		case strings.Contains(ok, "GOQ_JSERV_IP"):
			fmt.Fscanf(readme, "export GOQ_JSERV_IP=%s\n", &cfg.JservIP)

		case strings.Contains(ok, "GOQ_JSERV_PORT"):
			fmt.Fscanf(readme, "export GOQ_JSERV_PORT=%d\n", &cfg.JservPort)

		case strings.Contains(ok, "GOQ_SENDTIMEOUT_MSEC"):
			fmt.Fscanf(readme, "export GOQ_SENDTIMEOUT_MSEC=%d\n", &cfg.SendTimeoutMsec)

		case strings.Contains(ok, "GOQ_RECVTIMEOUT_MSEC"):
			fmt.Fscanf(readme, "export GOQ_RECVTIMEOUT_MSEC=%d\n", &cfg.RecvTimeoutMsec)

		case strings.Contains(ok, "GOQ_HEARTBEAT_SEC"):
			fmt.Fscanf(readme, "export GOQ_HEARTBEAT_SEC=%d\n", &cfg.Heartbeat)

		case strings.Contains(ok, "GOQ_USE_QUIC"):
			fmt.Fscanf(readme, "export GOQ_USE_QUIC=%t\n", &cfg.UseQUIC)
		}
	}

	return nil
}

func GetRandomCidDistinctFrom(avoidcid string) string {
	randomCid := RandomClusterId()

	if avoidcid != "" {
		// don't collide with the avoidcid (e.g. from the env, even by chance)
		for {
			if avoidcid == randomCid {
				randomCid = RandomClusterId()
			} else {
				break
			}
		}
	}
	return randomCid
}

var regexStartsWithCOG = regexp.MustCompile(`GOQ_`)

func GetNonGOQEnv(env []string, omitid string) []string {
	res := make([]string, 0)

	var filterid = regexp.MustCompile(omitid)

	for i := range env {
		match := regexStartsWithCOG.FindStringSubmatch(env[i])
		if match == nil {
			m2 := filterid.FindStringSubmatch(env[i])
			if m2 == nil {
				res = append(res, env[i])
			}
		}
	}
	return res
}

func MakeDotGoqDir(cfg *Config) error {
	if cfg.Home == "" {
		panic("cfg.Home cannot be empty")
	}
	d := fixSlash(cfg.Home + "/.goq")
	if !DirExists(d) {
		err := os.MkdirAll(d, 0700)
		if err != nil {
			return fmt.Errorf("error creating directory '%s': %s", d, err)
		}
	}
	return nil
}

func DeleteDotGoqDir(cfg *Config) {
	if cfg.Home == "" {
		panic("cfg.Home cannot be empty")
	}
	d := fixSlash(cfg.Home + "/.goq")
	if DirExists(d) {
		err := os.RemoveAll(d)
		if err != nil {
			panic(err)
		}
	}
}

func FindGoqHome() (h string, err error) {
	home := os.Getenv("GOQ_HOME")
	if home == "" {
		err = fmt.Errorf("GOQ_HOME environment variable not found")
	}
	return home, err
}

func (cfg *Config) KeyLocation() string {
	return fixSlash(cfg.Home + "/.goq/aes")
}

func GenNewCreds(cfg *Config) {
	var err error
	cfg.ClusterId = RandomClusterId()
	err = MakeDotGoqDir(cfg)
	if err != nil {
		panic(err)
	}
	SaveLocalClusterId(cfg.ClusterId, cfg)
	cfg.Cypher, err = NewKey(cfg)
	if err != nil {
		panic(err)
	}
	err = WriteServerLoc(cfg)
	if err != nil {
		panic(err)
	}

	panicOn(rpc.SelfyNewKey("node", cfg.Home+"/.goq"))
	panicOn(rpc.SelfyNewKey("client", cfg.Home+"/.goq"))
}

// fill cfg.JservPublicFacingIP if we can,
// using the api.ipify.org service.
func (cfg *Config) fillPublicFacingIP() {
	publicIP, err := getPublicIP()
	if err == nil {
		cfg.JservPublicFacingIP = publicIP
	}
}

func getPublicIP() (string, error) {
	// Make a GET request to a public IP service
	response, err := http.Get("https://api.ipify.org")
	if err != nil {
		return "", err
	}
	defer response.Body.Close()

	// Read the response body
	ip, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", err
	}

	return string(ip), nil
}