mirror

config.go (2959B)

---

 package service
 
 import (
 	"fmt"
 	"os"
 	"path/filepath"
 	"time"
 
 	"git.server.ky/slackcoder/mirror/internal"
 	"github.com/BurntSushi/toml"
 )
 
 type StagingMethod string
 
 const (
 	StagingMethodNone       = "none"
 	StagingMethodTemporary  = "temporary"
 	StagingMethodPersistent = "persistent"
 )
 
 // Global parameters
 type GlobalConfig struct {
 	// MaxInterval is the maximum time to wait before syncing with a
 	// mirror. The wait time is a randomly generated time between the Min
 	// and Max intervals. The mirror is immediately downloaded once if both
 	// the Min and Max intervals are set to zero.
 	MaxInterval *Duration `toml:"max-interval"`
 	// MinInterval is the minimum time to wait before syncing with a mirror.
 	MinInterval   *Duration `toml:"min-interval"`
 	StagingMethod string    `toml:"staging-method,omitempty"`
 	StagingPath   string    `toml:"staging-path,omitempty"`
 }
 
 type Config struct {
 	GlobalConfig `toml:"global"`
 	Mirrors      []*Mirror `toml:"mirrors,omitempty"`
 }
 
 func (c *Config) String() string {
 	return internal.MustTOML(c)
 }
 
 var DefaultConfig = Config{
 	GlobalConfig: GlobalConfig{
 		MaxInterval:   DurationRef(24 * time.Hour),
 		MinInterval:   DurationRef(time.Hour),
 		StagingMethod: StagingMethodNone,
 		StagingPath:   "/tmp/mirror",
 	},
 }
 
 // Read the given configuration file.
 func readConfigFile(fp string) (*Config, error) {
 	var config Config
 
 	f, err := os.Open(fp)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 
 	_, err = toml.NewDecoder(f).Decode(&config)
 	if err != nil {
 		return nil, fmt.Errorf("loading configuration file: %w", err)
 	}
 
 	return &config, nil
 }
 
 // Read all configuration in the given directory.
 func readConfigDir(fp string) (*Config, error) {
 	var cfg Config
 
 	confDDir, err := os.ReadDir(fp)
 	if os.IsNotExist(err) {
 		// No directory is an empty one.
 		return &Config{}, nil
 	} else if err != nil {
 		return nil, err
 	}
 
 	for _, entry := range confDDir {
 		if filepath.Ext(entry.Name()) != ".toml" {
 			continue
 		}
 
 		entryCfg, err := readConfigFile(filepath.Join(fp, entry.Name()))
 		if err != nil {
 			return nil, err
 		}
 
 		cfg.Append(entryCfg)
 	}
 
 	return &cfg, nil
 }
 
 // Read all configuration in the given directory.
 func ReadConfig(fps ...string) (*Config, error) {
 	var cfg Config
 
 	for _, fp := range fps {
 		stat, err := os.Stat(fp)
 		if err != nil {
 			return nil, err
 		}
 
 		var c *Config
 
 		if stat.IsDir() {
 			c, err = readConfigDir(fp)
 			if err != nil {
 				return nil, err
 			}
 		} else {
 			c, err = readConfigFile(fp)
 		}
 
 		cfg.Append(c)
 	}
 
 	return &cfg, nil
 }
 
 // Apply the given configuration parameters.
 func (c *Config) Append(src *Config) {
 	if src.MaxInterval != nil {
 		c.MaxInterval = src.MaxInterval
 	}
 	if src.MinInterval != nil {
 		c.MinInterval = src.MinInterval
 	}
 	if src.StagingMethod != "" {
 		c.StagingMethod = src.StagingMethod
 	}
 	if src.StagingPath != "" {
 		c.StagingPath = src.StagingPath
 	}
 	c.Mirrors = append(c.Mirrors, src.Mirrors...)
 }