mstore/app/config/config.go

package config

import (
	"flag"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"

	"mstore/pkg/auxx509"

	"sigs.k8s.io/yaml"
)

type Service struct {
	Address string `json:"address" yaml:"address"`
	Port    int64  `json:"port"    yaml:"port"`
}

type Database struct {
	Basepath string `json:"basepath" yaml:"basepath"`
}

type Storage struct {
	Basepath string `json:"basepath" yaml:"basepath"`
}

type Config struct {
	Service  Service  `json:"service"  yaml:"service"`
	Database Database `json:"database" yaml:"database"`
	Storage  Storage  `json:"storage"  yaml:"storage"`
	AsDaemon bool     `json:"asDaemon" yaml:"asDaemon"`
	Logpath  string   `json:"logpath"  yaml:"logpath"`
	Runpath  string   `json:"runpath"  yaml:"runpath"`
	Version  string   `json:"version"  yaml:"version"`
	Certpath string   `json:"certpath" yaml:"certath"`
	Keypath  string   `json:"keypath"  yaml:"keypath"`
	X509Cert string   `json:"X509cert" yaml:"X509cert"`
	X509Key  string   `json:"X509key"  yaml:"X509key"`
}

func NewConfig() *Config {
	logfile := fmt.Sprintf("%s.log", srvname)
	logpath := filepath.Join(logdir, logfile)

	runfile := fmt.Sprintf("%s.run", srvname)
	runpath := filepath.Join(rundir, runfile)

	certpath := fmt.Sprintf("%s.crt", srvname)
	certpath = filepath.Join(confdir, certpath)

	keypath := fmt.Sprintf("%s.crt", srvname)
	keypath = filepath.Join(confdir, keypath)

	return &Config{
		Service: Service{
			Address: "0.0.0.0",
			Port:    1025,
		},
		Database: Database{
			Basepath: datadir,
		},
		Storage: Storage{
			Basepath: datadir,
		},
		AsDaemon: false,
		Logpath:  logpath,
		Runpath:  runpath,
		Version:  version,
		Certpath: certpath,
		Keypath:  keypath,
	}
}

func (conf *Config) String() string {
	confbytes, _ := yaml.Marshal(conf)
	return string(confbytes)
}

func (conf *Config) ReadConfigfile() error {
	conffile := fmt.Sprintf("%sd.yaml", srvname)
	confpath := filepath.Join(confdir, conffile)

	confdata, err := ioutil.ReadFile(confpath)
	if err != nil {
		return err
	}
	err = yaml.Unmarshal(confdata, conf)
	if err != nil {
		return err
	}
	return err
}

func (conf *Config) ReadOptions() error {
	var err error
	exename := filepath.Base(os.Args[0])

	flag.Int64Var(&conf.Service.Port, "port", conf.Service.Port, "listen port")
	flag.BoolVar(&conf.AsDaemon, "daemon", conf.AsDaemon, "run as daemon")

	help := func() {
		fmt.Println("")
		fmt.Printf("Usage: %s [option]\n", exename)
		fmt.Println("")
		fmt.Println("Options:")
		flag.PrintDefaults()
		fmt.Println("")
	}
	flag.Usage = help
	flag.Parse()

	return err
}

func (conf *Config) ReadX509Cert() error {
	var err error
	if conf.Certpath != "" && conf.Keypath != "" {
		if !filepath.IsAbs(conf.Certpath) {
			conf.Certpath = filepath.Join(confdir, conf.Certpath)
		}
		certBytes, err := os.ReadFile(conf.Certpath)
		if err != nil {
			return err
		}
		if !filepath.IsAbs(conf.Keypath) {
			conf.Keypath = filepath.Join(confdir, conf.Keypath)
		}
		keyBytes, err := os.ReadFile(conf.Keypath)
		if err != nil {
			return err
		}
		conf.X509Cert = string(certBytes)
		conf.X509Key = string(keyBytes)
		return err
	}
	/*
		if conf.X509Cert != "" && conf.X509Key != "" {
			x509Cert, err := base64.StdEncoding.DecodeString(conf.X509Cert)
			if err != nil {
				return err
			}
			conf.X509Cert = string(x509Cert)
			x509Key, err := base64.StdEncoding.DecodeString(conf.X509Key)
			if err != nil {
				return err
			}
			conf.X509Key = string(x509Key)
		}
	*/
	if conf.X509Cert == "" || conf.X509Key == "" {
		certBytes, keyBytes, err := auxx509.CreateSelfSignedCert("localhost")
		if err != nil {
			return err
		}
		conf.X509Cert = string(certBytes)
		conf.X509Key = string(keyBytes)
		return err

	}

	return err
}