goseg/config/config.go

package config

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

var (
	globalConfig       structs.SysConfig
	logger             = slog.New(slog.NewJSONHandler(os.Stdout, nil))
	basePath           = "/home/nativeplanet/gits"
	Version            = "v2.0.0"
	Ready              = false
	VersionServerReady = false
	VersionInfo        structs.Version
	Ram                int
	Cpu                int
	CoreTemp           int
	Disk               int
	WifiEnabled        = false
	ActiveNetwork      string
	WifiNetworks       []string
	HttpOpen           = false
	UploadSecret       string
	confMutex          sync.Mutex
)

func init() {
	confPath := filepath.Join(basePath, "settings", "system2.json")
	file, err := os.Open(confPath)
	if err != nil {
		err = createDefaultConf()
		if err != nil {
			logger.Error("Unable to create config!")
		}
	}
	defer file.Close()
	decoder := json.NewDecoder(file)
	err = decoder.Decode(&globalConfig)
	if err != nil {
		logger.Error("Error decoding JSON: %v", err)
	}
}

func Conf() structs.SysConfig {
	return globalConfig
}

func UpdateConf(values map[string]interface{}) error {
	confMutex.Lock()
	defer confMutex.Unlock()
	confPath := filepath.Join(basePath, "settings", "system2.json")
	file, err := ioutil.ReadFile(confPath)
	if err != nil {
		logger.Error("Unable to load config")
		return err
	}
	var configMap map[string]interface{}
	if err := json.Unmarshal(file, &configMap); err != nil {
		logger.Error("Error decoding JSON: %v", err)
		return err
	}
	for key, value := range values {
		configMap[key] = value
	}
	updatedJSON, err := json.Marshal(configMap)
	if err != nil {
		logger.Error("Error encoding JSON: %v", err)
		return err
	}
	if err := json.Unmarshal(updatedJSON, &globalConfig); err != nil {
		logger.Error("Error updating global config: %v", err)
		return err
	}
	if err := ioutil.WriteFile(confPath, updatedJSON, 0644); err != nil {
		logger.Error("Error writing to file: %v", err)
		return err
	}
	return nil
}

func createDefaultConf() error {
	defaultConfig := structs.SysConfig{
		Setup:        "start",
		EndpointUrl:  "api.startram.io",
		ApiVersion:   "v1",
		Piers:        []string{},
		NetCheck:     "1.1.1.1:53",
		UpdateMode:   "auto",
		UpdateUrl:    "https://version.groundseg.app",
		UpdateBranch: "latest",
		SwapVal:      16,
		SwapFile:     filepath.Join(basePath, "settings", "swapfile"),
		KeyFile:      filepath.Join(basePath, "settings", "session.key"),
		Sessions: struct {
			Authorized   map[string]structs.SessionInfo `json:"authorized"`
			Unauthorized map[string]structs.SessionInfo `json:"unauthorized"`
		}{
			Authorized:   make(map[string]structs.SessionInfo),
			Unauthorized: make(map[string]structs.SessionInfo),
		},
		LinuxUpdates: struct {
			Value    int    `json:"value"`
			Interval string `json:"interval"`
			Previous bool   `json:"previous"`
		}{
			Value:    1,
			Interval: "week",
			Previous: false,
		},
		DockerData:     "/var/lib/docker",
		WgOn:           false,
		WgRegistered:   false,
		PwHash:         "",
		C2cInterval:    0,
		FirstBoot:      false,
		WgRegisterd:    false,
		GsVersion:      Version,
		CfgDir:         "",
		UpdateInterval: 0,
		BinHash:        "",
		Pubkey:         "",
		Privkey:        "",
		Salt:           "",
	}
	path := filepath.Join(basePath, "settings", "system2.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)
	if err := encoder.Encode(&defaultConfig); err != nil {
		return err
	}
	return nil
}

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 {
		logger.Error("Check internet access error: %v\n", err)
	} else {
		internet = true
		_ = conn.Close()
		logger.Info("Internet connection is available!")
	}
	return internet
}

func CheckVersion() bool {
	const retries = 10
	const delay = time.Second
	var version structs.Version
	url := globalConfig.UpdateUrl
	for i := 0; i < retries; i++ {
		resp, err := http.Get(url)
		if err != nil {
			errmsg := fmt.Sprintf("Unable to connect to update server: %v", err)
			logger.Warn(errmsg)
			if i < retries-1 {
				time.Sleep(delay)
				continue
			} else {
				return false
			}
		}
		body, err := ioutil.ReadAll(resp.Body)
		resp.Body.Close()
		if err != nil {
			errmsg := fmt.Sprintf("Error reading version info: %v", err)
			logger.Warn(errmsg)
			if i < retries-1 {
				time.Sleep(delay)
				continue
			} else {
				return false
			}
		}
		err = json.Unmarshal(body, &version)
		if err != nil {
			errmsg := fmt.Sprintf("Error unmarshalling JSON: %v", err)
			logger.Warn(errmsg)
			if i < retries-1 {
				time.Sleep(delay)
				continue
			} else {
				return false
			}
		}
		versionUpdate := map[string]interface{}{
			"VersionInfo": version,
		}
		err = UpdateConf(versionUpdate)
		if err != nil {
			errmsg := fmt.Sprintf("Error updating version config: %v", err)
			logger.Warn(errmsg)
			if i < retries-1 {
				time.Sleep(delay)
				continue
			} else {
				return false
			}
		}
		return true
	}
	return false
}