diff --git a/internal/config/config.go b/internal/config/config.go index f5c8da9..9314840 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -26,7 +26,12 @@ type Config struct { Hosts []StaticHost `mapstructure:"hosts"` // Groups name lists of hosts and selectors for netssh multi (@name). Groups map[string][]string `mapstructure:"groups"` - Multi MultiConfig `mapstructure:"multi"` + // Links map a short name to a host selector: netssh NAME connects to it, + // and the shell gets an alias NAME. Created after a DNS suggestion or + // with netssh link add. + Links map[string]string `mapstructure:"links"` + DNS DNSConfig `mapstructure:"dns"` + Multi MultiConfig `mapstructure:"multi"` } type ShellConfig struct { @@ -185,7 +190,7 @@ func Load() (*Config, error) { v.SetEnvPrefix("NETSSH") v.SetEnvKeyReplacer(strings.NewReplacer(".", "_")) v.AutomaticEnv() - for _, key := range []string{"netbox.url", "netbox.token", "netbox.token_version", "resolver.strategies", "resolver.management_subnets", "resolver.interface_name", "resolver.hostname_domain", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shortcuts.show", "shell.alias", "ssh.proxy_jump", "ssh.pre_connect", "ssh.post_disconnect", "tui.history_limit", "activity.enabled", "activity.retention_days", "activity.max_entries", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results", "multi.multiplexer", "multi.panes_per_window", "ssh.warn_status", "tui.columns", "tui.reachability_timeout", "resolver.fallback", "resolver.fallback_timeout"} { + for _, key := range []string{"netbox.url", "netbox.token", "netbox.token_version", "resolver.strategies", "resolver.management_subnets", "resolver.interface_name", "resolver.hostname_domain", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shortcuts.show", "shell.alias", "ssh.proxy_jump", "ssh.pre_connect", "ssh.post_disconnect", "tui.history_limit", "activity.enabled", "activity.retention_days", "activity.max_entries", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results", "multi.multiplexer", "multi.panes_per_window", "ssh.warn_status", "tui.columns", "tui.reachability_timeout", "resolver.fallback", "resolver.fallback_timeout", "dns.suggest", "dns.save_link"} { if err := v.BindEnv(key); err != nil { return nil, err } @@ -239,6 +244,12 @@ func Load() (*Config, error) { if err := cfg.ValidateHosts(); err != nil { return nil, err } + if err := cfg.ValidateLinks(); err != nil { + return nil, err + } + if err := cfg.ValidateDNS(); err != nil { + return nil, err + } if err := cfg.ValidateOperations(); err != nil { return nil, err } diff --git a/internal/config/dns.go b/internal/config/dns.go new file mode 100644 index 0000000..b289631 --- /dev/null +++ b/internal/config/dns.go @@ -0,0 +1,96 @@ +package config + +import ( + "fmt" + "path" + "strings" +) + +// DNSConfig controls what netssh does with names that are neither in NetBox +// nor in the cache: resolve them through DNS and suggest the owning host. +type DNSConfig struct { + // Suggest is ask (default), always (take the first suggestion without + // asking, also in scripts) or never (no DNS lookup, plain "not found"). + Suggest string `mapstructure:"suggest"` + // SaveLink is ask (default), always (save the shortcut without asking) + // or never, for the link offered after a suggestion. + SaveLink string `mapstructure:"save_link"` + // Domains are appended to names without a dot that match the rule. + Domains []DNSDomain `mapstructure:"domains"` +} + +// DNSDomain appends Domain to names matching Match (a shell glob such as +// "mx*"; empty matches every name). +type DNSDomain struct { + Match string `mapstructure:"match"` + Domain string `mapstructure:"domain"` +} + +// DNS modes for dns.suggest and dns.save_link. +const ( + DNSAsk = "ask" + DNSAlways = "always" + DNSNever = "never" +) + +// SuggestMode returns dns.suggest, ask by default. +func (d DNSConfig) SuggestMode() string { return dnsMode(d.Suggest) } + +// SaveLinkMode returns dns.save_link, ask by default. +func (d DNSConfig) SaveLinkMode() string { return dnsMode(d.SaveLink) } + +func dnsMode(mode string) string { + if mode == "" { + return DNSAsk + } + return strings.ToLower(mode) +} + +// Names lists the DNS names to try for what the user typed. A name with a +// dot is used as is. A name without a dot gets the domain of every rule it +// matches, in order; only when no rule matches is the bare name looked up. +func (d DNSConfig) Names(query string) []string { + if strings.Contains(query, ".") { + return []string{query} + } + var names []string + seen := map[string]bool{} + lower := strings.ToLower(query) + for _, rule := range d.Domains { + if rule.Match != "" { + if ok, _ := path.Match(strings.ToLower(rule.Match), lower); !ok { + continue + } + } + name := query + "." + strings.Trim(strings.TrimSpace(rule.Domain), ".") + if !seen[strings.ToLower(name)] { + seen[strings.ToLower(name)] = true + names = append(names, name) + } + } + if len(names) == 0 { + return []string{query} + } + return names +} + +// ValidateDNS rejects unknown modes, broken patterns and empty domains. +func (c *Config) ValidateDNS() error { + for key, mode := range map[string]string{"dns.suggest": c.DNS.Suggest, "dns.save_link": c.DNS.SaveLink} { + switch dnsMode(mode) { + case DNSAsk, DNSAlways, DNSNever: + default: + return fmt.Errorf("%s must be ask, always, or never", key) + } + } + for i, rule := range c.DNS.Domains { + if _, err := path.Match(rule.Match, ""); err != nil { + return fmt.Errorf("dns.domains[%d]: invalid match pattern %q", i, rule.Match) + } + domain := strings.Trim(strings.TrimSpace(rule.Domain), ".") + if domain == "" || strings.ContainsAny(domain, " \t/@*?") || strings.HasPrefix(domain, "-") { + return fmt.Errorf("dns.domains[%d]: invalid domain %q", i, rule.Domain) + } + } + return nil +} diff --git a/internal/config/hosts.go b/internal/config/hosts.go index 4adaff3..07484e1 100644 --- a/internal/config/hosts.go +++ b/internal/config/hosts.go @@ -60,3 +60,34 @@ func (c *Config) StaticHost(name string) *StaticHost { } return nil } + +// Link returns the target of the link named name (case-insensitive). +func (c *Config) Link(name string) (string, bool) { + for key, target := range c.Links { + if strings.EqualFold(key, name) { + return target, true + } + } + return "", false +} + +// ValidateLinks keeps link names usable as selectors and shell aliases and +// rejects chains, which could loop. +func (c *Config) ValidateLinks() error { + for name, target := range c.Links { + if !staticHostName.MatchString(name) || strings.Contains(name, "/") { + return fmt.Errorf("links: name %q must start with a letter or digit and contain only letters, digits, dots, underscores, or hyphens", name) + } + if c.StaticHost(name) != nil { + return fmt.Errorf("links: %q is also a static host", name) + } + target = strings.TrimSpace(target) + if target == "" || strings.HasPrefix(target, "-") || strings.ContainsAny(target, " \t\n\r@") { + return fmt.Errorf("links.%s: invalid target %q", name, target) + } + if _, chained := c.Link(target); chained { + return fmt.Errorf("links.%s: target %q is another link", name, target) + } + } + return nil +} diff --git a/internal/config/insights_test.go b/internal/config/insights_test.go index 541c6a9..74da99f 100644 --- a/internal/config/insights_test.go +++ b/internal/config/insights_test.go @@ -106,3 +106,15 @@ func TestTUIColumnsValidation(t *testing.T) { } } } + +func TestDNSConfigValidation(t *testing.T) { + cfg := loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\ndns:\n suggest: Always\n domains:\n - match: \"mx*\"\n domain: easysahre.de\n")) + if cfg.DNS.SuggestMode() != DNSAlways || cfg.DNS.SaveLinkMode() != DNSAsk || len(cfg.DNS.Domains) != 1 { + t.Fatalf("dns: %+v", cfg.DNS) + } + for _, bad := range []DNSConfig{{Suggest: "sometimes"}, {SaveLink: "yes"}, {Domains: []DNSDomain{{Match: "[", Domain: "a.de"}}}, {Domains: []DNSDomain{{Domain: " "}}}, {Domains: []DNSDomain{{Domain: "a b.de"}}}} { + if err := (&Config{DNS: bad}).ValidateDNS(); err == nil { + t.Errorf("%+v accepted", bad) + } + } +} diff --git a/internal/setup/wizard.go b/internal/setup/wizard.go index 69232db..42587ce 100644 --- a/internal/setup/wizard.go +++ b/internal/setup/wizard.go @@ -3,6 +3,7 @@ package setup import ( "errors" "fmt" + "io" "os" "path/filepath" "sort" @@ -181,6 +182,11 @@ func editResolverCache(cfg *config.Config) error { hostnameDomain := cfg.Resolver.HostnameDomain cacheTTL := strconv.Itoa(cfg.Cache.TTL) cachePath := cfg.Cache.Path + dnsSuggest, dnsSaveLink := cfg.DNS.SuggestMode(), cfg.DNS.SaveLinkMode() + dnsDomains := formatDNSDomains(cfg.DNS.Domains) + modes := func(ask, always, never string) []huh.Option[string] { + return []huh.Option[string]{huh.NewOption(ask, config.DNSAsk), huh.NewOption(always, config.DNSAlways), huh.NewOption(never, config.DNSNever)} + } err := huh.NewForm(huh.NewGroup( huh.NewInput(). Title("Resolver strategies"). @@ -214,7 +220,25 @@ func editResolverCache(cfg *config.Config) error { Title("Cache file"). Description("Where resolved hosts are stored. Leave empty for the default location."). Value(&cachePath), - ).Title("Resolver & cache")).Run() + ).Title("Resolver & cache"), huh.NewGroup( + huh.NewSelect[string](). + Title("Unknown names: suggest the host behind the DNS address?"). + Options(modes("ask", "always take the first suggestion (also in scripts)", "never (no DNS lookup)")...). + Value(&dnsSuggest), + huh.NewSelect[string](). + Title("Save a shortcut (link) after a suggestion?"). + Options(modes("ask", "always", "never")...). + Value(&dnsSaveLink), + huh.NewText(). + Title("DNS domains for short names"). + Description("One rule per line: PATTERN = DOMAIN, e.g.\nmx* = easysahre.de\nah* = jhfduwia.de\nA line with only a domain applies to every name."). + Lines(5). + Value(&dnsDomains). + Validate(func(s string) error { + _, err := parseDNSDomains(s) + return err + }), + ).Title("DNS names")).Run() if err != nil { return err } @@ -224,9 +248,49 @@ func editResolverCache(cfg *config.Config) error { cfg.Resolver.HostnameDomain = strings.Trim(strings.TrimSpace(hostnameDomain), ".") cfg.Cache.TTL, _ = strconv.Atoi(cacheTTL) cfg.Cache.Path = strings.TrimSpace(cachePath) + cfg.DNS.Domains, _ = parseDNSDomains(dnsDomains) + cfg.DNS.Suggest, cfg.DNS.SaveLink = keepDefault(dnsSuggest), keepDefault(dnsSaveLink) return nil } +// keepDefault stores "ask" as unset, so the config only lists changes. +func keepDefault(mode string) string { + if mode == config.DNSAsk { + return "" + } + return mode +} + +func formatDNSDomains(rules []config.DNSDomain) string { + lines := make([]string, 0, len(rules)) + for _, rule := range rules { + if rule.Match == "" { + lines = append(lines, rule.Domain) + } else { + lines = append(lines, rule.Match+" = "+rule.Domain) + } + } + return strings.Join(lines, "\n") +} + +// parseDNSDomains reads "PATTERN = DOMAIN" lines; a bare domain matches all names. +func parseDNSDomains(text string) ([]config.DNSDomain, error) { + var rules []config.DNSDomain + for _, line := range strings.Split(text, "\n") { + line = strings.TrimSpace(line) + if line == "" { + continue + } + rule := config.DNSDomain{Domain: line} + if match, domain, ok := strings.Cut(line, "="); ok { + rule = config.DNSDomain{Match: strings.TrimSpace(match), Domain: strings.TrimSpace(domain)} + } + rules = append(rules, rule) + } + err := (&config.Config{DNS: config.DNSConfig{Domains: rules}}).ValidateDNS() + return rules, err +} + func editShortcuts(cfg *config.Config) error { shortcutDomains := strings.Join(cfg.Shortcuts.Domains, ", ") stripHyphens := cfg.Shortcuts.StripHyphens @@ -367,9 +431,15 @@ func validateStrategies(s string) error { func parseStrategies(s string) []string { return splitList(s) } // Save validates cfg and writes it to the config file, replacing the old file. -func Save(cfg config.Config) error { return save(cfg) } +func Save(cfg config.Config) error { return SaveTo(cfg, os.Stdout) } -func save(cfg config.Config) error { +// SaveTo is Save with the confirmation written to w; callers that run +// before a connection pass os.Stderr to keep stdout clean. +func SaveTo(cfg config.Config, w io.Writer) error { return saveTo(cfg, w) } + +func save(cfg config.Config) error { return saveTo(cfg, os.Stdout) } + +func saveTo(cfg config.Config, w io.Writer) error { if err := config.ValidateCommandAlias(cfg.Shell.Alias); err != nil { return err } @@ -385,6 +455,12 @@ func save(cfg config.Config) error { if err := cfg.ValidateHosts(); err != nil { return err } + if err := cfg.ValidateLinks(); err != nil { + return err + } + if err := cfg.ValidateDNS(); err != nil { + return err + } if err := cfg.ValidateOperations(); err != nil { return err } @@ -502,6 +578,38 @@ func save(cfg config.Config) error { } } + if cfg.DNS.Suggest != "" || cfg.DNS.SaveLink != "" || len(cfg.DNS.Domains) > 0 { + b.WriteString("\ndns:\n") + if cfg.DNS.Suggest != "" { + fmt.Fprintf(&b, " suggest: %s\n", cfg.DNS.SuggestMode()) + } + if cfg.DNS.SaveLink != "" { + fmt.Fprintf(&b, " save_link: %s\n", cfg.DNS.SaveLinkMode()) + } + if len(cfg.DNS.Domains) > 0 { + b.WriteString(" domains:\n") + for _, rule := range cfg.DNS.Domains { + if rule.Match != "" { + fmt.Fprintf(&b, " - match: %q\n domain: %q\n", rule.Match, rule.Domain) + } else { + fmt.Fprintf(&b, " - domain: %q\n", rule.Domain) + } + } + } + } + + if len(cfg.Links) > 0 { + b.WriteString("\nlinks:\n") + names := make([]string, 0, len(cfg.Links)) + for name := range cfg.Links { + names = append(names, name) + } + sort.Strings(names) + for _, name := range names { + fmt.Fprintf(&b, " %s: %q\n", strings.ToLower(name), cfg.Links[name]) + } + } + if len(cfg.Groups) > 0 { b.WriteString("\ngroups:\n") names := make([]string, 0, len(cfg.Groups)) @@ -599,7 +707,7 @@ func save(cfg config.Config) error { return fmt.Errorf("writing config: %w", err) } - fmt.Printf("\nConfig saved → %s\n", path) + fmt.Fprintf(w, "\nConfig saved → %s\n", path) return nil } diff --git a/internal/setup/wizard_test.go b/internal/setup/wizard_test.go index c63e2e4..27bf5d8 100644 --- a/internal/setup/wizard_test.go +++ b/internal/setup/wizard_test.go @@ -771,3 +771,29 @@ func TestSaveRoundtripNetBoxInsightSettings(t *testing.T) { } } } + +func TestDNSDomainsTextAndSave(t *testing.T) { + rules, err := parseDNSDomains("mx* = easysahre.de\n\nah* = jhfduwia.de\nfallback.de\n") + if err != nil || len(rules) != 3 || rules[0] != (config.DNSDomain{Match: "mx*", Domain: "easysahre.de"}) || rules[2].Match != "" { + t.Fatalf("parsed %+v, %v", rules, err) + } + if formatDNSDomains(rules) != "mx* = easysahre.de\nah* = jhfduwia.de\nfallback.de" { + t.Fatalf("format: %q", formatDNSDomains(rules)) + } + if _, err := parseDNSDomains("mx* = "); err == nil { + t.Fatal("empty domain accepted") + } + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + cfg := config.Config{NetBox: config.NetBoxConfig{URL: "https://nb.example"}, Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}}, + DNS: config.DNSConfig{Suggest: "never", SaveLink: "always", Domains: rules}, Links: map[string]string{"mx123": "prod/web07"}} + if err := Save(cfg); err != nil { + t.Fatal(err) + } + loaded, err := config.Load() + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(loaded.DNS, cfg.DNS) || loaded.Links["mx123"] != "prod/web07" { + t.Fatalf("lost: %+v %v", loaded.DNS, loaded.Links) + } +}