feat: NetBox insights, host tools and configurable TUI
Test / test (pull_request) Successful in 4m15s
Test / test (pull_request) Successful in 4m15s
- info/open/whois: NetBox details (site, nested locations, rack units, role, platform, tenant, IPs per interface), web page, reverse IP lookup - cache status, site, role, platform, tenant, location chain and rack; ask before connecting to hosts in ssh.warn_status (--force skips) - ssh rules and command restrictions match site/role/platform/tenant/status - tui.columns selects what the TUI shows; optional TCP reachability column; detail view (Ctrl+L), NetBox page (Ctrl+G), status/location filters - resolver.fallback tries other strategies' addresses when unreachable - copy-id, known-hosts reset and address-change notices - export ansible (YAML/INI) and export ssh-config - token: keyring stores NetBox tokens in the system keyring - fix stale menu number in testenv configure test Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
e5bde9c61f
commit
1660bb3098
39 files changed
+4868
-96
No files matched your search
@@ -0,0 +1,422 @@
|
||||
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()
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user