goseg/config/config.go

package config

import (
	"encoding/json"
	"fmt"
	"goseg/defaults"
	"goseg/structs"
	"io/ioutil"
	"log/slog"
	"net"
	"os"
	"path/filepath"
	"runtime"
	"sync"
	"time"
)

var (
	globalConfig  structs.SysConfig
	logger        = slog.New(slog.NewJSONHandler(os.Stdout, nil))
	BasePath      = os.Getenv("GS_BASE_PATH")
	Architecture  = getArchitecture()
	DebugMode     = false
	Ready         = false
	GSContainers  = make(map[string]structs.ContainerState)
	checkInterval = 5 * time.Minute
	confMutex     sync.Mutex
	contMutex     sync.Mutex
	versMutex     sync.Mutex
)

// try initializing from system.json on disk
func init() {
	logger.Info("Starting GroundSeg")
	logger.Info("Urbit is love <3")
	for _, arg := range os.Args[1:] {
		// trigger this with `./groundseg dev`
		if arg == "dev" {
			logger.Info("Starting GroundSeg in debug mode")
			DebugMode = true
		}
	}
	if BasePath == "" {
		// default base path
		BasePath = "/opt/nativeplanet/groundseg"
	}
	pathMsg := fmt.Sprintf("Loading configs from %s", BasePath)
	logger.Info(pathMsg)
	confPath := filepath.Join(BasePath, "settings", "system.json")
	file, err := os.Open(confPath)
	if err != nil {
		// create a default if it doesn't exist
		err = createDefaultConf()
		if err != nil {
			// panic if we can't create it
			errmsg := fmt.Sprintf("Unable to create config! Please elevate permissions. %v", err)
			logger.Error(errmsg)
			panic(errmsg)
		}
	}
	defer file.Close()
	// read the sysconfig to memory
	decoder := json.NewDecoder(file)
	err = decoder.Decode(&globalConfig)
	if err != nil {
		errmsg := fmt.Sprintf("Error decoding JSON: %v", err)
		logger.Error(errmsg)
	}
}

// return the global conf var
func Conf() structs.SysConfig {
	confMutex.Lock()
	defer confMutex.Unlock()
	return globalConfig
}

// tell if we're amd64 or arm64
func getArchitecture() string {
	switch runtime.GOARCH {
	case "arm64", "aarch64":
		return "arm64"
	default:
		return "amd64"
	}
}

// update by passing in a map of key:values you want to modify
func UpdateConf(values map[string]interface{}) error {
	// mutex lock to avoid race conditions
	confMutex.Lock()
	defer confMutex.Unlock()
	confPath := filepath.Join(BasePath, "settings", "system.json")
	file, err := ioutil.ReadFile(confPath)
	if err != nil {
		errmsg := fmt.Sprintf("Unable to load config: %v", err)
		logger.Error(errmsg)
		return err
	}
	// unmarshal the config to struct
	var configMap map[string]interface{}
	if err := json.Unmarshal(file, &configMap); err != nil {
		errmsg := fmt.Sprintf("Error decoding JSON: %v", err)
		logger.Error(errmsg)
		return err
	}
	// update our unmarshaled struct
	for key, value := range values {
		configMap[key] = value
	}
	// marshal and persist it
	updatedJSON, err := json.MarshalIndent(configMap, "", "    ")
	if err != nil {
		errmsg := fmt.Sprintf("Error encoding JSON: %v", err)
		logger.Error(errmsg)
		return err
	}
	// update the globalConfig var
	if err := json.Unmarshal(updatedJSON, &globalConfig); err != nil {
		errmsg := fmt.Sprintf("Error updating global config: %v", err)
		logger.Error(errmsg)
		return err
	}
	if err := ioutil.WriteFile(confPath, updatedJSON, 0644); err != nil {
		errmsg := fmt.Sprintf("Error writing to file: %v", err)
		logger.Error(errmsg)
		return err
	}
	return nil
}

// we keep map[string]structs.ContainerState in memory to keep track of the containers
// eg if they're running and whether they should be

// modify the desired/actual state of containers
func UpdateContainerState(name string, containerState structs.ContainerState) {
	contMutex.Lock()
	defer contMutex.Unlock()
	GSContainers[name] = containerState
	res, _ := json.Marshal(containerState)
	logger.Info(fmt.Sprintf("%s:%s", name, string(res)))
}

// get the current container state
func GetContainerState() map[string]structs.ContainerState {
	contMutex.Lock()
	defer contMutex.Unlock()
	return GSContainers
}

// write a default conf to disk
func createDefaultConf() error {
	defaultConfig := defaults.SysConfig(BasePath)
	path := filepath.Join(BasePath, "settings", "system.json")
	if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
		return err
	}
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()
	encoder := json.NewEncoder(file)
	encoder.SetIndent("", "    ")
	if err := encoder.Encode(&defaultConfig); err != nil {
		return err
	}
	return nil
}

// check outbound tcp connectivity
// takes ip:port
func NetCheck(netCheck string) bool {
	logger.Info("Checking internet access")
	internet := false
	timeout := 3 * time.Second
	conn, err := net.DialTimeout("tcp", netCheck, timeout)
	if err != nil {
		errmsg := fmt.Sprintf("Check internet access error: %v", err)
		logger.Error(errmsg)
	} else {
		internet = true
		_ = conn.Close()
	}
	return internet
}