package main import ( "fmt" "io" "os" "regexp" "sort" "strconv" "strings" "time" "github.com/spf13/cobra" "go.yaml.in/yaml/v3" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage" ) // exportFilter selects the cached hosts to export. type exportFilter struct { tag, kind, instance, status string noStatic bool output string } func (f *exportFilter) register(cmd *cobra.Command) { cmd.Flags().StringVar(&f.tag, "tag", "", "Only hosts with this tag") cmd.Flags().StringVar(&f.kind, "kind", "", "Only this kind: device, vm, or static") cmd.Flags().StringVar(&f.instance, "instance", "", "Only hosts of this NetBox instance") cmd.Flags().StringVar(&f.status, "status", "", "Only hosts with this NetBox status, e.g. active") cmd.Flags().BoolVar(&f.noStatic, "no-static", false, "Leave out static hosts (hosts:)") cmd.Flags().StringVarP(&f.output, "output", "o", "", "Write to this file instead of stdout") _ = cmd.RegisterFlagCompletionFunc("kind", cobra.FixedCompletions([]cobra.Completion{"device", "vm", "static"}, cobra.ShellCompDirectiveNoFileComp)) } func (f exportFilter) matches(e cache.Entry) bool { instance, _ := netbox.SplitTarget(e.Name) switch { case f.noStatic && e.Static, f.kind != "" && !strings.EqualFold(e.Kind, f.kind), f.instance != "" && !strings.EqualFold(instance, f.instance), f.status != "" && !strings.EqualFold(e.Status, f.status), f.tag != "" && !hasTag(e.Tags, f.tag): return false } return true } // exportHost is one host with the connection settings netssh would use. type exportHost struct { entry cache.Entry name string // unique inventory / Host name address string user string port int opts config.SSHOptions } // exportHosts loads the filtered cache entries. Hostnames that exist in // several instances get the instance as prefix ("prod-web01"), others stay bare. func exportHosts(cfg *config.Config, f exportFilter) ([]exportHost, error) { c := newCache(cfg) if err := c.Load(); err != nil { return nil, err } var entries []cache.Entry counts := map[string]int{} for _, e := range c.All() { if !f.matches(e) { continue } entries = append(entries, e) _, name := netbox.SplitTarget(e.Name) counts[strings.ToLower(name)]++ } sort.Slice(entries, func(i, j int) bool { return entries[i].Name < entries[j].Name }) out := make([]exportHost, 0, len(entries)) for _, e := range entries { instance, name := netbox.SplitTarget(e.Name) if counts[strings.ToLower(name)] > 1 && instance != "" { name = instance + "-" + name } h := hostFromEntry(e, "cache") user, port := hostDefaults(cfg, h) out = append(out, exportHost{entry: e, name: name, address: e.IP, user: user, port: port, opts: hostOptions(cfg, h)}) } if len(out) == 0 { return nil, fmt.Errorf("no cached hosts match; run netssh cache refresh first") } return out, nil } // writeExport writes data to the --output file, or stdout. func writeExport(f exportFilter, data []byte) error { if f.output == "" || f.output == "-" { _, err := os.Stdout.Write(data) return err } if err := storage.WriteFile(f.output, data, 0o600); err != nil { return err } fmt.Fprintf(os.Stderr, "Written → %s\n", f.output) return nil } func exportCmd() *cobra.Command { cmd := &cobra.Command{ Use: "export", Short: "Export cached hosts as Ansible inventory or ssh_config", } cmd.AddCommand(exportAnsibleCmd(), exportSSHConfigCmd()) return cmd } // ansibleGroupKeys are the attributes --group-by accepts. var ansibleGroupKeys = []string{"tag", "site", "location", "rack", "role", "platform", "tenant", "kind", "instance", "cluster", "status"} func exportAnsibleCmd() *cobra.Command { var f exportFilter var format, groupBy string var noVars bool cmd := &cobra.Command{ Use: "ansible", Short: "Print an Ansible inventory (YAML or INI) of the cached hosts", Long: `Print an Ansible inventory of the cached hosts. Every host gets ansible_host (the address netssh connects to), ansible_user, ansible_port and, with a jump host, ansible_ssh_common_args. NetBox attributes are added as netbox_* host variables (disable with --no-vars). Groups are formed from host attributes, named like tag_prod, site_fsn1, role_router or platform_junos. Choose them with --group-by (comma-separated: ` + strings.Join(ansibleGroupKeys, ", ") + `, or none).`, Example: ` netssh export ansible > inventory.yml netssh export ansible --format ini --group-by site,role -o hosts.ini netssh export ansible --tag prod --status active`, Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() if err != nil { return err } keys, err := parseGroupBy(groupBy) if err != nil { return err } hosts, err := exportHosts(cfg, f) if err != nil { return err } inv := buildInventory(hosts, keys, !noVars) var data []byte switch strings.ToLower(format) { case "yaml", "yml": data, err = inv.yaml() case "ini": data = inv.ini() default: return fmt.Errorf("--format must be yaml or ini") } if err != nil { return err } return writeExport(f, data) }, } f.register(cmd) cmd.Flags().StringVar(&format, "format", "yaml", "Inventory format: yaml or ini") cmd.Flags().StringVar(&groupBy, "group-by", "tag,site,role,platform,kind", "Attributes to group hosts by, or none") cmd.Flags().BoolVar(&noVars, "no-vars", false, "Leave out the netbox_* host variables") _ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]cobra.Completion{"yaml", "ini"}, cobra.ShellCompDirectiveNoFileComp)) return cmd } func parseGroupBy(value string) ([]string, error) { if strings.EqualFold(strings.TrimSpace(value), "none") || strings.TrimSpace(value) == "" { return nil, nil } var keys []string for _, key := range strings.Split(value, ",") { key = strings.ToLower(strings.TrimSpace(key)) valid := false for _, known := range ansibleGroupKeys { valid = valid || key == known } if !valid { return nil, fmt.Errorf("--group-by: unknown attribute %q; use %s, or none", key, strings.Join(ansibleGroupKeys, ", ")) } keys = append(keys, key) } return keys, nil } // inventoryVar is a host variable; list values stay lists in YAML. type inventoryVar struct { key string value any // string, int, or []string } type inventory struct { hosts []string vars map[string][]inventoryVar groups map[string][]string } var groupInvalid = regexp.MustCompile(`[^a-z0-9_]+`) // groupName builds a valid Ansible group name such as site_fsn1. func groupName(prefix, value string) string { name := strings.Trim(groupInvalid.ReplaceAllString(strings.ToLower(value), "_"), "_") if name == "" { return "" } return prefix + "_" + name } func buildInventory(hosts []exportHost, groupBy []string, netboxVars bool) inventory { inv := inventory{vars: map[string][]inventoryVar{}, groups: map[string][]string{}} for _, h := range hosts { e := h.entry inv.hosts = append(inv.hosts, h.name) vars := []inventoryVar{{"ansible_host", h.address}} if h.user != "" { vars = append(vars, inventoryVar{"ansible_user", h.user}) } if h.port > 0 && h.port != 22 { vars = append(vars, inventoryVar{"ansible_port", h.port}) } if jump := h.opts.ProxyJump; jump != "" && !strings.EqualFold(jump, "none") { vars = append(vars, inventoryVar{"ansible_ssh_common_args", "-o ProxyJump=" + jump}) } instance, _ := netbox.SplitTarget(e.Name) if netboxVars && !e.Static { for _, pair := range [][2]string{ {"netbox_instance", instance}, {"netbox_kind", e.Kind}, {"netbox_status", e.Status}, {"netbox_site", cache.RefOf(e.Site).Name}, {"netbox_role", cache.RefOf(e.Role).Name}, {"netbox_platform", cache.RefOf(e.Platform).Name}, {"netbox_tenant", cache.RefOf(e.Tenant).Name}, {"netbox_cluster", e.Cluster}, {"netbox_location", locationNames(e.Location)}, {"netbox_rack", e.Rack}, {"netbox_position", e.Position}, } { if pair[1] != "" { vars = append(vars, inventoryVar{pair[0], pair[1]}) } } if e.ID > 0 { vars = append(vars, inventoryVar{"netbox_id", e.ID}) } if len(e.Tags) > 0 { vars = append(vars, inventoryVar{"netbox_tags", append([]string(nil), e.Tags...)}) } } inv.vars[h.name] = vars for _, key := range groupBy { var values []string switch key { case "tag": values = e.Tags case "site": values = []string{cache.RefOf(e.Site).Key()} case "location": // Every level, so a play can target a building or a single room. for _, location := range e.Location { values = append(values, location.Key()) } case "rack": values = []string{e.Rack} case "role": values = []string{cache.RefOf(e.Role).Key()} case "platform": values = []string{cache.RefOf(e.Platform).Key()} case "tenant": values = []string{cache.RefOf(e.Tenant).Key()} case "kind": values = []string{e.Kind} case "instance": values = []string{instance} case "cluster": values = []string{e.Cluster} case "status": values = []string{e.Status} } for _, value := range values { if group := groupName(key, value); group != "" { inv.groups[group] = append(inv.groups[group], h.name) } } } } return inv } func (inv inventory) groupNames() []string { names := make([]string, 0, len(inv.groups)) for name := range inv.groups { names = append(names, name) } sort.Strings(names) return names } func exportHeader(comment string) string { return fmt.Sprintf("%s Generated by netssh export on %s — changes are overwritten on the next export.\n", comment, time.Now().Format(time.RFC3339)) } // yaml renders the inventory with host variables under all.hosts and the // groups as children of all, listing their member hosts. func (inv inventory) yaml() ([]byte, error) { node := func(kind yaml.Kind, value string) *yaml.Node { n := &yaml.Node{Kind: kind, Value: value} if kind == yaml.ScalarNode { n.Tag = "!!str" } return n } mapping := func() *yaml.Node { return &yaml.Node{Kind: yaml.MappingNode} } add := func(m *yaml.Node, key string, value *yaml.Node) { m.Content = append(m.Content, node(yaml.ScalarNode, key), value) } hosts := mapping() for _, name := range inv.hosts { vars := mapping() for _, v := range inv.vars[name] { var value *yaml.Node switch typed := v.value.(type) { case int: value = &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!int", Value: strconv.Itoa(typed)} case []string: value = &yaml.Node{Kind: yaml.SequenceNode} for _, item := range typed { value.Content = append(value.Content, node(yaml.ScalarNode, item)) } default: value = node(yaml.ScalarNode, fmt.Sprint(typed)) } add(vars, v.key, value) } add(hosts, name, vars) } all := mapping() add(all, "hosts", hosts) if len(inv.groups) > 0 { children := mapping() for _, group := range inv.groupNames() { members := mapping() for _, host := range inv.groups[group] { add(members, host, &yaml.Node{Kind: yaml.MappingNode, Style: yaml.FlowStyle}) } g := mapping() add(g, "hosts", members) add(children, group, g) } add(all, "children", children) } root := mapping() add(root, "all", all) var b strings.Builder b.WriteString(exportHeader("#")) enc := yaml.NewEncoder(&b) enc.SetIndent(2) if err := enc.Encode(&yaml.Node{Kind: yaml.DocumentNode, Content: []*yaml.Node{root}}); err != nil { return nil, err } if err := enc.Close(); err != nil { return nil, err } return []byte(b.String()), nil } // ini renders host variables in [all] and one section per group. Lists such // as netbox_tags become comma-separated strings, since INI has no lists. func (inv inventory) ini() []byte { var b strings.Builder b.WriteString(exportHeader(";")) b.WriteString("[all]\n") for _, name := range inv.hosts { b.WriteString(name) for _, v := range inv.vars[name] { value := fmt.Sprint(v.value) if list, ok := v.value.([]string); ok { value = strings.Join(list, ",") } fmt.Fprintf(&b, " %s=%s", v.key, iniQuote(value)) } b.WriteString("\n") } for _, group := range inv.groupNames() { fmt.Fprintf(&b, "\n[%s]\n", group) for _, host := range inv.groups[group] { b.WriteString(host + "\n") } } return []byte(b.String()) } // iniQuote quotes values that Ansible's INI parser (shlex) would split. func iniQuote(value string) string { if value != "" && !strings.ContainsAny(value, " \t\"'\\#;=") { return value } return `"` + strings.NewReplacer(`\`, `\\`, `"`, `\"`).Replace(value) + `"` } func exportSSHConfigCmd() *cobra.Command { var f exportFilter var noAliases bool cmd := &cobra.Command{ Use: "ssh-config", Short: "Print ssh_config Host blocks for the cached hosts", Long: `Print one ssh_config Host block per cached host with the address, user, port, jump host and SSH options netssh would use. Tools that run ssh themselves (VS Code Remote, rsync, git, Ansible) can then reach the hosts by name. Include the file from ~/.ssh/config: netssh export ssh-config -o ~/.ssh/netssh.conf echo 'Include ~/.ssh/netssh.conf' >> ~/.ssh/config # once Shortcut aliases are added as extra Host names (disable with --no-aliases). extra_args, forwards and hooks have no ssh_config equivalent and are skipped.`, Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() if err != nil { return err } hosts, err := exportHosts(cfg, f) if err != nil { return err } aliases := map[string]string{} if !noAliases { c := newCache(cfg) _ = c.Load() aliases = shortcutAliases(c.All(), *cfg) } var b strings.Builder writeSSHConfig(&b, hosts, aliases) return writeExport(f, []byte(b.String())) }, } f.register(cmd) cmd.Flags().BoolVar(&noAliases, "no-aliases", false, "Do not add shortcut aliases as Host names") return cmd } var sshConfigUnsafe = regexp.MustCompile(`[\s"#*?!,]`) func writeSSHConfig(w io.Writer, hosts []exportHost, aliases map[string]string) { fmt.Fprint(w, exportHeader("#")) used := map[string]bool{} for _, h := range hosts { used[strings.ToLower(h.name)] = true } for _, h := range hosts { if sshConfigUnsafe.MatchString(h.name) { fmt.Fprintf(w, "\n# skipped %q: not usable as a Host name\n", h.name) continue } names := []string{h.name} if alias := aliases[strings.ToLower(h.entry.Name)]; alias != "" && !used[strings.ToLower(alias)] && !sshConfigUnsafe.MatchString(alias) { used[strings.ToLower(alias)] = true names = append(names, alias) } fmt.Fprintf(w, "\nHost %s\n", strings.Join(names, " ")) _, bare := netbox.SplitTarget(h.entry.Name) hostName := h.address if h.opts.Target == "hostname" && plainName(bare) { hostName = bare } line := func(key, value string) { if value != "" { fmt.Fprintf(w, " %s %s\n", key, value) } } line("HostName", hostName) if h.opts.Target == "name" && plainName(bare) { line("HostKeyAlias", bare) } line("User", h.user) if h.port > 0 && h.port != 22 { line("Port", strconv.Itoa(h.port)) } if jump := h.opts.ProxyJump; jump != "" { line("ProxyJump", jump) } switch h.opts.HostKeyChecking { case "strict": line("StrictHostKeyChecking", "yes") case "accept-new": line("StrictHostKeyChecking", "accept-new") case "off": line("StrictHostKeyChecking", "no") line("UserKnownHostsFile", "/dev/null") } line("AddressFamily", h.opts.AddressFamily) keys := make([]string, 0, len(h.opts.Options)) for key := range h.opts.Options { keys = append(keys, key) } sort.Strings(keys) for _, key := range keys { line(key, h.opts.Options[key]) } if len(h.opts.ExtraArgs) > 0 { fmt.Fprintf(w, " # extra_args not exported: %s\n", strings.Join(h.opts.ExtraArgs, " ")) } } } var plainNamePattern = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?$`) func plainName(name string) bool { return plainNamePattern.MatchString(name) } // locationNames joins a location chain as "Building A/Room 2.04". func locationNames(chain []config.Ref) string { names := make([]string, 0, len(chain)) for _, location := range chain { names = append(names, location.Name) } return strings.Join(names, "/") }