common/config/config.go

// Package config provides environment-based configuration management for NTP Pool services.
//
// This package handles configuration loading from environment variables and provides
// utilities for constructing URLs for web and management interfaces. It supports
// deployment-specific settings including hostname configuration, TLS settings,
// and deployment modes.
//
// Configuration is loaded automatically from environment variables:
//   - deployment_mode: The deployment environment (devel, production, etc.)
//   - manage_hostname: Hostname for management interface
//   - web_hostname: Comma-separated list of web hostnames (first is primary)
//   - manage_tls: Enable TLS for management interface (yes, no, true, false)
//   - web_tls: Enable TLS for web interface (yes, no, true, false)
//
// The package includes code generation for accessor methods using the accessory tool.
package config

import (
	"net/url"
	"os"
	"strconv"
	"strings"

	"go.ntppool.org/common/logger"
)

//go:generate go tool github.com/masaushi/accessory -type Config

// Config holds environment-based configuration for NTP Pool services.
// It manages hostnames, TLS settings, and deployment modes loaded from
// environment variables. The struct includes code-generated accessor methods.
type Config struct {
	deploymentMode string `accessor:"getter"`

	manageHostname string `accessor:"getter"`
	manageTLS      bool

	webHostname  string `accessor:"getter"`
	webHostnames []string
	webTLS       bool

	poolDomain string `accessor:"getter"`

	valid bool `accessor:"getter"`
}

// New creates a new Config instance by loading configuration from environment variables.
// It automatically parses hostnames, TLS settings, and deployment mode from the environment.
// The configuration is considered valid if at least one web hostname is provided.
//
// Environment variables used:
//   - deployment_mode: Deployment environment identifier
//   - manage_hostname: Management interface hostname
//   - web_hostname: Comma-separated web hostnames (first becomes primary)
//   - manage_tls: Management interface TLS setting
//   - web_tls: Web interface TLS setting
//   - pool_domain: NTP pool domain (default: pool.ntp.org)
func New() *Config {
	c := Config{}
	c.deploymentMode = os.Getenv("deployment_mode")
	c.manageHostname = os.Getenv("manage_hostname")

	c.webHostnames = strings.Split(os.Getenv("web_hostname"), ",")
	for i, h := range c.webHostnames {
		c.webHostnames[i] = strings.TrimSpace(h)
	}
	if len(c.webHostnames) > 0 {
		c.webHostname = c.webHostnames[0]
		c.valid = true
	}

	c.manageTLS = parseBool(os.Getenv("manage_tls"))
	c.webTLS = parseBool(os.Getenv("web_tls"))

	c.poolDomain = os.Getenv("pool_domain")
	if c.poolDomain == "" {
		c.poolDomain = "pool.ntp.org"
	}

	return &c
}

// WebURL constructs a complete URL for the web interface using the primary web hostname.
// It automatically selects HTTP or HTTPS based on the web_tls configuration setting.
//
// Parameters:
//   - path: URL path component (should start with "/")
//   - query: Optional URL query parameters (can be nil)
//
// Returns a complete URL string suitable for web interface requests.
func (c *Config) WebURL(path string, query *url.Values) string {
	return baseURL(c.webHostname, c.webTLS, path, query)
}

// ManageURL constructs a complete URL for the management interface using the management hostname.
// It automatically selects HTTP or HTTPS based on the manage_tls configuration setting.
//
// Parameters:
//   - path: URL path component (should start with "/")
//   - query: Optional URL query parameters (can be nil)
//
// Returns a complete URL string suitable for management interface requests.
func (c *Config) ManageURL(path string, query *url.Values) string {
	return baseURL(c.manageHostname, c.webTLS, path, query)
}

func baseURL(host string, tls bool, path string, query *url.Values) string {
	uri := url.URL{}
	uri.Host = host
	if tls {
		uri.Scheme = "https"
	} else {
		uri.Scheme = "http"
	}
	uri.Path = path
	if query != nil {
		uri.RawQuery = query.Encode()
	}

	return uri.String()
}

func parseBool(s string) bool {
	switch strings.ToLower(s) {
	case "yes":
		return true
	case "y":
		return true
	case "no":
		return false
	case "n":
		return false
	case "":
		return false
	}

	t, err := strconv.ParseBool(s)
	if err != nil {
		logger.Setup().Error("could not parse bool", "string", s, "err", err)
		return false
	}

	return t
}