142 lines
3.4 KiB
Go
142 lines
3.4 KiB
Go
package config
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"golang.org/x/term"
|
|
)
|
|
|
|
const DefaultSyncInterval = "5m"
|
|
|
|
// Config holds runtime settings. JSON field names are stable for operators editing by hand.
|
|
type Config struct {
|
|
Endpoint string `json:"endpoint"`
|
|
APIKey string `json:"api_key"`
|
|
PlayersDBPath string `json:"players_db_path"`
|
|
SyncInterval string `json:"sync_interval"`
|
|
}
|
|
|
|
// DefaultPath returns config.json next to the executable.
|
|
func DefaultPath() (string, error) {
|
|
exe, err := os.Executable()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
exe, err = filepath.EvalSymlinks(exe)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return filepath.Join(filepath.Dir(exe), "config.json"), nil
|
|
}
|
|
|
|
func (c *Config) Validate() error {
|
|
if strings.TrimSpace(c.Endpoint) == "" {
|
|
return errors.New("endpoint is required")
|
|
}
|
|
if strings.TrimSpace(c.APIKey) == "" {
|
|
return errors.New("api_key is required")
|
|
}
|
|
if strings.TrimSpace(c.PlayersDBPath) == "" {
|
|
return errors.New("players_db_path is required")
|
|
}
|
|
interval := strings.TrimSpace(c.SyncInterval)
|
|
if interval == "" {
|
|
interval = DefaultSyncInterval
|
|
}
|
|
if _, err := time.ParseDuration(interval); err != nil {
|
|
return fmt.Errorf("sync_interval: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Config) IntervalDuration() (time.Duration, error) {
|
|
s := strings.TrimSpace(c.SyncInterval)
|
|
if s == "" {
|
|
s = DefaultSyncInterval
|
|
}
|
|
return time.ParseDuration(s)
|
|
}
|
|
|
|
func Load(path string) (*Config, error) {
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var c Config
|
|
if err := json.Unmarshal(b, &c); err != nil {
|
|
return nil, err
|
|
}
|
|
return &c, nil
|
|
}
|
|
|
|
func Save(path string, c *Config) error {
|
|
b, err := json.MarshalIndent(c, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(path, b, 0600)
|
|
}
|
|
|
|
// RunWizard interactively collects settings and writes config to path. Requires a TTY on stdin.
|
|
func RunWizard(path string) error {
|
|
if !term.IsTerminal(int(os.Stdin.Fd())) {
|
|
return errors.New("stdin is not a terminal: run this program from a console to create config.json, or create the file by hand")
|
|
}
|
|
|
|
fmt.Fprintln(os.Stderr, "tx-sync: first-time setup — values are saved to:", path)
|
|
fmt.Fprintln(os.Stderr)
|
|
|
|
endpoint := promptLine("HTTPS endpoint URL (POST, full URL): ")
|
|
apiKey, err := promptPassword("API key (X-API-Key, hidden): ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
dbPath := promptLine("Path to playersDB.json: ")
|
|
interval := promptLine(fmt.Sprintf("Sync interval [%s]: ", DefaultSyncInterval))
|
|
if strings.TrimSpace(interval) == "" {
|
|
interval = DefaultSyncInterval
|
|
}
|
|
|
|
cfg := Config{
|
|
Endpoint: strings.TrimSpace(endpoint),
|
|
APIKey: strings.TrimSpace(apiKey),
|
|
PlayersDBPath: strings.TrimSpace(dbPath),
|
|
SyncInterval: strings.TrimSpace(interval),
|
|
}
|
|
if err := cfg.Validate(); err != nil {
|
|
return err
|
|
}
|
|
if err := Save(path, &cfg); err != nil {
|
|
return err
|
|
}
|
|
fmt.Fprintln(os.Stderr)
|
|
fmt.Fprintln(os.Stderr, "Configuration saved. Run tx-sync again to start syncing (immediate upload, then on the timer).")
|
|
return nil
|
|
}
|
|
|
|
func promptLine(label string) string {
|
|
fmt.Fprint(os.Stderr, label)
|
|
s := bufio.NewScanner(os.Stdin)
|
|
if !s.Scan() {
|
|
return ""
|
|
}
|
|
return s.Text()
|
|
}
|
|
|
|
func promptPassword(label string) (string, error) {
|
|
fmt.Fprint(os.Stderr, label)
|
|
b, err := term.ReadPassword(int(os.Stdin.Fd()))
|
|
fmt.Fprintln(os.Stderr)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(b), nil
|
|
}
|