package main import ( "context" "encoding/json" "errors" "fmt" "io" "net" "os" "os/exec" "runtime" "sort" "strings" "text/tabwriter" "time" "github.com/spf13/cobra" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" ) // hostCompletion completes cached hostnames for commands taking hosts. func hostCompletion(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) { return completeHosts(toComplete), cobra.ShellCompDirectiveNoFileComp } // 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) if err != nil { return netbox.HostEntry{}, nil, h, err } if h.Kind == config.StaticKind { return netbox.HostEntry{}, nil, h, fmt.Errorf("%s is a static host (hosts:) and has no NetBox record", h.Name) } client := newNetBoxClient(cfg) if client == nil { return netbox.HostEntry{}, nil, h, fmt.Errorf("no NetBox is configured (netssh configure)") } return netboxEntry(ctx, client, h.Name, h.Kind, h.ID, h) } // netboxEntry completes a cached host with its NetBox ID, looking it up if needed. func netboxEntry(ctx context.Context, client *netbox.Client, name, kind string, id int, h resolvedHost) (netbox.HostEntry, *netbox.Client, resolvedHost, error) { source, bare := netbox.SplitTarget(name) entry := netbox.HostEntry{Source: source, Name: bare, Kind: kind, ID: id} if id <= 0 { found, err := client.FindHost(ctx, name, kind) if err != nil { return entry, client, h, fmt.Errorf("NetBox: %w", err) } entry = found } return entry, client, h, nil } // openBrowser opens url with $BROWSER, open (macOS), or xdg-open. var openBrowser = func(url string) error { var cmd *exec.Cmd switch browser := os.Getenv("BROWSER"); { case browser != "": cmd = exec.Command(browser, url) case runtime.GOOS == "darwin": cmd = exec.Command("open", url) default: cmd = exec.Command("xdg-open", url) } cmd.Stdout, cmd.Stderr = nil, nil if err := cmd.Start(); err != nil { return fmt.Errorf("opening browser: %w (print the URL with --print)", err) } return cmd.Process.Release() } func openCmd() *cobra.Command { var printOnly bool cmd := &cobra.Command{ Use: "open HOST", Short: "Open the NetBox page of a host in the web browser", Long: "Open the device or virtual machine page in the NetBox web interface.\nThe browser is $BROWSER, else open (macOS) or xdg-open.", Args: cobra.ExactArgs(1), ValidArgsFunction: hostCompletion, RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() if err != nil { return err } ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() entry, client, _, err := netboxHost(ctx, cfg, args[0]) if err != nil { return err } url, err := client.WebURL(entry) if err != nil { return err } if printOnly { fmt.Fprintln(cmd.OutOrStdout(), url) return nil } fmt.Fprintf(os.Stderr, "Opening %s\n", url) return openBrowser(url) }, } cmd.Flags().BoolVar(&printOnly, "print", false, "Print the URL instead of opening it") return cmd } func infoCmd() *cobra.Command { var asJSON bool cmd := &cobra.Command{ Use: "info HOST", Short: "Show site, rack, role, platform, status and IP addresses of a host", Args: cobra.ExactArgs(1), ValidArgsFunction: hostCompletion, RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() if err != nil { return err } h, err := resolveTargetE(cfg, args[0], false) if err != nil { return err } out := cmd.OutOrStdout() if h.Kind == config.StaticKind { return printStaticInfo(out, cfg, h, asJSON) } client := newNetBoxClient(cfg) if client == nil { return fmt.Errorf("no NetBox is configured (netssh configure)") } ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) defer cancel() entry, _, _, err := netboxEntry(ctx, client, h.Name, h.Kind, h.ID, h) if err != nil { return err } details, err := client.GetDetails(ctx, entry) if err != nil && details.Name == "" { return fmt.Errorf("NetBox: %w", err) } if asJSON { return json.NewEncoder(out).Encode(map[string]any{"host": details, "connect": map[string]any{"address": h.IP, "source": h.Origin, "resolver": h.Resolver}}) } writeDetails(out, details, h) if err != nil { fmt.Fprintf(os.Stderr, "warning: %v\n", err) } return nil }, } cmd.Flags().BoolVar(&asJSON, "json", false, "Print JSON") return cmd } func printStaticInfo(w io.Writer, cfg *config.Config, h resolvedHost, asJSON bool) error { user, port := hostDefaults(cfg, h) if asJSON { 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) row(tw, "Address", h.IP) row(tw, "User", user) if port > 0 { row(tw, "Port", fmt.Sprint(port)) } row(tw, "Tags", strings.Join(h.Tags, ", ")) return tw.Flush() } func row(w io.Writer, label, value string) { if strings.TrimSpace(value) != "" { fmt.Fprintf(w, " %s\t%s\n", label, value) } } // formatDetails renders netssh info output; the TUI detail view uses it too. func formatDetails(d netbox.HostDetails, h resolvedHost) string { var b strings.Builder writeDetails(&b, d, h) return b.String() } func writeDetails(w io.Writer, d netbox.HostDetails, h resolvedHost) { tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0) header := d.Target() + "\t(" + d.Kind if d.Source != "" { header += ", NetBox " + d.Source } fmt.Fprintln(tw, header+")") status := d.StatusLabel if status == "" { status = d.Status } row(tw, "Status", status) row(tw, "Site", d.Site.Name) var locations []string for _, location := range d.Location { locations = append(locations, location.Name) } row(tw, "Location", strings.Join(locations, " › ")) row(tw, "Rack", strings.TrimSpace(d.Rack+" "+d.RackUnits())) if len(d.Location) > 0 || d.Rack != "" { row(tw, "Path", d.LocationPath()) } row(tw, "Role", d.Role.Name) row(tw, "Platform", d.Platform.Name) row(tw, "Tenant", d.Tenant.Name) row(tw, "Type", d.DeviceType) row(tw, "Serial", d.Serial) row(tw, "Asset tag", d.AssetTag) row(tw, "Cluster", d.Cluster) var resources []string if d.VCPUs != "" { resources = append(resources, d.VCPUs+" vCPU") } if d.MemoryMB > 0 { resources = append(resources, fmt.Sprintf("%d MB RAM", d.MemoryMB)) } if d.DiskGB > 0 { resources = append(resources, fmt.Sprintf("%d GB disk", d.DiskGB)) } row(tw, "Resources", strings.Join(resources, ", ")) row(tw, "Tags", strings.Join(d.Tags, ", ")) if h.IP != "" { via := h.Resolver if h.Origin != "" { via = strings.Trim(via+", "+h.Origin, ", ") } connect := h.IP if via != "" { connect += " (" + via + ")" } row(tw, "Connect", connect) } row(tw, "URL", d.URL) row(tw, "Description", d.Description) _ = tw.Flush() if len(d.IPs) == 0 { return } fmt.Fprintln(w, "\nIP addresses") tw = tabwriter.NewWriter(w, 0, 0, 2, ' ', 0) for _, ip := range d.IPs { mark := " " if ip.Primary { mark = "*" } extra := ip.Status if ip.Role != "" { extra = strings.Trim(extra+", "+ip.Role, ", ") } if ip.VRF != "" { extra = strings.Trim(extra+", vrf "+ip.VRF, ", ") } fmt.Fprintf(tw, " %s %s\t%s\t%s\t%s\n", mark, ip.Address, orDash(ip.Interface), ip.DNSName, extra) } _ = tw.Flush() } // whoisResult is what netssh whois found for one address. type whoisResult struct { Address string `json:"address"` NetBox []netbox.IPOwner `json:"netbox"` Prefixes []netbox.PrefixInfo `json:"prefixes"` Cached []string `json:"cached_hosts"` } func whoisCmd() *cobra.Command { var asJSON bool cmd := &cobra.Command{ Use: "whois ADDRESS|HOSTNAME", Short: "Find the host, interface and prefix an IP address belongs to", Long: `Look an IP address up in every NetBox instance and in the local cache: the device or VM and interface it is assigned to, its DNS name, and the prefixes containing it. A hostname is resolved through DNS first.`, Example: " netssh whois 10.20.0.15\n netssh whois mail.example.com", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() if err != nil { return err } ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) defer cancel() addresses, err := whoisAddresses(ctx, args[0]) if err != nil { return err } c := newCache(cfg) _ = c.Load() var client *netbox.Client if cfg.HasNetBox() { client = newNetBoxClient(cfg) } var results []whoisResult var warnings []error found := false for _, address := range addresses { r := whoisResult{Address: address} for _, e := range c.All() { if e.IP == address { r.Cached = append(r.Cached, e.Name) } } sort.Strings(r.Cached) if client != nil { owners, err := client.LookupIP(ctx, address) if err != nil { warnings = append(warnings, err) } r.NetBox = owners prefixes, err := client.PrefixesContaining(ctx, address) if err != nil { warnings = append(warnings, err) } r.Prefixes = prefixes } found = found || len(r.NetBox) > 0 || len(r.Cached) > 0 || len(r.Prefixes) > 0 results = append(results, r) } for _, warning := range warnings { fmt.Fprintf(os.Stderr, "warning: %v\n", warning) } out := cmd.OutOrStdout() if asJSON { return json.NewEncoder(out).Encode(results) } writeWhois(out, results) if !found { cmd.SilenceErrors, cmd.SilenceUsage = true, true return &commandExit{code: 1} } return nil }, } cmd.Flags().BoolVar(&asJSON, "json", false, "Print JSON") return cmd } // lookupHost is replaced in tests. var lookupHost = net.DefaultResolver.LookupHost func whoisAddresses(ctx context.Context, query string) ([]string, error) { query = strings.TrimSpace(query) if ip := net.ParseIP(query); ip != nil { return []string{ip.String()}, nil } if _, network, err := net.ParseCIDR(query); err == nil { return []string{network.IP.String()}, nil } addresses, err := lookupHost(ctx, query) if err != nil { return nil, fmt.Errorf("%q is no IP address and cannot be resolved: %w", query, err) } if len(addresses) == 0 { return nil, errors.New("no addresses found") } return addresses, nil } func writeWhois(w io.Writer, results []whoisResult) { for i, r := range results { if i > 0 { fmt.Fprintln(w) } fmt.Fprintln(w, r.Address) tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0) if len(r.NetBox) == 0 && len(r.Cached) == 0 && len(r.Prefixes) == 0 { fmt.Fprintln(tw, " not found in NetBox or the cache") } for _, o := range r.NetBox { owner := "unassigned" if o.Target() != "" { owner = o.Target() + " (" + o.HostKind + ")" if o.Interface != "" { owner += " " + o.Interface } } var extra []string if o.Status != "" { extra = append(extra, o.Status) } if o.VRF != "" { extra = append(extra, "vrf "+o.VRF) } if o.DNSName != "" { extra = append(extra, "dns "+o.DNSName) } if o.Description != "" { extra = append(extra, fmt.Sprintf("%q", o.Description)) } fmt.Fprintf(tw, " IP\t%s\t%s\t%s\n", o.Address, owner, strings.Join(extra, " ")) } for _, p := range r.Prefixes { var extra []string for _, pair := range [][2]string{{"", p.Status}, {"site ", p.Site}, {"role ", p.Role}, {"vlan ", p.VLAN}, {"vrf ", p.VRF}} { if pair[1] != "" { extra = append(extra, pair[0]+pair[1]) } } if p.Description != "" { extra = append(extra, fmt.Sprintf("%q", p.Description)) } prefix := p.Prefix if p.Source != "" { prefix += " (" + p.Source + ")" } fmt.Fprintf(tw, " Prefix\t%s\t%s\n", prefix, strings.Join(extra, " ")) } for _, name := range r.Cached { fmt.Fprintf(tw, " Cache\t%s\n", name) } _ = tw.Flush() } }