diff --git a/cmd/netssh/dns_suggest.go b/cmd/netssh/dns_suggest.go new file mode 100644 index 0000000..249ace0 --- /dev/null +++ b/cmd/netssh/dns_suggest.go @@ -0,0 +1,301 @@ +package main + +import ( + "bufio" + "context" + "errors" + "fmt" + "io" + "os" + "sort" + "strconv" + "strings" + "time" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" + internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh" +) + +// dnsSuggestion is a host that owns an address the queried name resolves to. +type dnsSuggestion struct { + target string // host selector, e.g. prod/web07 + reason string // e.g. "203.0.113.5 on eth0 (NetBox)" +} + +// dnsMatch is what a DNS lookup of an unknown name found. +type dnsMatch struct { + name string // the DNS name that resolved, e.g. mx123.webseite.de + addresses []string // its addresses + suggestions []dnsSuggestion +} + +// offerLinkFunc is offerLink; link add replaces it to avoid a second question. +// The first argument is dns.save_link. +var offerLinkFunc = offerLink + +// promptInput is replaced in tests. +var promptInput io.Reader = os.Stdin + +// promptReader buffers promptInput once, so that consecutive questions do +// not lose answers that a previous reader had already buffered. +var ( + promptReader *bufio.Reader + promptSource io.Reader +) + +func readAnswer() (string, error) { + if promptReader == nil || promptSource != promptInput { + promptReader, promptSource = bufio.NewReader(promptInput), promptInput + } + line, err := promptReader.ReadString('\n') + if err != nil && err != io.EOF { + return "", err + } + return strings.TrimSpace(line), nil +} + +// dnsNames lists the DNS names to try for query, following dns.domains. +func dnsNames(cfg *config.Config, query string) []string { + if !plainName(query) { + return nil + } + return cfg.DNS.Names(query) +} + +// lookupDNS resolves the first of names that has addresses. +func lookupDNS(ctx context.Context, names []string) (string, []string) { + for _, name := range names { + addresses, err := lookupHost(ctx, name) + if err == nil && len(addresses) > 0 { + return name, addresses + } + } + return "", nil +} + +// findDNSMatch resolves query through DNS and finds the hosts in NetBox and +// the cache that own the addresses. It returns nil when DNS knows no address. +func findDNSMatch(ctx context.Context, cfg *config.Config, query string) *dnsMatch { + if source, _ := netbox.SplitTarget(query); source != "" { + return nil + } + name, addresses := lookupDNS(ctx, dnsNames(cfg, query)) + if name == "" { + return nil + } + match := &dnsMatch{name: name, addresses: addresses} + seen := map[string]bool{} + add := func(target, reason string) { + if target != "" && !seen[strings.ToLower(target)] { + seen[strings.ToLower(target)] = true + match.suggestions = append(match.suggestions, dnsSuggestion{target: target, reason: reason}) + } + } + if cfg.HasNetBox() { + client := newNetBoxClient(cfg) + for _, address := range addresses { + owners, err := client.LookupIP(ctx, address) + if err != nil { + fmt.Fprintf(os.Stderr, "netssh: warning: %v\n", err) + } + for _, owner := range owners { + reason := address + if owner.Interface != "" { + reason += " on " + owner.Interface + } + add(owner.Target(), reason+" (NetBox)") + } + } + } + c := newCache(cfg) + _ = c.Load() + entries := c.All() + sort.Slice(entries, func(i, j int) bool { return entries[i].Name < entries[j].Name }) + for _, address := range addresses { + for _, e := range entries { + if e.IP == address { + source := "cache" + if e.Static { + source = "static host" + } + add(e.Name, address+" ("+source+")") + } + } + } + return match +} + +// resolveOrSuggest resolves host like resolveTargetE. When neither NetBox nor +// the cache know it, the name is resolved through DNS and the hosts owning +// its address are offered, in a terminal, together with a direct connection +// to the DNS name. Without a terminal the suggestion is part of the error. +func resolveOrSuggest(cfg *config.Config, host string, record bool) (resolvedHost, error) { + resolved, err := resolveTargetE(cfg, host, record) + if err == nil || !errors.Is(err, netbox.ErrHostNotFound) || cfg.DNS.SuggestMode() == config.DNSNever { + return resolved, err + } + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + match := findDNSMatch(ctx, cfg, host) + if match == nil { + return resolved, err + } + var ( + choice string + ok bool + promptErr error + ) + switch { + case cfg.DNS.SuggestMode() == config.DNSAlways: + choice, ok = match.first(host) + case !stdinIsTerminal(): + return resolved, fmt.Errorf("%w\n%s", err, match.describe()) + default: + choice, ok, promptErr = chooseDNSSuggestion(host, match) + } + if promptErr != nil { + return resolved, promptErr + } + if !ok { + return resolved, errors.New("cancelled") + } + if choice == "" { + if !internalssh.ValidAddress(match.name) { + return resolved, fmt.Errorf("refusing DNS name %q", match.name) + } + return resolvedHost{Name: host, Kind: "dns", IP: match.name, Origin: "dns"}, nil + } + resolved, err = resolveTargetE(cfg, choice, record) + if err != nil { + return resolved, err + } + offerLinkFunc(cfg.DNS.SaveLinkMode(), host, resolved.Name) + return resolved, nil +} + +// first takes the first suggestion for dns.suggest: always, or the DNS name +// itself when no host owns the address. +func (m *dnsMatch) first(query string) (string, bool) { + if len(m.suggestions) == 0 { + fmt.Fprintf(os.Stderr, "netssh: %s → %s (%s), no host owns it; connecting directly (dns.suggest: always)\n", query, m.name, strings.Join(m.addresses, ", ")) + return "", true + } + s := m.suggestions[0] + fmt.Fprintf(os.Stderr, "netssh: %s → %s, %s: connecting to %s (dns.suggest: always)\n", query, m.name, s.reason, s.target) + return s.target, true +} + +// describe renders the DNS result and the owning hosts for an error message. +func (m *dnsMatch) describe() string { + var b strings.Builder + fmt.Fprintf(&b, "DNS: %s → %s", m.name, strings.Join(m.addresses, ", ")) + if len(m.suggestions) == 0 { + fmt.Fprintf(&b, "; no host in NetBox or the cache has this address") + return b.String() + } + for _, s := range m.suggestions { + fmt.Fprintf(&b, "\n netssh %s # %s", s.target, s.reason) + } + return b.String() +} + +// chooseDNSSuggestion asks which host to connect to. It returns the chosen +// target, "" for a direct connection to the DNS name, and false on cancel. +func chooseDNSSuggestion(query string, m *dnsMatch) (string, bool, error) { + fmt.Fprintf(os.Stderr, "netssh: %q is not in NetBox or the cache. DNS: %s → %s\n", query, m.name, strings.Join(m.addresses, ", ")) + if len(m.suggestions) == 0 { + fmt.Fprintln(os.Stderr, "No host in NetBox or the cache has this address.") + } + for i, s := range m.suggestions { + fmt.Fprintf(os.Stderr, " %d) %s %s\n", i+1, s.target, s.reason) + } + direct := len(m.suggestions) + 1 + fmt.Fprintf(os.Stderr, " %d) connect directly to %s\n", direct, m.name) + fmt.Fprintf(os.Stderr, "Choose [1-%d, Enter = 1, q = cancel]: ", direct) + answer, err := readAnswer() + if err != nil { + return "", false, err + } + switch { + case answer == "": + answer = "1" + case strings.EqualFold(answer, "q"): + return "", false, nil + } + n, convErr := strconv.Atoi(answer) + if convErr != nil || n < 1 || n > direct { + return "", false, fmt.Errorf("invalid choice %q", answer) + } + if n == direct { + return "", true, nil + } + return m.suggestions[n-1].target, true, nil +} + +// linkName proposes a link name for what the user typed: the first label of +// a DNS name ("mx123" for mx123.webseite.de), else the input. +func linkName(query string) string { + if first, _, ok := strings.Cut(query, "."); ok && first != "" { + return strings.ToLower(first) + } + return strings.ToLower(query) +} + +// offerLink asks whether to save query as a link to target, so that the next +// netssh NAME (and the shell alias NAME) connects without asking. +func offerLink(mode, query, target string) { + name := linkName(query) + if strings.EqualFold(name, target) || mode == config.DNSNever { + return + } + if mode == config.DNSAlways { + if err := saveLink(name, target); err != nil { + fmt.Fprintf(os.Stderr, "netssh: shortcut not saved: %v\n", err) + return + } + fmt.Fprintf(os.Stderr, "netssh: saved shortcut %s → %s (dns.save_link: always)\n", name, target) + return + } + if !stdinIsTerminal() { + return + } + fmt.Fprintf(os.Stderr, "Save shortcut %q → %s (netssh %s, shell alias %s)? [y/N or another name]: ", name, target, name, name) + answer, err := readAnswer() + if err != nil { + return + } + switch strings.ToLower(answer) { + case "", "n", "no": + return + case "y", "yes", "j", "ja": + default: + name = strings.ToLower(answer) + } + if err := saveLink(name, target); err != nil { + fmt.Fprintf(os.Stderr, "netssh: shortcut not saved: %v\n", err) + return + } + fmt.Fprintf(os.Stderr, "netssh: saved; netssh %s now connects to %s (new shells also get the alias %s).\n", name, target, name) +} + +// saveLink adds a link to the config file and regenerates the shell aliases. +var saveLink = func(name, target string) error { + cfg, err := config.Load() + if err != nil { + return err + } + if cfg.Links == nil { + cfg.Links = map[string]string{} + } + for key := range cfg.Links { + if strings.EqualFold(key, name) { + delete(cfg.Links, key) + } + } + cfg.Links[name] = target + if err := cfg.ValidateLinks(); err != nil { + return err + } + return saveHostsTo(cfg, os.Stderr) +} diff --git a/cmd/netssh/dns_suggest_test.go b/cmd/netssh/dns_suggest_test.go new file mode 100644 index 0000000..13af199 --- /dev/null +++ b/cmd/netssh/dns_suggest_test.go @@ -0,0 +1,199 @@ +package main + +import ( + "context" + "errors" + "fmt" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" +) + +// dnsEnv: NetBox "prod" knows web07 (203.0.113.5 on eth0) but not mx123; +// DNS resolves mx123.webseite.de to 203.0.113.5. +func dnsEnv(t *testing.T, extra string) { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api/ipam/ip-addresses/": + if r.URL.Query().Get("address") == "203.0.113.5" { + fmt.Fprint(w, `{"count":1,"results":[{"address":"203.0.113.5/24","assigned_object":{"name":"eth0","virtual_machine":{"id":7,"name":"web07"}}}]}`) + return + } + fmt.Fprint(w, `{"count":0,"results":[]}`) + case "/api/dcim/devices/", "/api/virtualization/virtual-machines/": + fmt.Fprint(w, `{"count":0,"results":[]}`) + default: + http.NotFound(w, r) + } + })) + t.Cleanup(srv.Close) + insightEnv(t, fmt.Sprintf("netboxes:\n - name: prod\n url: %s\n token: t\nshortcuts:\n domains: [shortcut.example]\ndns:\n domains:\n - match: \"mx*\"\n domain: webseite.de\n - match: \"ah*\"\n domain: other.example\n%s", srv.URL, extra)) + cfg, err := config.Load() + if err != nil { + t.Fatal(err) + } + c := cache.New(cfg.CachePath(), 3600) + c.Upsert(cache.Entry{Name: "prod/web07", IP: "203.0.113.5", Kind: "vm", ID: 7}) + if err := c.Save(); err != nil { + t.Fatal(err) + } + old := lookupHost + lookupHost = func(_ context.Context, name string) ([]string, error) { + if name == "mx123.webseite.de" { + return []string{"203.0.113.5"}, nil + } + if strings.HasSuffix(name, ".shortcut.example") { + t.Errorf("shortcut domain looked up: %s", name) + } + return nil, errors.New("no such host") + } + t.Cleanup(func() { lookupHost = old }) +} + +func answer(t *testing.T, input string) { + t.Helper() + old := promptInput + promptInput = strings.NewReader(input) + t.Cleanup(func() { promptInput = old }) +} + +func TestDNSNames(t *testing.T) { + cfg := &config.Config{ + Shortcuts: config.ShortcutsConfig{Domains: []string{"shortcut.example"}}, + DNS: config.DNSConfig{Domains: []config.DNSDomain{ + {Match: "mx*", Domain: "easysahre.de"}, {Match: "ah*", Domain: ".jhfduwia.de."}, {Match: "MX1*", Domain: "backup.de"}, + }}, + } + for query, want := range map[string]string{ + "mx123": "mx123.easysahre.de mx123.backup.de", + "ah123": "ah123.jhfduwia.de", + "web01": "web01", + "mx123.webseite.de": "mx123.webseite.de", + } { + if got := strings.Join(dnsNames(cfg, query), " "); got != want { + t.Errorf("%s: got %q, want %q", query, got, want) + } + } + cfg.DNS.Domains = append(cfg.DNS.Domains, config.DNSDomain{Domain: "fallback.de"}) + if got := strings.Join(dnsNames(cfg, "web01"), " "); got != "web01.fallback.de" { + t.Fatalf("rule without match: %q", got) + } + if dnsNames(cfg, "-oProxyCommand=x") != nil { + t.Fatal("option-like name looked up") + } +} + +func TestDNSSuggestionWithoutTerminalExplains(t *testing.T) { + dnsEnv(t, "") + stubTerminal(t, false) + cfg, _ := config.Load() + _, err := resolveOrSuggest(cfg, "mx123", false) + if err == nil { + t.Fatal("must not connect without asking") + } + for _, want := range []string{"host not found", "DNS: mx123.webseite.de → 203.0.113.5", "netssh prod/web07", "203.0.113.5 on eth0 (NetBox)"} { + if !strings.Contains(err.Error(), want) { + t.Errorf("missing %q in %v", want, err) + } + } +} + +func TestDNSSuggestionChooseHostAndSaveLink(t *testing.T) { + dnsEnv(t, "") + stubTerminal(t, true) + var saved [2]string + old := saveLink + saveLink = func(name, target string) error { saved = [2]string{name, target}; return nil } + t.Cleanup(func() { saveLink = old }) + answer(t, "\ny\n") + + cfg, _ := config.Load() + h, err := resolveOrSuggest(cfg, "mx123.webseite.de", false) + if err != nil { + t.Fatal(err) + } + if h.Name != "prod/web07" || h.IP != "203.0.113.5" { + t.Fatalf("resolved %+v", h) + } + if saved != [2]string{"mx123", "prod/web07"} { + t.Fatalf("link %v", saved) + } +} + +func TestDNSSuggestionDirectAndCancel(t *testing.T) { + dnsEnv(t, "") + stubTerminal(t, true) + cfg, _ := config.Load() + answer(t, "2\n") + h, err := resolveOrSuggest(cfg, "mx123", false) + if err != nil || h.Kind != "dns" || h.IP != "mx123.webseite.de" || h.Name != "mx123" { + t.Fatalf("direct: %+v %v", h, err) + } + answer(t, "q\n") + if _, err := resolveOrSuggest(cfg, "mx123", false); err == nil || err.Error() != "cancelled" { + t.Fatalf("cancel: %v", err) + } + answer(t, "7\n") + if _, err := resolveOrSuggest(cfg, "mx123", false); err == nil || !strings.Contains(err.Error(), "invalid choice") { + t.Fatalf("invalid: %v", err) + } + // Names DNS does not know keep the plain not-found error. + if _, err := resolveOrSuggest(cfg, "nothere", false); err == nil || strings.Contains(err.Error(), "DNS") { + t.Fatalf("unknown: %v", err) + } +} + +func stubSaveLink(t *testing.T) *[][2]string { + t.Helper() + var saved [][2]string + old := saveLink + saveLink = func(name, target string) error { saved = append(saved, [2]string{name, target}); return nil } + t.Cleanup(func() { saveLink = old }) + return &saved +} + +func TestDNSSuggestAlwaysWorksWithoutTerminal(t *testing.T) { + dnsEnv(t, " suggest: always\n save_link: always\n") + stubTerminal(t, false) + saved := stubSaveLink(t) + cfg, _ := config.Load() + h, err := resolveOrSuggest(cfg, "mx123", true) + if err != nil || h.Name != "prod/web07" { + t.Fatalf("always: %+v %v", h, err) + } + if len(*saved) != 1 || (*saved)[0] != [2]string{"mx123", "prod/web07"} { + t.Fatalf("save_link always: %v", *saved) + } +} + +func TestDNSSaveLinkNeverAndAskWithoutTerminal(t *testing.T) { + dnsEnv(t, " suggest: always\n save_link: never\n") + stubTerminal(t, false) + saved := stubSaveLink(t) + cfg, _ := config.Load() + if _, err := resolveOrSuggest(cfg, "mx123", false); err != nil || len(*saved) != 0 { + t.Fatalf("never: %v %v", *saved, err) + } + cfg.DNS.SaveLink = "" + if _, err := resolveOrSuggest(cfg, "mx123", false); err != nil || len(*saved) != 0 { + t.Fatalf("ask without terminal must not save: %v %v", *saved, err) + } +} + +func TestDNSSuggestNeverSkipsLookup(t *testing.T) { + dnsEnv(t, " suggest: never\n") + stubTerminal(t, true) + looked := false + old := lookupHost + lookupHost = func(context.Context, string) ([]string, error) { looked = true; return []string{"203.0.113.5"}, nil } + t.Cleanup(func() { lookupHost = old }) + cfg, _ := config.Load() + if _, err := resolveOrSuggest(cfg, "mx123", false); err == nil || looked { + t.Fatalf("never: looked=%v err=%v", looked, err) + } +} diff --git a/cmd/netssh/hosts.go b/cmd/netssh/hosts.go index 94b5e26..dfe70b7 100644 --- a/cmd/netssh/hosts.go +++ b/cmd/netssh/hosts.go @@ -2,6 +2,7 @@ package main import ( "fmt" + "io" "os" "strings" "text/tabwriter" @@ -146,8 +147,11 @@ func hostsRemoveCmd() *cobra.Command { } // saveHosts writes the config and regenerates the shell aliases. -func saveHosts(cfg *config.Config) error { - if err := setup.Save(*cfg); err != nil { +func saveHosts(cfg *config.Config) error { return saveHostsTo(cfg, os.Stdout) } + +// saveHostsTo writes the config, reporting to w, and regenerates the aliases. +func saveHostsTo(cfg *config.Config, w io.Writer) error { + if err := setup.SaveTo(*cfg, w); err != nil { return err } loaded, err := config.Load() diff --git a/cmd/netssh/insights.go b/cmd/netssh/insights.go index 6fc1e69..72fd23e 100644 --- a/cmd/netssh/insights.go +++ b/cmd/netssh/insights.go @@ -29,12 +29,15 @@ func hostCompletion(cmd *cobra.Command, args []string, toComplete string) ([]cob // netboxHost finds the NetBox record of a host given like on the command line // (shortcut, instance/host). The cache supplies the ID when it has one. func netboxHost(ctx context.Context, cfg *config.Config, target string) (netbox.HostEntry, *netbox.Client, resolvedHost, error) { - h, err := resolveTargetE(cfg, target, false) + h, err := resolveOrSuggest(cfg, target, false) if err != nil { return netbox.HostEntry{}, nil, h, err } - if h.Kind == config.StaticKind { + switch h.Kind { + case config.StaticKind: return netbox.HostEntry{}, nil, h, fmt.Errorf("%s is a static host (hosts:) and has no NetBox record", h.Name) + case "dns": + return netbox.HostEntry{}, nil, h, fmt.Errorf("%s (%s) is not in NetBox", h.Name, h.IP) } client := newNetBoxClient(cfg) if client == nil { @@ -122,12 +125,12 @@ func infoCmd() *cobra.Command { if err != nil { return err } - h, err := resolveTargetE(cfg, args[0], false) + h, err := resolveOrSuggest(cfg, args[0], false) if err != nil { return err } out := cmd.OutOrStdout() - if h.Kind == config.StaticKind { + if h.Kind == config.StaticKind || h.Kind == "dns" { return printStaticInfo(out, cfg, h, asJSON) } client := newNetBoxClient(cfg) @@ -164,7 +167,11 @@ func printStaticInfo(w io.Writer, cfg *config.Config, h resolvedHost, asJSON boo return json.NewEncoder(w).Encode(map[string]any{"host": map[string]any{"name": h.Name, "kind": h.Kind, "address": h.IP, "user": user, "port": port, "tags": h.Tags}}) } tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0) - fmt.Fprintf(tw, "%s\t(static host from hosts:)\n", h.Name) + origin := "(static host from hosts:)" + if h.Kind == "dns" { + origin = "(DNS name, not in NetBox)" + } + fmt.Fprintf(tw, "%s\t%s\n", h.Name, origin) row(tw, "Address", h.IP) row(tw, "User", user) if port > 0 { @@ -290,6 +297,14 @@ prefixes containing it. A hostname is resolved through DNS first.`, ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) defer cancel() addresses, err := whoisAddresses(ctx, args[0]) + if err != nil { + // A short name like mx123 may resolve with a shortcut domain. + if names := dnsNames(cfg, args[0]); len(names) > 0 && names[0] != args[0] { + if _, found := lookupDNS(ctx, names); len(found) > 0 { + addresses, err = found, nil + } + } + } if err != nil { return err } diff --git a/cmd/netssh/main.go b/cmd/netssh/main.go index 7c763e8..c35895b 100644 --- a/cmd/netssh/main.go +++ b/cmd/netssh/main.go @@ -276,13 +276,16 @@ func upsertResolved(c *cache.Cache, entry cache.Entry) (previous string) { // resolveTarget finds host in the cache (also by shortcut) or NetBox and // resolves its address. It exits on failure. func resolveTarget(cfg *config.Config, host string) resolvedHost { - result, err := resolveTargetE(cfg, host, true) + result, err := resolveOrSuggest(cfg, host, true) if err != nil { fatalf("%v", err) } return result } func resolveTargetE(cfg *config.Config, host string, record bool) (resolvedHost, error) { + if target, ok := cfg.Link(host); ok { + host = target + } c := newCache(cfg) _ = c.Load() if record { @@ -343,7 +346,7 @@ func resolveTargetE(cfg *config.Config, host string, record bool) (resolvedHost, } if !cfg.HasNetBox() { - return resolvedHost{}, fmt.Errorf("host %q is not in hosts: and no NetBox is configured (netssh configure)", host) + return resolvedHost{}, fmt.Errorf("host %q is not in hosts: and no NetBox is configured (netssh configure): %w", host, netbox.ErrHostNotFound) } nbClient := newNetBoxClient(cfg)