mugit @ 9c82bda

package config

import (

	"errors"

	"fmt"

	"os"

	"path/filepath"

	"time"

	"gopkg.in/yaml.v2"

)

var ErrConfigNotFound = errors.New("no config file found")

type ServerConfig struct {

	Host string `yaml:"host"`

	Port int    `yaml:"port"`

}

type MetaConfig struct {

	Title       string `yaml:"title"`

	Description string `yaml:"description"`

	Host        string `yaml:"host"`

}

type RepoConfig struct {

	Dir     string   `yaml:"dir"`

	Readmes []string `yaml:"readmes"`

	Masters []string `yaml:"masters"`

}

type SSHConfig struct {

	Enable  bool     `yaml:"enable"`

	Port    int      `yaml:"port"`

	HostKey string   `yaml:"host_key"`

	Keys    []string `yaml:"keys"`

}

type MirrorConfig struct {

	Enable      bool   `yaml:"enable"`

	Interval    string `yaml:"interval"`

	GithubToken string `yaml:"github_token"`

}

type Config struct {

	Server ServerConfig `yaml:"server"`

	Meta   MetaConfig   `yaml:"meta"`

	Repo   RepoConfig   `yaml:"repo"`

	SSH    SSHConfig    `yaml:"ssh"`

	Mirror MirrorConfig `yaml:"mirror"`

}

// Load loads configuration with the following priority:

// 1. User provided fpath (if provided and exists)

// 2. /var/lib/mugit/config.yaml

// 3. $XDG_CONFIG_HOME/mugit/config.yaml or $HOME/.config/mugit/config.yaml

func Load(fpath string) (*Config, error) {

	// 4. /etc/mugit/config.yaml

	configPath, err := findConfigFile(fpath)

	if err != nil {

		return nil, err

	}

	configBytes, err := os.ReadFile(configPath)

	if err != nil {

		return nil, err

	}

	var config Config

	if cerr := yaml.Unmarshal(configBytes, &config); cerr != nil {

		return nil, fmt.Errorf("parsing config: %w", cerr)

	}

	if config.Repo.Dir, err = filepath.Abs(config.Repo.Dir); err != nil {

		return nil, err

	}

	if verr := config.validate(); verr != nil {

		return nil, verr

	}

	return &config, nil

}

func (c Config) validate() error {

	var errs []error

	// server

	if err := validatePort(c.Server.Port, "server.port"); err != nil {

		errs = append(errs, err)

	}

	// meta

	if c.Meta.Host == "" {

		errs = append(errs, errors.New("meta.host is required"))

	}

	// repo

	if err := validateDirExists(c.Repo.Dir, "repo.dir"); err != nil {

		errs = append(errs, err)

	}

	if len(c.Repo.Readmes) == 0 {

		errs = append(errs, errors.New("repo.readmes must have at least one value"))

	}

	if len(c.Repo.Masters) == 0 {

		errs = append(errs, errors.New("repo.masters must have at least one value"))

	}

	// ssh

	if c.SSH.Enable {

		if err := validatePort(c.SSH.Port, "ssh.port"); err != nil {

			errs = append(errs, err)

		}

		if c.SSH.Port == c.Server.Port {

			errs = append(errs, fmt.Errorf("ssh.port must differ from server.port (both are %d)", c.Server.Port))

		}

		if err := validateFileExists(c.SSH.HostKey, "ssh.host_key"); err != nil {

			errs = append(errs, err)

		}

		if len(c.SSH.Keys) == 0 {

			errs = append(errs, errors.New("ssh.keys must have at least one value when ssh is enabled"))

		}

	}

	// mirror

	if c.Mirror.Enable {

		if c.Mirror.Interval == "" {

			errs = append(errs, errors.New("mirror.interval is required when mirror is enabled"))

		} else if _, err := time.ParseDuration(c.Mirror.Interval); err != nil {

			errs = append(errs, fmt.Errorf("mirror.interval: invalid duration format: %w", err))

		}

	}

	return errors.Join(errs...)

}

func findConfigFile(userPath string) (string, error) {

	if userPath != "" {

		if _, err := os.Stat(userPath); err == nil {

			return userPath, nil

		}

	}

	path := "/var/lib/mugit/config.yaml"

	if _, err := os.Stat(path); err == nil {

		return path, nil

	}

	if configDir, err := os.UserConfigDir(); err == nil {

		p := filepath.Join(configDir, "mugit", "config.yaml")

		if _, err := os.Stat(p); err == nil {

			return p, nil

		}

	}

	path = "/etc/mugit/config.yaml"

	if _, err := os.Stat(path); err == nil {

		return path, nil

	}

	return "", ErrConfigNotFound

}

func validatePort(port int, fieldName string) error {

	if port < 1 || port > 65535 {

		return fmt.Errorf("%s must be between 1 and 65535, got %d", fieldName, port)

	}

	return nil

}

func validateDirExists(path string, fieldName string) error {

	if path == "" {

		return fmt.Errorf("%s is required", fieldName)

	}

	info, err := os.Stat(path)

	if err != nil {

		if os.IsNotExist(err) {

			return fmt.Errorf("%s: directory does not exist: %s", fieldName, path)

		}

		return fmt.Errorf("%s: cannot access directory: %w", fieldName, err)

	}

	if !info.IsDir() {

		return fmt.Errorf("%s: path exists but is not a directory: %s", fieldName, path)

	}

	return nil

}

func validateFileExists(path string, fieldName string) error {

	if path == "" {

		return fmt.Errorf("%s is required", fieldName)

	}

	info, err := os.Stat(path)

	if err != nil {

		if os.IsNotExist(err) {

			return fmt.Errorf("%s: file does not exist: %s", fieldName, path)

		}

		return fmt.Errorf("%s: cannot access file: %w", fieldName, err)

	}

	if info.IsDir() {

		return fmt.Errorf("%s: path is a directory, not a file: %s", fieldName, path)

	}

	return nil

}