feat(config): add links and dns settings

- links: short names mapped to host selectors, validated against chains
  and static host names
- dns.suggest / dns.save_link: ask, always or never
- dns.domains: domain rules per name pattern (mx* -> easysahre.de)
- the wizard edits the dns settings under Resolver & cache and keeps links;
  setup.SaveTo reports to a chosen writer

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Sebastian UnterschützandClaude Opus 5.5 committed 2026-11-18 13:07:08 +01:00
1 parent c408d529a0
commit 5c41a5eb6f
6 files changed
+289 -5

No files matched your search

+12 -1
View File
@@ -26,6 +26,11 @@ type Config struct {
Hosts []StaticHost `mapstructure:"hosts"`
// Groups name lists of hosts and selectors for netssh multi (@name).
Groups map[string][]string `mapstructure:"groups"`
// 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"`
}
@@ -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
}
+96
View File
@@ -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
}
+31
View File
@@ -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
}
+12
View File
@@ -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)
}
}
}
+112 -4
View File
@@ -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
}
+26
View File
@@ -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)
}
}