kor-elf-shield/internal/setting/setting.go

package setting

import (
	"errors"
	"strings"

	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/daemon"
	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/i18n"
	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/setting/validate"
)

type setting struct {
	ConfigPath string

	Testing          bool   `mapstructure:"testing"`
	TestingInterval  int16  `mapstructure:"testing_interval"`
	Language         string `mapstructure:"language"`
	FallbackLanguage string `mapstructure:"fallback_language"`
	PidFile          string `mapstructure:"pid_file"`
	SocketFile       string `mapstructure:"socket_file"`
	DataDir          string `mapstructure:"data_dir"`

	Log               *log
	BinaryLocations   *binaryLocations
	OtherSettingsPath *otherSettingsPath
}

func settingDefault(configPath string) *setting {
	return &setting{
		ConfigPath: configPath,

		Testing:          true,
		TestingInterval:  5,
		Language:         "ru",
		FallbackLanguage: "ru",
		PidFile:          "/var/run/kor-elf-shield/kor-elf-shield.pid",
		SocketFile:       "/var/run/kor-elf-shield/kor-elf-shield.sock",
		DataDir:          "/var/lib/kor-elf-shield/",

		Log:               logDefault(),
		BinaryLocations:   binaryLocationsDefault(),
		OtherSettingsPath: otherSettingsPathDefault(),
	}
}

func (s setting) ToDaemonOptions(dockerSupport bool) (daemon.DaemonOptions, error) {
	if err := s.ValidateBeforeStart(); err != nil {
		return daemon.DaemonOptions{}, err
	}

	firewallConfig, guardConfig, err := s.OtherSettingsPath.ToFirewallConfig(dockerSupport)
	if err != nil {
		return daemon.DaemonOptions{}, err
	}

	analyzerConfig, err := s.OtherSettingsPath.ToAnalyzerConfig(s.BinaryLocations)
	if err != nil {
		return daemon.DaemonOptions{}, err
	}

	return daemon.DaemonOptions{
		PathPidFile:         s.PidFile,
		PathSocketFile:      s.SocketFile,
		DataDir:             s.DataDir,
		PathNftables:        s.BinaryLocations.Nftables,
		ConfigFirewall:      firewallConfig,
		ConfigFirewallGuard: guardConfig,
		ConfigAnalyzer:      analyzerConfig,
	}, nil
}

func (s setting) ValidateBeforeStart() error {
	if s.PidFile == "" {
		return errors.New(i18n.Lang.T("parameter is not specified", map[string]any{
			"Parameter": "pid_file",
		}))
	}

	if s.SocketFile == "" {
		return errors.New(i18n.Lang.T("parameter is not specified", map[string]any{
			"Parameter": "socket_file",
		}))
	}

	if s.BinaryLocations.Nftables == "" {
		return errors.New(i18n.Lang.T("parameter is not specified", map[string]any{
			"Parameter": "binaryLocations.nftables",
		}))
	}

	if s.DataDir == "" {
		return errors.New(i18n.Lang.T("parameter is not specified", map[string]any{
			"Parameter": "data_dir",
		}))
	}

	return nil
}

func (s setting) Validate() error {
	if err := s.validationTestingInterval(); err != nil {
		return err
	}
	if err := s.validateLanguage(); err != nil {
		return err
	}
	if err := s.validatePidFile(); err != nil {
		return err
	}
	if err := s.validateSocketFile(); err != nil {
		return err
	}

	return nil
}

func (s setting) validationTestingInterval() error {
	if s.TestingInterval < 1 {
		return errors.New("testing_interval must be greater than 0")
	}
	if s.TestingInterval > 30000 {
		return errors.New("testing_interval must be less than 30000")
	}
	return nil
}

func (s setting) validatePidFile() error {
	if err := validate.PathFile(s.PidFile, "pid_file"); err != nil {
		return err
	}
	if !strings.HasSuffix(strings.ToLower(s.PidFile), ".pid") {
		return errors.New("invalid pid_file. Must be .pid")
	}
	return nil
}

func (s setting) validateLanguage() error {
	if err := validateLanguage(s.Language, "language"); err != nil {
		return err
	}
	if err := validateLanguage(s.FallbackLanguage, "fallback_language"); err != nil {
		return err
	}
	return nil
}

func validateLanguage(language string, parameterName string) error {
	switch language {
	case "ru", "en", "kk":
		return nil
	}
	return errors.New("invalid " + parameterName + ". Must be ru, en, kk")
}

func (s setting) validateSocketFile() error {
	if err := validate.PathFile(s.SocketFile, "socket_file"); err != nil {
		return err
	}
	if !strings.HasSuffix(strings.ToLower(s.SocketFile), ".sock") {
		return errors.New("invalid socket_file. Must be .sock")
	}
	return nil
}

func (s setting) ListPathConfigFiles() map[string]string {
	filePaths := s.OtherSettingsPath.ListPathFiles()
	filePaths["kor-elf-shield"] = s.ConfigPath
	return filePaths
}