Author SHA1 Message Date
Sebi 85f1f3ea6e chore(deps): update module github.com/charmbracelet/x/ansi to v0.11.10
Test / test (pull_request) Successful in 4m13s
2026-11-18 14:45:44 +00:00
Sebi 0e7d06df11 Merge pull request 'docs: changelog for v1.3.1' (#52) from chore/release-v1.3.1 into main
Test / test (push) Successful in 4m11s
Release / release (push) Successful in 7m59s
2026-11-18 12:33:04 +00:00
Sebastian UnterschützandClaude Opus 5.5 bda57375bd docs: changelog for v1.3.1
Test / test (pull_request) Successful in 6m15s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:26:12 +01:00
Sebi c502dd0a2a Merge pull request 'chore(deps): update remaining dependencies' (#51) from chore/update-deps into main
Test / test (push) Successful in 3m54s
2026-11-18 12:23:19 +00:00
Sebastian UnterschützandClaude Opus 5.5 9f6a2b5c19 chore(deps): update github.com/godbus/dbus/v5 to v5.2.4
Test / test (pull_request) Successful in 4m4s
Supersedes #50, which conflicts after the go-keyring update; #49 is
obsolete because go-keyring v0.2.8 no longer uses shellescape.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:18:28 +01:00
Sebi 1cc2935115 Merge pull request 'fix(deps): update module github.com/zalando/go-keyring to v0.2.8' (#47) from renovate/github.com-zalando-go-keyring-0.x into main
Test / test (push) Successful in 4m14s
2026-11-18 12:16:54 +00:00
Sebi 86e53e4c41 Merge pull request 'chore(deps): update module github.com/danieljoos/wincred to v1.2.3' (#46) from renovate/github.com-danieljoos-wincred-1.x into main
Test / test (push) Successful in 6m21s
2026-11-18 12:16:33 +00:00
Sebi dd427681b6 Merge pull request 'fix(deps): update module charm.land/bubbletea/v2 to v2.1.2' (#44) from renovate/charm.land-bubbletea-v2-2.x into main
Test / test (push) Successful in 3m56s
2026-11-18 12:16:12 +00:00
Sebi 172258960e Merge pull request 'feat: DNS host suggestions, dns settings and links' (#48) from feat/dns-suggest into main
Test / test (push) Successful in 4m12s
Release / release (push) Successful in 9m12s
2026-11-18 12:13:12 +00:00
Sebastian UnterschützandClaude Opus 5.5 080e52b437 docs: document DNS suggestions, dns settings and links (v1.3.0)
Test / test (pull_request) Successful in 4m16s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:07:09 +01:00
Sebastian UnterschützandClaude Opus 5.5 e905a39068 feat: add netssh link and shell aliases for links
netssh link add|list|remove manages links; netssh NAME follows them, links
complete with Tab and get a shell alias.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:07:09 +01:00
Sebastian UnterschützandClaude Opus 5.5 793f095e80 feat: suggest the host behind unknown DNS names
A name neither in NetBox nor in the cache is resolved through DNS, using
dns.domains for short names. The hosts owning the address in NetBox or the
cache are offered together with a direct connection; without a terminal the
suggestions are part of the error. Afterwards netssh offers to save the name
as a link. info, open and whois use the same lookup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:07:08 +01:00
Sebastian UnterschützandClaude Opus 5.5 5c41a5eb6f 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>
2026-11-18 13:07:08 +01:00
Sebastian UnterschützandClaude Opus 5.5 c408d529a0 fix(hook): honour NetBox attribute restrictions in command aliases
Generated command aliases checked commands.*.match against hosts without
their status, site, role, platform and tenant, so a restriction such as
match: {platform: junos} produced no aliases.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:07:08 +01:00
Sebi 04523569ab fix(deps): update module github.com/zalando/go-keyring to v0.2.8
Test / test (pull_request) Successful in 4m2s
2026-11-18 11:46:34 +00:00
Sebi fde4298f50 chore(deps): update module github.com/danieljoos/wincred to v1.2.3
Test / test (pull_request) Successful in 4m12s
2026-11-18 11:46:20 +00:00
Sebi c87c2623ec Merge pull request 'feat: NetBox insights, host tools and configurable TUI' (#45) from feat/netbox-insights into main
Test / test (push) Successful in 4m14s
Release / release (push) Successful in 8m0s
2026-11-18 11:39:44 +00:00
Sebastian UnterschützandClaude Opus 5.5 1660bb3098 feat: NetBox insights, host tools and configurable TUI
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>
2026-11-18 12:33:59 +01:00
Sebi e01f86f2db Update module charm.land/bubbletea/v2 to v2.1.2
Test / test (pull_request) Successful in 3m57s
2026-11-18 09:46:12 +00:00
Sebastian Unterschütz e5bde9c61f feat: add host actions, lifecycle hooks and operational tools
Test / test (push) Successful in 4m4s
Release / release (push) Successful in 7m39s
2026-11-18 10:41:36 +01:00
Sebastian Unterschütz 8d4915543e v1
Test / test (push) Successful in 3m36s
Release / release (push) Successful in 7m31s
2026-11-17 19:00:44 +01:00
139 changed files with 17295 additions and 574 deletions

No files matched your search

+4
View File
@@ -0,0 +1,4 @@
.git
testenv/.keys
testenv/.state
testenv/.artifacts
+33
View File
@@ -0,0 +1,33 @@
name: Test
on:
pull_request:
push:
branches:
- main
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-go@v7
with:
go-version-file: go.mod
cache: true
- name: Check formatting
run: |
unformatted=$(gofmt -l .)
if [ -n "$unformatted" ]; then
echo "gofmt needed for:"
echo "$unformatted"
exit 1
fi
- name: Vet
run: go vet ./...
- name: Run tests
run: go test -race ./...
+5
View File
@@ -19,3 +19,8 @@ dist/
# OS
.DS_Store
Thumbs.db
# local test environment (testenv/up.sh)
testenv/.keys/
testenv/.state/
testenv/.artifacts/
+85
View File
@@ -1,5 +1,90 @@
# Changelog
## v1.3.1
- Update dependencies: charm.land/bubbletea/v2 v2.1.2, github.com/zalando/go-keyring v0.2.8 (no longer needs al.essio.dev/pkg/shellescape), github.com/danieljoos/wincred v1.2.3, github.com/godbus/dbus/v5 v5.2.4.
## v1.3.0
- Unknown names are resolved through DNS, and the hosts owning the address in NetBox or the cache are suggested, together with a direct connection to the DNS name. Without a terminal the suggestions are part of the error. `netssh info`, `open` and `whois` use it too.
- Add `dns.domains`: domain rules per name pattern for short names (`mx*` → `easysahre.de`, `ah*` → `jhfduwia.de`), independent of `shortcuts.domains`.
- Add `dns.suggest` and `dns.save_link` (`ask`, `always`, `never`) to always accept or always decline the host suggestion and the shortcut offer; `always` also works in scripts. Both are in `netssh configure`.
- Add links (`links:` in the config, `netssh link add|list|remove`): `netssh mx123` and the shell alias `mx123` connect to the linked host. netssh offers to save a link after a DNS suggestion.
- Generated command aliases honour command restrictions on site, role, platform, tenant and status.
## v1.2.0
- Add `netssh info HOST` and `Ctrl+L` in the TUI: site, rack/U, role, platform, tenant, device type, serial, VM resources and all IP addresses per interface from NetBox; `--json` for scripts.
- Add `netssh open HOST` and `Ctrl+G` in the TUI to open the host's NetBox page (`--print` prints the URL).
- Add `netssh whois ADDRESS|HOSTNAME`: the device or VM, interface, DNS name and containing prefixes of an address across all NetBox instances, plus matching cached hosts.
- Cache NetBox ID, status, site, role, platform and tenant. Ask before connecting to hosts whose status is in `ssh.warn_status` (default: offline, planned, staged, failed, inventory, decommissioning); `--force` skips the question, non-interactive callers get a warning. The TUI shows a status badge and filters by `status:`, `site:`, `role:`, `platform:` and `tenant:`.
- `ssh.rules` and command restrictions match `site`, `role`, `platform`, `tenant` and `status` (name or slug), e.g. legacy key exchange for `platform: junos`. The wizard edits the new selectors.
- Show where a device is: site › all nested NetBox locations › rack › rack unit. `netssh info` and the TUI detail view add `Location`, `Rack` (units, height, face) and `Path`; the TUI gets a `location` column and `location:`/`rack:` filters; Ansible exports add `netbox_location`, `netbox_rack`, `netbox_position` and `--group-by location,rack`. Each location is fetched once per run.
- Add `tui.columns` to choose what the TUI shows next to each host and in which order: `alias`, `ip`, `kind`, `source`, `status`, `site`, `location`, `role`, `platform`, `tenant`, `cluster`, `tags`, `reachability` (default `[alias, ip, source, status]`). Also in `netssh configure`.
- Optional TUI reachability check (`reachability` column, off by default): listed hosts are probed on their SSH port and marked ✓/✗ (`tui.reachability_timeout`); hosts behind a jump host are skipped.
- Add `resolver.fallback`: when the chosen address does not answer, connect to the first answering address of the other strategies (or the other primary IP) for this connection.
- Add `netssh copy-id` to run ssh-copy-id with netssh's address, user, port, jump host and options, for single hosts, `tag:`, `cluster:` and `@group`.
- Report changed host addresses on connect and in `netssh cache refresh`, offer to remove the old known_hosts entry, and add `netssh known-hosts reset HOST...`.
- Add `netssh export ansible` (YAML or INI inventory with groups by tag/site/role/platform/… and `netbox_*` host variables) and `netssh export ssh-config`.
- Add keyring token storage: `token: keyring` reads the NetBox token from the system keyring; `netssh token set|migrate|delete|status` manage it, `netssh doctor` checks it.
## v1.1.0
- Add local post-disconnect/post-command scripts, execution timeouts, cancellation, per-command confirmation and host restrictions.
- Add configurable recent-host count, persistent favorites/pins, a TUI command menu and cache/live/stale indicators.
- Add doctor/explain diagnostics, parallel batch commands with failed-host retry, and optional bounded local action history.
- Add configuration export/import that excludes credentials and executable settings while preserving matching local credentials.
- Preserve terminal behavior and process exit status during supervised execution; test Bash/Python scripts, process cancellation, concurrency and batch retries.
## v1.0.0
- Consolidate the complete project into the initial v1 commit.
- Add configurable local host commands and automatically generated aliases, such as `mxg1` for `mtr` on host shortcut `xg1`. Commands resolve the destination at invocation using the configured resolver strategy.
- Support executable scripts and interpreter-based scripts, host/address placeholders, extra arguments, dry runs, and configuration through `netssh configure`.
- Include all previous SSH, SFTP/SCP, forwarding, multi-session, NetBox instance, shortcut, and security improvements.
## v0.0.29
- Add `ssh.pre_connect`: a shell command run locally before every connection (ssh, sftp, scp, tunnel), e.g. to check a VPN. A non-zero exit aborts the connection. Layered like `proxy_jump` (global → instance or static host → rules, `none` disables an inherited hook); the host is passed as `NETSSH_HOST`, `NETSSH_TARGET`, `NETSSH_INSTANCE`, `NETSSH_IP`, `NETSSH_KIND`, `NETSSH_TAGS`, `NETSSH_CLIENT`. Editable in `netssh configure`, also `NETSSH_SSH_PRE_CONNECT`. `--dry-run` shows it without running it.
- Add `shortcuts.show`: shows each host's shortcut alias (e.g. `fsnbx1` for `fsn1-bx1.hoster.de`) in the TUI and as an `ALIAS` column in `netssh cache list` and `netssh hosts list`, and offers shortcuts in Tab completion even when the full name matches. `--aliases` shows the column for a single call. Editable in `netssh configure`, also `NETSSH_SHORTCUTS_SHOW`.
## v0.0.25
- Security: `netssh.yaml` is read from the user config directory only. A file of that name in the working directory (e.g. of a cloned repository) was loaded when no user config existed, and could set ssh options such as `ProxyCommand` or a NetBox URL.
- Security: an address from NetBox or the cache that is neither an IP address nor a hostname is refused. A value such as `-oProxyCommand=…` was passed to ssh as an option.
- The resolver chain stops at an API failure instead of trying the next strategy. Before, a NetBox error in `management_subnet` or `interface_name` connected to the primary IP and cached it. A strategy that finds no address (including a missing interface) still falls through. Note: a token without permission to read IP addresses now gives an error instead of silently using `primary_ip`.
- `netssh --help` and `netssh -h` show netssh's help instead of `unknown option --help` and ssh's usage.
- Background cache refreshes are started at most every 5 minutes. While NetBox was unreachable, every command and every new shell started another one.
- `netbox.url` is validated like the URLs of named instances (HTTP or HTTPS, no query or fragment).
- Hosts with more than 100 IP addresses: all pages are read, so `management_subnet` no longer misses addresses.
- CI: tests, `go vet`, and a format check run on pull requests and pushes to `main`.
## v0.0.24
- Fix the `interface_name` resolver strategy: it sent filter names that NetBox ignores and therefore returned the host's first IP address instead of the named interface's. It now uses NetBox's `interface` and `vminterface` filters; a missing interface falls through to the next strategy.
- Fix `netssh sftp` and `netssh scp` with instance-qualified hosts (`prod/web01:/path`), which were taken for local paths.
- Fix shell aliases of instance-qualified hosts ignoring anchored rewrite rules (`fsn_fsn1-pve1` instead of `fsn_fsnpve1`).
- Add `netssh multi` to open several hosts side by side in tmux or zellij: host lists, `tag:`, NetBox virtualization clusters (`cluster:`, devices by default, `--kind vm|all`), and groups from the config (`@name`). `--sync` sends typing to all panes; `netssh sync` toggles it later. In the TUI, `Space` marks hosts and `Enter` opens them together. Configurable in `netssh configure` (multiplexer, panes per window, groups).
- tmux keys for broadcast in `netssh multi` windows: prefix `S` toggles all panes, prefix `e` excludes the current pane (border `[SOLO]`) or includes it again; also `netssh sync --pane`. Both keys are unbound in a default tmux, are not bound if your tmux.conf uses them, act only in netssh windows, and can be changed or turned off (`multi.sync_key`, `multi.solo_key`).
- `netssh multi` widens the status bar of its own tmux session, which tmux otherwise cuts to `[netssh-pv`.
- Cache entries remember the NetBox cluster of a host, for `cluster:` completion and offline use.
- Add `testenv/`, a local Docker environment with two NetBox instances, SSH targets, a jump host, tmux, zellij, and bash/zsh/fish, and 185 end-to-end checks of all features, including `netssh multi` with real tmux and zellij and screenshot checks of what a real terminal (xterm) renders (`testenv/up.sh`, `testenv/test.sh`). Not part of CI/CD.
## v0.0.23
- `netssh configure` now covers every setting: after the instances, a menu opens with SSH defaults, SSH options (jump host, host key checking, connection target, address family, extra arguments, `-o` options), SSH rules (add, edit, remove by tag, instance, kind, name pattern), resolver & cache (including the cache file), shortcuts & command alias, and completion (`max_results`). SSH options can also be set per NetBox instance from the instance list.
- Fix `netssh configure` dropping global SSH options, `ssh.rules`, and `completion.max_results` from the config file when saving.
- The configurator validates SSH options and rules before writing the config.
- Add `shortcuts.rewrites`: regex rules that shorten hostnames, e.g. `^([a-z]+)[0-9]+-` → `$1` turns `fsn1-bx1.hoster.de` into `fsnbx1`. Shortcuts work for connecting, shell aliases, and Tab completion (offered when the full name does not match), and can be edited in `netssh configure`.
- Add `netssh alias --test HOSTNAME` to show the shortcut of a name and the cached hosts it matches.
- Add `netssh sftp` and `netssh scp`: host lookup, shortcuts, instances, default user and port, SSH options and rules, jump host, `--dry-run`, and completion work as for ssh. IPv6 addresses are bracketed for host:path.
- Add named port forwards (`ssh.forwards` globally, per instance, and per rule), `netssh tunnel HOST NAME|SPEC...` (ssh -N with ExitOnForwardFailure), and `netssh --forward NAME`. Forwards are editable in `netssh configure` and completed in the shell.
- TUI: `Ctrl+O` opens SFTP, `Ctrl+T` starts a tunnel with configured or ad hoc forwards.
- Add the `hostname` resolver strategy: connect by the NetBox name (plus optional `resolver.hostname_domain`) instead of an IP, always or as a fallback after `primary_ip`.
- Add static hosts (`hosts:`) for machines that are not in NetBox, with user, port, tags, and SSH options, managed with `netssh hosts list|add|remove` and in `netssh configure`. They are found before NetBox, work offline and without any NetBox, and support shortcuts, rules (`kind: static`), completion, aliases, sftp, scp, tunnels, and the TUI.
- Fix options added by netssh landing after `--` (`netssh --no-jump -- host`), where ssh read them as the destination.
## v0.0.22
- Fix shell completion with multiple NetBox instances: typing a hostname without an instance prefix (`fsn1-bx1<Tab>`) found nothing in bash and zsh, because only `prod/…` was offered. Hostnames that are unique across all instances are now offered without the prefix; connecting to them still checks every instance for ambiguous names.
+1382 -30
View File
File diff suppressed because it is too large. Load diff
+191
View File
@@ -0,0 +1,191 @@
package main
import (
"context"
"encoding/json"
"fmt"
"io"
"os"
"os/signal"
"path/filepath"
"sync"
"syscall"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/runner"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
"github.com/spf13/cobra"
)
type batchRetry struct {
Command string
Hosts []string
Extra []string
}
type batchResult struct {
Host string
Code int
}
var batchExecutable = os.Executable
func batchPath() string {
return filepath.Join(filepath.Dir(config.Path()), "netssh", "last-failed.json")
}
func batchCmd() *cobra.Command {
var parallel int
var retry, yes, dry bool
cmd := &cobra.Command{Use: "batch COMMAND HOST... [-- EXTRA_ARGS...]", Short: "Run a configured command on hosts with bounded parallelism", RunE: func(cmd *cobra.Command, args []string) error {
if parallel < 1 || parallel > 64 {
return fmt.Errorf("parallel must be between 1 and 64")
}
cfg, err := config.Load()
if err != nil {
return err
}
work := batchRetry{}
if retry {
if len(args) > 0 {
return fmt.Errorf("--retry-failed takes no positional arguments")
}
data, err := os.ReadFile(batchPath())
if err != nil {
return err
}
if err = json.Unmarshal(data, &work); err != nil {
return err
}
} else {
split := cmd.ArgsLenAtDash()
if split >= 0 {
work.Extra = args[split:]
args = args[:split]
}
if len(args) < 2 {
return fmt.Errorf("specify COMMAND and at least one HOST")
}
work.Command, work.Hosts = args[0], args[1:]
}
command, ok := cfg.Commands[work.Command]
if !ok {
return fmt.Errorf("unknown command %q", work.Command)
}
if len(work.Hosts) == 0 {
fmt.Fprintln(cmd.OutOrStdout(), "No failed hosts to retry.")
return nil
}
// Resolve and validate the entire list before launching any action.
var targets []string
seen := map[string]bool{}
for _, target := range work.Hosts {
h, err := resolveTargetE(cfg, target, false)
if err != nil {
return err
}
if !command.Allowed(commandHost(h)) {
return fmt.Errorf("%s is not allowed on %s", work.Command, h.Name)
}
if !seen[h.Name] {
targets = append(targets, h.Name)
seen[h.Name] = true
}
}
if command.Confirm && !dry {
if err := confirmAction(fmt.Sprintf("Run %s on %d hosts", work.Command, len(targets)), yes); err != nil {
return err
}
}
executable, err := batchExecutable()
if err != nil {
return err
}
// Temporary output files bound memory even for very verbose commands.
dir, err := os.MkdirTemp("", "netssh-batch-")
if err != nil {
return err
}
defer os.RemoveAll(dir)
ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer cancel()
jobs := make(chan int)
results := make(chan batchResult, len(targets))
var wg sync.WaitGroup
var output sync.Mutex
for n := 0; n < parallel; n++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := range jobs {
host := targets[i]
if ctx.Err() != nil {
results <- batchResult{host, 130}
continue
}
output.Lock()
fmt.Fprintf(cmd.OutOrStdout(), "[%s] starting\n", host)
output.Unlock()
f, err := os.CreateTemp(dir, "output-")
if err != nil {
results <- batchResult{host, 1}
continue
}
argv := []string{executable, "run", "--yes"}
if dry {
argv = append(argv, "--dry-run")
}
argv = append(argv, work.Command, "--", host)
argv = append(argv, work.Extra...)
r := runner.Run(ctx, argv, runner.Options{Stdout: f, Stderr: f})
f.Close()
output.Lock()
fmt.Fprintf(cmd.OutOrStdout(), "[%s] exit=%d duration=%s\n", host, r.Code, r.Duration.Round(time.Millisecond))
read, err := os.Open(f.Name())
if err == nil {
_, _ = io.Copy(cmd.OutOrStdout(), read)
read.Close()
}
output.Unlock()
results <- batchResult{host, r.Code}
}
}()
}
for i := range targets {
jobs <- i
}
close(jobs)
wg.Wait()
close(results)
failed := map[string]bool{}
for r := range results {
if r.Code != 0 {
failed[r.Host] = true
}
}
work.Hosts = nil
for _, host := range targets {
if failed[host] {
work.Hosts = append(work.Hosts, host)
}
}
if !dry {
data, _ := json.Marshal(work)
if err := os.MkdirAll(filepath.Dir(batchPath()), 0700); err != nil {
return err
}
if err := storage.WriteFile(batchPath(), data, 0600); err != nil {
return err
}
}
fmt.Fprintf(cmd.OutOrStdout(), "%d succeeded, %d failed\n", len(targets)-len(failed), len(failed))
if len(failed) > 0 {
return fmt.Errorf("batch failed; retry with netssh batch --retry-failed")
}
return nil
}}
cmd.Flags().IntVar(&parallel, "parallel", 4, "Maximum simultaneous hosts (1-64)")
cmd.Flags().BoolVar(&retry, "retry-failed", false, "Repeat failed targets from the last batch")
cmd.Flags().BoolVar(&yes, "yes", false, "Confirm the batch action")
cmd.Flags().BoolVar(&dry, "dry-run", false, "Resolve and print commands without running")
return cmd
}
+217
View File
@@ -0,0 +1,217 @@
package main
import (
"context"
"fmt"
"net"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/charmbracelet/x/term"
"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/resolver"
internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh"
)
// stdinIsTerminal is replaced in tests.
var stdinIsTerminal = func() bool { return term.IsTerminal(os.Stdin.Fd()) }
// confirmStatus asks before connecting to a host whose NetBox status is listed
// in ssh.warn_status. Without a terminal it only warns, so scripts keep working.
func confirmStatus(cfg *config.Config, host resolvedHost, force bool) error {
if force || !cfg.SSH.WarnsStatus(host.Status) {
return nil
}
message := fmt.Sprintf("%s has NetBox status %q", host.Name, host.Status)
if !stdinIsTerminal() {
fmt.Fprintf(os.Stderr, "netssh: warning: %s\n", message)
return nil
}
if err := confirmAction(message+" — connect anyway", false); err != nil {
return fmt.Errorf("%s: %w (skip this question with --force)", host.Name, err)
}
return nil
}
// connectPort returns the port given in args (-p for ssh, -P for sftp and scp,
// or -o Port=), else 22. The default port is already in args at this point.
func connectPort(client internalssh.Client, args []string, dests []int) int {
end := len(args)
if len(dests) > 0 && dests[0] <= len(args) {
end = dests[0]
}
flag := client.PortArgs("")[0]
for i := 0; i < end; i++ {
arg := args[i]
value := ""
switch {
case arg == flag && i+1 < end:
value = args[i+1]
case strings.HasPrefix(arg, flag) && len(arg) > len(flag):
value = arg[len(flag):]
case arg == "-o" && i+1 < end:
if key, v, ok := strings.Cut(args[i+1], "="); ok && strings.EqualFold(strings.TrimSpace(key), "port") {
value = v
}
}
if port, err := strconv.Atoi(strings.TrimSpace(value)); err == nil && port > 0 && port <= 65535 {
return port
}
}
return 22
}
// reachable reports whether address accepts TCP connections on port.
func reachable(address string, port int, timeout time.Duration) bool {
conn, err := net.DialTimeout("tcp", net.JoinHostPort(address, strconv.Itoa(port)), timeout)
if err != nil {
return false
}
_ = conn.Close()
return true
}
// usesJumpHost reports whether the connection goes through a jump host, so
// the target address cannot be probed from this machine.
func usesJumpHost(opts config.SSHOptions, flags internalssh.WrapperFlags) bool {
if flags.NoJump {
return false
}
return flags.Jump != "" || (opts.ProxyJump != "" && !strings.EqualFold(opts.ProxyJump, "none")) || opts.Options["proxycommand"] != ""
}
// fallbackProbe and fallbackCandidates are replaced in tests.
var (
fallbackProbe = reachable
fallbackCandidates = netboxCandidates
)
// applyFallback keeps host.IP when it answers on the SSH port. Otherwise it
// tries the addresses the other resolver strategies find and connects to the
// first one that answers, with resolver.fallback enabled.
func applyFallback(cfg *config.Config, host resolvedHost, opts config.SSHOptions, flags internalssh.WrapperFlags, port int) resolvedHost {
if !cfg.Resolver.Fallback || host.Kind == config.StaticKind || usesJumpHost(opts, flags) {
return host
}
timeout := cfg.Resolver.FallbackTimeoutDuration()
if fallbackProbe(host.IP, port, timeout) {
return host
}
candidates, err := fallbackCandidates(cfg, host)
if err != nil {
fmt.Fprintf(os.Stderr, "netssh: %s does not answer on port %d and no other address is known: %v\n", host.IP, port, err)
return host
}
for _, candidate := range candidates {
if candidate.Address == host.IP || !internalssh.ValidAddress(candidate.Address) {
continue
}
if fallbackProbe(candidate.Address, port, timeout) {
fmt.Fprintf(os.Stderr, "netssh: %s does not answer on port %d, using %s (%s)\n", host.IP, port, candidate.Address, candidate.Strategy)
host.IP = candidate.Address
return host
}
}
fmt.Fprintf(os.Stderr, "netssh: no address of %s answers on port %d; trying %s anyway\n", host.Name, port, host.IP)
return host
}
// netboxCandidates looks the host up again and lists every strategy's address.
func netboxCandidates(cfg *config.Config, host resolvedHost) ([]resolver.Candidate, error) {
if !cfg.HasNetBox() {
return nil, fmt.Errorf("no NetBox configured")
}
client := newNetBoxClient(cfg)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
target, err := client.FindHost(ctx, host.Name, host.Kind)
if err != nil {
return nil, err
}
chain, err := resolver.New(cfg.Resolver)
if err != nil {
return nil, err
}
return chain.Candidates(ctx, &target, client)
}
// knownHostsKeys lists the known_hosts names ssh may have stored for a host.
func knownHostsKeys(name string, addresses []string, port int) []string {
seen := map[string]bool{}
var keys []string
add := func(key string) {
if key == "" || seen[strings.ToLower(key)] {
return
}
seen[strings.ToLower(key)] = true
keys = append(keys, key)
if port != 22 {
keys = append(keys, "["+key+"]:"+strconv.Itoa(port))
}
}
_, bare := netbox.SplitTarget(name)
add(bare)
for _, address := range addresses {
add(address)
}
return keys
}
// knownHostsFile returns the first UserKnownHostsFile configured for the
// host, or "" for ssh-keygen's default (~/.ssh/known_hosts).
func knownHostsFile(opts config.SSHOptions) string {
fields := strings.Fields(opts.Options["userknownhostsfile"])
if len(fields) == 0 || fields[0] == "/dev/null" {
return ""
}
file := fields[0]
if rest, ok := strings.CutPrefix(file, "~/"); ok {
if home, err := os.UserHomeDir(); err == nil {
file = filepath.Join(home, rest)
}
}
return file
}
// removeKnownHosts runs ssh-keygen -R for every key. ssh-keygen keeps a
// known_hosts.old backup of the previous file.
var removeKnownHosts = func(keys []string, file string) error {
for _, key := range keys {
args := []string{"-R", key}
if file != "" {
args = append(args, "-f", file)
}
cmd := exec.Command("ssh-keygen", args...)
cmd.Stdout, cmd.Stderr = os.Stderr, os.Stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("ssh-keygen -R %s: %w", key, err)
}
}
return nil
}
// offerKnownHostsCleanup reports a changed NetBox address and, in a terminal,
// offers to remove the host key stored for the old address.
func offerKnownHostsCleanup(opts config.SSHOptions, host resolvedHost, port int) {
fmt.Fprintf(os.Stderr, "netssh: address of %s changed from %s to %s\n", host.Name, host.PreviousIP, host.IP)
if opts.HostKeyChecking == "off" {
return
}
keys := knownHostsKeys("", []string{host.PreviousIP}, port)
if !stdinIsTerminal() {
fmt.Fprintf(os.Stderr, "netssh: remove the old host key with: netssh known-hosts reset %s\n", host.Name)
return
}
if confirmAction("Remove the known_hosts entry of the old address "+host.PreviousIP, false) != nil {
return
}
if err := removeKnownHosts(keys, knownHostsFile(opts)); err != nil {
fmt.Fprintf(os.Stderr, "netssh: %v\n", err)
}
}
+186
View File
@@ -0,0 +1,186 @@
package main
import (
"errors"
"fmt"
"os"
"os/exec"
"strconv"
"strings"
"github.com/spf13/cobra"
"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"
)
type copyIDFlags struct {
identity, user, kind, jump string
force, check, dryRun, yes bool
noJump, ignoreStatus bool
}
func copyIDCmd() *cobra.Command {
var f copyIDFlags
cmd := &cobra.Command{
Use: "copy-id [flags] HOST|tag:TAG|cluster:NAME|@GROUP...",
Short: "Install your public key on hosts with ssh-copy-id",
Long: `Run ssh-copy-id for each host with the address, user, port, jump host and
SSH options netssh would use to connect. Hosts are given like for netssh multi:
names, tag:TAG, cluster:NAME (devices; --kind vm|all for VMs) or @GROUP.
Hosts run one after another, so password prompts stay readable. A failing
host does not stop the others; the exit code is 1 if any host failed.`,
Example: ` netssh copy-id web01
netssh copy-id -i ~/.ssh/id_ed25519.pub tag:lab
netssh copy-id --dry-run @k8s`,
Args: cobra.MinimumNArgs(1),
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
return multiCompletions(cfg, toComplete)
},
RunE: func(cmd *cobra.Command, args []string) error {
return runCopyID(loadConfigOrSetup(), args, f)
},
}
cmd.Flags().StringVarP(&f.identity, "identity", "i", "", "Public key file to install (ssh-copy-id -i)")
cmd.Flags().StringVarP(&f.user, "user", "l", "", "Login user for every host")
cmd.Flags().StringVar(&f.kind, "kind", "", "Host kind for tag: and cluster: — device, vm, or all")
cmd.Flags().StringVar(&f.jump, "jump", "", "Jump host for every host")
cmd.Flags().BoolVar(&f.noJump, "no-jump", false, "Disable jump hosts")
cmd.Flags().BoolVarP(&f.force, "force", "f", false, "Install the key even if it seems present (ssh-copy-id -f)")
cmd.Flags().BoolVarP(&f.check, "check", "n", false, "Only show which keys would be installed (ssh-copy-id -n)")
cmd.Flags().BoolVar(&f.dryRun, "dry-run", false, "Print the ssh-copy-id commands without running them")
cmd.Flags().BoolVarP(&f.yes, "yes", "y", false, fmt.Sprintf("Run for more than %d hosts without asking", maxHostsWithoutConfirm))
cmd.Flags().BoolVar(&f.ignoreStatus, "ignore-status", false, "Do not ask about hosts with a NetBox status in ssh.warn_status")
_ = cmd.RegisterFlagCompletionFunc("kind", cobra.FixedCompletions([]cobra.Completion{"device", "vm", "all"}, cobra.ShellCompDirectiveNoFileComp))
return cmd
}
func runCopyID(cfg *config.Config, selectors []string, f copyIDFlags) error {
if f.jump != "" && f.noJump {
return errors.New("--jump and --no-jump are mutually exclusive")
}
switch f.kind {
case "", "device", "vm", "all":
default:
return fmt.Errorf("--kind must be device, vm, or all")
}
if strings.HasPrefix(f.user, "-") || strings.ContainsAny(f.user, " \t\n@") {
return fmt.Errorf("invalid user %q", f.user)
}
if strings.HasPrefix(f.jump, "-") {
return fmt.Errorf("--jump: invalid host %q", f.jump)
}
c := newCache(cfg)
_ = c.Load()
targets, warnings, err := expandSelectors(cfg, c, selectors, f.kind)
for _, warning := range warnings {
fmt.Fprintln(os.Stderr, "netssh: warning: "+warning)
}
if err != nil {
return err
}
if len(targets) > maxHostsWithoutConfirm && !f.yes && !f.dryRun {
if err := confirmAction(fmt.Sprintf("Run ssh-copy-id for %d hosts", len(targets)), false); err != nil {
return err
}
}
var failed []string
for _, target := range targets {
h, err := resolveTargetE(cfg, target, false)
if err != nil {
fmt.Fprintf(os.Stderr, "netssh: %s: %v\n", target, err)
failed = append(failed, target)
continue
}
if !f.dryRun {
if err := confirmStatus(cfg, h, f.ignoreStatus); err != nil {
fmt.Fprintf(os.Stderr, "netssh: skipping %v\n", err)
failed = append(failed, target)
continue
}
}
argv, err := copyIDArgv(cfg, h, f)
if err != nil {
fmt.Fprintf(os.Stderr, "netssh: %s: %v\n", target, err)
failed = append(failed, target)
continue
}
if f.dryRun {
fmt.Println(internalssh.Quote(argv))
continue
}
fmt.Fprintf(os.Stderr, "==> %s (%s)\n", h.Name, h.IP)
if err := runCopyIDCommand(argv); err != nil {
fmt.Fprintf(os.Stderr, "netssh: %s: %v\n", h.Name, err)
failed = append(failed, h.Name)
}
}
if len(failed) > 0 {
return fmt.Errorf("ssh-copy-id failed for %d of %d hosts: %s", len(failed), len(targets), strings.Join(failed, " "))
}
return nil
}
// runCopyIDCommand is replaced in tests.
var runCopyIDCommand = func(argv []string) error {
path, err := exec.LookPath(argv[0])
if err != nil {
return fmt.Errorf("%s not found in PATH (it ships with OpenSSH): %w", argv[0], err)
}
cmd := exec.Command(path, argv[1:]...)
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
return cmd.Run()
}
// copyIDArgv builds the ssh-copy-id command for a resolved host. The
// connection options come from the same code that builds ssh commands, so
// the key lands where netssh HOST connects to. ssh-copy-id passes -o and -p
// on to ssh but has no -J, so a jump host becomes -o ProxyJump=.
func copyIDArgv(cfg *config.Config, h resolvedHost, f copyIDFlags) ([]string, error) {
if !internalssh.ValidAddress(h.IP) {
return nil, fmt.Errorf("refusing address %q", h.IP)
}
user, port := hostDefaults(cfg, h)
if f.user != "" {
user = f.user
}
_, name := netbox.SplitTarget(h.Name)
dest := name
if user != "" {
dest = user + "@" + name
}
var args []string
if port > 0 && port != 22 {
args = append(args, "-p", strconv.Itoa(port))
}
args = append(args, dest)
opts := hostOptions(cfg, h)
opts.ExtraArgs, opts.Forwards = nil, nil
result := internalssh.SSH.Apply(args, []int{len(args) - 1}, internalssh.Host{Name: name, IP: h.IP}, opts, internalssh.WrapperFlags{Jump: f.jump, NoJump: f.noJump})
argv := []string{"ssh-copy-id"}
if f.identity != "" {
argv = append(argv, "-i", f.identity)
}
if f.force {
argv = append(argv, "-f")
}
if f.check {
argv = append(argv, "-n")
}
for i := 0; i < len(result.Args); i++ {
if result.Args[i] == "-J" && i+1 < len(result.Args) {
argv = append(argv, "-o", "ProxyJump="+result.Args[i+1])
i++
continue
}
argv = append(argv, result.Args[i])
}
return argv, nil
}
+301
View File
@@ -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)
}
+199
View File
@@ -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)
}
}
+523
View File
@@ -0,0 +1,523 @@
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, "/")
}
+167
View File
@@ -0,0 +1,167 @@
package main
import (
"fmt"
"io"
"os"
"strings"
"text/tabwriter"
"github.com/spf13/cobra"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/hook"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/setup"
)
func hostsCmd() *cobra.Command {
var showAliases bool
cmd := &cobra.Command{
Use: "hosts",
Short: "Manage static hosts that are not in NetBox",
Long: `Static hosts are defined under hosts: in the config. They are found before
NetBox, work offline, and support shortcuts, rules (kind: static), aliases,
completion, sftp, scp, and tunnels like NetBox hosts.`,
RunE: func(cmd *cobra.Command, args []string) error { return listHosts(showAliases) },
}
cmd.AddCommand(hostsListCmd(), hostsAddCmd(), hostsRemoveCmd())
cmd.Flags().BoolVar(&showAliases, "aliases", false, "Show each host's shortcut alias (always on with shortcuts.show)")
return cmd
}
func hostsListCmd() *cobra.Command {
var showAliases bool
cmd := &cobra.Command{
Use: "list",
Short: "List static hosts",
RunE: func(cmd *cobra.Command, args []string) error { return listHosts(showAliases) },
}
cmd.Flags().BoolVar(&showAliases, "aliases", false, "Show each host's shortcut alias (always on with shortcuts.show)")
return cmd
}
func listHosts(showAliases bool) error {
cfg, err := config.Load()
if err != nil {
return err
}
if len(cfg.Hosts) == 0 {
fmt.Println("No static hosts. Add one with: netssh hosts add NAME ADDRESS")
return nil
}
withAliases := showAliases || cfg.Shortcuts.Show
var aliases map[string]string
if withAliases {
// Aliases are unique across all hosts, so compute them with the cache.
c := newCache(cfg)
_ = c.Load()
aliases = shortcutAliases(c.All(), *cfg)
}
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
if withAliases {
fmt.Fprintln(w, "NAME\tALIAS\tADDRESS\tUSER\tPORT\tTAGS")
} else {
fmt.Fprintln(w, "NAME\tADDRESS\tUSER\tPORT\tTAGS")
}
for _, host := range cfg.Hosts {
port := ""
if host.Port > 0 {
port = fmt.Sprint(host.Port)
}
if withAliases {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n", host.Name, orDash(aliases[strings.ToLower(host.Name)]), host.Address, host.User, port, strings.Join(host.Tags, ","))
continue
}
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", host.Name, host.Address, host.User, port, strings.Join(host.Tags, ","))
}
return w.Flush()
}
func hostsAddCmd() *cobra.Command {
var host config.StaticHost
var replace bool
cmd := &cobra.Command{
Use: "add NAME ADDRESS",
Short: "Add a static host (or replace one with --replace)",
Example: ` netssh hosts add router 192.168.1.1 --user admin
netssh hosts add backup backup.example.org --port 2222 --tag offsite`,
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
host.Name, host.Address = args[0], args[1]
if existing := cfg.StaticHost(host.Name); existing != nil {
if !replace {
return fmt.Errorf("static host %q already exists; use --replace to overwrite it", existing.Name)
}
host.SSH = existing.SSH // keep SSH options set in the config or wizard
*existing = host
} else {
cfg.Hosts = append(cfg.Hosts, host)
}
return saveHosts(cfg)
},
}
cmd.Flags().StringVar(&host.User, "user", "", "Login user (default: ssh.default_user)")
cmd.Flags().IntVar(&host.Port, "port", 0, "SSH port (default: ssh.default_port or 22)")
cmd.Flags().StringSliceVar(&host.Tags, "tag", nil, "Tag for ssh.rules (repeatable)")
cmd.Flags().BoolVar(&replace, "replace", false, "Overwrite an existing static host")
return cmd
}
func hostsRemoveCmd() *cobra.Command {
return &cobra.Command{
Use: "remove NAME",
Aliases: []string{"rm"},
Short: "Remove a static host",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
for i, host := range cfg.Hosts {
if strings.EqualFold(host.Name, args[0]) {
cfg.Hosts = append(cfg.Hosts[:i], cfg.Hosts[i+1:]...)
return saveHosts(cfg)
}
}
return fmt.Errorf("no static host %q", args[0])
},
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
cfg, err := config.Load()
if err != nil || len(args) > 0 {
return nil, cobra.ShellCompDirectiveNoFileComp
}
var names []string
for _, host := range cfg.Hosts {
if strings.HasPrefix(strings.ToLower(host.Name), strings.ToLower(toComplete)) {
names = append(names, host.Name)
}
}
return names, cobra.ShellCompDirectiveNoFileComp
},
}
}
// saveHosts writes the config and regenerates the shell aliases.
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()
if err != nil {
return err
}
c := newCache(loaded)
_ = c.Load()
if err := hook.WriteAliasFiles(hook.BuildAliasEntries(c.All(), *loaded)); err != nil {
fmt.Fprintf(os.Stderr, "warning: could not write alias files: %v\n", err)
}
return nil
}
+130
View File
@@ -0,0 +1,130 @@
package main
import (
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// prepareConfig writes data as the only config, with empty cache and home.
func prepareConfig(t *testing.T, data string) string {
t.Helper()
dir := t.TempDir()
t.Setenv("HOME", t.TempDir())
t.Setenv("XDG_CONFIG_HOME", dir)
t.Setenv("XDG_CACHE_HOME", t.TempDir())
t.Setenv("NETSSH_NETBOX_URL", "")
t.Setenv("NETSSH_NETBOX_TOKEN", "")
t.Setenv("NETSSH_CACHE_PATH", filepath.Join(t.TempDir(), "hosts.json"))
t.Setenv("NETSSH_SHELL_ALIAS", "")
path := filepath.Join(dir, "netssh.yaml")
if err := os.WriteFile(path, []byte(data), 0o600); err != nil {
t.Fatal(err)
}
return path
}
const staticOnlyConfig = `ssh:
default_user: ops
rules:
- match: {kind: static, tag: home}
host_key_checking: accept-new
shortcuts:
domains: [.lan]
hosts:
- name: router.lan
address: 192.168.1.1
user: admin
port: 2222
tags: [home]
- name: nas
address: nas.example.org
ssh:
proxy_jump: jh.example.com
`
// Static hosts work without any NetBox and with their own user, port, tags, and options.
func TestStaticHostsWithoutNetBox(t *testing.T) {
prepareConfig(t, staticOnlyConfig)
for _, tc := range []struct {
args []string
want string
}{
{[]string{"--dry-run", "router.lan"}, "ssh -p 2222 -l admin -o StrictHostKeyChecking=accept-new 192.168.1.1"},
{[]string{"--dry-run", "router"}, "ssh -p 2222 -l admin -o StrictHostKeyChecking=accept-new 192.168.1.1"}, // shortcut
{[]string{"--dry-run", "-l", "root", "nas", "uptime"}, "ssh -l root -J jh.example.com nas.example.org uptime"},
{[]string{"sftp", "--dry-run", "router:/etc"}, "sftp -P 2222 -o User=admin -o StrictHostKeyChecking=accept-new 192.168.1.1:/etc"},
{[]string{"scp", "--dry-run", "a.txt", "nas:/tmp/"}, "scp -o User=ops -J jh.example.com a.txt nas.example.org:/tmp/"},
} {
out, err := runNetssh(t, tc.args...)
if err != nil || out != tc.want {
t.Errorf("%v:\n got %s (%v)\n want %s", tc.args, out, err, tc.want)
}
}
if out, err := runNetssh(t, "--dry-run", "unknown"); err == nil || !strings.Contains(out, "no NetBox is configured") {
t.Errorf("unknown host: %s (%v)", out, err)
}
if out, _ := runNetssh(t, "__complete", "rou"); !strings.HasPrefix(out, "router.lan\n") {
t.Errorf("completion: %q", out)
}
if out, _ := runNetssh(t, "alias", "--shell", "bash"); !strings.Contains(out, "alias router='netssh router.lan'") || !strings.Contains(out, "alias nas='netssh nas'") {
t.Errorf("aliases: %s", out)
}
}
func TestHostsCommand(t *testing.T) {
path := prepareConfig(t, "hosts:\n - {name: nas, address: nas.example.org, ssh: {proxy_jump: jh}}\n")
steps := []struct {
args []string
wantErr string
}{
{[]string{"hosts", "add", "router", "192.168.1.1", "--user", "admin", "--port", "2222", "--tag", "home", "--tag", "lab"}, ""},
{[]string{"hosts", "add", "router", "10.0.0.1"}, "already exists"},
{[]string{"hosts", "add", "nas", "10.0.0.5", "--replace"}, ""},
{[]string{"hosts", "add", "bad name", "10.0.0.1"}, "must start with"},
{[]string{"hosts", "remove", "missing"}, "no static host"},
}
for _, step := range steps {
out, err := runNetssh(t, step.args...)
if step.wantErr == "" && err != nil || step.wantErr != "" && !strings.Contains(out, step.wantErr) {
t.Fatalf("%v: %s (%v)", step.args, out, err)
}
}
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
router, nas := cfg.StaticHost("router"), cfg.StaticHost("nas")
if router == nil || router.User != "admin" || router.Port != 2222 || strings.Join(router.Tags, ",") != "home,lab" {
t.Fatalf("router: %+v", router)
}
if nas == nil || nas.Address != "10.0.0.5" || nas.SSH.ProxyJump != "jh" {
t.Fatalf("--replace must keep SSH options: %+v", nas)
}
out, err := runNetssh(t, "hosts", "list")
if err != nil || !strings.Contains(out, "router 192.168.1.1 admin 2222 home,lab") {
t.Fatalf("list:\n%s (%v)", out, err)
}
if out, err := runNetssh(t, "hosts", "rm", "router"); err != nil {
t.Fatalf("remove: %s (%v)", out, err)
}
data, _ := os.ReadFile(path)
if strings.Contains(string(data), "router") || strings.Contains(string(data), "netbox:") {
t.Fatalf("config after remove:\n%s", data)
}
}
// The hostname strategy passes the NetBox name (plus domain) instead of an IP.
func TestHostnameStrategyConnects(t *testing.T) {
srv := connectionTestServer(t, []connectionTestHost{{ID: 1, Name: "web01"}, multiHost("db01", "10.0.0.7")}, nil)
prepareConfig(t, fmt.Sprintf("netbox:\n url: %q\n token: t\nresolver:\n strategies: [primary_ip, hostname]\n hostname_domain: example.com\n", srv.URL))
for host, want := range map[string]string{"web01": "ssh web01.example.com", "db01": "ssh 10.0.0.7"} {
if out, err := runNetssh(t, "--dry-run", host); err != nil || out != want {
t.Errorf("%s: got %s (%v), want %s", host, out, err, want)
}
}
}
+437
View File
@@ -0,0 +1,437 @@
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 := resolveOrSuggest(cfg, target, false)
if err != nil {
return netbox.HostEntry{}, nil, h, err
}
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 {
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 := resolveOrSuggest(cfg, args[0], false)
if err != nil {
return err
}
out := cmd.OutOrStdout()
if h.Kind == config.StaticKind || h.Kind == "dns" {
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)
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 {
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 {
// 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
}
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()
}
}
+559
View File
@@ -0,0 +1,559 @@
package main
import (
"bytes"
"context"
"errors"
"fmt"
"net"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"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/resolver"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/secret"
internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh"
)
// insightEnv writes a config and a cache with two NetBox hosts and a static host.
func insightEnv(t *testing.T, yamlConfig string) string {
t.Helper()
configDir := t.TempDir()
t.Setenv("HOME", t.TempDir())
t.Setenv("XDG_CONFIG_HOME", configDir)
t.Setenv("XDG_CACHE_HOME", t.TempDir())
path := filepath.Join(t.TempDir(), "hosts.json")
t.Setenv("NETSSH_CACHE_PATH", path)
t.Setenv("NETSSH_SHELL_ALIAS", "")
if err := os.WriteFile(filepath.Join(configDir, "netssh.yaml"), []byte(yamlConfig), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
c := cache.New(cfg.CachePath(), 3600)
c.Upsert(cache.Entry{Name: "prod/web01", IP: "10.0.0.1", Kind: "vm", Tags: []string{"prod", "Web Server"}, ID: 11, Status: "active",
Site: &config.Ref{Name: "FSN 1", Slug: "fsn1"}, Role: &config.Ref{Name: "Web", Slug: "web"}, Platform: &config.Ref{Name: "Ubuntu 24.04", Slug: "ubuntu-24-04"}})
c.Upsert(cache.Entry{Name: "lab/web01", IP: "10.9.0.1", Kind: "vm", ID: 12, Status: "planned"})
c.Upsert(cache.Entry{Name: "prod/sw1", IP: "10.0.0.2", Kind: "device", ID: 13, Status: "active", Platform: &config.Ref{Name: "Junos", Slug: "junos"},
Location: []config.Ref{{Name: "Building A", Slug: "building-a"}, {Name: "Room 2.04", Slug: "room-2-04"}}, Rack: "R12", Position: "20"})
if err := c.Save(); err != nil {
t.Fatal(err)
}
return path
}
const insightConfig = `netboxes:
- name: prod
url: https://nb.example
token: t
- name: lab
url: https://lab.example
token: t
ssh:
default_user: admin
rules:
- match: {platform: junos}
proxy_jump: jump.example
options: {KexAlgorithms: +diffie-hellman-group14-sha1}
hosts:
- name: router
address: 192.168.1.1
port: 2222
tags: [home]
`
func TestExportAnsibleYAML(t *testing.T) {
insightEnv(t, insightConfig)
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
keys, _ := parseGroupBy("tag,site,platform,status")
hosts, err := exportHosts(cfg, exportFilter{})
if err != nil {
t.Fatal(err)
}
data, err := buildInventory(hosts, keys, true).yaml()
if err != nil {
t.Fatal(err)
}
var inv struct {
All struct {
Hosts map[string]map[string]any `yaml:"hosts"`
Children map[string]struct {
Hosts map[string]any `yaml:"hosts"`
} `yaml:"children"`
} `yaml:"all"`
}
if err := yaml.Unmarshal(data, &inv); err != nil {
t.Fatalf("invalid YAML: %v\n%s", err, data)
}
web := inv.All.Hosts["prod-web01"]
if web["ansible_host"] != "10.0.0.1" || web["ansible_user"] != "admin" || web["netbox_site"] != "FSN 1" || web["netbox_id"] != 11 {
t.Fatalf("prod-web01 vars wrong: %+v\n%s", web, data)
}
if tags, _ := web["netbox_tags"].([]any); len(tags) != 2 {
t.Fatalf("tags should stay a list: %#v", web["netbox_tags"])
}
if _, ok := inv.All.Hosts["lab-web01"]; !ok {
t.Fatalf("duplicate hostnames must be qualified: %v", inv.All.Hosts)
}
sw := inv.All.Hosts["sw1"]
if sw["ansible_ssh_common_args"] != "-o ProxyJump=jump.example" {
t.Fatalf("jump host missing for platform rule: %+v", sw)
}
router := inv.All.Hosts["router"]
if router["ansible_port"] != 2222 || router["ansible_host"] != "192.168.1.1" {
t.Fatalf("static host wrong: %+v", router)
}
for _, group := range []string{"tag_prod", "tag_web_server", "site_fsn1", "platform_junos", "status_planned", "tag_home"} {
if _, ok := inv.All.Children[group]; !ok {
t.Errorf("group %s missing in\n%s", group, data)
}
}
if _, ok := inv.All.Children["platform_junos"].Hosts["sw1"]; !ok {
t.Fatal("sw1 not in platform_junos")
}
}
func TestExportAnsibleINI(t *testing.T) {
insightEnv(t, insightConfig)
cfg, _ := config.Load()
hosts, err := exportHosts(cfg, exportFilter{instance: "prod"})
if err != nil {
t.Fatal(err)
}
keys, _ := parseGroupBy("tag,role")
out := string(buildInventory(hosts, keys, true).ini())
for _, want := range []string{
"[all]\nsw1 ansible_host=10.0.0.2 ansible_user=admin ansible_ssh_common_args=\"-o ProxyJump=jump.example\"",
`web01 ansible_host=10.0.0.1`,
`netbox_site="FSN 1"`,
`netbox_tags="prod,Web Server"`,
"\n[role_web]\nweb01\n",
"\n[tag_prod]\nweb01\n",
} {
if !strings.Contains(out, want) {
t.Errorf("missing %q in\n%s", want, out)
}
}
if strings.Contains(out, "lab") || strings.Contains(out, "router") {
t.Fatalf("--instance prod not applied:\n%s", out)
}
}
func TestExportFiltersAndGroupByValidation(t *testing.T) {
insightEnv(t, insightConfig)
cfg, _ := config.Load()
hosts, err := exportHosts(cfg, exportFilter{status: "active", noStatic: true})
if err != nil {
t.Fatal(err)
}
if len(hosts) != 2 {
t.Fatalf("status filter: %+v", hosts)
}
if _, err := parseGroupBy("site,color"); err == nil {
t.Fatal("unknown group-by accepted")
}
if keys, err := parseGroupBy("none"); err != nil || keys != nil {
t.Fatal("none should disable groups")
}
if _, err := exportHosts(cfg, exportFilter{tag: "missing"}); err == nil {
t.Fatal("empty export should fail")
}
}
func TestExportSSHConfig(t *testing.T) {
insightEnv(t, insightConfig)
cfg, _ := config.Load()
hosts, err := exportHosts(cfg, exportFilter{})
if err != nil {
t.Fatal(err)
}
var b bytes.Buffer
writeSSHConfig(&b, hosts, map[string]string{"prod/sw1": "sw"})
out := b.String()
for _, want := range []string{
"\nHost sw1 sw\n HostName 10.0.0.2\n User admin\n ProxyJump jump.example\n kexalgorithms +diffie-hellman-group14-sha1\n",
"\nHost router\n HostName 192.168.1.1\n User admin\n Port 2222\n",
"\nHost prod-web01\n HostName 10.0.0.1\n",
} {
if !strings.Contains(out, want) {
t.Errorf("missing %q in\n%s", want, out)
}
}
}
func TestCopyIDArgv(t *testing.T) {
insightEnv(t, insightConfig)
cfg, _ := config.Load()
h, err := resolveTargetE(cfg, "prod/sw1", false)
if err != nil {
t.Fatal(err)
}
argv, err := copyIDArgv(cfg, h, copyIDFlags{identity: "/k.pub"})
if err != nil {
t.Fatal(err)
}
got := internalssh.Quote(argv)
for _, want := range []string{"ssh-copy-id -i /k.pub", "-o ProxyJump=jump.example", "-o kexalgorithms=+diffie-hellman-group14-sha1", "admin@10.0.0.2"} {
if !strings.Contains(got, want) {
t.Errorf("missing %q in %s", want, got)
}
}
if strings.Contains(got, " -J ") {
t.Fatalf("ssh-copy-id has no -J: %s", got)
}
router, _ := resolveTargetE(cfg, "router", false)
argv, _ = copyIDArgv(cfg, router, copyIDFlags{user: "root", noJump: true, check: true})
if got := internalssh.Quote(argv); !strings.Contains(got, "-n") || !strings.Contains(got, "-p 2222") || !strings.HasSuffix(got, "root@192.168.1.1") {
t.Fatalf("static host argv wrong: %s", got)
}
}
func TestRunCopyIDContinuesAfterFailure(t *testing.T) {
insightEnv(t, insightConfig)
cfg, _ := config.Load()
var ran []string
old := runCopyIDCommand
runCopyIDCommand = func(argv []string) error {
ran = append(ran, argv[len(argv)-1])
if strings.Contains(argv[len(argv)-1], "10.0.0.2") {
return errors.New("permission denied")
}
return nil
}
t.Cleanup(func() { runCopyIDCommand = old })
stubTerminal(t, false)
err := runCopyID(cfg, []string{"prod/sw1", "router"}, copyIDFlags{})
if err == nil || !strings.Contains(err.Error(), "1 of 2 hosts") || len(ran) != 2 {
t.Fatalf("err %v, ran %v", err, ran)
}
}
func stubTerminal(t *testing.T, tty bool) {
t.Helper()
old := stdinIsTerminal
stdinIsTerminal = func() bool { return tty }
t.Cleanup(func() { stdinIsTerminal = old })
}
func TestConfirmStatusWarnsWithoutTerminal(t *testing.T) {
stubTerminal(t, false)
cfg := &config.Config{}
if err := confirmStatus(cfg, resolvedHost{Name: "web", Status: "offline"}, false); err != nil {
t.Fatalf("non-interactive status check must not fail: %v", err)
}
if err := confirmStatus(cfg, resolvedHost{Name: "web", Status: "active"}, false); err != nil {
t.Fatal(err)
}
}
func TestKnownHostsKeysAndFile(t *testing.T) {
keys := knownHostsKeys("prod/web01", []string{"10.0.0.1", "10.0.0.1", "10.0.0.9"}, 2222)
want := []string{"web01", "[web01]:2222", "10.0.0.1", "[10.0.0.1]:2222", "10.0.0.9", "[10.0.0.9]:2222"}
if strings.Join(keys, " ") != strings.Join(want, " ") {
t.Fatalf("got %v", keys)
}
if keys := knownHostsKeys("web", []string{"10.0.0.1"}, 22); strings.Join(keys, " ") != "web 10.0.0.1" {
t.Fatalf("got %v", keys)
}
t.Setenv("HOME", "/home/u")
if f := knownHostsFile(config.SSHOptions{Options: map[string]string{"userknownhostsfile": "~/.ssh/lab_hosts ~/.ssh/other"}}); f != "/home/u/.ssh/lab_hosts" {
t.Fatalf("file %q", f)
}
if f := knownHostsFile(config.SSHOptions{Options: map[string]string{"userknownhostsfile": "/dev/null"}}); f != "" {
t.Fatalf("file %q", f)
}
}
func TestKnownHostsResetRemovesNameAndAddresses(t *testing.T) {
insightEnv(t, insightConfig)
var removed []string
old := removeKnownHosts
removeKnownHosts = func(keys []string, file string) error { removed = append(removed, keys...); return nil }
t.Cleanup(func() { removeKnownHosts = old })
cmd := rootCmd()
cmd.SetArgs([]string{"known-hosts", "reset", "--yes", "router"})
if err := cmd.Execute(); err != nil {
t.Fatal(err)
}
if strings.Join(removed, " ") != "router [router]:2222 192.168.1.1 [192.168.1.1]:2222" {
t.Fatalf("removed %v", removed)
}
}
func TestConnectPort(t *testing.T) {
for _, tc := range []struct {
client internalssh.Client
args []string
want int
}{
{internalssh.SSH, []string{"-p", "2222", "web"}, 2222},
{internalssh.SSH, []string{"-p2200", "web"}, 2200},
{internalssh.SSH, []string{"-o", "Port=2022", "web"}, 2022},
{internalssh.SFTP, []string{"-P", "23", "web"}, 23},
{internalssh.SSH, []string{"web", "-p", "1"}, 22},
} {
dest := 0
for i, a := range tc.args {
if a == "web" {
dest = i
}
}
if got := connectPort(tc.client, tc.args, []int{dest}); got != tc.want {
t.Errorf("%v: got %d, want %d", tc.args, got, tc.want)
}
}
}
func TestApplyFallback(t *testing.T) {
up := map[string]bool{"10.0.0.2": true}
oldProbe, oldCandidates := fallbackProbe, fallbackCandidates
fallbackProbe = func(address string, port int, _ time.Duration) bool { return up[address] && port == 22 }
fallbackCandidates = func(*config.Config, resolvedHost) ([]resolver.Candidate, error) {
return []resolver.Candidate{{Address: "10.0.0.1", Strategy: "management_subnet"}, {Address: "10.0.0.2", Strategy: "primary_ip"}}, nil
}
t.Cleanup(func() { fallbackProbe, fallbackCandidates = oldProbe, oldCandidates })
host := resolvedHost{Name: "web", Kind: "vm", IP: "10.0.0.1"}
cfg := &config.Config{}
if got := applyFallback(cfg, host, config.SSHOptions{}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.1" {
t.Fatal("fallback ran while disabled")
}
cfg.Resolver.Fallback = true
if got := applyFallback(cfg, host, config.SSHOptions{}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.2" {
t.Fatalf("fallback did not switch: %s", got.IP)
}
if got := applyFallback(cfg, host, config.SSHOptions{ProxyJump: "jump"}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.1" {
t.Fatal("hosts behind a jump host must not be probed")
}
if got := applyFallback(cfg, host, config.SSHOptions{ProxyJump: "jump"}, internalssh.WrapperFlags{NoJump: true}, 22); got.IP != "10.0.0.2" {
t.Fatal("--no-jump should allow the fallback")
}
up = map[string]bool{}
if got := applyFallback(cfg, host, config.SSHOptions{}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.1" {
t.Fatal("must keep the chosen address when nothing answers")
}
}
func TestReachableProbe(t *testing.T) {
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Skip(err)
}
port := ln.Addr().(*net.TCPAddr).Port
if !reachable("127.0.0.1", port, time.Second) {
t.Fatal("listening port reported unreachable")
}
ln.Close()
if reachable("127.0.0.1", port, 200*time.Millisecond) {
t.Fatal("closed port reported reachable")
}
}
func TestWhoisAddresses(t *testing.T) {
old := lookupHost
lookupHost = func(_ context.Context, host string) ([]string, error) {
if host == "mail.example.com" {
return []string{"192.0.2.25"}, nil
}
return nil, errors.New("no such host")
}
t.Cleanup(func() { lookupHost = old })
for in, want := range map[string]string{"10.0.0.1": "10.0.0.1", "10.0.0.0/24": "10.0.0.0", "mail.example.com": "192.0.2.25"} {
got, err := whoisAddresses(context.Background(), in)
if err != nil || len(got) != 1 || got[0] != want {
t.Errorf("%s: %v %v", in, got, err)
}
}
if _, err := whoisAddresses(context.Background(), "nope.invalid"); err == nil {
t.Fatal("unresolvable name accepted")
}
}
func TestWhoisCommandUsesNetBoxAndCache(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/api/ipam/ip-addresses/":
fmt.Fprint(w, `{"count":1,"results":[{"address":"10.0.0.1/24","dns_name":"web01.example.com","assigned_object":{"name":"eth0","virtual_machine":{"id":11,"name":"web01"}}}]}`)
case "/api/ipam/prefixes/":
fmt.Fprint(w, `{"count":1,"results":[{"prefix":"10.0.0.0/24","description":"servers"}]}`)
default:
http.NotFound(w, r)
}
}))
defer srv.Close()
insightEnv(t, fmt.Sprintf("netboxes:\n - name: prod\n url: %s\n token: t\n", srv.URL))
var out bytes.Buffer
cmd := rootCmd()
cmd.SetOut(&out)
cmd.SetArgs([]string{"whois", "10.0.0.1"})
if err := cmd.Execute(); err != nil {
t.Fatal(err)
}
for _, want := range []string{"prod/web01 (vm) eth0", "dns web01.example.com", "10.0.0.0/24 (prod)", `"servers"`, "Cache prod/web01"} {
if !strings.Contains(out.String(), want) {
t.Errorf("missing %q in\n%s", want, out.String())
}
}
}
func TestOpenPrintsNetBoxURL(t *testing.T) {
insightEnv(t, insightConfig)
var out bytes.Buffer
cmd := rootCmd()
cmd.SetOut(&out)
cmd.SetArgs([]string{"open", "--print", "prod/sw1"})
if err := cmd.Execute(); err != nil {
t.Fatal(err)
}
if strings.TrimSpace(out.String()) != "https://nb.example/dcim/devices/13/" {
t.Fatalf("got %q", out.String())
}
cmd = rootCmd()
cmd.SetArgs([]string{"open", "--print", "router"})
if err := cmd.Execute(); err == nil || !strings.Contains(err.Error(), "static host") {
t.Fatalf("static host: %v", err)
}
}
func TestTokenMigrateAndResolve(t *testing.T) {
secret.MockInit()
insightEnv(t, insightConfig)
var saved config.Config
old := saveConfig
saveConfig = func(cfg config.Config) error { saved = cfg; return nil }
t.Cleanup(func() { saveConfig = old })
tokenMu.Lock()
tokenCache = map[string]string{}
tokenMu.Unlock()
var out bytes.Buffer
cmd := rootCmd()
cmd.SetOut(&out)
cmd.SetArgs([]string{"token", "migrate"})
if err := cmd.Execute(); err != nil {
t.Fatal(err)
}
if len(saved.NetBoxes) != 2 || !config.IsKeyringToken(saved.NetBoxes[0].Token) || !config.IsKeyringToken(saved.NetBoxes[1].Token) {
t.Fatalf("tokens not replaced: %+v", saved.NetBoxes)
}
token, err := resolveToken(saved.NetBoxes[0])
if err != nil || token != "t" {
t.Fatalf("token %q, %v", token, err)
}
cmd = rootCmd()
cmd.SetIn(strings.NewReader("nbt_secret\n"))
cmd.SetOut(&out)
cmd.SetArgs([]string{"token", "set", "lab"})
if err := cmd.Execute(); err != nil {
t.Fatal(err)
}
stored, err := secret.Get("lab")
if err != nil || stored != "nbt_secret" {
t.Fatalf("stored %q, %v", stored, err)
}
for _, n := range saved.NetBoxes {
if n.Name == "lab" && n.TokenVersion != 2 {
t.Fatalf("token version not detected: %+v", n)
}
}
cmd = rootCmd()
cmd.SetArgs([]string{"token", "set"})
if err := cmd.Execute(); err == nil {
t.Fatal("ambiguous instance accepted")
}
}
func TestCacheRefreshStoresAttributesAndReportsChangedAddresses(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/api/dcim/devices/":
fmt.Fprint(w, `{"count":1,"results":[{"id":5,"name":"sw1","primary_ip4":{"address":"192.0.2.5/24"},
"status":{"value":"offline"},"site":{"name":"FSN1","slug":"fsn1"},"role":{"name":"Switch","slug":"switch"},"platform":{"name":"Junos","slug":"junos"}}]}`)
case "/api/virtualization/virtual-machines/", "/api/ipam/ip-addresses/":
fmt.Fprint(w, `{"count":0,"results":[]}`)
default:
http.NotFound(w, r)
}
}))
defer srv.Close()
path := prepareRefreshTest(t, srv.URL, "[primary_ip]")
c := cache.New(path, 3600)
c.Upsert(cache.Entry{Name: "sw1", IP: "192.0.2.99", Kind: "device"})
if err := c.Save(); err != nil {
t.Fatal(err)
}
stdout := captureStdout(t, func() {
cmd := rootCmd()
cmd.SetArgs([]string{"cache", "refresh"})
if err := cmd.Execute(); err != nil {
t.Fatal(err)
}
})
if !strings.Contains(stdout, "sw1: 192.0.2.99 → 192.0.2.5") || !strings.Contains(stdout, "known-hosts reset") {
t.Fatalf("address change not reported:\n%s", stdout)
}
if err := c.Load(); err != nil {
t.Fatal(err)
}
got, _ := c.Get("sw1")
if got.ID != 5 || got.Status != "offline" || cache.RefOf(got.Site).Slug != "fsn1" || cache.RefOf(got.Platform).Slug != "junos" || cache.RefOf(got.Role).Name != "Switch" {
t.Fatalf("attributes not cached: %+v", got)
}
cfg, _ := config.Load()
h, _ := resolveTargetE(cfg, "sw1", false)
if h.Status != "offline" || h.Platform.Slug != "junos" || h.ID != 5 {
t.Fatalf("resolved host lacks attributes: %+v", h)
}
}
func captureStdout(t *testing.T, fn func()) string {
t.Helper()
r, w, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
old := os.Stdout
os.Stdout = w
done := make(chan string)
go func() {
var b bytes.Buffer
_, _ = b.ReadFrom(r)
done <- b.String()
}()
defer func() { os.Stdout = old }()
fn()
w.Close()
os.Stdout = old
return <-done
}
func TestExportLocationVarsAndGroups(t *testing.T) {
insightEnv(t, insightConfig)
cfg, _ := config.Load()
hosts, err := exportHosts(cfg, exportFilter{instance: "prod", kind: "device"})
if err != nil {
t.Fatal(err)
}
keys, _ := parseGroupBy("location,rack")
out := string(buildInventory(hosts, keys, true).ini())
for _, want := range []string{`netbox_location="Building A/Room 2.04"`, "netbox_rack=R12", "netbox_position=20",
"\n[location_building_a]\nsw1\n", "\n[location_room_2_04]\nsw1\n", "\n[rack_r12]\nsw1\n"} {
if !strings.Contains(out, want) {
t.Errorf("missing %q in\n%s", want, out)
}
}
}
+104 -8
View File
@@ -6,22 +6,52 @@ import (
"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/hook"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/shortcuts"
)
// newCache opens the host cache with the config's static hosts.
func newCache(cfg *config.Config) *cache.Cache {
return cache.New(cfg.CachePath(), cfg.Cache.TTL).WithStatic(cfg.Hosts)
}
func newNetBoxClient(cfg *config.Config) *netbox.Client {
if len(cfg.NetBoxes) > 0 {
sources := make([]netbox.Source, 0, len(cfg.NetBoxes))
for _, source := range cfg.NetBoxes {
sources = append(sources, netbox.Source{Name: source.Name, URL: source.URL, Token: source.Token, TokenVersion: source.TokenVersion})
token, version := clientToken(source)
sources = append(sources, netbox.Source{Name: source.Name, URL: source.URL, Token: token, TokenVersion: version})
}
return netbox.NewMultiClient(sources)
}
if cfg.NetBox.URL == "" {
return nil
}
return netbox.NewClient(cfg.NetBox.URL, cfg.NetBox.Token, cfg.NetBox.TokenVersion)
token, version := clientToken(cfg.NetBox)
return netbox.NewClient(cfg.NetBox.URL, token, version)
}
// shortcutAliases maps each target (lowercased) to the shell alias generated for
// it, but only where shortcuts actually shorten the displayed name: an alias that
// merely replaces dots with underscores ("web01_example_com") adds nothing.
// The aliases are the same ones netssh alias and the shell hook define.
func shortcutAliases(entries []cache.Entry, cfg config.Config) map[string]string {
out := make(map[string]string)
if !cfg.Shortcuts.Enabled() {
return out
}
plain := strings.NewReplacer(".", "_", "/", "_")
for _, alias := range hook.BuildAliasEntries(append([]cache.Entry(nil), entries...), cfg) {
if alias.Host == "" || alias.Command != "" {
continue // the command alias for netssh itself
}
if alias.Name == plain.Replace(strings.ToLower(cfg.HostLabel(alias.Host))) {
continue
}
out[strings.ToLower(alias.Host)] = alias.Name
}
return out
}
func normalizeTarget(cfg config.ShortcutsConfig, qualified bool) func(string) string {
@@ -41,7 +71,12 @@ func normalizeTarget(cfg config.ShortcutsConfig, qualified bool) func(string) st
// all instances is offered bare ("web01"), so it completes like with a single
// NetBox; connecting to it still checks every instance for ambiguity.
// Names present in several instances stay qualified ("prod/web01").
func hostCompletions(entries []cache.Entry, toComplete string) []string {
// Hosts whose full name does not match are offered by their configured
// shortcut instead ("fsnb" → "fsnbx1" for fsn1-bx1.example.com).
//
// With shortcuts.show, shortcuts are also offered for hosts whose full name
// matches, so "fsn" lists both fsn1-bx1.example.com and fsnbx1.
func hostCompletions(entries []cache.Entry, toComplete string, sc config.ShortcutsConfig) []string {
prefix := strings.ToLower(toComplete)
qualifiedInput := strings.Contains(prefix, "/")
instances := make(map[string]int)
@@ -49,21 +84,82 @@ func hostCompletions(entries []cache.Entry, toComplete string) []string {
_, name := netbox.SplitTarget(e.Name)
instances[strings.ToLower(name)]++
}
var out []string
var unmatched []cache.Entry
var names []string
for _, e := range entries {
source, name := netbox.SplitTarget(e.Name)
target := strings.ToLower(e.Name)
switch {
case source != "" && !qualifiedInput && strings.HasPrefix(strings.ToLower(name), prefix):
if instances[strings.ToLower(name)] == 1 {
out = append(out, name)
names = append(names, name)
} else {
out = append(out, e.Name)
names = append(names, e.Name)
}
case strings.HasPrefix(target, prefix):
out = append(out, e.Name)
names = append(names, e.Name)
default:
unmatched = append(unmatched, e)
}
}
if sc.Enabled() {
candidates := unmatched
if sc.Show {
candidates = entries
}
offered := make(map[string]bool, len(names))
for _, name := range names {
offered[strings.ToLower(name)] = true
}
for _, name := range shortcutCompletions(entries, candidates, prefix, sc) {
if !offered[name] {
offered[name] = true
names = append(names, name)
}
}
}
sort.Strings(names)
return names
}
// shortcutCompletions offers the shortcut of each unmatched host when it starts
// with prefix and selects exactly one host, qualified by instance if needed.
func shortcutCompletions(all, unmatched []cache.Entry, prefix string, sc config.ShortcutsConfig) []string {
bare := make(map[string]int)
qualified := make(map[string]int)
short := func(e cache.Entry) (string, string) {
source, name := netbox.SplitTarget(e.Name)
s := shortcuts.Normalize(name, sc)
if source == "" {
return s, s
}
return s, strings.ToLower(source) + "/" + s
}
for _, e := range all {
b, q := short(e)
bare[b]++
qualified[q]++
}
seen := make(map[string]bool)
var out []string
for _, e := range unmatched {
b, q := short(e)
candidate := ""
switch {
case strings.Contains(prefix, "/"):
if qualified[q] == 1 && strings.HasPrefix(q, prefix) {
candidate = q
}
case !strings.HasPrefix(b, prefix):
case bare[b] == 1:
candidate = b
case q != b && qualified[q] == 1:
candidate = q // like full names: zsh accepts it, bash/fish ignore it
}
if candidate != "" && !seen[candidate] {
seen[candidate] = true
out = append(out, candidate)
}
}
sort.Strings(out)
return out
}
+82 -2
View File
@@ -228,12 +228,92 @@ func TestHostCompletionsMatchTypedText(t *testing.T) {
// An instance name typed without the slash completes qualified targets.
{"st", []string{"stg/fsn1-bx2.example.com", "stg/hel1-tb1.example.com"}},
} {
if got := hostCompletions(entries, tc.input); !reflect.DeepEqual(got, tc.want) {
if got := hostCompletions(entries, tc.input, config.ShortcutsConfig{}); !reflect.DeepEqual(got, tc.want) {
t.Errorf("%q: got %v, want %v", tc.input, got, tc.want)
}
}
// Single-instance caches are unchanged.
if got := hostCompletions([]cache.Entry{{Name: "web01"}, {Name: "db01"}}, "w"); !reflect.DeepEqual(got, []string{"web01"}) {
if got := hostCompletions([]cache.Entry{{Name: "web01"}, {Name: "db01"}}, "w", config.ShortcutsConfig{}); !reflect.DeepEqual(got, []string{"web01"}) {
t.Errorf("single instance: %v", got)
}
}
var fsnRewrite = config.ShortcutsConfig{
Domains: []string{".hoster.de"},
Rewrites: []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}},
}
func TestHostCompletionsOfferShortcuts(t *testing.T) {
entries := []cache.Entry{
{Name: "prod/fsn1-bx1.hoster.de"},
{Name: "prod/fsn1-db1.hoster.de"},
{Name: "stg/fsn1-db1.hoster.de"},
{Name: "prod/web01.hoster.de"},
}
for _, tc := range []struct {
input string
want []string
}{
{"fsnb", []string{"fsnbx1"}},
// Shortcut shared by two instances stays qualified.
{"fsnd", []string{"prod/fsndb1", "stg/fsndb1"}},
{"prod/fsn", []string{"prod/fsn1-bx1.hoster.de", "prod/fsn1-db1.hoster.de"}},
{"stg/fsnd", []string{"stg/fsndb1"}},
// A matching full name is not repeated as shortcut.
{"web", []string{"web01.hoster.de"}},
} {
if got := hostCompletions(entries, tc.input, fsnRewrite); !reflect.DeepEqual(got, tc.want) {
t.Errorf("%q: got %v, want %v", tc.input, got, tc.want)
}
}
// Two hosts of the same instance with one shortcut cannot be selected by it.
same := []cache.Entry{{Name: "fsn1-bx1.hoster.de"}, {Name: "fsn2-bx1.hoster.de"}}
if got := hostCompletions(same, "fsnb", fsnRewrite); len(got) != 0 {
t.Errorf("ambiguous shortcut offered: %v", got)
}
}
func TestShortcutTestOutput(t *testing.T) {
var out bytes.Buffer
printShortcutTest(&out, "fsn1-bx1.hoster.de", []cache.Entry{{Name: "fsn1-bx1.hoster.de"}, {Name: "fsn2-bx1.hoster.de"}, {Name: "web01.hoster.de"}}, fsnRewrite)
want := "fsn1-bx1.hoster.de → fsnbx1\nambiguous, matches 2 hosts:\n fsn1-bx1.hoster.de\n fsn2-bx1.hoster.de\n"
if out.String() != want {
t.Fatalf("got:\n%s", out.String())
}
}
// Rewrite rules alone must enable the shortcut lookup; NetBox is unreachable,
// so only the cached host can answer.
func TestWrapperConnectsByRewriteShortcut(t *testing.T) {
dir := t.TempDir()
t.Setenv("HOME", t.TempDir())
t.Setenv("XDG_CONFIG_HOME", dir)
t.Setenv("XDG_CACHE_HOME", t.TempDir())
t.Setenv("NETSSH_NETBOX_URL", "")
t.Setenv("NETSSH_NETBOX_TOKEN", "")
t.Setenv("NETSSH_CACHE_PATH", filepath.Join(t.TempDir(), "hosts.json"))
t.Setenv("NETSSH_SHELL_ALIAS", "")
data := "netbox:\n url: http://127.0.0.1:1\n token: t\nshortcuts:\n rewrites:\n - pattern: '^([a-z]+)[0-9]+-'\n replace: '$1'\n"
if err := os.WriteFile(filepath.Join(dir, "netssh.yaml"), []byte(data), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
c := cache.New(cfg.CachePath(), 3600)
c.Upsert(cache.Entry{Name: "fsn1-bx1.hoster.de", IP: "10.0.0.9", Kind: "device"})
if err := c.Save(); err != nil {
t.Fatal(err)
}
bin := t.TempDir()
if err := os.WriteFile(filepath.Join(bin, "ssh"), []byte("#!/bin/sh\nprintf '%s\\n' \"$@\"\n"), 0o755); err != nil {
t.Fatal(err)
}
cmd := exec.Command(os.Args[0], "-test.run=^TestMultiInstanceWrapperHelper$")
cmd.Env = append(os.Environ(), "NETSSH_TEST_MULTI_TARGET=fsnbx1.hoster.de", "PATH="+bin+":"+os.Getenv("PATH"))
out, err := cmd.CombinedOutput()
if err != nil || !strings.Contains(string(out), "10.0.0.9\n") {
t.Fatalf("shortcut not resolved from cache: %s, %v", out, err)
}
}
+98
View File
@@ -0,0 +1,98 @@
package main
import (
"fmt"
"os"
"strings"
"github.com/spf13/cobra"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh"
)
func knownHostsCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "known-hosts",
Short: "Clean up host keys of re-deployed hosts",
}
cmd.AddCommand(knownHostsResetCmd())
return cmd
}
func knownHostsResetCmd() *cobra.Command {
var yes, dryRun bool
cmd := &cobra.Command{
Use: "reset HOST...",
Short: "Remove the known_hosts entries of hosts (name, current and previous address)",
Long: `Remove the stored host keys of hosts with ssh-keygen -R, after a host was
re-installed or got a new address. Removed are the hostname, the address
netssh connects to, the previously cached address if NetBox changed it, and
[name]:port / [address]:port for a non-standard port. ssh-keygen keeps the
previous file as known_hosts.old.`,
Example: " netssh known-hosts reset web01\n netssh known-hosts reset --dry-run web01 web02",
Args: cobra.MinimumNArgs(1),
ValidArgsFunction: hostCompletion,
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
c := newCache(cfg)
_ = c.Load()
type plan struct {
keys []string
file string
}
var plans []plan
var all []string
for _, target := range args {
previous, _ := c.Get(target)
h, err := resolveTargetE(cfg, target, false)
if err != nil {
return err
}
addresses := []string{h.IP}
if h.PreviousIP != "" {
addresses = append(addresses, h.PreviousIP)
}
if previous.IP != "" && previous.IP != h.IP {
addresses = append(addresses, previous.IP)
}
_, port := hostDefaults(cfg, h)
if port <= 0 {
port = 22
}
opts := hostOptions(cfg, h)
p := plan{keys: knownHostsKeys(h.Name, addresses, port), file: knownHostsFile(opts)}
plans = append(plans, p)
all = append(all, p.keys...)
}
if dryRun {
for _, p := range plans {
for _, key := range p.keys {
argv := []string{"ssh-keygen", "-R", key}
if p.file != "" {
argv = append(argv, "-f", p.file)
}
fmt.Fprintln(cmd.OutOrStdout(), internalssh.Quote(argv))
}
}
return nil
}
if err := confirmAction("Remove known_hosts entries for "+strings.Join(all, ", "), yes); err != nil {
return err
}
for _, p := range plans {
if err := removeKnownHosts(p.keys, p.file); err != nil {
return err
}
}
fmt.Fprintln(os.Stderr, "Done. The next connection asks to confirm the new host key.")
return nil
},
}
cmd.Flags().BoolVarP(&yes, "yes", "y", false, "Do not ask for confirmation")
cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Print the ssh-keygen commands without running them")
return cmd
}
+140
View File
@@ -0,0 +1,140 @@
package main
import (
"fmt"
"sort"
"strings"
"text/tabwriter"
"github.com/spf13/cobra"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func linkCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "link",
Short: "Short names for hosts: netssh NAME and shell alias NAME",
Long: `Links give a host a name of your own, for example mx123 for the server that
mx123.webseite.de points to. netssh NAME then connects to the host, and new
shells get the alias NAME. netssh offers to create a link after a DNS
suggestion; links are stored under links: in the config.`,
}
cmd.AddCommand(linkListCmd(), linkAddCmd(), linkRemoveCmd())
return cmd
}
func linkListCmd() *cobra.Command {
return &cobra.Command{
Use: "list",
Short: "List links",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
if len(cfg.Links) == 0 {
fmt.Fprintln(cmd.OutOrStdout(), "No links. Add one with: netssh link add NAME HOST")
return nil
}
names := make([]string, 0, len(cfg.Links))
for name := range cfg.Links {
names = append(names, name)
}
sort.Strings(names)
w := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 2, ' ', 0)
fmt.Fprintln(w, "NAME\tHOST")
for _, name := range names {
fmt.Fprintf(w, "%s\t%s\n", name, cfg.Links[name])
}
return w.Flush()
},
}
}
func linkAddCmd() *cobra.Command {
return &cobra.Command{
Use: "add NAME HOST",
Short: "Create or replace a link",
Example: " netssh link add mx123 prod/web07\n netssh link add mx123 mx123.webseite.de # asks which host owns the address",
Args: cobra.ExactArgs(2),
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
if len(args) == 1 {
return hostCompletion(cmd, args, toComplete)
}
return nil, cobra.ShellCompDirectiveNoFileComp
},
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
name := strings.ToLower(args[0])
if _, isLink := cfg.Link(args[1]); isLink {
return fmt.Errorf("%q is a link itself; link to a host", args[1])
}
// Resolve now, so a typo fails here and the link stores the canonical target.
h, err := resolveOrSuggestQuiet(cfg, args[1])
if err != nil {
return err
}
if h.Kind == "dns" {
return fmt.Errorf("%s is not a NetBox or static host; links point to hosts netssh knows", args[1])
}
if err := saveLink(name, h.Name); err != nil {
return err
}
fmt.Fprintf(cmd.OutOrStdout(), "netssh %s → %s (open a new shell for the alias %s)\n", name, h.Name, name)
return nil
},
}
}
// resolveOrSuggestQuiet resolves for link add without offering another link.
func resolveOrSuggestQuiet(cfg *config.Config, host string) (resolvedHost, error) {
old := offerLinkFunc
offerLinkFunc = func(string, string, string) {}
defer func() { offerLinkFunc = old }()
return resolveOrSuggest(cfg, host, false)
}
func linkRemoveCmd() *cobra.Command {
return &cobra.Command{
Use: "remove NAME",
Short: "Remove a link",
Args: cobra.ExactArgs(1),
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
var names []string
for name := range cfg.Links {
names = append(names, name)
}
return filterPrefix(names, toComplete, nil), cobra.ShellCompDirectiveNoFileComp
},
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
removed := false
for key := range cfg.Links {
if strings.EqualFold(key, args[0]) {
delete(cfg.Links, key)
removed = true
}
}
if !removed {
return fmt.Errorf("no link %q", args[0])
}
if err := saveHosts(cfg); err != nil {
return err
}
fmt.Fprintf(cmd.OutOrStdout(), "Link %s removed.\n", args[0])
return nil
},
}
}
+85
View File
@@ -0,0 +1,85 @@
package main
import (
"os"
"path/filepath"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/hook"
)
func TestLinksResolveAndBecomeAliases(t *testing.T) {
dnsEnv(t, "links:\n mx123: prod/web07\n")
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
h, err := resolveTargetE(cfg, "MX123", false)
if err != nil || h.Name != "prod/web07" {
t.Fatalf("link not followed: %+v %v", h, err)
}
var found bool
for _, a := range hook.BuildAliasEntries(nil, *cfg) {
if a.Name == "mx123" && a.Host == "mx123" {
found = true
}
}
if !found {
t.Fatal("link has no shell alias")
}
if got := completeHosts("mx"); len(got) == 0 || got[0] != "mx123" {
t.Fatalf("completion: %v", got)
}
}
func TestLinkAddListRemove(t *testing.T) {
dnsEnv(t, "")
stubTerminal(t, false)
run := func(args ...string) (string, error) {
var out strings.Builder
cmd := rootCmd()
cmd.SetOut(&out)
cmd.SetArgs(args)
err := cmd.Execute()
return out.String(), err
}
if _, err := run("link", "add", "mx123", "prod/web07"); err != nil {
t.Fatal(err)
}
data, _ := os.ReadFile(filepath.Join(os.Getenv("XDG_CONFIG_HOME"), "netssh.yaml"))
if !strings.Contains(string(data), "links:\n mx123: \"prod/web07\"") {
t.Fatalf("link not written:\n%s", data)
}
if out, _ := run("link", "list"); !strings.Contains(out, "mx123 prod/web07") {
t.Fatalf("list: %q", out)
}
if _, err := run("link", "add", "x", "missing-host"); err == nil {
t.Fatal("link to unknown host accepted")
}
if _, err := run("link", "remove", "mx123"); err != nil {
t.Fatal(err)
}
cfg, _ := config.Load()
if len(cfg.Links) != 0 {
t.Fatalf("not removed: %v", cfg.Links)
}
}
func TestValidateLinks(t *testing.T) {
for _, tc := range []struct {
cfg config.Config
ok bool
}{
{config.Config{Links: map[string]string{"mx123": "prod/web07"}}, true},
{config.Config{Links: map[string]string{"bad name": "web"}}, false},
{config.Config{Links: map[string]string{"a": "-oProxyCommand=x"}}, false},
{config.Config{Links: map[string]string{"a": "b", "b": "web"}}, false},
{config.Config{Links: map[string]string{"router": "web"}, Hosts: []config.StaticHost{{Name: "router", Address: "1.2.3.4"}}}, false},
} {
if err := tc.cfg.ValidateLinks(); (err == nil) != tc.ok {
t.Errorf("%v: %v", tc.cfg.Links, err)
}
}
}
+548 -126
View File
@@ -17,6 +17,7 @@ import (
tea "charm.land/bubbletea/v2"
"github.com/spf13/cobra"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity"
"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/hook"
@@ -30,18 +31,34 @@ import (
// managedSubcommands are dispatched to cobra; everything else is treated as SSH wrapper mode.
var managedSubcommands = map[string]bool{
"configure": true,
"notes": true,
"search": true,
"cache": true,
"alias": true,
"hook": true,
"shell-init": true,
"completion": true,
"__complete": true,
"help": true,
"version": true,
"uninstall": true,
"doctor": true, "explain": true, "favorites": true, "history": true, "batch": true, "config": true,
"configure": true,
"notes": true,
"search": true,
"cache": true,
"alias": true,
"hook": true,
"shell-init": true,
"completion": true,
"__complete": true,
"help": true,
"version": true,
"uninstall": true,
"sftp": true,
"scp": true,
"tunnel": true,
"hosts": true,
"multi": true,
"sync": true,
"run": true,
"open": true,
"info": true,
"whois": true,
"copy-id": true,
"export": true,
"token": true,
"known-hosts": true,
"link": true,
}
func main() {
@@ -56,8 +73,22 @@ func main() {
return
}
// ssh has neither option, so both can only mean netssh's own help.
if args[0] == "--help" || args[0] == "-h" {
root := rootCmd()
root.SetArgs([]string{"help"})
if err := root.Execute(); err != nil {
os.Exit(1)
}
return
}
if managedSubcommands[args[0]] {
if err := rootCmd().Execute(); err != nil {
var exit *commandExit
if errors.As(err, &exit) {
os.Exit(exit.code)
}
os.Exit(1)
}
return
@@ -72,7 +103,7 @@ func loadConfigOrSetup() *config.Config {
if err != nil {
fatalf("config: %v", err)
}
if !cfg.HasNetBox() {
if !cfg.HasHosts() {
fmt.Fprintln(os.Stderr, "No configuration found. Starting setup…")
if err := setup.RunWizard(cfg); err != nil {
fatalf("setup: %v", err)
@@ -91,60 +122,224 @@ func runSSHWrapper(args []string) {
if err != nil {
fatalf("%v", err)
}
cfg := loadConfigOrSetup()
runClient(internalssh.SSH, flags, args)
}
parsed := internalssh.Parse(args)
// destination is the NetBox host named in the arguments of a client.
type destination struct {
host string
user string
dests []int // argument indices naming the host; several only for scp
}
func findDestination(client internalssh.Client, args []string) (*destination, error) {
if client.Name == internalssh.SCP.Name {
operands, err := client.Operands(args)
if err != nil || len(operands) == 0 {
return nil, err
}
dest := &destination{host: operands[0].Host}
for _, operand := range operands {
dest.dests = append(dest.dests, operand.Idx)
if operand.User != "" {
dest.user = operand.User
}
}
return dest, nil
}
parsed := client.Parse(args)
if parsed == nil {
// No destination found — pass arguments straight through to ssh.
execSSH(internalssh.Result{Args: args}, flags)
return nil, nil
}
return &destination{host: parsed.Host, user: parsed.User, dests: []int{parsed.DestIdx}}, nil
}
// runClient resolves the NetBox host in args and execs ssh, sftp, or scp.
func runClient(client internalssh.Client, flags internalssh.WrapperFlags, args []string) {
cfg := loadConfigOrSetup()
client = client.WithInstances(instanceNames(cfg))
dest, err := findDestination(client, args)
if err != nil {
fatalf("%v", err)
}
if dest == nil {
if len(flags.Forwards) > 0 {
fatalf("--forward needs a destination host")
}
// No destination found — pass arguments straight through.
execClient(client, internalssh.Result{Args: args}, flags)
return
}
connect := func(name, kind, ip string, tags []string) {
connectHost(cfg, flags, name, kind, ip, tags, parsed.DestIdx, args)
host := resolveTarget(cfg, dest.host)
user, port := hostDefaults(cfg, host)
// Inject the default user if none was given on the command line.
if user != "" && dest.user == "" && !client.HasUserFlag(args) {
args = prependArgs(client.UserArgs(user), args, dest.dests)
}
// Inject the default port if none was given on the command line.
if port > 0 && !client.HasPortFlag(args) {
args = prependArgs(client.PortArgs(strconv.Itoa(port)), args, dest.dests)
}
// Inject the configured default user if none was given on the command line.
if cfg.SSH.DefaultUser != "" && parsed.User == "" && !internalssh.HasUserFlag(args) {
args = append([]string{"-l", cfg.SSH.DefaultUser}, args...)
parsed.DestIdx += 2
}
// Inject the configured default port if none was given on the command line.
if cfg.SSH.DefaultPort > 0 && !internalssh.HasPortFlag(args) {
args = append([]string{"-p", strconv.Itoa(cfg.SSH.DefaultPort)}, args...)
parsed.DestIdx += 2
}
connectHost(cfg, client, flags, host, dest.dests, args)
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
// hostDefaults returns the login user and port for host: those of a static
// host if set, else ssh.default_user and ssh.default_port.
func hostDefaults(cfg *config.Config, host resolvedHost) (string, int) {
user, port := cfg.SSH.DefaultUser, cfg.SSH.DefaultPort
if host.Kind == config.StaticKind {
if static := cfg.StaticHost(host.Name); static != nil {
if static.User != "" {
user = static.User
}
if static.Port > 0 {
port = static.Port
}
}
}
return user, port
}
// instanceNames lists the named NetBox instances, which may prefix hostnames.
func instanceNames(cfg *config.Config) []string {
names := make([]string, 0, len(cfg.NetBoxes))
for _, source := range cfg.NetBoxes {
names = append(names, source.Name)
}
return names
}
// prependArgs puts extra before args and shifts the destination indices.
func prependArgs(extra, args []string, dests []int) []string {
for i := range dests {
dests[i] += len(extra)
}
return append(append([]string(nil), extra...), args...)
}
// resolvedHost is a NetBox host with the address to connect to.
type resolvedHost struct {
Origin string
Resolver string
CachedAt time.Time
Name string // cache/selector name, may carry an instance prefix
Kind string
IP string
Tags []string
ID int // NetBox ID; 0 for static hosts and old cache entries
Status string
Site config.Ref
Role config.Ref
Platform config.Ref
Tenant config.Ref
Location []config.Ref
Rack string
Position string
// PreviousIP is the cached address a live lookup replaced, if it differs.
PreviousIP string
}
// hostFromEntry converts a cache entry into a resolved host.
func hostFromEntry(entry cache.Entry, origin string) resolvedHost {
return resolvedHost{
Name: entry.Name, Kind: entry.Kind, IP: entry.IP, Tags: entry.Tags, Origin: origin, Resolver: entry.Resolver, CachedAt: entry.CachedAt,
ID: entry.ID, Status: entry.Status, Site: cache.RefOf(entry.Site), Role: cache.RefOf(entry.Role), Platform: cache.RefOf(entry.Platform), Tenant: cache.RefOf(entry.Tenant),
Location: entry.Location, Rack: entry.Rack, Position: entry.Position,
}
}
// LocationPath renders site › locations › rack › U position.
func (h resolvedHost) LocationPath() string {
return config.LocationPath(h.Site, h.Location, h.Rack, h.Position)
}
// cacheEntry records a NetBox host and its resolved address in the cache.
func cacheEntry(target netbox.HostEntry, ip, strategy string) cache.Entry {
return cache.Entry{
Name: target.Target(), IP: ip, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster, Resolver: strategy,
ID: target.ID, Status: target.Status, Site: cache.RefPtr(target.Site), Role: cache.RefPtr(target.Role), Platform: cache.RefPtr(target.Platform), Tenant: cache.RefPtr(target.Tenant),
Location: target.Location, Rack: target.Rack, Position: target.Position,
}
}
// upsertResolved caches a live result and reports the address it replaced.
func upsertResolved(c *cache.Cache, entry cache.Entry) (previous string) {
if old, _ := c.Get(entry.Name); old.Name != "" && !old.Static && old.IP != "" && old.IP != entry.IP {
previous = old.IP
}
c.Upsert(entry)
return previous
}
// 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 := 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()
maybeBackgroundRefresh(cfg, c)
if record {
maybeBackgroundRefresh(cfg, c)
}
source, _ := netbox.SplitTarget(parsed.Host)
source, _ := netbox.SplitTarget(host)
useCache := len(cfg.NetBoxes) == 0 || source != ""
used := func(entry cache.Entry) resolvedHost {
if record {
c.MarkUsed(entry.Name)
_ = c.Save()
}
origin := "cache"
if entry.Static {
origin = "static"
}
return hostFromEntry(entry, origin)
}
// Static hosts from the config win and need no NetBox.
if source == "" {
var normalize func(string) string
if cfg.Shortcuts.Enabled() {
normalize = normalizeTarget(cfg.Shortcuts, false)
}
entry, found, err := c.GetStatic(host, normalize)
if err != nil {
return resolvedHost{}, err
}
if found {
return used(entry), nil
}
}
// Cache hit with a fresh TTL — connect directly without querying NetBox.
if entry, fresh := c.Get(parsed.Host); fresh && useCache {
c.MarkUsed(parsed.Host)
_ = c.Save()
connect(entry.Name, entry.Kind, entry.IP, entry.Tags)
return
if entry, fresh := c.Get(host); fresh && useCache {
return used(entry), nil
}
// Shortcut cache lookup: scan entries whose normalized name matches the input.
// If a stale match is found, use the canonical name for the NetBox re-fetch below.
lookupHost := parsed.Host
shortcutsEnabled := len(cfg.Shortcuts.Domains) > 0 || cfg.Shortcuts.StripHyphens
lookupHost := host
shortcutsEnabled := cfg.Shortcuts.Enabled()
if cached, _ := c.Get(lookupHost); shortcutsEnabled && cached.Name == "" && useCache {
normalize := normalizeTarget(cfg.Shortcuts, source != "")
entry, found, fresh, err := c.GetByShortcut(lookupHost, normalize)
if err != nil {
fatalf("%v", err)
return resolvedHost{}, err
}
if found {
if fresh {
c.MarkUsed(entry.Name)
_ = c.Save()
connect(entry.Name, entry.Kind, entry.IP, entry.Tags)
return
return used(entry), nil
}
// Stale shortcut match — use canonical name for NetBox re-fetch.
lookupHost = entry.Name
@@ -152,7 +347,7 @@ func runSSHWrapper(args []string) {
}
if !cfg.HasNetBox() {
fatalf("netbox.url is not configured (~/.config/netssh.yaml)")
return resolvedHost{}, fmt.Errorf("host %q is not in hosts: and no NetBox is configured (netssh configure): %w", host, netbox.ErrHostNotFound)
}
nbClient := newNetBoxClient(cfg)
@@ -161,40 +356,38 @@ func runSSHWrapper(args []string) {
target, err := findSSHHost(ctx, nbClient, lookupHost, cfg.Shortcuts.Domains)
if errors.Is(err, netbox.ErrHostNotFound) && !useCache && shortcutsEnabled {
entry, found, _, cacheErr := c.GetByShortcut(parsed.Host, normalizeTarget(cfg.Shortcuts, false))
entry, found, _, cacheErr := c.GetByShortcut(host, normalizeTarget(cfg.Shortcuts, false))
if cacheErr != nil {
fatalf("%v", cacheErr)
return resolvedHost{}, cacheErr
}
if found {
target, err = findSSHHost(ctx, nbClient, entry.Name, cfg.Shortcuts.Domains)
}
}
if err != nil {
fatalf("NetBox: %v", err)
return resolvedHost{}, fmt.Errorf("NetBox: %w", err)
}
if cached, fresh := c.Get(target.Target()); fresh && cached.Kind == target.Kind {
c.MarkUsed(target.Target())
_ = c.Save()
connect(cached.Name, cached.Kind, cached.IP, cached.Tags)
return
return used(cached), nil
}
chain, err := resolver.New(cfg.Resolver)
if err != nil {
fatalf("resolver: %v", err)
return resolvedHost{}, err
}
ip, err := chain.Resolve(ctx, &target, nbClient)
ip, strategy, err := chain.ResolveWithStrategy(ctx, &target, nbClient)
if err != nil {
fatalf("IP resolution for %q: %v", parsed.Host, err)
return resolvedHost{}, fmt.Errorf("IP resolution for %q: %w", host, err)
}
c.Upsert(cache.Entry{Name: target.Target(), IP: ip, Kind: target.Kind, Tags: target.Tags})
c.MarkUsed(target.Target())
_ = c.Save()
connect(target.Target(), target.Kind, ip, target.Tags)
entry := cacheEntry(target, ip, strategy)
previous := upsertResolved(c, entry)
result := used(entry)
result.Origin = "live"
result.PreviousIP = previous
return result, nil
}
// findSSHHost uses the paginated, ambiguity-checking lookup for connection
@@ -217,24 +410,79 @@ func findSSHHost(ctx context.Context, client *netbox.Client, name string, domain
return netbox.HostEntry{}, fmt.Errorf("%w: %q", netbox.ErrHostNotFound, name)
}
// connectHost applies the SSH options configured for the host and execs ssh.
// target is the cache/selector name, which may carry an instance prefix.
func connectHost(cfg *config.Config, flags internalssh.WrapperFlags, target, kind, ip string, tags []string, destIdx int, args []string) {
instance, name := netbox.SplitTarget(target)
opts := cfg.SSHOptionsFor(config.SSHHost{Instance: instance, Name: name, Kind: kind, Tags: tags})
execSSH(internalssh.Apply(args, destIdx, internalssh.Host{Name: name, IP: ip}, opts, flags), flags)
// connectHost applies the SSH options configured for the host and execs the client.
func connectHost(cfg *config.Config, client internalssh.Client, flags internalssh.WrapperFlags, host resolvedHost, dests []int, args []string) {
if !internalssh.ValidAddress(host.IP) {
fatalf("refusing address %q for %s: not an IP address or hostname (check NetBox, or run netssh cache clear)", host.IP, host.Name)
}
opts := hostOptions(cfg, host)
if len(flags.Forwards) > 0 {
forwardArgs, err := internalssh.ForwardArgs(flags.Forwards, opts.Forwards)
if err != nil {
fatalf("%v", err)
}
flags.ForwardArgs = forwardArgs
}
if flags.Tunnel && len(flags.ForwardArgs) == 0 && !client.HasForwardFlag(args) {
available := "none configured (ssh.forwards)"
if names := forwardNames(opts); len(names) > 0 {
available = strings.Join(names, ", ")
}
fatalf("name a forward or a spec such as 8080:localhost:80; forwards for %s: %s", host.Name, available)
}
if flags.DryRun {
if cfg.SSH.WarnsStatus(host.Status) {
fmt.Fprintf(os.Stderr, "# warning: %s has NetBox status %q\n", host.Name, host.Status)
}
} else {
if err := confirmStatus(cfg, host, flags.Force); err != nil {
fatalf("%v", err)
}
port := connectPort(client, args, dests)
host = applyFallback(cfg, host, opts, flags, port)
if host.PreviousIP != "" {
offerKnownHostsCleanup(opts, host, port)
}
}
if err := runPreConnect(opts.PreConnectCommand(), host, client.Name, flags.DryRun); err != nil {
fatalf("%v", err)
}
_, name := netbox.SplitTarget(host.Name)
result := client.Apply(args, dests, internalssh.Host{Name: name, IP: host.IP}, opts, flags)
post := config.HookCommand(opts.PostDisconnect)
if flags.DryRun {
if post != "" {
fmt.Fprintf(os.Stderr, "# post_disconnect (skipped in --dry-run): %s\n", post)
}
}
if !flags.DryRun && (post != "" || cfg.Activity.Enabled) {
if result.Notice != "" {
fmt.Fprintln(os.Stderr, result.Notice)
}
code := supervise(cfg, host, client.Name, append([]string{client.Name}, result.Args...), post, 0, false, os.Stdin, os.Stdout, os.Stderr)
if code != 0 {
os.Exit(code)
}
return
}
execClient(client, result, flags)
}
// execSSH replaces the process with ssh, or prints the command for --dry-run.
func execSSH(result internalssh.Result, flags internalssh.WrapperFlags) {
// hostOptions merges the global, instance, and rule SSH options for host.
func hostOptions(cfg *config.Config, host resolvedHost) config.SSHOptions {
return cfg.SSHOptionsFor(commandHost(host))
}
// execClient replaces the process with the client, or prints the command for --dry-run.
func execClient(client internalssh.Client, result internalssh.Result, flags internalssh.WrapperFlags) {
if flags.DryRun {
fmt.Println(internalssh.Quote(append([]string{"ssh"}, result.Args...)))
fmt.Println(internalssh.Quote(append([]string{client.Name}, result.Args...)))
return
}
if result.Notice != "" {
fmt.Fprintf(os.Stderr, "netssh: %s\n", result.Notice)
}
if err := internalssh.Exec(result.Args); err != nil {
if err := client.Exec(result.Args); err != nil {
fatalf("%v", err)
}
}
@@ -243,7 +491,7 @@ func execSSH(result internalssh.Result, flags internalssh.WrapperFlags) {
func runTUI() {
cfg := loadConfigOrSetup()
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
_ = c.Load()
maybeBackgroundRefresh(cfg, c)
@@ -253,7 +501,65 @@ func runTUI() {
}
m := tui.New(nbClient, c, cfg.SSH.DefaultUser, cfg.SSH.DefaultPort)
m.SetHostLabel(cfg.HostLabel)
m.SetHistoryLimit(cfg.TUI.HistoryLimit)
state, stateErr := activity.Read()
if stateErr != nil {
fmt.Fprintf(os.Stderr, "favorites: %v\n", stateErr)
}
m.SetPreferences(state.Favorites, state.Pinned, func(favorites, pinned map[string]bool) error {
err := activity.Update(func(s *activity.State) {
merge := func(dst, previous, next map[string]bool) {
for name, value := range next {
if previous[name] != value {
if value {
dst[name] = true
} else {
delete(dst, name)
}
}
}
for name, value := range previous {
if value && !next[name] {
delete(dst, name)
}
}
}
merge(s.Favorites, state.Favorites, favorites)
merge(s.Pinned, state.Pinned, pinned)
})
if err == nil {
state.Favorites = favorites
state.Pinned = pinned
}
return err
})
known := func(name, kind string, tags []string) resolvedHost {
if e, _ := c.Get(name); e.Name != "" && e.Kind == kind {
return hostFromEntry(e, "cache")
}
return resolvedHost{Name: name, Kind: kind, Tags: tags}
}
m.SetCommands(func(name, kind string, tags []string) []string {
var names []string
h := commandHost(known(name, kind, tags))
for name, c := range cfg.Commands {
if c.Allowed(h) {
names = append(names, name)
}
}
sort.Strings(names)
return names
})
if cfg.Shortcuts.Show {
aliases := shortcutAliases(c.All(), *cfg)
m.SetAliases(func(target string) string { return aliases[strings.ToLower(target)] })
}
m.SetNotes(notes.New(cfg.NetBox.URL, nbClient))
m.SetForwards(func(name, kind string, tags []string) []string {
return forwardNames(hostOptions(cfg, known(name, kind, tags)))
})
configureTUIExtras(m, cfg, nbClient, known)
p := tea.NewProgram(m)
final, err := p.Run()
if err != nil {
@@ -268,12 +574,33 @@ func runTUI() {
if host == nil {
return
}
if host.Command != "" {
args := []string{"run", host.Command, "--", host.Name}
if len(host.Targets) > 0 {
args = append([]string{"batch", host.Command}, host.Targets...)
}
root := rootCmd()
root.SetArgs(args)
if err := root.Execute(); err != nil {
var exit *commandExit
if errors.As(err, &exit) {
os.Exit(exit.code)
}
fatalf("%v", err)
}
return
}
if host.Action == tui.ActionMulti {
if err := runMulti(cfg, host.Targets, multiFlags{}); err != nil {
fatalf("%v", err)
}
return
}
// Revalidate stale or live TUI results through the configured resolver chain.
var tags []string
var resolved resolvedHost
if cached, fresh := c.Get(host.Name); fresh && cached.Kind == host.Kind {
host.IP = cached.IP
tags = cached.Tags
resolved = hostFromEntry(cached, "cache")
} else {
if nbClient == nil {
fatalf("cannot resolve %q: NetBox is not configured", host.Name)
@@ -288,40 +615,68 @@ func runTUI() {
if err != nil {
fatalf("resolver: %v", err)
}
host.IP, err = chain.Resolve(ctx, &target, nbClient)
var strategy string
host.IP, strategy, err = chain.ResolveWithStrategy(ctx, &target, nbClient)
if err != nil {
fatalf("IP resolution: %v", err)
}
c.Upsert(cache.Entry{Name: target.Target(), IP: host.IP, Kind: target.Kind, Tags: target.Tags})
tags = target.Tags
entry := cacheEntry(target, host.IP, strategy)
previous := upsertResolved(c, entry)
resolved = hostFromEntry(entry, "live")
resolved.PreviousIP = previous
}
host.IP = resolved.IP
fmt.Fprintf(os.Stderr, "Connecting to %s (%s)…\n", host.Name, host.IP)
var sshArgs []string
// User override from TUI edit mode takes priority, then config default.
user := host.User
if user == "" {
user = cfg.SSH.DefaultUser
}
if user != "" {
sshArgs = append(sshArgs, "-l", user)
}
port := host.Port
if port == "" && cfg.SSH.DefaultPort > 0 {
port = strconv.Itoa(cfg.SSH.DefaultPort)
}
if port != "" {
sshArgs = append(sshArgs, "-p", port)
}
sshArgs = append(sshArgs, host.IP)
c.MarkUsed(host.Name)
_ = c.Save()
connectHost(cfg, internalssh.WrapperFlags{}, host.Name, host.Kind, host.IP, tags, len(sshArgs)-1, sshArgs)
client, flags, args := tuiCommand(cfg, host)
connectHost(cfg, client, flags, resolved, []int{len(args) - 1}, args)
}
// tuiCommand builds the client and arguments for the action chosen in the TUI.
func tuiCommand(cfg *config.Config, host *tui.SelectedHost) (internalssh.Client, internalssh.WrapperFlags, []string) {
client := internalssh.SSH
var flags internalssh.WrapperFlags
switch host.Action {
case tui.ActionSFTP:
client = internalssh.SFTP
case tui.ActionTunnel:
flags = internalssh.WrapperFlags{Forwards: host.Forwards, Tunnel: true}
}
var args []string
// User override from TUI edit mode takes priority, then static host and config defaults.
defaultUser, defaultPort := hostDefaults(cfg, resolvedHost{Name: host.Name, Kind: host.Kind})
user := host.User
if user == "" {
user = defaultUser
}
if user != "" {
args = append(args, client.UserArgs(user)...)
}
port := host.Port
if port == "" && defaultPort > 0 {
port = strconv.Itoa(defaultPort)
}
if port != "" {
args = append(args, client.PortArgs(port)...)
}
// Apply replaces the destination; a bare name cannot be mistaken for
// host:path by sftp, unlike an IPv6 address.
_, name := netbox.SplitTarget(host.Name)
return client, flags, append(args, name)
}
// forwardNames lists the forwards configured for a host, sorted.
func forwardNames(opts config.SSHOptions) []string {
names := make([]string, 0, len(opts.Forwards))
for name := range opts.Forwards {
names = append(names, name)
}
sort.Strings(names)
return names
}
// --- cobra root + subcommands ---
@@ -332,17 +687,14 @@ func rootCmd() *cobra.Command {
Short: "SSH wrapper with NetBox hostname resolution",
DisableFlagParsing: true,
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
_ = c.Load()
hosts := hostCompletions(c.All(), toComplete)
if limit := cfg.Completion.MaxResults; limit > 0 && len(hosts) > limit {
hosts = hosts[:limit]
if len(args) > 0 && args[len(args)-1] == "--forward" {
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
return filterPrefix(allForwardNames(cfg), toComplete, nil), cobra.ShellCompDirectiveNoFileComp
}
hosts := completeHosts(toComplete)
completions := make([]cobra.Completion, 0, len(hosts))
for _, host := range hosts {
completions = append(completions, cobra.Completion(host))
@@ -357,7 +709,8 @@ func rootCmd() *cobra.Command {
},
}
root.AddCommand(notesCmd(), configureCmd(), searchCmd(), cacheCmd(), aliasCmd(), hookCmd(), shellInitCmd(), versionCmd(), uninstallCmd())
root.AddCommand(doctorCmd(), explainCmd(), favoritesCmd(), historyCmd(), batchCmd(), configCmd(), runCmd(), notesCmd(), configureCmd(), searchCmd(), cacheCmd(), aliasCmd(), hookCmd(), shellInitCmd(), versionCmd(), uninstallCmd(), sftpCmd(), scpCmd(), tunnelCmd(), hostsCmd(), multiCmd(), syncCmd(),
openCmd(), infoCmd(), whoisCmd(), copyIDCmd(), exportCmd(), tokenCmd(), knownHostsCmd(), linkCmd())
// cobra builds the "completion" command lazily; force init so we can extend it.
root.InitDefaultCompletionCmd()
@@ -479,7 +832,7 @@ func searchCmd() *cobra.Command {
if err != nil {
return err
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
if err := c.Load(); err != nil {
return err
}
@@ -505,7 +858,8 @@ func cacheCmd() *cobra.Command {
}
func cacheListCmd() *cobra.Command {
return &cobra.Command{
var showAliases bool
cmd := &cobra.Command{
Use: "list",
Short: "Show all cached entries",
RunE: func(cmd *cobra.Command, args []string) error {
@@ -513,7 +867,7 @@ func cacheListCmd() *cobra.Command {
if err != nil {
return err
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
if err := c.Load(); err != nil {
return err
}
@@ -521,13 +875,31 @@ func cacheListCmd() *cobra.Command {
sort.Slice(entries, func(i, j int) bool { return entries[i].Name < entries[j].Name })
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintln(w, "NAME\tIP\tKIND\tCACHED AT")
if !showAliases && !cfg.Shortcuts.Show {
fmt.Fprintln(w, "NAME\tIP\tKIND\tCACHED AT")
for _, e := range entries {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", e.Name, e.IP, e.Kind, e.CachedAt.Format(time.RFC3339))
}
return w.Flush()
}
aliases := shortcutAliases(entries, *cfg)
fmt.Fprintln(w, "NAME\tALIAS\tIP\tKIND\tCACHED AT")
for _, e := range entries {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", e.Name, e.IP, e.Kind, e.CachedAt.Format(time.RFC3339))
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", e.Name, orDash(aliases[strings.ToLower(e.Name)]), e.IP, e.Kind, e.CachedAt.Format(time.RFC3339))
}
return w.Flush()
},
}
cmd.Flags().BoolVar(&showAliases, "aliases", false, "Show each host's shortcut alias (always on with shortcuts.show)")
return cmd
}
// orDash keeps empty table cells visible.
func orDash(s string) string {
if s == "" {
return "-"
}
return s
}
func cacheClearCmd() *cobra.Command {
@@ -539,7 +911,7 @@ func cacheClearCmd() *cobra.Command {
if err != nil {
return err
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
c.Clear()
if err := c.Save(); err != nil {
return err
@@ -581,7 +953,7 @@ func cacheRefreshCmd() *cobra.Command {
return fmt.Errorf("NetBox: %w", err)
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
_ = c.Load()
chain, err := resolver.New(cfg.Resolver)
@@ -589,6 +961,7 @@ func cacheRefreshCmd() *cobra.Command {
return fmt.Errorf("resolver: %w", err)
}
written := 0
var changed []string
nameCounts := make(map[string]int)
for _, e := range entries {
nameCounts[strings.ToLower(e.Target())]++
@@ -601,7 +974,7 @@ func cacheRefreshCmd() *cobra.Command {
continue
}
ip, err := chain.Resolve(ctx, e, nbClient)
ip, strategy, err := chain.ResolveWithStrategy(ctx, e, nbClient)
if err != nil {
// Do not turn a failed configured strategy into a fresh
// primary-IP cache hit that bypasses the resolver.
@@ -612,7 +985,9 @@ func cacheRefreshCmd() *cobra.Command {
fmt.Fprintf(os.Stderr, "warning: skipping %s: %v\n", e.Name, err)
continue
}
c.Upsert(cache.Entry{Name: e.Target(), IP: ip, Kind: e.Kind, Tags: e.Tags})
if previous := upsertResolved(c, cacheEntry(*e, ip, strategy)); previous != "" {
changed = append(changed, fmt.Sprintf("%s: %s → %s", e.Target(), previous, ip))
}
written++
}
@@ -630,6 +1005,14 @@ func cacheRefreshCmd() *cobra.Command {
}
}
fmt.Printf("%d entries written to cache.\n", written)
if len(changed) > 0 {
sort.Strings(changed)
fmt.Printf("%d hosts changed their address:\n", len(changed))
for _, line := range changed {
fmt.Printf(" %s\n", line)
}
fmt.Println("Remove outdated host keys with: netssh known-hosts reset HOST")
}
return nil
},
}
@@ -645,13 +1028,15 @@ func buildAliasEntries(c *cache.Cache, cfg config.Config) []hook.AliasEntry {
}
func aliasCmd() *cobra.Command {
var shell string
var shell, test string
cmd := &cobra.Command{
Use: "alias",
Short: "Print shell aliases for all cached hosts",
Long: `Print shell alias definitions for all cached hosts.
The alias name is the shortened form derived from the configured shortcuts
(domain suffixes stripped, hyphens optionally stripped).
(domain suffixes stripped, rewrite rules applied, hyphens optionally stripped).
Check a rule with: netssh alias --test fsn1-bx1.example.com
Source the output in your shell profile:
bash/zsh: eval "$(netssh alias)"
@@ -664,10 +1049,14 @@ Or use in a script:
if err != nil {
return err
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
if err := c.Load(); err != nil {
return err
}
if test != "" {
printShortcutTest(os.Stdout, test, c.All(), cfg.Shortcuts)
return nil
}
if shell == "" {
shell = filepath.Base(os.Getenv("SHELL"))
}
@@ -694,9 +1083,36 @@ Or use in a script:
},
}
cmd.Flags().StringVar(&shell, "shell", "", "Output format: bash, zsh, fish (default: $SHELL)")
cmd.Flags().StringVar(&test, "test", "", "Show the shortcut for a hostname and the cached hosts it matches")
return cmd
}
// printShortcutTest helps writing shortcut rules: it shows what a name is
// shortened to and which cached hosts share that shortcut.
func printShortcutTest(w io.Writer, name string, entries []cache.Entry, sc config.ShortcutsConfig) {
normalize := normalizeTarget(sc, strings.Contains(name, "/"))
short := normalize(name)
fmt.Fprintf(w, "%s → %s\n", name, short)
var matches []string
for _, e := range entries {
if normalize(e.Name) == short {
matches = append(matches, e.Name)
}
}
sort.Strings(matches)
switch len(matches) {
case 0:
fmt.Fprintln(w, "no cached host has this shortcut")
case 1:
fmt.Fprintf(w, "matches %s\n", matches[0])
default:
fmt.Fprintf(w, "ambiguous, matches %d hosts:\n", len(matches))
for _, m := range matches {
fmt.Fprintf(w, " %s\n", m)
}
}
}
// shellInitCmd is called at shell startup to update alias files and trigger a
// background cache refresh when stale. Intentionally silent — never disrupts the prompt.
func shellInitCmd() *cobra.Command {
@@ -709,7 +1125,7 @@ func shellInitCmd() *cobra.Command {
if err != nil {
return nil
}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
_ = c.Load()
// Regenerate alias files from the current cache every shell start
@@ -768,7 +1184,7 @@ After installation, reload your profile or open a new shell.`,
// Generate the aliases file immediately so it is ready on the next shell start.
cfg, cfgErr := config.Load()
if cfgErr == nil && cfg.HasNetBox() {
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
if _ = c.Load(); true {
if entries := buildAliasEntries(c, *cfg); len(entries) > 0 {
if err := hook.WriteAliasFiles(entries); err != nil {
@@ -817,13 +1233,19 @@ func hookUninstallCmd() *cobra.Command {
return cmd
}
// refreshRetryInterval is the pause between background refresh attempts.
const refreshRetryInterval = 5 * time.Minute
// maybeBackgroundRefresh starts a background `netssh cache refresh` if the cache
// has not been fully refreshed within the last 24 hours.
func maybeBackgroundRefresh(cfg *config.Config, c *cache.Cache) {
if !cfg.HasNetBox() {
// netssh multi checks once and starts its panes with NETSSH_NO_REFRESH.
if !cfg.HasNetBox() || os.Getenv("NETSSH_NO_REFRESH") != "" {
return
}
if !c.NeedsRefresh(24 * time.Hour) {
// While NetBox is unreachable the cache stays stale; without the retry
// interval every command and every new shell would start another refresh.
if !c.ClaimRefresh(24*time.Hour, refreshRetryInterval) {
return
}
self, err := os.Executable()
+414
View File
@@ -0,0 +1,414 @@
package main
import (
"context"
"errors"
"fmt"
"os"
"os/exec"
"path/filepath"
"regexp"
"sort"
"strings"
"time"
"github.com/spf13/cobra"
"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/multiplex"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
)
// maxHostsWithoutConfirm guards against opening hundreds of panes by accident.
const maxHostsWithoutConfirm = 24
// multiFlags are the options shared by netssh multi and the TUI.
type multiFlags struct {
kind, user, jump, multiplexer string
noJump, sync, dryRun, yes bool
}
func multiCmd() *cobra.Command {
var f multiFlags
var useTmux, useZellij bool
cmd := &cobra.Command{
Use: "multi [flags] HOST|tag:TAG|cluster:NAME|@GROUP...",
Short: "Open several hosts side by side in tmux or zellij",
Long: `Open one pane per host in a tmux window or zellij tab. Hosts are given as
names (shortcuts, instance/host, static hosts) or selectors:
tag:TAG all hosts with this NetBox tag, and static hosts with this tag
cluster:NAME devices of a NetBox virtualization cluster (--kind vm|all for VMs)
@GROUP a group from the config (groups:)
Broadcast typing to all panes of a window with --sync, or toggle it later with
netssh sync. Inside tmux or zellij the panes open in the current session.`,
Example: ` netssh multi web01 web02 db01
netssh multi cluster:pve-fsn1
netssh multi --kind vm cluster:pve-fsn1
netssh multi --sync tag:k8s-worker
netssh multi @k8s`,
Args: cobra.MinimumNArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
if useTmux && useZellij {
return errors.New("--tmux and --zellij are mutually exclusive")
}
if useTmux {
f.multiplexer = multiplex.Tmux
} else if useZellij {
f.multiplexer = multiplex.Zellij
}
return runMulti(loadConfigOrSetup(), args, f)
},
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
return multiCompletions(cfg, toComplete)
},
}
cmd.Flags().StringVar(&f.kind, "kind", "", "Host kind for tag: and cluster: — device, vm, or all (default: all for tags, device for clusters)")
cmd.Flags().BoolVar(&f.sync, "sync", false, "Start with typing broadcast to all panes")
cmd.Flags().BoolVar(&useTmux, "tmux", false, "Use tmux")
cmd.Flags().BoolVar(&useZellij, "zellij", false, "Use zellij")
cmd.Flags().StringVarP(&f.user, "user", "l", "", "Login user for every host")
cmd.Flags().StringVar(&f.jump, "jump", "", "Jump host for every host")
cmd.Flags().BoolVar(&f.noJump, "no-jump", false, "Disable jump hosts")
cmd.Flags().BoolVar(&f.dryRun, "dry-run", false, "Print the hosts and multiplexer commands")
cmd.Flags().BoolVarP(&f.yes, "yes", "y", false, fmt.Sprintf("Open more than %d hosts without asking", maxHostsWithoutConfirm))
_ = cmd.RegisterFlagCompletionFunc("kind", cobra.FixedCompletions([]cobra.Completion{"device", "vm", "all"}, cobra.ShellCompDirectiveNoFileComp))
return cmd
}
func syncCmd() *cobra.Command {
var pane bool
cmd := &cobra.Command{
Use: "sync [--pane]",
Short: "Toggle typing into all panes of the current tmux window or zellij tab",
Long: `Toggle broadcast in the current tmux window or zellij tab. With --pane,
exclude the current tmux pane from broadcast, or include it again.
In windows opened by netssh multi, tmux also has keys for this:
prefix S (all panes) and prefix e (this pane); see multi.sync_key and
multi.solo_key. In zellij, use Ctrl+t then s.`,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
state, err := multiplex.ToggleSync(multiplex.System{}, pane)
if err != nil {
return err
}
fmt.Fprintln(os.Stderr, "netssh: "+state)
return nil
},
}
cmd.Flags().BoolVar(&pane, "pane", false, "Exclude the current tmux pane from broadcast, or include it again")
return cmd
}
// runMulti expands selectors and opens one pane per host.
func runMulti(cfg *config.Config, selectors []string, f multiFlags) error {
if f.jump != "" && f.noJump {
return errors.New("--jump and --no-jump are mutually exclusive")
}
switch f.kind {
case "", "device", "vm", "all":
default:
return fmt.Errorf("--kind must be device, vm, or all")
}
c := newCache(cfg)
_ = c.Load()
targets, warnings, err := expandSelectors(cfg, c, selectors, f.kind)
for _, warning := range warnings {
fmt.Fprintln(os.Stderr, "netssh: warning: "+warning)
}
if err != nil {
return err
}
if len(targets) > maxHostsWithoutConfirm && !f.yes && !f.dryRun {
return fmt.Errorf("%d hosts selected; pass --yes to open them all", len(targets))
}
var runner multiplex.Runner = multiplex.System{}
if f.dryRun {
fmt.Printf("# %d hosts: %s\n", len(targets), strings.Join(targets, " "))
runner = &multiplex.DryRun{W: os.Stdout}
}
requested := f.multiplexer
if requested == "" {
requested = cfg.Multi.Multiplexer
}
kind, err := multiplex.Detect(requested, runner)
if err != nil {
return err
}
if !f.dryRun {
// Checked once here; the panes skip it (NETSSH_NO_REFRESH).
maybeBackgroundRefresh(cfg, c)
}
panes := make([]multiplex.Pane, 0, len(targets))
for _, target := range targets {
panes = append(panes, multiplex.Pane{Title: target, Argv: paneArgv(target, f)})
}
layoutDir := filepath.Dir(cfg.Cache.Path)
if err := os.MkdirAll(layoutDir, 0o700); err != nil {
return err
}
syncKey, soloKey := cfg.Multi.Keys()
return multiplex.Open(kind, panes, multiplex.Options{
SyncKey: syncKey,
SoloKey: soloKey,
Label: multiLabel(selectors),
Sync: f.sync,
PerWindow: cfg.Multi.PanesPerWindowOrDefault(),
LayoutDir: layoutDir,
Hint: func(s string) { fmt.Fprintln(os.Stderr, "netssh: "+s) },
}, runner)
}
// paneArgv runs netssh for one host. Panes of an existing tmux or zellij
// session inherit that server's environment, so the paths that select the
// config and cache are passed explicitly; NETSSH_* values are not, because
// arguments are visible to other users (tokens).
func paneArgv(target string, f multiFlags) []string {
self, err := os.Executable()
if err != nil {
self = "netssh"
}
env, err := exec.LookPath("env")
if err != nil {
env = "/usr/bin/env"
}
argv := []string{env, "NETSSH_NO_REFRESH=1"}
for _, key := range []string{"HOME", "XDG_CONFIG_HOME", "XDG_CACHE_HOME"} {
if value, ok := os.LookupEnv(key); ok {
argv = append(argv, key+"="+value)
}
}
argv = append(argv, self)
switch {
case f.jump != "":
argv = append(argv, "--jump", f.jump)
case f.noJump:
argv = append(argv, "--no-jump")
}
if f.user != "" {
argv = append(argv, "-l", f.user)
}
return append(argv, target)
}
var unsafeLabel = regexp.MustCompile(`[^A-Za-z0-9_-]+`)
// multiLabel names the window, session, or tab after a single selector.
func multiLabel(selectors []string) string {
if len(selectors) != 1 {
return "multi"
}
s := selectors[0]
for _, prefix := range []string{"@", "tag:", "cluster:"} {
s = strings.TrimPrefix(s, prefix)
}
if s = strings.Trim(unsafeLabel.ReplaceAllString(s, "-"), "-"); s == "" {
return "multi"
}
return s
}
// expander resolves selectors into an ordered list of unique host targets.
type expander struct {
cfg *config.Config
cache *cache.Cache
kind string
client *netbox.Client
seen map[string]bool
visiting map[string]bool
targets []string
warnings []string
}
func expandSelectors(cfg *config.Config, c *cache.Cache, selectors []string, kind string) ([]string, []string, error) {
e := &expander{cfg: cfg, cache: c, kind: kind, seen: map[string]bool{}, visiting: map[string]bool{}}
for _, selector := range selectors {
if err := e.expand(selector); err != nil {
return nil, e.warnings, err
}
}
if len(e.targets) == 0 {
return nil, e.warnings, errors.New("no hosts selected")
}
return e.targets, e.warnings, nil
}
func (e *expander) add(target string) {
key := strings.ToLower(target)
if !e.seen[key] {
e.seen[key] = true
e.targets = append(e.targets, target)
}
}
func (e *expander) expand(selector string) error {
switch {
case strings.HasPrefix(selector, "@"):
return e.group(strings.ToLower(strings.TrimPrefix(selector, "@")))
case strings.HasPrefix(selector, "tag:"):
return e.query(selector, netbox.SearchOptions{Tag: strings.TrimPrefix(selector, "tag:")}, "all")
case strings.HasPrefix(selector, "cluster:"):
return e.query(selector, netbox.SearchOptions{Cluster: strings.TrimPrefix(selector, "cluster:")}, "device")
case selector == "":
return nil
}
e.add(selector)
return nil
}
func (e *expander) group(name string) error {
members, ok := e.cfg.Groups[name]
if !ok {
names := make([]string, 0, len(e.cfg.Groups))
for group := range e.cfg.Groups {
names = append(names, "@"+group)
}
sort.Strings(names)
if len(names) == 0 {
return fmt.Errorf("unknown group @%s; no groups are configured (groups:)", name)
}
return fmt.Errorf("unknown group @%s; available: %s", name, strings.Join(names, ", "))
}
if e.visiting[name] {
return fmt.Errorf("group @%s contains itself", name)
}
e.visiting[name] = true
defer delete(e.visiting, name)
for _, member := range members {
if err := e.expand(member); err != nil {
return err
}
}
return nil
}
// query expands tag: and cluster: through NetBox, plus static hosts for tags;
// if NetBox fails, the cache answers with a warning.
func (e *expander) query(selector string, opts netbox.SearchOptions, defaultKind string) error {
kind := e.kind
if kind == "" {
kind = defaultKind
}
if kind != "all" {
opts.Kind = kind
}
before := len(e.targets)
if opts.Tag != "" && (kind == "all" || kind == config.StaticKind) {
for _, host := range e.cfg.Hosts {
if hasTag(host.Tags, opts.Tag) {
e.add(host.Name)
}
}
}
if e.cfg.HasNetBox() {
if e.client == nil {
e.client = newNetBoxClient(e.cfg)
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
entries, err := e.client.SearchAll(ctx, "", opts)
cancel()
if err != nil {
e.warnings = append(e.warnings, fmt.Sprintf("%s: NetBox unavailable, using the cache: %v", selector, err))
entries = e.fromCache(opts)
} else {
sort.Slice(entries, func(i, j int) bool { return entries[i].Target() < entries[j].Target() })
}
for _, entry := range entries {
e.add(entry.Target())
}
}
if len(e.targets) == before {
hint := ""
if opts.Cluster != "" && e.kind == "" {
hint = " (only devices by default; try --kind vm or --kind all)"
}
return fmt.Errorf("%s matches no hosts%s", selector, hint)
}
return nil
}
func (e *expander) fromCache(opts netbox.SearchOptions) []netbox.HostEntry {
var out []netbox.HostEntry
for _, entry := range e.cache.All() {
if entry.Static || opts.Kind != "" && entry.Kind != opts.Kind {
continue
}
if opts.Tag != "" && !hasTag(entry.Tags, opts.Tag) || opts.Cluster != "" && !strings.EqualFold(entry.Cluster, opts.Cluster) {
continue
}
source, name := netbox.SplitTarget(entry.Name)
out = append(out, netbox.HostEntry{Source: source, Name: name, Kind: entry.Kind})
}
sort.Slice(out, func(i, j int) bool { return out[i].Target() < out[j].Target() })
return out
}
// hasTag compares a tag by name or slug, like ssh.rules.
func hasTag(tags []string, want string) bool {
for _, tag := range tags {
if strings.EqualFold(tag, want) || strings.EqualFold(strings.Join(strings.Fields(strings.ToLower(tag)), "-"), want) {
return true
}
}
return false
}
// multiCompletions offers hosts, @groups, and tag:/cluster: values from the cache.
func multiCompletions(cfg *config.Config, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
c := newCache(cfg)
_ = c.Load()
lower := strings.ToLower(toComplete)
var out []string
switch {
case strings.HasPrefix(lower, "tag:"), strings.HasPrefix(lower, "cluster:"):
prefix, value, _ := strings.Cut(lower, ":")
values := map[string]bool{}
for _, entry := range c.All() {
if prefix == "tag" {
for _, tag := range entry.Tags {
values[strings.ToLower(tag)] = true
}
} else if entry.Cluster != "" {
values[entry.Cluster] = true
}
}
for v := range values {
if strings.HasPrefix(strings.ToLower(v), value) {
out = append(out, prefix+":"+v)
}
}
case strings.HasPrefix(lower, "@"):
for group := range cfg.Groups {
if strings.HasPrefix("@"+group, lower) {
out = append(out, "@"+group)
}
}
default:
out = completeHosts(toComplete)
var prefixes []string
for _, p := range []string{"tag:", "cluster:"} {
if toComplete != "" && strings.HasPrefix(p, lower) {
prefixes = append(prefixes, p)
}
}
if len(out) == 0 && len(prefixes) > 0 {
return prefixes, cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
}
for group := range cfg.Groups {
if toComplete == "" {
out = append(out, "@"+group)
}
}
}
sort.Strings(out)
return out, cobra.ShellCompDirectiveNoFileComp
}
+92
View File
@@ -0,0 +1,92 @@
package main
import (
"reflect"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func TestExpandSelectors(t *testing.T) {
cfg := &config.Config{
Hosts: []config.StaticHost{{Name: "box", Address: "10.0.0.1", Tags: []string{"Web Servers"}}},
Groups: map[string][]string{
"all": {"@web", "db1", "box"},
"web": {"web1", "tag:web-servers", "web1"},
"loop": {"@loop"},
},
}
c := cache.New(t.TempDir()+"/hosts.json", 60).WithStatic(cfg.Hosts)
got, _, err := expandSelectors(cfg, c, []string{"@all", "WEB1"}, "")
if err != nil || !reflect.DeepEqual(got, []string{"web1", "box", "db1"}) {
t.Fatalf("got %v %v", got, err)
}
if _, _, err := expandSelectors(cfg, c, []string{"@loop"}, ""); err == nil || !strings.Contains(err.Error(), "contains itself") {
t.Fatalf("cycle: %v", err)
}
if _, _, err := expandSelectors(cfg, c, []string{"@nope"}, ""); err == nil || !strings.Contains(err.Error(), "available: @all, @loop, @web") {
t.Fatalf("unknown group: %v", err)
}
if _, _, err := expandSelectors(cfg, c, []string{"tag:web-servers"}, "device"); err == nil {
t.Fatal("--kind device must exclude static hosts")
}
}
// Without a reachable NetBox, tag: and cluster: fall back to the cache.
func TestExpandSelectorsCacheFallback(t *testing.T) {
cfg := &config.Config{NetBox: config.NetBoxConfig{URL: "http://127.0.0.1:1", Token: "t", TokenVersion: 1}}
c := cache.New(t.TempDir()+"/hosts.json", 60)
c.Upsert(cache.Entry{Name: "node2", Kind: "device", Cluster: "pve"})
c.Upsert(cache.Entry{Name: "node1", Kind: "device", Cluster: "pve", Tags: []string{"pve"}})
c.Upsert(cache.Entry{Name: "vm1", Kind: "vm", Cluster: "pve"})
got, warnings, err := expandSelectors(cfg, c, []string{"cluster:PVE"}, "")
if err != nil || !reflect.DeepEqual(got, []string{"node1", "node2"}) || len(warnings) != 1 {
t.Fatalf("devices: %v %v %v", got, warnings, err)
}
if got, _, _ := expandSelectors(cfg, c, []string{"cluster:pve"}, "all"); len(got) != 3 {
t.Fatalf("all: %v", got)
}
if _, _, err := expandSelectors(cfg, c, []string{"cluster:other"}, ""); err == nil || !strings.Contains(err.Error(), "--kind vm") {
t.Fatalf("empty cluster: %v", err)
}
}
func TestMultiLabelAndPaneArgv(t *testing.T) {
for selectors, want := range map[string]string{"@k8s": "k8s", "cluster:pve-fsn1": "pve-fsn1", "tag:a.b": "a-b", "a b": "multi"} {
if got := multiLabel(strings.Fields(selectors)); got != want {
t.Errorf("%q: got %q", selectors, got)
}
}
t.Setenv("XDG_CONFIG_HOME", "/cfg")
t.Setenv("NETSSH_NETBOX_TOKEN", "secret")
argv := strings.Join(paneArgv("prod/web1", multiFlags{user: "ops", jump: "jh"}), " ")
for _, want := range []string{"NETSSH_NO_REFRESH=1", "XDG_CONFIG_HOME=/cfg", "--jump jh -l ops prod/web1"} {
if !strings.Contains(argv, want) {
t.Errorf("argv lacks %q: %s", want, argv)
}
}
if strings.Contains(argv, "secret") {
t.Fatalf("token leaked into the pane arguments: %s", argv)
}
}
func TestMultiDryRun(t *testing.T) {
prepareConfig(t, "hosts:\n - {name: a, address: 10.0.0.1, tags: [web]}\n - {name: b, address: 10.0.0.2, tags: [web]}\ngroups:\n web: [\"tag:web\"]\n")
out, err := runNetssh(t, "multi", "--dry-run", "--tmux", "--sync", "@web")
if err != nil {
t.Fatalf("%s %v", out, err)
}
for _, want := range []string{"# 2 hosts: a b", "tmux new-session -d -x 240 -y 70 -s netssh-web", "synchronize-panes on", "tmux attach-session -t netssh-web"} {
if !strings.Contains(out, want) {
t.Errorf("missing %q:\n%s", want, out)
}
}
if out, err := runNetssh(t, "multi", "--dry-run", "--zellij", "a", "b"); err != nil || !strings.Contains(out, `pane name="b"`) {
t.Errorf("zellij: %s %v", out, err)
}
if out, err := runNetssh(t, "sync"); err == nil || !strings.Contains(out, "inside tmux or zellij") {
t.Errorf("sync outside: %s %v", out, err)
}
}
+1 -1
View File
@@ -38,7 +38,7 @@ func notesCmd() *cobra.Command {
client = newNetBoxClient(cfg)
}
host := netbox.HostEntry{Name: args[0], Kind: kind}
c := cache.New(cfg.CachePath(), cfg.Cache.TTL)
c := newCache(cfg)
if err := c.Load(); err != nil {
return err
}
+201
View File
@@ -0,0 +1,201 @@
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"os/exec"
"sort"
"strings"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity"
"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/resolver"
"github.com/spf13/cobra"
)
func doctorCmd() *cobra.Command {
var online bool
cmd := &cobra.Command{Use: "doctor", Short: "Check configuration, programs, cache and optional NetBox connectivity", Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, _ []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
failed := false
report := func(label string, err error) {
if err != nil {
failed = true
fmt.Fprintf(cmd.OutOrStdout(), "FAIL %s: %v\n", label, err)
} else {
fmt.Fprintf(cmd.OutOrStdout(), "OK %s\n", label)
}
}
report("configuration", nil)
_, err = resolver.New(cfg.Resolver)
report("resolver", err)
programs := map[string]bool{"ssh": true, "sftp": true, "scp": true}
for name, c := range cfg.Commands {
programs[c.Args[0]] = true
if len(c.Args) > 1 && !strings.HasPrefix(c.Args[1], "-") {
switch c.Args[0] {
case "bash", "sh", "python", "python3":
f, err := os.Open(c.Args[1])
if err == nil {
f.Close()
}
report("script "+name, err)
}
}
}
var names []string
for p := range programs {
names = append(names, p)
}
sort.Strings(names)
for _, p := range names {
_, err := exec.LookPath(p)
report("program "+p, err)
}
report("cache", newCache(cfg).Load())
for _, instance := range instanceConfigs(cfg) {
if config.IsKeyringToken(instance.Token) {
_, err := resolveToken(*instance)
report("keyring token "+instance.KeyringAccount(), err)
}
}
if online {
sources := cfg.NetBoxes
if len(sources) == 0 && cfg.NetBox.URL != "" {
sources = []config.NetBoxConfig{cfg.NetBox}
}
for _, s := range sources {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
token, version := clientToken(s)
_, err := netbox.NewClient(s.URL, token, version).Search(ctx, "", netbox.SearchOptions{})
cancel()
report("NetBox "+s.Name, err)
}
}
if failed {
return fmt.Errorf("doctor found problems")
}
return nil
}}
cmd.Flags().BoolVar(&online, "online", false, "Also query every NetBox instance")
return cmd
}
func explainCmd() *cobra.Command {
return &cobra.Command{Use: "explain HOST", Short: "Explain actual host resolution and effective SSH settings without connecting", Args: cobra.ExactArgs(1), 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
}
selectors := commandHost(h)
user, port := hostDefaults(cfg, h)
opts := hostOptions(cfg, h)
var rules []int
for i, r := range cfg.SSH.Rules {
if r.Match.Matches(selectors) {
rules = append(rules, i+1)
}
}
strategy := h.Resolver
if strategy == "" {
if h.Origin == "static" {
strategy = "static address"
} else {
strategy = "not recorded in this cache entry"
}
}
return json.NewEncoder(cmd.OutOrStdout()).Encode(map[string]any{
"target": h.Name, "instance": selectors.Instance, "address": h.IP, "source": h.Origin, "cached_at": h.CachedAt,
"status": h.Status, "site": h.Site.Name, "role": h.Role.Name, "platform": h.Platform.Name, "tenant": h.Tenant.Name, "netbox_id": h.ID, "location": h.LocationPath(),
"resolver_order": cfg.Resolver.Strategies, "resolver_used": strategy, "matching_rules": rules, "user": user, "port": port, "ssh": opts,
})
}}
}
func favoritesCmd() *cobra.Command {
cmd := &cobra.Command{Use: "favorites", Short: "List or change favorite and pinned hosts", RunE: func(cmd *cobra.Command, _ []string) error {
s, err := activity.Read()
if err != nil {
return err
}
var names []string
for n := range s.Favorites {
if s.Favorites[n] {
names = append(names, n)
}
}
sort.Strings(names)
for _, n := range names {
marker := "favorite"
if s.Pinned[n] {
marker = "pinned"
}
fmt.Fprintf(cmd.OutOrStdout(), "%s\t%s\n", n, marker)
}
return nil
}}
for _, action := range []string{"add", "remove", "pin", "unpin"} {
cmd.AddCommand(&cobra.Command{Use: action + " HOST", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error {
target := args[0]
if action == "add" || action == "pin" {
cfg, err := config.Load()
if err != nil {
return err
}
h, err := resolveTargetE(cfg, target, false)
if err != nil {
return err
}
target = h.Name
}
return activity.Update(func(s *activity.State) {
switch action {
case "add":
s.Favorites[target] = true
case "pin":
s.Favorites[target] = true
s.Pinned[target] = true
case "unpin":
delete(s.Pinned, target)
case "remove":
delete(s.Favorites, target)
delete(s.Pinned, target)
}
})
}})
}
return cmd
}
func historyCmd() *cobra.Command {
cmd := &cobra.Command{Use: "history", Short: "Show optional local action history", RunE: func(cmd *cobra.Command, _ []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
if err := activity.Update(func(s *activity.State) { activity.Prune(s, cfg.Activity) }); err != nil {
return err
}
s, err := activity.Read()
if err != nil {
return err
}
for i := len(s.Records) - 1; i >= 0; i-- {
r := s.Records[i]
fmt.Fprintf(cmd.OutOrStdout(), "%s\t%s\t%s\texit=%d\t%s\n", r.Time.Format(time.RFC3339), r.Host, r.Command, r.Code, r.Duration.Round(time.Millisecond))
}
return nil
}}
cmd.AddCommand(&cobra.Command{Use: "clear", Short: "Delete recorded actions, preserving favorites", Args: cobra.NoArgs, RunE: func(_ *cobra.Command, _ []string) error {
return activity.Update(func(s *activity.State) { s.Records = nil })
}})
return cmd
}
+258
View File
@@ -0,0 +1,258 @@
package main
import (
"bytes"
"encoding/json"
"fmt"
"os"
"os/exec"
"path/filepath"
"reflect"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func writeOperationsConfig(t *testing.T, extra string) {
t.Helper()
prepareTransferTest(t)
data := `hosts:
- name: router
address: 192.0.2.1
tags: [router]
- name: fail
address: 192.0.2.2
- name: okay
address: 192.0.2.3
resolver:
strategies: [primary_ip]
` + extra
if err := os.WriteFile(config.Path(), []byte(data), 0600); err != nil {
t.Fatal(err)
}
}
func TestPostHooksFiltersAndConfirmation(t *testing.T) {
dir := t.TempDir()
marker := filepath.Join(dir, "post")
writeOperationsConfig(t, fmt.Sprintf(`
commands:
success:
args: [sh, -c, "exit 0", "{host}"]
post_run: 'printf "%%s:%%s" "$NETSSH_HOST" "$NETSSH_EXIT_CODE" > %s'
failure:
args: [sh, -c, "exit 7", "{host}"]
post_run: 'printf "%%s" "$NETSSH_EXIT_CODE" > %s; exit 9'
postfail:
args: [sh, -c, "exit 0", "{host}"]
post_run: exit 9
protected:
args: [sh, -c, "exit 0", "{host}"]
confirm: true
match: {tag: router, kind: static, name: "rou*"}
timeout:
args: [sh, -c, "sleep 20", "{host}"]
timeout: 50ms
activity:
enabled: true
retention_days: 30
max_entries: 50
`, marker, marker))
if out, err := runNetssh(t, "run", "--dry-run", "success", "router"); err != nil {
t.Fatalf("%s %v", out, err)
}
if _, err := os.Stat(marker); !os.IsNotExist(err) {
t.Fatal("dry-run executed post hook")
}
if out, err := runNetssh(t, "run", "success", "router"); err != nil {
t.Fatalf("%s %v", out, err)
}
data, _ := os.ReadFile(marker)
if string(data) != "router:0" {
t.Fatal(string(data))
}
for _, tc := range []struct {
name string
code int
}{{"failure", 7}, {"postfail", 9}, {"timeout", 124}} {
_, err := runNetssh(t, "run", tc.name, "router")
exit, ok := err.(*exec.ExitError)
if !ok || exit.ExitCode() != tc.code {
t.Fatalf("%s: %v", tc.name, err)
}
}
data, _ = os.ReadFile(marker)
if string(data) != "7" {
t.Fatal(string(data))
}
if out, err := runNetssh(t, "run", "protected", "router"); err == nil || !strings.Contains(out, "--yes") {
t.Fatalf("%q %v", out, err)
}
if out, err := runNetssh(t, "run", "--yes", "protected", "router"); err != nil {
t.Fatalf("%q %v", out, err)
}
if out, err := runNetssh(t, "run", "--yes", "protected", "okay"); err == nil || !strings.Contains(out, "not allowed") {
t.Fatalf("%q %v", out, err)
}
state, err := activity.Read()
if err != nil || len(state.Records) != 5 {
t.Fatalf("%+v %v", state, err)
}
}
func TestSSHPostDisconnect(t *testing.T) {
dir := t.TempDir()
marker := filepath.Join(dir, "after")
writeOperationsConfig(t, fmt.Sprintf("ssh:\n post_disconnect: 'printf \"%%s\" \"$NETSSH_EXIT_CODE\" > %s'\n", marker))
if err := os.WriteFile(filepath.Join(dir, "ssh"), []byte("#!/bin/sh\nexit 6\n"), 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH"))
_, err := runNetssh(t, "router")
exit, ok := err.(*exec.ExitError)
if !ok || exit.ExitCode() != 6 {
t.Fatal(err)
}
data, _ := os.ReadFile(marker)
if string(data) != "6" {
t.Fatalf("post: %s", data)
}
}
func TestExplainAndFavorites(t *testing.T) {
writeOperationsConfig(t, "tui:\n history_limit: 25\nssh:\n rules:\n - match: {tag: router}\n post_disconnect: echo done\n")
out, err := runNetssh(t, "explain", "router")
if err != nil {
t.Fatalf("%s %v", out, err)
}
var result map[string]any
if err := json.Unmarshal([]byte(out), &result); err != nil {
t.Fatal(err)
}
if result["source"] != "static" || result["address"] != "192.0.2.1" {
t.Fatal(result)
}
for _, args := range [][]string{{"favorites", "pin", "router"}, {"favorites", "add", "okay"}} {
if out, err := runNetssh(t, args...); err != nil {
t.Fatalf("%s %v", out, err)
}
}
state, err := activity.Read()
if err != nil || !state.Pinned["router"] || !state.Favorites["okay"] {
t.Fatalf("%+v %v", state, err)
}
if out, err := runNetssh(t, "favorites", "remove", "router"); err != nil {
t.Fatalf("%s %v", out, err)
}
state, _ = activity.Read()
if state.Pinned["router"] || state.Favorites["router"] {
t.Fatal(state)
}
}
func TestPortableConfigOmitsAllExecutableSecrets(t *testing.T) {
c := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://user:URLSECRET@netbox.example", Token: "TOKEN", SSH: config.SSHOptions{PreConnect: "HOOKSECRET"}}},
SSH: config.SSHConfig{SSHOptions: config.SSHOptions{Options: map[string]string{"ProxyCommand": "OPTIONSECRET"}, PostDisconnect: "POSTSECRET"}},
Commands: map[string]config.HostCommand{"check": {Args: []string{"echo", "COMMANDSECRET", "{host}"}}},
Hosts: []config.StaticHost{{Name: "router", Address: "192.0.2.1", SSH: config.SSHOptions{PreConnect: "STATICSECRET"}}},
TUI: config.TUIConfig{HistoryLimit: 25},
}
data, err := json.Marshal(portableConfig(c))
if err != nil {
t.Fatal(err)
}
for _, secret := range []string{"URLSECRET", "TOKEN", "HOOKSECRET", "OPTIONSECRET", "POSTSECRET", "COMMANDSECRET", "STATICSECRET"} {
if bytes.Contains(data, []byte(secret)) {
t.Fatalf("export leaked %s", secret)
}
}
parsed, err := decodePortable(data)
if err != nil {
t.Fatal(err)
}
if parsed.TUI.HistoryLimit != 25 || len(parsed.NetBoxes) != 1 || parsed.NetBoxes[0].URL != "https://netbox.example" {
t.Fatalf("%+v", parsed)
}
hostile := []byte("netbox:\n url: https://netbox.example\n token: bad\nssh:\n pre_connect: touch /tmp/never\ncommands:\n check:\n args: [sh, -c, evil]\n")
parsed, err = decodePortable(hostile)
if err != nil || parsed.NetBox.Token != "" || parsed.SSH.PreConnect != "" || len(parsed.Commands) != 0 {
t.Fatalf("%+v %v", parsed, err)
}
}
func TestBatchRetryFailedOnly(t *testing.T) {
bin := filepath.Join(t.TempDir(), "netssh")
build := exec.Command("go", "build", "-o", bin, ".")
if out, err := build.CombinedOutput(); err != nil {
t.Fatalf("build: %s %v", out, err)
}
old := batchExecutable
batchExecutable = func() (string, error) { return bin, nil }
t.Cleanup(func() { batchExecutable = old })
dir := t.TempDir()
script := filepath.Join(dir, "check.sh")
ready := filepath.Join(dir, "ready")
if err := os.WriteFile(script, []byte(fmt.Sprintf("#!/bin/sh\nif [ \"$1\" = fail ] && [ ! -f %q ]; then exit 3; fi\nprintf 'ran %%s\\n' \"$1\"\n", ready)), 0700); err != nil {
t.Fatal(err)
}
writeOperationsConfig(t, fmt.Sprintf("commands:\n check:\n args: [%q, \"{host}\"]\n", script))
run := func(args ...string) (string, error) {
cmd := batchCmd()
cmd.SetArgs(args)
var out bytes.Buffer
cmd.SetOut(&out)
cmd.SetErr(&out)
err := cmd.Execute()
return out.String(), err
}
out, err := run("--parallel", "2", "check", "router", "fail", "okay")
if err == nil || !strings.Contains(out, "2 succeeded, 1 failed") {
t.Fatalf("%s %v", out, err)
}
data, _ := os.ReadFile(batchPath())
var retry batchRetry
if err := json.Unmarshal(data, &retry); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(retry.Hosts, []string{"fail"}) {
t.Fatalf("%+v", retry)
}
if err := os.WriteFile(ready, nil, 0600); err != nil {
t.Fatal(err)
}
out, err = run("--retry-failed")
if err != nil || !strings.Contains(out, "1 succeeded, 0 failed") || strings.Contains(out, "ran router") {
t.Fatalf("%s %v", out, err)
}
}
func TestImportPreservesOnlyMatchingCredentials(t *testing.T) {
writeOperationsConfig(t, "")
original := []byte("netboxes:\n - name: prod\n url: https://prod.example\n token: LOCALPROD\n - name: lab\n url: https://lab.example\n token: LOCALLAB\ncommands:\n local:\n args: [echo, \"{host}\"]\n")
if err := os.WriteFile(config.Path(), original, 0600); err != nil {
t.Fatal(err)
}
shared := filepath.Join(t.TempDir(), "shared.yaml")
if err := os.WriteFile(shared, []byte("netboxes:\n - name: prod\n url: https://prod.example\n token: UNTRUSTED\n - name: lab\n url: https://other.example\ntui:\n history_limit: 25\nssh:\n pre_connect: evil\n"), 0600); err != nil {
t.Fatal(err)
}
if out, err := runNetssh(t, "config", "import", shared, "--dry-run"); err != nil {
t.Fatalf("%s %v", out, err)
}
after, _ := os.ReadFile(config.Path())
if !bytes.Equal(original, after) {
t.Fatal("preview changed config")
}
if out, err := runNetssh(t, "config", "import", shared, "--yes"); err != nil {
t.Fatalf("%s %v", out, err)
}
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
if cfg.NetBoxes[0].Token != "LOCALPROD" || cfg.NetBoxes[1].Token != "" || cfg.SSH.PreConnect != "" || len(cfg.Commands) != 1 || cfg.TUI.HistoryLimit != 25 {
t.Fatalf("incorrect imported settings: names=%d tui=%d", len(cfg.NetBoxes), cfg.TUI.HistoryLimit)
}
backup, _ := os.ReadFile(config.Path() + ".before-import")
if !bytes.Equal(backup, original) {
t.Fatal("backup differs")
}
}
+164
View File
@@ -0,0 +1,164 @@
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/url"
"os"
"strings"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/setup"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
"github.com/spf13/cobra"
"github.com/spf13/viper"
)
// Portable config deliberately omits arbitrary command/hook/SSH option strings:
// secrets may be embedded there, and cannot reliably be detected by key name.
func portableConfig(c config.Config) map[string]any {
cleanURL := func(raw string) string {
u, err := url.Parse(raw)
if err != nil {
return ""
}
u.User = nil
u.RawQuery = ""
u.Fragment = ""
return u.String()
}
sources := []map[string]any{}
for _, s := range c.NetBoxes {
sources = append(sources, map[string]any{"name": s.Name, "url": cleanURL(s.URL), "disable_prefix": s.DisablePrefix})
}
hosts := []map[string]any{}
for _, h := range c.Hosts {
hosts = append(hosts, map[string]any{"name": h.Name, "address": h.Address, "user": h.User, "port": h.Port, "tags": h.Tags})
}
rewrites := []map[string]string{}
for _, r := range c.Shortcuts.Rewrites {
rewrites = append(rewrites, map[string]string{"pattern": r.Pattern, "replace": r.Replace})
}
out := map[string]any{
"hosts": hosts, "groups": c.Groups,
"ssh": map[string]any{"default_user": c.SSH.DefaultUser, "default_port": c.SSH.DefaultPort},
"resolver": map[string]any{"strategies": c.Resolver.Strategies, "management_subnets": c.Resolver.ManagementSubnets, "interface_name": c.Resolver.InterfaceName, "hostname_domain": c.Resolver.HostnameDomain},
"shortcuts": map[string]any{"domains": c.Shortcuts.Domains, "rewrites": rewrites, "strip_hyphens": c.Shortcuts.StripHyphens, "show": c.Shortcuts.Show},
"completion": map[string]any{"max_results": c.Completion.MaxResults},
"tui": map[string]any{"history_limit": c.TUI.HistoryLimit},
}
if len(sources) > 0 {
out["netboxes"] = sources
} else if c.NetBox.URL != "" {
out["netbox"] = map[string]string{"url": cleanURL(c.NetBox.URL)}
}
return out
}
func decodePortable(data []byte) (config.Config, error) {
v := viper.New()
v.SetConfigType("yaml")
v.SetDefault("tui.history_limit", 10)
var c config.Config
if err := v.ReadConfig(bytes.NewReader(data)); err != nil {
return c, err
}
if err := v.Unmarshal(&c); err != nil {
return c, err
}
// Strip executable settings and credentials even from externally edited files.
safe, _ := json.Marshal(portableConfig(c))
v = viper.New()
v.SetConfigType("json")
if err := v.ReadConfig(bytes.NewReader(safe)); err != nil {
return c, err
}
c = config.Config{}
err := v.Unmarshal(&c)
return c, err
}
func configCmd() *cobra.Command {
cmd := &cobra.Command{Use: "config", Short: "Share configuration without credentials or executable settings"}
export := &cobra.Command{Use: "export [FILE]", Short: "Export a secret-free JSON configuration (also valid YAML)", Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
data, err := json.MarshalIndent(portableConfig(*cfg), "", " ")
if err != nil {
return err
}
if len(args) == 0 {
fmt.Fprintln(cmd.OutOrStdout(), string(data))
return nil
}
return storage.WriteFile(args[0], append(data, '\n'), 0600)
}}
var yes, dry bool
imp := &cobra.Command{Use: "import FILE", Short: "Import shared host settings; preserve matching local credentials and commands", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error {
data, err := os.ReadFile(args[0])
if err != nil {
return err
}
incoming, err := decodePortable(data)
if err != nil {
return err
}
current, err := config.Load()
if err != nil {
return err
}
same := func(a, b string) bool { return strings.TrimRight(a, "/") == strings.TrimRight(b, "/") }
for i := range incoming.NetBoxes {
for _, old := range current.NetBoxes {
s := &incoming.NetBoxes[i]
if strings.EqualFold(s.Name, old.Name) && same(s.URL, old.URL) {
s.Token = old.Token
s.TokenVersion = old.TokenVersion
s.SSH = old.SSH
}
}
}
if incoming.NetBox.URL != "" && same(incoming.NetBox.URL, current.NetBox.URL) {
incoming.NetBox.Token = current.NetBox.Token
incoming.NetBox.TokenVersion = current.NetBox.TokenVersion
incoming.NetBox.SSH = current.NetBox.SSH
}
incoming.Commands = current.Commands
incoming.Activity = current.Activity
incoming.Cache = current.Cache
incoming.Multi = current.Multi
incoming.Shell = current.Shell
incoming.SSH.SSHOptions = current.SSH.SSHOptions
incoming.SSH.Rules = current.SSH.Rules
for i := range incoming.Hosts {
for _, old := range current.Hosts {
if incoming.Hosts[i].Name == old.Name && incoming.Hosts[i].Address == old.Address {
incoming.Hosts[i].SSH = old.SSH
}
}
}
for _, validate := range []func() error{incoming.ValidateNetBoxes, incoming.ValidateHosts, incoming.ValidateSSH, incoming.ValidateCommands, incoming.ValidateOperations, incoming.Shortcuts.Validate, incoming.ValidateMulti} {
if err := validate(); err != nil {
return err
}
}
fmt.Fprintf(cmd.OutOrStdout(), "Import: %d named instances, %d static hosts. Local commands and matching credentials are retained.\n", len(incoming.NetBoxes), len(incoming.Hosts))
if dry {
return nil
}
if err := confirmAction("Replace shared configuration settings", yes); err != nil {
return err
}
if existing, err := os.ReadFile(config.Path()); err == nil {
if err := storage.WriteFile(config.Path()+".before-import", existing, 0600); err != nil {
return err
}
}
return setup.Save(incoming)
}}
imp.Flags().BoolVar(&yes, "yes", false, "Approve replacing shared configuration settings")
imp.Flags().BoolVar(&dry, "dry-run", false, "Validate and preview without writing")
cmd.AddCommand(export, imp)
return cmd
}
+54
View File
@@ -0,0 +1,54 @@
package main
import (
"fmt"
"io"
"os"
"os/exec"
"strings"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
)
// preConnectRunner runs the hook; tests replace it to avoid spawning a shell.
var preConnectRunner = runPreConnectCommand
// preConnectEnv describes the host to the hook through environment variables.
func preConnectEnv(host resolvedHost, clientName string) []string {
instance, name := netbox.SplitTarget(host.Name)
return []string{
"NETSSH_HOST=" + name,
"NETSSH_TARGET=" + host.Name,
"NETSSH_INSTANCE=" + instance,
"NETSSH_IP=" + host.IP,
"NETSSH_KIND=" + host.Kind,
"NETSSH_TAGS=" + strings.Join(host.Tags, ","),
"NETSSH_CLIENT=" + clientName,
}
}
// runPreConnect runs the configured pre_connect hook for host. Its output goes
// to stderr so it never mixes with the output of a remote command or scp.
// A failing hook returns an error and the connection must not be opened.
func runPreConnect(command string, host resolvedHost, clientName string, dryRun bool) error {
if command == "" {
return nil
}
if dryRun {
fmt.Fprintf(os.Stderr, "# pre_connect (skipped in --dry-run): %s\n", command)
return nil
}
if err := preConnectRunner(command, preConnectEnv(host, clientName), os.Stdin, os.Stderr); err != nil {
return fmt.Errorf("pre_connect hook for %s failed: %w", host.Name, err)
}
return nil
}
func runPreConnectCommand(command string, env []string, stdin io.Reader, out io.Writer) error {
cmd := exec.Command("sh", "-c", command)
cmd.Env = append(os.Environ(), env...)
cmd.Stdin = stdin
cmd.Stdout = out
cmd.Stderr = out
return cmd.Run()
}
+112
View File
@@ -0,0 +1,112 @@
package main
import (
"bytes"
"errors"
"io"
"os"
"reflect"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh"
)
func TestRunPreConnectPassesHostAndStopsOnFailure(t *testing.T) {
host := resolvedHost{Name: "prod/web01", Kind: "vm", IP: "10.0.0.5", Tags: []string{"dmz", "web"}}
var gotCommand string
var gotEnv []string
fail := false
preConnectRunner = func(command string, env []string, _ io.Reader, _ io.Writer) error {
gotCommand, gotEnv = command, env
if fail {
return errors.New("exit status 1")
}
return nil
}
t.Cleanup(func() { preConnectRunner = runPreConnectCommand })
if err := runPreConnect("vpn-check", host, "sftp", false); err != nil {
t.Fatal(err)
}
want := []string{"NETSSH_HOST=web01", "NETSSH_TARGET=prod/web01", "NETSSH_INSTANCE=prod", "NETSSH_IP=10.0.0.5", "NETSSH_KIND=vm", "NETSSH_TAGS=dmz,web", "NETSSH_CLIENT=sftp"}
if gotCommand != "vpn-check" || !reflect.DeepEqual(gotEnv, want) {
t.Fatalf("got %q %v", gotCommand, gotEnv)
}
fail = true
if err := runPreConnect("vpn-check", host, "ssh", false); err == nil || !strings.Contains(err.Error(), "prod/web01") {
t.Fatalf("failure not reported: %v", err)
}
gotCommand = ""
if err := runPreConnect("vpn-check", host, "ssh", true); err != nil || gotCommand != "" {
t.Fatalf("dry-run ran the hook: %v %q", err, gotCommand)
}
if err := runPreConnect("", host, "ssh", false); err != nil || gotCommand != "" {
t.Fatalf("empty hook ran: %v %q", err, gotCommand)
}
}
func TestRunPreConnectCommandUsesShell(t *testing.T) {
var out bytes.Buffer
err := runPreConnectCommand(`echo "$NETSSH_HOST via $NETSSH_CLIENT"`, []string{"NETSSH_HOST=web01", "NETSSH_CLIENT=ssh"}, strings.NewReader(""), &out)
if err != nil || out.String() != "web01 via ssh\n" {
t.Fatalf("got %q, %v", out.String(), err)
}
if err := runPreConnectCommand("exit 3", nil, strings.NewReader(""), io.Discard); err == nil {
t.Fatal("non-zero exit not reported")
}
}
// --dry-run only prints the ssh command: it must not run the hook, which may
// have side effects (bringing up a VPN, logging).
func TestConnectHostDryRunSkipsPreConnect(t *testing.T) {
ran := 0
preConnectRunner = func(string, []string, io.Reader, io.Writer) error { ran++; return nil }
t.Cleanup(func() { preConnectRunner = runPreConnectCommand })
cfg := &config.Config{SSH: config.SSHConfig{SSHOptions: config.SSHOptions{PreConnect: "hook"}}}
stdout := os.Stdout
r, w, _ := os.Pipe()
os.Stdout = w
connectHost(cfg, internalssh.SSH, internalssh.WrapperFlags{DryRun: true}, resolvedHost{Name: "web01", IP: "10.0.0.1"}, []int{0}, []string{"web01"})
w.Close()
os.Stdout = stdout
printed, _ := io.ReadAll(r)
if ran != 0 || !strings.Contains(string(printed), "10.0.0.1") {
t.Fatalf("dry-run: ran=%d printed=%q", ran, printed)
}
}
func TestShortcutAliasesOnlyWhenShortened(t *testing.T) {
cfg := config.Config{Shell: config.ShellConfig{Alias: "j"}, Shortcuts: fsnRewrite}
entries := []cache.Entry{{Name: "fsn1-bx1.hoster.de"}, {Name: "web01.other.de"}, {Name: "db01.hoster.de"}}
got := shortcutAliases(entries, cfg)
want := map[string]string{"fsn1-bx1.hoster.de": "fsnbx1", "db01.hoster.de": "db01"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %v, want %v", got, want)
}
if got := shortcutAliases(entries, config.Config{}); len(got) != 0 {
t.Fatalf("aliases without shortcuts: %v", got)
}
}
func TestHostCompletionsShowShortcutsForMatchingNames(t *testing.T) {
entries := []cache.Entry{{Name: "fsn1-bx1.hoster.de"}, {Name: "fsn1-db1.hoster.de"}}
if got := hostCompletions(entries, "fsn", fsnRewrite); !reflect.DeepEqual(got, []string{"fsn1-bx1.hoster.de", "fsn1-db1.hoster.de"}) {
t.Fatalf("without show: %v", got)
}
show := fsnRewrite
show.Show = true
want := []string{"fsn1-bx1.hoster.de", "fsn1-db1.hoster.de", "fsnbx1", "fsndb1"}
if got := hostCompletions(entries, "fsn", show); !reflect.DeepEqual(got, want) {
t.Fatalf("with show: got %v, want %v", got, want)
}
// A shortcut equal to an offered name is not repeated.
plain := []cache.Entry{{Name: "web01"}}
if got := hostCompletions(plain, "web", show); !reflect.DeepEqual(got, []string{"web01"}) {
t.Fatalf("duplicate: %v", got)
}
}
+106
View File
@@ -0,0 +1,106 @@
package main
import (
"fmt"
"os"
"sort"
"strings"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
"github.com/charmbracelet/x/term"
"github.com/spf13/cobra"
)
// expandHostCommand substitutes each argument once, without shell evaluation.
func expandHostCommand(command config.HostCommand, host resolvedHost, extra []string) []string {
_, name := netbox.SplitTarget(host.Name)
replace := strings.NewReplacer("{host}", name, "{address}", host.IP, "{target}", host.Name)
argv := make([]string, 0, len(command.Args)+len(extra))
for _, arg := range command.Args {
argv = append(argv, replace.Replace(arg))
}
return append(argv, extra...)
}
func runCmd() *cobra.Command {
var dryRun, yes, status bool
cmd := &cobra.Command{
Use: "run [--dry-run] COMMAND HOST [-- EXTRA_ARGS...]",
Short: "Run a configured local command for a NetBox or static host",
Args: cobra.MinimumNArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
command, ok := cfg.Commands[args[0]]
if !ok {
return fmt.Errorf("unknown configured command %q", args[0])
}
host, err := resolveTargetE(cfg, args[1], !dryRun)
if err != nil {
return err
}
if !command.Allowed(commandHost(host)) {
return fmt.Errorf("command %q is not allowed for %s", args[0], host.Name)
}
argv := expandHostCommand(command, host, args[2:])
if dryRun {
if post := config.HookCommand(command.PostRun); post != "" {
fmt.Fprintf(cmd.ErrOrStderr(), "# post_run (skipped in --dry-run): %s\n", post)
}
for i, arg := range argv {
if i > 0 {
fmt.Fprint(cmd.OutOrStdout(), " ")
}
fmt.Fprintf(cmd.OutOrStdout(), "%q", arg)
}
fmt.Fprintln(cmd.OutOrStdout())
return nil
}
if command.Confirm {
if err := confirmAction("Run "+args[0]+" on "+host.Name, yes); err != nil {
return err
}
}
timeout, _ := time.ParseDuration(command.Timeout)
code := supervise(cfg, host, args[0], argv, command.PostRun, timeout, status || term.IsTerminal(os.Stderr.Fd()), os.Stdin, cmd.OutOrStdout(), cmd.ErrOrStderr())
if code != 0 {
cmd.SilenceErrors = true
cmd.SilenceUsage = true
return &commandExit{code}
}
return nil
},
ValidArgsFunction: func(cmd *cobra.Command, args []string, prefix string) ([]string, cobra.ShellCompDirective) {
if len(args) == 0 {
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
var names []string
for name := range cfg.Commands {
if strings.HasPrefix(name, prefix) {
names = append(names, name)
}
}
sort.Strings(names)
return names, cobra.ShellCompDirectiveNoFileComp
}
if len(args) == 1 {
return completeHosts(prefix), cobra.ShellCompDirectiveNoFileComp
}
return nil, cobra.ShellCompDirectiveNoFileComp
},
}
cmd.Flags().BoolVar(&yes, "yes", false, "Approve an action requiring confirmation")
cmd.Flags().BoolVar(&status, "status", false, "Show elapsed runtime")
cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Print the command without running it")
return cmd
}
type commandExit struct{ code int }
func (e *commandExit) Error() string { return fmt.Sprintf("command exited with status %d", e.code) }
+130
View File
@@ -0,0 +1,130 @@
package main
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"reflect"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func TestExpandHostCommand(t *testing.T) {
command := config.HostCommand{Args: []string{"mtr", "--target={address}", "{host}", "{target}", "$(literal)"}}
host := resolvedHost{Name: "office/xzi-groß1", IP: "2001:db8::1"}
got := expandHostCommand(command, host, []string{"--report", "two words"})
want := []string{"mtr", "--target=2001:db8::1", "xzi-groß1", "office/xzi-groß1", "$(literal)", "--report", "two words"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("%q, want %q", got, want)
}
}
func TestRunConfiguredHostCommand(t *testing.T) {
prepareTransferTest(t)
f, err := os.OpenFile(config.Path(), os.O_APPEND|os.O_WRONLY, 0)
if err != nil {
t.Fatal(err)
}
_, err = f.WriteString(`
commands:
trace:
alias_prefix: m
args: [mtr, "{address}", "{host}", "{target}"]
literal:
args: [printf, "%s|%s|%s", "{address}", "{host}", "$(touch should-not-exist)"]
`)
if closeErr := f.Close(); err != nil || closeErr != nil {
t.Fatalf("write config: %v %v", err, closeErr)
}
for _, tc := range []struct {
args []string
want string
}{
{[]string{"run", "--dry-run", "trace", "fsnbx1", "--", "--report"}, `"mtr" "10.0.0.9" "fsn1-bx1.hoster.de" "fsn1-bx1.hoster.de" "--report"`},
{[]string{"run", "--dry-run", "trace", "--", "fsnbx1", "--help"}, `"mtr" "10.0.0.9" "fsn1-bx1.hoster.de" "fsn1-bx1.hoster.de" "--help"`},
{[]string{"run", "literal", "fsnbx1"}, "10.0.0.9|fsn1-bx1.hoster.de|$(touch should-not-exist)"},
} {
out, err := runNetssh(t, tc.args...)
if err != nil || out != tc.want {
t.Fatalf("%v: %q (%v), want %q", tc.args, out, err, tc.want)
}
}
out, err := runNetssh(t, "run", "missing", "fsnbx1")
if err == nil || !strings.Contains(out, "unknown configured command") {
t.Fatalf("%q %v", out, err)
}
}
func TestRunCommandAcceptsResolvedHostname(t *testing.T) {
prepareTransferTest(t)
data := `netbox:
url: http://127.0.0.1:1
token: t
hosts:
- name: router
address: router.example.com
commands:
trace:
args: [mtr, "{address}"]
`
if err := os.WriteFile(filepath.Join(os.Getenv("XDG_CONFIG_HOME"), "netssh.yaml"), []byte(data), 0600); err != nil {
t.Fatal(err)
}
out, err := runNetssh(t, "run", "--dry-run", "trace", "router")
if err != nil || out != `"mtr" "router.example.com"` {
t.Fatalf("%q %v", out, err)
}
}
func TestRunOwnScripts(t *testing.T) {
for _, mode := range []string{"executable", "bash", "python3"} {
t.Run(mode, func(t *testing.T) {
if mode != "executable" {
if _, err := exec.LookPath(mode); err != nil {
t.Skip("interpreter not installed")
}
}
prepareTransferTest(t)
script := filepath.Join(t.TempDir(), "my host check")
body := "#!/bin/sh\nprintf '<%s>\\n' \"$@\"\nexit 7\n"
permissions := os.FileMode(0700)
argv := []string{script}
if mode != "executable" {
permissions = 0600
argv = []string{mode, script}
}
if mode == "python3" {
body = "import sys\nfor arg in sys.argv[1:]:\n print('<' + arg + '>')\nsys.exit(7)\n"
}
if err := os.WriteFile(script, []byte(body), permissions); err != nil {
t.Fatal(err)
}
argv = append(argv, "{address}", "{host}", "{target}")
var yaml strings.Builder
yaml.WriteString("\ncommands:\n check:\n alias_prefix: c\n args:\n")
for _, arg := range argv {
fmt.Fprintf(&yaml, " - %q\n", arg)
}
f, err := os.OpenFile(config.Path(), os.O_APPEND|os.O_WRONLY, 0)
if err != nil {
t.Fatal(err)
}
_, err = f.WriteString(yaml.String())
if closeErr := f.Close(); err != nil || closeErr != nil {
t.Fatalf("config write: %v %v", err, closeErr)
}
out, err := runNetssh(t, "run", "check", "fsnbx1", "--", "--report", "two words", "$(literal)")
want := "<10.0.0.9>\n<fsn1-bx1.hoster.de>\n<fsn1-bx1.hoster.de>\n<--report>\n<two words>\n<$(literal)>"
if out != want {
t.Fatalf("script args: %q, want %q", out, want)
}
exit, ok := err.(*exec.ExitError)
if !ok || exit.ExitCode() != 7 {
t.Fatalf("script exit status lost: %v", err)
}
})
}
}
+59
View File
@@ -0,0 +1,59 @@
package main
import (
"bufio"
"context"
"fmt"
"io"
"os"
"strconv"
"strings"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity"
"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/runner"
"github.com/charmbracelet/x/term"
)
func commandHost(h resolvedHost) config.SSHHost {
instance, name := netbox.SplitTarget(h.Name)
return config.SSHHost{Instance: instance, Name: name, Kind: h.Kind, Tags: h.Tags, Status: h.Status, Site: h.Site, Role: h.Role, Platform: h.Platform, Tenant: h.Tenant}
}
func confirmAction(message string, yes bool) error {
if yes {
return nil
}
if !term.IsTerminal(os.Stdin.Fd()) {
return fmt.Errorf("%s requires confirmation; use --yes for unattended execution", message)
}
fmt.Fprintf(os.Stderr, "%s? [y/N] ", message)
answer, err := bufio.NewReader(os.Stdin).ReadString('\n')
if err != nil {
return err
}
if strings.EqualFold(strings.TrimSpace(answer), "y") || strings.EqualFold(strings.TrimSpace(answer), "yes") {
return nil
}
return fmt.Errorf("cancelled")
}
func supervise(cfg *config.Config, h resolvedHost, name string, argv []string, post string, timeout time.Duration, status bool, stdin io.Reader, stdout, stderr io.Writer) int {
start := time.Now()
env := append(preConnectEnv(h, name), "NETSSH_COMMAND="+name)
result := runner.Run(context.Background(), argv, runner.Options{Stdin: stdin, Stdout: stdout, Stderr: stderr, Env: env, Timeout: timeout, Status: status, Label: name + " " + h.Name})
code := result.Code
if result.Started && config.HookCommand(post) != "" {
hook := runner.Run(context.Background(), []string{"sh", "-c", post}, runner.Options{Stdin: nil, Stdout: stderr, Stderr: stderr, Env: append(env, "NETSSH_EXIT_CODE="+strconv.Itoa(code)), Timeout: 30 * time.Second})
if hook.Code != 0 {
fmt.Fprintf(stderr, "post hook failed (exit %d)\n", hook.Code)
if code == 0 {
code = hook.Code
}
}
}
if err := activity.Append(cfg.Activity, activity.Record{Time: start, Host: h.Name, Command: name, Code: code, Duration: time.Since(start)}); err != nil {
fmt.Fprintf(stderr, "activity: %v\n", err)
}
return code
}
+14
View File
@@ -0,0 +1,14 @@
package main
import (
"os"
"testing"
)
// Integration helpers run this test binary as netssh. An automatic refresh
// would otherwise launch the test binary again with "cache refresh", rerunning
// the entire suite. Explicit cache-refresh tests still exercise the real command.
func TestMain(m *testing.M) {
_ = os.Setenv("NETSSH_NO_REFRESH", "1")
os.Exit(m.Run())
}
+260
View File
@@ -0,0 +1,260 @@
package main
import (
"bufio"
"errors"
"fmt"
"io"
"os"
"strings"
"sync"
"text/tabwriter"
"github.com/charmbracelet/x/term"
"github.com/spf13/cobra"
"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/secret"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/setup"
)
var (
tokenMu sync.Mutex
tokenCache = map[string]string{}
)
// resolveToken returns the API token of an instance: the configured value,
// or the keyring entry when the value is "keyring". Lookups are cached per
// process, since each one can be a D-Bus round trip.
func resolveToken(n config.NetBoxConfig) (string, error) {
if !config.IsKeyringToken(n.Token) {
return n.Token, nil
}
account := n.KeyringAccount()
tokenMu.Lock()
defer tokenMu.Unlock()
if token, ok := tokenCache[account]; ok {
return token, nil
}
token, err := secret.Get(account)
if err != nil {
return "", err
}
tokenCache[account] = token
return token, nil
}
// clientToken resolves a token for a client; a failure is reported once and
// leaves the token empty, so NetBox answers with a clear authentication error.
func clientToken(n config.NetBoxConfig) (string, int) {
token, err := resolveToken(n)
if err != nil {
label := n.Name
if label == "" {
label = "netbox"
}
fmt.Fprintf(os.Stderr, "netssh: %s: %v\n", label, err)
return "", n.TokenVersion
}
version := n.TokenVersion
if config.IsKeyringToken(n.Token) {
version = netbox.TokenVersion(token)
}
return token, version
}
// instanceConfigs returns the configured NetBox instances, including the
// legacy unnamed one.
func instanceConfigs(cfg *config.Config) []*config.NetBoxConfig {
var out []*config.NetBoxConfig
for i := range cfg.NetBoxes {
out = append(out, &cfg.NetBoxes[i])
}
if len(out) == 0 && cfg.NetBox.URL != "" {
out = append(out, &cfg.NetBox)
}
return out
}
// selectInstance finds the instance named in args, or the only one.
func selectInstance(cfg *config.Config, args []string) (*config.NetBoxConfig, error) {
instances := instanceConfigs(cfg)
if len(instances) == 0 {
return nil, errors.New("no NetBox is configured (netssh configure)")
}
if len(args) == 0 {
if len(instances) == 1 {
return instances[0], nil
}
return nil, fmt.Errorf("name the NetBox instance: %s", strings.Join(instanceNames(cfg), ", "))
}
for _, instance := range instances {
if strings.EqualFold(instance.Name, args[0]) || (instance.Name == "" && strings.EqualFold(args[0], "default")) {
return instance, nil
}
}
return nil, fmt.Errorf("unknown NetBox instance %q", args[0])
}
// readToken reads a token without echo from a terminal, or a line from stdin.
func readToken(label string, stdin io.Reader) (string, error) {
if f, ok := stdin.(*os.File); ok && term.IsTerminal(f.Fd()) {
fmt.Fprintf(os.Stderr, "NetBox API token for %s: ", label)
data, err := term.ReadPassword(f.Fd())
fmt.Fprintln(os.Stderr)
if err != nil {
return "", err
}
return strings.TrimSpace(string(data)), nil
}
line, err := bufio.NewReader(stdin).ReadString('\n')
if err != nil && err != io.EOF {
return "", err
}
return strings.TrimSpace(line), nil
}
// saveConfig is replaced in tests.
var saveConfig = setup.Save
func tokenCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "token",
Short: "Keep NetBox API tokens in the system keyring",
Long: `Store NetBox API tokens in the system keyring (Secret Service / GNOME Keyring /
KWallet on Linux, Keychain on macOS) instead of the config file. The config
then contains token: keyring, and netssh reads the token from the keyring.
NETSSH_NETBOX_TOKEN still overrides the token of the unnamed instance.`,
}
cmd.AddCommand(tokenSetCmd(), tokenMigrateCmd(), tokenDeleteCmd(), tokenStatusCmd())
return cmd
}
func tokenSetCmd() *cobra.Command {
return &cobra.Command{
Use: "set [INSTANCE]",
Short: "Store a token in the keyring and switch the config to token: keyring",
Long: "Read the token without echo (or from stdin) and store it in the keyring.\nExample for scripts: echo \"$TOKEN\" | netssh token set prod",
Args: cobra.MaximumNArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
instance, err := selectInstance(cfg, args)
if err != nil {
return err
}
token, err := readToken(instance.KeyringAccount(), cmd.InOrStdin())
if err != nil {
return err
}
if token == "" || config.IsKeyringToken(token) {
return errors.New("no token given")
}
if err := secret.Set(instance.KeyringAccount(), token); err != nil {
return err
}
instance.Token, instance.TokenVersion = config.KeyringToken, netbox.TokenVersion(token)
if err := saveConfig(*cfg); err != nil {
return err
}
fmt.Fprintf(cmd.OutOrStdout(), "Token for %s stored in the system keyring.\n", instance.KeyringAccount())
return nil
},
}
}
func tokenMigrateCmd() *cobra.Command {
return &cobra.Command{
Use: "migrate",
Short: "Move all tokens from the config file into the keyring",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
moved := 0
for _, instance := range instanceConfigs(cfg) {
if instance.Token == "" || config.IsKeyringToken(instance.Token) {
continue
}
if err := secret.Set(instance.KeyringAccount(), instance.Token); err != nil {
return err
}
instance.TokenVersion = netbox.TokenVersion(instance.Token)
instance.Token = config.KeyringToken
moved++
fmt.Fprintf(cmd.OutOrStdout(), "%s: moved to the keyring\n", instance.KeyringAccount())
}
if moved == 0 {
fmt.Fprintln(cmd.OutOrStdout(), "No tokens in the config file.")
return nil
}
return saveConfig(*cfg)
},
}
}
func tokenDeleteCmd() *cobra.Command {
return &cobra.Command{
Use: "delete [INSTANCE]",
Short: "Remove a token from the keyring",
Args: cobra.MaximumNArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
instance, err := selectInstance(cfg, args)
if err != nil {
return err
}
if err := secret.Delete(instance.KeyringAccount()); err != nil {
return err
}
fmt.Fprintf(cmd.OutOrStdout(), "Token for %s removed from the keyring.\n", instance.KeyringAccount())
if config.IsKeyringToken(instance.Token) {
fmt.Fprintln(cmd.OutOrStdout(), "The config still says token: keyring; store a new one with netssh token set.")
}
return nil
},
}
}
func tokenStatusCmd() *cobra.Command {
return &cobra.Command{
Use: "status",
Short: "Show where each instance's token comes from",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
if err != nil {
return err
}
w := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 2, ' ', 0)
fmt.Fprintln(w, "INSTANCE\tTOKEN")
for _, instance := range instanceConfigs(cfg) {
fmt.Fprintf(w, "%s\t%s\n", instance.KeyringAccount(), tokenSource(*instance))
}
return w.Flush()
},
}
}
func tokenSource(n config.NetBoxConfig) string {
switch {
case n.Token == "":
return "missing"
case config.IsKeyringToken(n.Token):
if _, err := resolveToken(n); err != nil {
return "keyring (not readable: " + err.Error() + ")"
}
return "keyring"
default:
return "config file (plain text; move it with netssh token migrate)"
}
}
+204
View File
@@ -0,0 +1,204 @@
package main
import (
"sort"
"strings"
"github.com/spf13/cobra"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh"
)
func sftpCmd() *cobra.Command {
return transferCmd(internalssh.SFTP, "sftp [--dry-run] [--jump HOST|--no-jump] [sftp options] HOST[:PATH]",
"Open an SFTP session to a NetBox host",
`Resolve HOST like netssh does for ssh (cache, shortcuts, instance/host,
SSH options and rules, jump host) and run sftp. sftp options are passed
through; note that sftp uses -P for the port.
netssh sftp fsnbx1
netssh sftp -P 2222 prod/web01:/var/log`)
}
func scpCmd() *cobra.Command {
return transferCmd(internalssh.SCP, "scp [--dry-run] [--jump HOST|--no-jump] [scp options] SOURCE... TARGET",
"Copy files to or from a NetBox host",
`Resolve the host in HOST:PATH operands like netssh does for ssh and run scp.
All remote operands must name the same host.
netssh scp ./app.tar fsnbx1:/tmp/
netssh scp -r prod/web01:/etc/nginx ./nginx`)
}
func transferCmd(client internalssh.Client, use, short, long string) *cobra.Command {
return &cobra.Command{
Use: use,
Short: short,
Long: long,
DisableFlagParsing: true,
Run: func(cmd *cobra.Command, args []string) {
if len(args) == 0 || args[0] == "--help" || args[0] == "-h" {
_ = cmd.Help()
return
}
flags, args, err := client.ExtractWrapperFlags(args)
if err != nil {
fatalf("%v", err)
}
if len(flags.Forwards) > 0 {
fatalf("--forward is only available for ssh and netssh tunnel")
}
runClient(client, flags, args)
},
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
if client.Name == internalssh.SFTP.Name && client.Parse(args) != nil {
return nil, cobra.ShellCompDirectiveNoFileComp
}
if strings.HasPrefix(toComplete, "-") {
return nil, cobra.ShellCompDirectiveNoFileComp
}
if client.Name == internalssh.SCP.Name {
if strings.Contains(toComplete, ":") {
return nil, cobra.ShellCompDirectiveNoFileComp // remote paths are not completed
}
// HOST: for remote operands; without a matching host, local files.
hosts := completeHosts(toComplete)
if len(hosts) == 0 {
return nil, cobra.ShellCompDirectiveDefault
}
for i := range hosts {
hosts[i] += ":"
}
return hosts, cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
}
return completeHosts(toComplete), cobra.ShellCompDirectiveNoFileComp
},
}
}
func tunnelCmd() *cobra.Command {
return &cobra.Command{
Use: "tunnel [--dry-run] [--jump HOST|--no-jump] [ssh options] HOST FORWARD...",
Short: "Open port forwards to a NetBox host without a shell",
Long: `Run ssh -N with the named forwards configured under ssh.forwards (globally,
per NetBox instance, or per rule). A FORWARD that is no configured name but a
port spec such as 8080:localhost:80 is used as a local forward (-L).
netssh tunnel fsnbx1 web socks
netssh tunnel prod/db01 5432:localhost:5432`,
DisableFlagParsing: true,
Run: func(cmd *cobra.Command, args []string) {
if len(args) == 0 || args[0] == "--help" || args[0] == "-h" {
_ = cmd.Help()
return
}
flags, args, err := internalssh.SSH.ExtractWrapperFlags(args)
if err != nil {
fatalf("%v", err)
}
parsed := internalssh.SSH.Parse(args)
if parsed == nil {
fatalf("usage: netssh tunnel HOST FORWARD...")
}
// Everything after the host names forwards instead of a remote command.
flags.Forwards = append(flags.Forwards, args[parsed.DestIdx+1:]...)
flags.Tunnel = true
runClient(internalssh.SSH, flags, args[:parsed.DestIdx+1])
},
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
parsed := internalssh.SSH.Parse(args)
if parsed == nil {
return completeHosts(toComplete), cobra.ShellCompDirectiveNoFileComp
}
cfg, err := config.Load()
if err != nil {
return nil, cobra.ShellCompDirectiveError
}
var names []string
if entry, ok := cachedHost(cfg, parsed.Host); ok {
names = forwardNames(hostOptions(cfg, resolvedHost{Name: entry.Name, Kind: entry.Kind, Tags: entry.Tags}))
} else {
names = allForwardNames(cfg)
}
return filterPrefix(names, toComplete, args[parsed.DestIdx+1:]), cobra.ShellCompDirectiveNoFileComp
},
}
}
// completeHosts returns the cached hosts for a completion request.
func completeHosts(toComplete string) []string {
cfg, err := config.Load()
if err != nil {
return nil
}
c := newCache(cfg)
_ = c.Load()
hosts := hostCompletions(c.All(), toComplete, cfg.Shortcuts)
for name := range cfg.Links {
if strings.HasPrefix(strings.ToLower(name), strings.ToLower(toComplete)) {
hosts = append(hosts, strings.ToLower(name))
}
}
sort.Strings(hosts)
if limit := cfg.Completion.MaxResults; limit > 0 && len(hosts) > limit {
hosts = hosts[:limit]
}
return hosts
}
// cachedHost finds a host for completion by name or shortcut, without NetBox.
func cachedHost(cfg *config.Config, host string) (cache.Entry, bool) {
c := newCache(cfg)
if err := c.Load(); err != nil {
return cache.Entry{}, false
}
if entry, _ := c.Get(host); entry.Name != "" {
return entry, true
}
if !cfg.Shortcuts.Enabled() {
return cache.Entry{}, false
}
entry, found, _, err := c.GetByShortcut(host, normalizeTarget(cfg.Shortcuts, strings.Contains(host, "/")))
return entry, found && err == nil
}
// allForwardNames lists every configured forward name, for when the host is unknown.
func allForwardNames(cfg *config.Config) []string {
seen := map[string]bool{}
add := func(o config.SSHOptions) {
for name := range o.Forwards {
seen[strings.ToLower(name)] = true
}
}
add(cfg.SSH.SSHOptions)
add(cfg.NetBox.SSH)
for _, source := range cfg.NetBoxes {
add(source.SSH)
}
for _, rule := range cfg.SSH.Rules {
add(rule.SSHOptions)
}
names := make([]string, 0, len(seen))
for name := range seen {
names = append(names, name)
}
sort.Strings(names)
return names
}
// filterPrefix keeps the names starting with prefix that were not given yet.
func filterPrefix(names []string, prefix string, given []string) []string {
used := map[string]bool{}
for _, name := range given {
used[strings.ToLower(name)] = true
}
var out []string
for _, name := range names {
if strings.HasPrefix(name, strings.ToLower(prefix)) && !used[name] {
out = append(out, name)
}
}
return out
}
+130
View File
@@ -0,0 +1,130 @@
package main
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// TestNetsshHelper runs main() with the arguments in NETSSH_TEST_ARGS.
func TestNetsshHelper(t *testing.T) {
if args := os.Getenv("NETSSH_TEST_ARGS"); args != "" {
os.Args = append([]string{"netssh"}, strings.Split(args, "\x1f")...)
main()
os.Exit(0)
}
}
// prepareTransferTest writes a config whose only host is cached; NetBox is
// unreachable, so every result must come from cache, shortcuts, and options.
func prepareTransferTest(t *testing.T) {
t.Helper()
dir := t.TempDir()
t.Setenv("HOME", t.TempDir())
t.Setenv("XDG_CONFIG_HOME", dir)
t.Setenv("XDG_CACHE_HOME", t.TempDir())
t.Setenv("NETSSH_NETBOX_URL", "")
t.Setenv("NETSSH_NETBOX_TOKEN", "")
t.Setenv("NETSSH_CACHE_PATH", filepath.Join(t.TempDir(), "hosts.json"))
t.Setenv("NETSSH_SHELL_ALIAS", "")
data := `netbox:
url: http://127.0.0.1:1
token: t
ssh:
default_user: ops
default_port: 2222
extra_args: ["-A"]
forwards:
web: {local: "8080:localhost:80"}
rules:
- match: {tag: dmz}
proxy_jump: jh.example.com
forwards:
socks: {dynamic: "1080"}
shortcuts:
domains: [.hoster.de]
rewrites:
- pattern: '^([a-z]+)[0-9]+-'
replace: '$1'
`
if err := os.WriteFile(filepath.Join(dir, "netssh.yaml"), []byte(data), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := config.Load()
if err != nil {
t.Fatal(err)
}
c := cache.New(cfg.CachePath(), 3600)
c.Upsert(cache.Entry{Name: "fsn1-bx1.hoster.de", IP: "10.0.0.9", Kind: "device", Tags: []string{"dmz"}})
if err := c.Save(); err != nil {
t.Fatal(err)
}
}
func runNetssh(t *testing.T, args ...string) (string, error) {
t.Helper()
cmd := exec.Command(os.Args[0], "-test.run=^TestNetsshHelper$")
cmd.Env = append(os.Environ(), "NETSSH_TEST_ARGS="+strings.Join(args, "\x1f"))
out, err := cmd.CombinedOutput()
return strings.TrimSpace(string(out)), err
}
func TestTransferAndTunnelCommands(t *testing.T) {
prepareTransferTest(t)
for _, tc := range []struct {
args []string
want string
}{
// sftp: -P and -o User, rule jump host, path kept, no ssh-only extra_args.
{[]string{"sftp", "--dry-run", "fsnbx1:/var/log"}, "sftp -P 2222 -o User=ops -J jh.example.com 10.0.0.9:/var/log"},
{[]string{"sftp", "--dry-run", "-P", "22", "root@fsnbx1"}, "sftp -P 22 -J jh.example.com root@10.0.0.9"},
{[]string{"scp", "--dry-run", "-r", "a.txt", "fsn1-bx1.hoster.de:/tmp/"}, "scp -P 2222 -o User=ops -r -J jh.example.com a.txt 10.0.0.9:/tmp/"},
{[]string{"scp", "--dry-run", "--no-jump", "fsnbx1:/etc/hosts", "."}, "scp -P 2222 -o User=ops -o ProxyJump=none 10.0.0.9:/etc/hosts ."},
// Forwards come from the global options and the matching rule.
{[]string{"tunnel", "--dry-run", "fsnbx1", "web", "socks", "5432:db:5432"}, "ssh -A -p 2222 -l ops -J jh.example.com -L 8080:localhost:80 -D 1080 -L 5432:db:5432 -o ExitOnForwardFailure=yes -N 10.0.0.9"},
{[]string{"--dry-run", "--forward", "web", "fsnbx1"}, "ssh -A -p 2222 -l ops -J jh.example.com -L 8080:localhost:80 10.0.0.9"},
} {
out, err := runNetssh(t, tc.args...)
if err != nil || out != tc.want {
t.Errorf("%v:\n got %s (%v)\n want %s", tc.args, out, err, tc.want)
}
}
for _, tc := range []struct {
args []string
want string
}{
{[]string{"tunnel", "--dry-run", "fsnbx1"}, "forwards for fsn1-bx1.hoster.de: socks, web"},
{[]string{"tunnel", "--dry-run", "fsnbx1", "db"}, `unknown forward "db"; available: socks, web`},
{[]string{"sftp", "--forward", "web", "fsnbx1"}, "only available for ssh"},
{[]string{"scp", "fsnbx1:a", "other:b"}, "not supported"},
} {
out, err := runNetssh(t, tc.args...)
if err == nil || !strings.Contains(out, tc.want) {
t.Errorf("%v: got %s (%v), want error containing %q", tc.args, out, err, tc.want)
}
}
}
func TestTransferCompletion(t *testing.T) {
prepareTransferTest(t)
for _, tc := range []struct {
args []string
want string
}{
{[]string{"__complete", "sftp", "fsnb"}, "fsnbx1\n"},
{[]string{"__complete", "scp", "a.txt", "fsnb"}, "fsnbx1:\n"},
{[]string{"__complete", "tunnel", "fsnbx1", ""}, "socks\nweb\n"},
{[]string{"__complete", "tunnel", "fsnbx1", "web", ""}, "socks\n"},
{[]string{"__complete", "--forward", ""}, "socks\nweb\n"},
} {
out, err := runNetssh(t, tc.args...)
if err != nil || !strings.HasPrefix(out+"\n", tc.want) {
t.Errorf("%v: got %q (%v), want prefix %q", tc.args, out, err, tc.want)
}
}
}
+87
View File
@@ -0,0 +1,87 @@
package main
import (
"context"
"fmt"
"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"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/tui"
)
// configureTUIExtras wires reachability, the detail view and opening NetBox
// pages into the TUI. known enriches a listed host from the cache.
func configureTUIExtras(m *tui.Model, cfg *config.Config, client *netbox.Client, known func(name, kind string, tags []string) resolvedHost) {
m.SetColumns(cfg.TUI.EffectiveColumns())
if cfg.TUI.ReachabilityEnabled() {
m.SetReachability(cfg.TUI.ReachabilityTimeoutDuration(), func(name, kind string, tags []string) (int, bool) {
h := known(name, kind, tags)
if usesJumpHost(hostOptions(cfg, h), internalssh.WrapperFlags{}) {
return 0, false
}
_, port := hostDefaults(cfg, h)
if port <= 0 {
port = 22
}
return port, true
})
}
lookup := func(ctx context.Context, name, kind string, id int) (netbox.HostEntry, resolvedHost, error) {
h := known(name, kind, nil)
if kind == config.StaticKind {
return netbox.HostEntry{}, h, fmt.Errorf("%s is a static host and has no NetBox record", name)
}
if client == nil {
return netbox.HostEntry{}, h, fmt.Errorf("no NetBox is configured")
}
if id <= 0 {
id = h.ID
}
entry, _, h, err := netboxEntry(ctx, client, name, kind, id, h)
return entry, h, err
}
m.SetOpener(func(name, kind string, id int) error {
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
entry, _, err := lookup(ctx, name, kind, id)
if err != nil {
return err
}
url, err := client.WebURL(entry)
if err != nil {
return err
}
return openBrowser(url)
})
m.SetDetails(func(name, kind string, id int) (string, error) {
if kind == config.StaticKind {
h := known(name, kind, nil)
user, port := hostDefaults(cfg, h)
text := fmt.Sprintf("%s (static host from hosts:)\n Address %s\n", name, h.IP)
if user != "" {
text += " User " + user + "\n"
}
if port > 0 {
text += fmt.Sprintf(" Port %d\n", port)
}
return text, nil
}
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
entry, h, err := lookup(ctx, name, kind, id)
if err != nil {
return "", err
}
details, err := client.GetDetails(ctx, entry)
if err != nil && details.Name == "" {
return "", err
}
text := formatDetails(details, h)
if err != nil {
text += "\nwarning: " + err.Error() + "\n"
}
return text, nil
})
}
+4 -3
View File
@@ -71,6 +71,7 @@ func buildUninstallPlan(cfg *config.Config, keepConfig bool) uninstallPlan {
addPath(path)
addPath(path + ".lock")
addPath(filepath.Join(filepath.Dir(path), "last_refresh"))
addPath(filepath.Join(filepath.Dir(path), "refresh_attempt"))
if strings.HasPrefix(filepath.Base(filepath.Dir(path)), "instances-") {
addPath(filepath.Dir(path))
}
@@ -203,10 +204,10 @@ func uninstallCmd() *cobra.Command {
- netssh blocks and unmarked entries of older versions in bash, zsh, and fish profiles
- shell completion files (bash, zsh, fish, oh-my-zsh cache, command alias)
- the cache directory with hosts, aliases, and per-instance caches
- the config file (a private backup is kept) and local server notes
- the config file (a private backup is kept) and local notes, favorites, action history and batch retry state
- the netssh binary
Use --keep-config to keep the config file and notes for a reinstall.`,
Use --keep-config to keep the config file and local state for a reinstall.`,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
cfg, err := config.Load()
@@ -243,7 +244,7 @@ Use --keep-config to keep the config file and notes for a reinstall.`,
return err
},
}
cmd.Flags().BoolVar(&keepConfig, "keep-config", false, "Keep the config file and local notes")
cmd.Flags().BoolVar(&keepConfig, "keep-config", false, "Keep the config file and local state")
cmd.Flags().BoolVarP(&yes, "yes", "y", false, "Do not ask for confirmation")
cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Only show what would be removed")
return cmd
+14 -11
View File
@@ -1,15 +1,18 @@
module git.zb-server.de/Sebi/ssh-netbox-wrapper
go 1.27.3
go 1.27.4
require (
charm.land/bubbles/v2 v2.2.1
charm.land/bubbletea/v2 v2.1.0
charm.land/bubbletea/v2 v2.1.2
charm.land/huh/v2 v2.0.3
charm.land/lipgloss/v2 v2.0.6
charm.land/lipgloss/v2 v2.1.1
github.com/charmbracelet/x/term v0.2.2
github.com/spf13/cobra v1.10.2
github.com/spf13/viper v1.21.0
golang.org/x/sys v0.49.0
github.com/zalando/go-keyring v0.2.8
go.yaml.in/yaml/v3 v3.0.6
golang.org/x/sys v0.50.0
)
require (
@@ -17,19 +20,20 @@ require (
github.com/catppuccin/go v0.3.0 // indirect
github.com/charmbracelet/colorprofile v0.4.3 // indirect
github.com/charmbracelet/ultraviolet v0.0.0-20261023060817-a45b7c86333f // indirect
github.com/charmbracelet/x/ansi v0.11.9 // indirect
github.com/charmbracelet/x/ansi v0.11.10 // indirect
github.com/charmbracelet/x/exp/golden v0.1.0 // indirect
github.com/charmbracelet/x/exp/ordered v0.1.0 // indirect
github.com/charmbracelet/x/exp/strings v0.1.0 // indirect
github.com/charmbracelet/x/term v0.2.2 // indirect
github.com/charmbracelet/x/termios v0.1.1 // indirect
github.com/charmbracelet/x/windows v0.2.2 // indirect
github.com/charmbracelet/x/xpty v0.1.4 // indirect
github.com/clipperhouse/displaywidth v0.11.0 // indirect
github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
github.com/danieljoos/wincred v1.2.3 // indirect
github.com/dustin/go-humanize v1.1.0 // indirect
github.com/fsnotify/fsnotify v1.10.1 // indirect
github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
github.com/godbus/dbus/v5 v5.2.4 // indirect
github.com/google/go-cmp v0.7.0 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/lucasb-eyer/go-colorful v1.4.1 // indirect
@@ -43,11 +47,10 @@ require (
github.com/sahilm/fuzzy v0.1.3 // indirect
github.com/spf13/afero v1.15.0 // indirect
github.com/spf13/cast v1.10.0 // indirect
github.com/spf13/pflag v1.0.10 // indirect
github.com/spf13/pflag v1.1.0 // indirect
github.com/stretchr/testify v1.12.1 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
github.com/xo/terminfo v1.2.1 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/sync v0.24.0 // indirect
golang.org/x/text v0.43.0 // indirect
github.com/xo/terminfo v1.3.1 // indirect
golang.org/x/sync v0.25.0 // indirect
golang.org/x/text v0.44.0 // indirect
)
+26 -18
View File
@@ -1,11 +1,11 @@
charm.land/bubbles/v2 v2.2.1 h1:Fq1+qm5hV6GkvzLQDhCBpXXE5tLgvh1PRriCLwSvIQU=
charm.land/bubbles/v2 v2.2.1/go.mod h1:wdMgn+sje1KNXdwFizIWjbf328fIUBxqEmJ/vYPo8yc=
charm.land/bubbletea/v2 v2.1.0 h1:A9fj9h5LFrvQhQHFNggp8K8rvY6CUfgn9dMbb6p2HIw=
charm.land/bubbletea/v2 v2.1.0/go.mod h1:xWHeyxIX9/wiFU2kgPW04ojOZyTzrWf+8lGjUCaftiU=
charm.land/bubbletea/v2 v2.1.2 h1:vB3XAcHhLB2gR3HOHpwO3lHB3nbvaowIgL3e5x/DUZo=
charm.land/bubbletea/v2 v2.1.2/go.mod h1:xWHeyxIX9/wiFU2kgPW04ojOZyTzrWf+8lGjUCaftiU=
charm.land/huh/v2 v2.0.3 h1:2cJsMqEPwSywGHvdlKsJyQKPtSJLVnFKyFbsYZTlLkU=
charm.land/huh/v2 v2.0.3/go.mod h1:93eEveeeqn47MwiC3tf+2atZ2l7Is88rAtmZNZ8x9Wc=
charm.land/lipgloss/v2 v2.0.6 h1:EaGKeuA8FvF+v2BT5VmZd2LoYLaMZJXA5n34th8nCIQ=
charm.land/lipgloss/v2 v2.0.6/go.mod h1:ipDDJNSGa1hlwDtSfW1s2/xR8Vdhbut4PXh2zEKZd0Q=
charm.land/lipgloss/v2 v2.1.1 h1:F+vKWis9Kz3MFRsbICSDFtT1ZwVL+8f+36Dtg+OpKwc=
charm.land/lipgloss/v2 v2.1.1/go.mod h1:k79y/56yThpkJvbwyrcHr8MyZF42e84Q5fW9Ibu6LFc=
github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
@@ -18,8 +18,8 @@ github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex
github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=
github.com/charmbracelet/ultraviolet v0.0.0-20261023060817-a45b7c86333f h1:D2JpB65eehsnkEwEG401dMBSNYtTDgvKXZZSl7ZCxWI=
github.com/charmbracelet/ultraviolet v0.0.0-20261023060817-a45b7c86333f/go.mod h1:aJDVk+WOVM1K04rdc/71PMPoUGfjxjhvXfP3Pjz1Zio=
github.com/charmbracelet/x/ansi v0.11.9 h1:kIrqLBxtTVbLyyHO2Evoi93EjQo1mylWmpNEsfPxXAM=
github.com/charmbracelet/x/ansi v0.11.9/go.mod h1:DG/hpOnaI2QJ/KMMqLL2h0KVhluuJLazf8973P+Vy5w=
github.com/charmbracelet/x/ansi v0.11.10 h1:GjcX3+rAk+8wDX/jY0XwrZstxkjRcLkYU3TvwzZWiRA=
github.com/charmbracelet/x/ansi v0.11.10/go.mod h1:DG/hpOnaI2QJ/KMMqLL2h0KVhluuJLazf8973P+Vy5w=
github.com/charmbracelet/x/conpty v0.2.0 h1:eKtA2hm34qNfgJCDp/M6Dc0gLy7e07YEK4qAdNGOvVY=
github.com/charmbracelet/x/conpty v0.2.0/go.mod h1:fexgUnVrZgw8scD49f6VSi0Ggj9GWYIrpedRthAwW/8=
github.com/charmbracelet/x/exp/golden v0.1.0 h1:qgUxGaHX4I8Fg077vD+54+qFmDWrgO19lTCQLblHWko=
@@ -43,6 +43,8 @@ github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJ
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
github.com/danieljoos/wincred v1.2.3 h1:v7dZC2x32Ut3nEfRH+vhoZGvN72+dQ/snVXo/vMFLdQ=
github.com/danieljoos/wincred v1.2.3/go.mod h1:6qqX0WNrS4RzPZ1tnroDzq9kY3fu1KwE7MRLQK4X0bs=
github.com/dustin/go-humanize v1.1.0 h1:dbKTrvD0klcbBV/h4AWJdMuZogJACoMlvWIWZ5b2xWg=
github.com/dustin/go-humanize v1.1.0/go.mod h1:hc1CvRkJMsgxqjmjMQF3QNRAZBwY8AXBAzKYoSX9sFI=
github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
@@ -51,6 +53,8 @@ github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx5
github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=
github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
github.com/godbus/dbus/v5 v5.2.4 h1:F2gUCy++NMIxGmo9J+z5le/+ZC8W1OgeR51P4i9ZB/U=
github.com/godbus/dbus/v5 v5.2.4/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -87,23 +91,27 @@ github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qq
github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/pflag v1.1.0 h1:6W6MbVUrnMb8PEhjkqwsVLY7ryuzRfFHF4mQd7L94ag=
github.com/spf13/pflag v1.1.0/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=
github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
github.com/xo/terminfo v1.2.1 h1:e5fQoon4xY/NK3LJzcF8me+JaknbLD8zjtRWm0uvxtw=
github.com/xo/terminfo v1.2.1/go.mod h1:lGzkSo8Fe7IRh/w+Gqz7n5mDog4FVXCj3gy/DYTBqio=
github.com/xo/terminfo v1.3.1 h1:4ZwPCuu4PEFw0PkNp3Hv/x3gqvgLCzYhurszsj101cM=
github.com/xo/terminfo v1.3.1/go.mod h1:lGzkSo8Fe7IRh/w+Gqz7n5mDog4FVXCj3gy/DYTBqio=
github.com/zalando/go-keyring v0.2.8 h1:6sD/Ucpl7jNq10rM2pgqTs0sZ9V3qMrqfIIy5YPccHs=
github.com/zalando/go-keyring v0.2.8/go.mod h1:tsMo+VpRq5NGyKfxoBVjCuMrG47yj8cmakZDO5QGii0=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
go.yaml.in/yaml/v3 v3.0.6 h1:zcDfvjXEqTQmpjniUBLc91xYJMB2c4QOFxEF/LCEckM=
go.yaml.in/yaml/v3 v3.0.6/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/sync v0.25.0 h1:dJnifr0nMV8/SBnBvdo4eSGGnrc3O4FFx6IqvtLcmRs=
golang.org/x/sync v0.25.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs=
golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo=
golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+94
View File
@@ -0,0 +1,94 @@
// Package activity stores local preferences and optional execution metadata.
// No command arguments, environment variables, tokens or command output are logged.
package activity
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"sort"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
"golang.org/x/sys/unix"
)
type Record struct {
Time time.Time `json:"time"`
Host string `json:"host"`
Command string `json:"command"`
Code int `json:"exit_code"`
Duration time.Duration `json:"duration_ns"`
}
type State struct {
Favorites map[string]bool `json:"favorites,omitempty"`
Pinned map[string]bool `json:"pinned,omitempty"`
Records []Record `json:"records,omitempty"`
}
func Path() string { return filepath.Join(filepath.Dir(config.Path()), "netssh", "activity.json") }
func Read() (State, error) {
var s State
data, err := os.ReadFile(Path())
if os.IsNotExist(err) {
err = nil
} else if err == nil {
err = json.Unmarshal(data, &s)
}
if s.Favorites == nil {
s.Favorites = map[string]bool{}
}
if s.Pinned == nil {
s.Pinned = map[string]bool{}
}
return s, err
}
func Update(change func(*State)) error {
p := Path()
if err := os.MkdirAll(filepath.Dir(p), 0700); err != nil {
return err
}
f, err := os.OpenFile(p+".lock", os.O_CREATE|os.O_RDWR, 0600)
if err != nil {
return err
}
defer f.Close()
if err = unix.Flock(int(f.Fd()), unix.LOCK_EX); err != nil {
return err
}
defer unix.Flock(int(f.Fd()), unix.LOCK_UN)
s, err := Read()
if err != nil {
return fmt.Errorf("local state: %w", err)
}
change(&s)
data, err := json.MarshalIndent(s, "", " ")
if err != nil {
return err
}
return storage.WriteFile(p, data, 0600)
}
func Prune(s *State, c config.ActivityConfig) {
if c.RetentionDays > 0 {
cutoff := time.Now().Add(-time.Duration(c.RetentionDays) * 24 * time.Hour)
keep := s.Records[:0]
for _, r := range s.Records {
if !r.Time.Before(cutoff) {
keep = append(keep, r)
}
}
s.Records = keep
}
sort.SliceStable(s.Records, func(i, j int) bool { return s.Records[i].Time.Before(s.Records[j].Time) })
if c.MaxEntries > 0 && len(s.Records) > c.MaxEntries {
s.Records = s.Records[len(s.Records)-c.MaxEntries:]
}
}
func Append(c config.ActivityConfig, r Record) error {
if !c.Enabled {
return nil
}
return Update(func(s *State) { s.Records = append(s.Records, r); Prune(s, c) })
}
+59
View File
@@ -0,0 +1,59 @@
package activity
import (
"fmt"
"os"
"sync"
"testing"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func TestConcurrentActivityAndRetention(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
cfg := config.ActivityConfig{Enabled: true, RetentionDays: 1, MaxEntries: 10}
if err := Update(func(s *State) {
s.Favorites["prod/web"] = true
s.Pinned["prod/web"] = true
s.Records = []Record{{Time: time.Now().Add(-48 * time.Hour), Host: "old"}}
}); err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
for i := 0; i < 20; i++ {
wg.Add(1)
go func() {
defer wg.Done()
if err := Append(cfg, Record{Time: time.Now(), Host: fmt.Sprint(i), Command: "test"}); err != nil {
t.Error(err)
}
}()
}
wg.Wait()
s, err := Read()
if err != nil {
t.Fatal(err)
}
if len(s.Records) != 10 || !s.Favorites["prod/web"] || !s.Pinned["prod/web"] {
t.Fatalf("%+v", s)
}
for _, r := range s.Records {
if r.Host == "old" {
t.Fatal("expired record retained")
}
}
info, _ := os.Stat(Path())
if info.Mode().Perm() != 0600 {
t.Fatal(info.Mode())
}
}
func TestDisabledHistoryDoesNotWrite(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
if err := Append(config.ActivityConfig{}, Record{}); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(Path()); !os.IsNotExist(err) {
t.Fatal("disabled history wrote data")
}
}
+150 -9
View File
@@ -12,16 +12,34 @@ import (
"golang.org/x/sys/unix"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
)
type Entry struct {
Name string `json:"name"`
IP string `json:"ip"`
Kind string `json:"kind"`
Tags []string `json:"tags,omitempty"`
CachedAt time.Time `json:"cached_at"`
LastUsed time.Time `json:"last_used,omitempty"`
Resolver string `json:"resolver,omitempty"`
Name string `json:"name"`
IP string `json:"ip"`
Kind string `json:"kind"`
Tags []string `json:"tags,omitempty"`
Cluster string `json:"cluster,omitempty"`
// ID, Status, Site, Role, Platform and Tenant come from NetBox; entries
// written by older versions lack them until the next refresh.
ID int `json:"id,omitempty"`
Status string `json:"status,omitempty"`
Site *config.Ref `json:"site,omitempty"`
Role *config.Ref `json:"role,omitempty"`
Platform *config.Ref `json:"platform,omitempty"`
Tenant *config.Ref `json:"tenant,omitempty"`
// Location is the chain of nested locations below the site, outermost first.
Location []config.Ref `json:"location,omitempty"`
Rack string `json:"rack,omitempty"`
Position string `json:"position,omitempty"`
CachedAt time.Time `json:"cached_at"`
LastUsed time.Time `json:"last_used,omitempty"`
// Static marks a host from the config's hosts: list. It never expires;
// it is stored only to remember LastUsed for the recently-used list.
Static bool `json:"static,omitempty"`
}
type changeKind uint8
@@ -40,6 +58,7 @@ type Cache struct {
path string
ttl time.Duration
refreshStamp string // path to last_refresh timestamp file
static []config.StaticHost
}
type diskFormat struct {
@@ -77,6 +96,26 @@ func (c *Cache) NeedsRefresh(d time.Duration) bool {
return time.Since(t) >= d
}
// ClaimRefresh reports whether a background refresh should start now: the last
// full refresh is older than d and no attempt was claimed within retry. It
// records the attempt, so parallel shells and repeated commands start one
// refresh per retry interval instead of one each.
func (c *Cache) ClaimRefresh(d, retry time.Duration) bool {
if !c.NeedsRefresh(d) {
return false
}
attempt := filepath.Join(filepath.Dir(c.refreshStamp), "refresh_attempt")
if info, err := os.Stat(attempt); err == nil && time.Since(info.ModTime()) < retry {
return false
}
if err := os.MkdirAll(filepath.Dir(attempt), 0o755); err != nil {
return true // cannot record the attempt; refreshing is still right
}
// Best effort: two processes racing here may both refresh once.
_ = os.WriteFile(attempt, nil, 0o600)
return true
}
// SetRefreshed records the current time as the last successful full refresh.
func (c *Cache) SetRefreshed() error {
if c.refreshStamp == "" {
@@ -98,6 +137,7 @@ func (c *Cache) Load() error {
data, err := os.ReadFile(c.path)
if os.IsNotExist(err) {
c.applyStatic()
return nil
}
if err != nil {
@@ -115,6 +155,7 @@ func (c *Cache) Load() error {
for _, e := range df.Entries {
c.entries[e.Name] = e
}
c.applyStatic()
return nil
}
@@ -188,6 +229,15 @@ func (c *Cache) Save() error {
if err := storage.WriteFile(c.path, data, 0o600); err != nil {
return err
}
// Static hosts come from the config, not the file: keep them in memory.
for name, e := range c.entries {
if e.Static {
if old, ok := merged[name]; ok && old.LastUsed.After(e.LastUsed) {
e.LastUsed = old.LastUsed
}
merged[name] = e
}
}
c.entries = merged
c.dirty = make(map[string]changeKind)
c.cleared = false
@@ -221,7 +271,10 @@ func (c *Cache) MarkUsed(name string) {
if e, ok := c.entries[name]; ok {
e.LastUsed = time.Now()
c.entries[name] = e
if _, changed := c.dirty[name]; !changed {
if e.Static {
// A static host may not be on disk yet; usage alone would not add it.
c.dirty[name] = upsertChange
} else if _, changed := c.dirty[name]; !changed {
c.dirty[name] = usageChange
}
}
@@ -279,7 +332,7 @@ func (c *Cache) GetByShortcut(shortcut string, normalize func(string) string) (e
entry, found = e, true
}
}
return entry, found, found && c.ttl > 0 && time.Since(entry.CachedAt) < c.ttl, nil
return entry, found, found && (entry.Static || c.ttl > 0 && time.Since(entry.CachedAt) < c.ttl), nil
}
// Get returns an entry and reports whether it is still within the TTL.
@@ -291,20 +344,92 @@ func (c *Cache) Get(name string) (entry Entry, fresh bool) {
if !ok {
return Entry{}, false
}
if e.Static {
return e, true
}
if c.ttl == 0 {
return e, false
}
return e, time.Since(e.CachedAt) < c.ttl
}
// Clear removes all NetBox entries; static hosts come from the config and stay.
func (c *Cache) Clear() {
c.mu.Lock()
c.entries = make(map[string]Entry)
static := make(map[string]Entry)
for name, e := range c.entries {
if e.Static {
static[name] = e
}
}
c.entries = static
c.dirty = make(map[string]changeKind)
c.cleared = true
c.mu.Unlock()
}
// SetStatic adds the config's static hosts. They replace cached entries of the
// same name, keep their recorded LastUsed, and static entries that are no
// longer configured are removed on the next Save.
func (c *Cache) SetStatic(hosts []config.StaticHost) {
c.mu.Lock()
defer c.mu.Unlock()
c.static = hosts
c.applyStatic()
}
// WithStatic sets the static hosts now and after every Load.
func (c *Cache) WithStatic(hosts []config.StaticHost) *Cache {
c.SetStatic(hosts)
return c
}
func (c *Cache) applyStatic() {
hosts := c.static
configured := make(map[string]bool, len(hosts))
for _, host := range hosts {
e := Entry{Name: host.Name, IP: host.Address, Kind: config.StaticKind, Tags: host.Tags, CachedAt: time.Now(), Static: true}
if old, ok := c.entries[host.Name]; ok && old.Static {
e.LastUsed = old.LastUsed
}
c.entries[host.Name] = e
configured[host.Name] = true
}
for name, e := range c.entries {
if e.Static && !configured[name] {
delete(c.entries, name)
c.dirty[name] = deleteChange
}
}
}
// GetStatic finds a static host by name or by shortcut. Static hosts are
// checked before NetBox, so they also work when NetBox is unreachable.
func (c *Cache) GetStatic(name string, normalize func(string) string) (Entry, bool, error) {
c.mu.RLock()
defer c.mu.RUnlock()
var match Entry
found := false
for key, e := range c.entries {
if e.Static && strings.EqualFold(key, name) {
return e, true, nil
}
}
if normalize == nil {
return Entry{}, false, nil
}
short := normalize(name)
for _, e := range c.entries {
if e.Static && normalize(e.Name) == short {
if found {
return Entry{}, false, fmt.Errorf("ambiguous shortcut %q; use a full hostname", name)
}
match, found = e, true
}
}
return match, found, nil
}
func (c *Cache) All() []Entry {
c.mu.RLock()
defer c.mu.RUnlock()
@@ -314,3 +439,19 @@ func (c *Cache) All() []Entry {
}
return out
}
// RefPtr returns nil for an empty reference, keeping the cache file small.
func RefPtr(r config.Ref) *config.Ref {
if r == (config.Ref{}) {
return nil
}
return &r
}
// RefOf returns the referenced value, or an empty Ref.
func RefOf(r *config.Ref) config.Ref {
if r == nil {
return config.Ref{}
}
return *r
}
+82
View File
@@ -4,8 +4,11 @@ import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func TestNew(t *testing.T) {
@@ -495,3 +498,82 @@ func TestSearchMatchesHostnamesAcrossQualifiedSources(t *testing.T) {
}
}
}
func TestStaticHosts(t *testing.T) {
path := filepath.Join(t.TempDir(), "hosts.json")
hosts := []config.StaticHost{{Name: "router", Address: "192.168.1.1", Tags: []string{"home"}}, {Name: "nas", Address: "nas.lan"}}
c := New(path, 1).WithStatic(hosts)
c.Upsert(Entry{Name: "web01", IP: "10.0.0.1", Kind: "device"})
if err := c.Load(); err != nil { // no file yet; static hosts stay
t.Fatal(err)
}
if e, fresh := c.Get("router"); !fresh || e.IP != "192.168.1.1" || e.Kind != config.StaticKind || !e.Static {
t.Fatalf("static get: %+v %v", e, fresh)
}
if e, found, err := c.GetStatic("ROUTER", nil); !found || err != nil || e.Name != "router" {
t.Fatalf("by name: %+v %v %v", e, found, err)
}
normalize := func(s string) string { return strings.TrimSuffix(strings.ToLower(s), ".lan") }
if e, found, _ := c.GetStatic("nas.lan", normalize); !found || e.Name != "nas" {
t.Fatalf("by shortcut: %+v", e)
}
if _, found, _ := c.GetStatic("web01", normalize); found {
t.Fatal("NetBox entry returned as static")
}
// Usage of a static host persists; the host itself stays after Save and Clear.
c.MarkUsed("router")
if err := c.Save(); err != nil {
t.Fatal(err)
}
if _, fresh := c.Get("nas"); !fresh {
t.Fatal("static host lost after Save")
}
reloaded := New(path, 1).WithStatic(hosts)
if err := reloaded.Load(); err != nil {
t.Fatal(err)
}
if recent := reloaded.RecentlyUsed(5); len(recent) != 1 || recent[0].Name != "router" {
t.Fatalf("recent: %+v", recent)
}
reloaded.Clear()
if _, fresh := reloaded.Get("router"); !fresh {
t.Fatal("Clear removed a static host")
}
// A host removed from the config disappears, also from the file.
removed := New(path, 1).WithStatic(hosts[1:])
if err := removed.Load(); err != nil {
t.Fatal(err)
}
if e, _ := removed.Get("router"); e.Name != "" {
t.Fatalf("removed static host still present: %+v", e)
}
if err := removed.Save(); err != nil {
t.Fatal(err)
}
data, _ := os.ReadFile(path)
if strings.Contains(string(data), "192.168.1.1") {
t.Fatalf("removed static host still on disk:\n%s", data)
}
}
func TestClaimRefreshThrottlesAttempts(t *testing.T) {
c := New(filepath.Join(t.TempDir(), "netssh", "hosts.json"), 60)
if !c.ClaimRefresh(24*time.Hour, time.Minute) {
t.Fatal("a never refreshed cache must claim a refresh")
}
// NetBox is down: the stamp stays stale, but the attempt is remembered.
if c.ClaimRefresh(24*time.Hour, time.Minute) {
t.Error("a second refresh within the retry interval must not start")
}
if !c.ClaimRefresh(24*time.Hour, 0) {
t.Error("after the retry interval a refresh must start again")
}
if err := c.SetRefreshed(); err != nil {
t.Fatal(err)
}
if c.ClaimRefresh(24*time.Hour, 0) {
t.Error("a freshly refreshed cache must not claim a refresh")
}
}
+73
View File
@@ -0,0 +1,73 @@
package config
import (
"fmt"
"regexp"
"strings"
"time"
)
// HostCommand defines a local command and the prefix of its generated host aliases.
type HostCommand struct {
PostRun string `mapstructure:"post_run"`
Match SSHMatch `mapstructure:"match"`
Confirm bool `mapstructure:"confirm"`
Timeout string `mapstructure:"timeout"`
AliasPrefix string `mapstructure:"alias_prefix" yaml:"alias_prefix"`
Args []string `mapstructure:"args" yaml:"args"`
}
func (c *Config) ValidateCommands() error {
prefixes := make(map[string]bool)
for name, command := range c.Commands {
if strings.ContainsRune(command.PostRun, 0) {
return fmt.Errorf("commands.%s.post_run contains NUL", name)
}
if command.Match != (SSHMatch{}) {
if err := command.Match.Validate("commands." + name); err != nil {
return err
}
}
if command.Timeout != "" {
d, err := time.ParseDuration(command.Timeout)
if err != nil || d <= 0 {
return fmt.Errorf("commands.%s.timeout requires a positive duration", name)
}
}
if name == "" || ValidateCommandAlias(name) != nil {
return fmt.Errorf("commands.%s: name must be a non-reserved shell identifier", name)
}
if command.AliasPrefix != "" {
if !regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`).MatchString(command.AliasPrefix) {
return fmt.Errorf("commands.%s.alias_prefix must be a shell identifier", name)
}
if prefixes[command.AliasPrefix] {
return fmt.Errorf("commands.%s: duplicate alias_prefix %q", name, command.AliasPrefix)
}
prefixes[command.AliasPrefix] = true
}
if len(command.Args) == 0 || strings.TrimSpace(command.Args[0]) == "" {
return fmt.Errorf("commands.%s.args requires an executable", name)
}
target := false
for i, arg := range command.Args {
if strings.ContainsRune(arg, 0) {
return fmt.Errorf("commands.%s.args cannot contain NUL", name)
}
if i == 0 && strings.ContainsAny(arg, "{}") {
return fmt.Errorf("commands.%s: executable cannot contain placeholders", name)
}
if strings.Contains(arg, "{host}") || strings.Contains(arg, "{address}") || strings.Contains(arg, "{target}") {
target = true
}
rest := strings.NewReplacer("{host}", "", "{address}", "", "{target}", "").Replace(arg)
if strings.ContainsAny(rest, "{}") {
return fmt.Errorf("commands.%s: supported placeholders are {host}, {address}, {target}", name)
}
}
if !target {
return fmt.Errorf("commands.%s.args requires {host}, {address}, or {target}", name)
}
}
return nil
}
+37
View File
@@ -0,0 +1,37 @@
package config
import "testing"
func TestValidateCommands(t *testing.T) {
for _, tc := range []struct {
name string
command HostCommand
valid bool
}{
{"mtr", HostCommand{AliasPrefix: "m", Args: []string{"mtr", "{address}"}}, true},
{"ping", HostCommand{Args: []string{"ping", "-c", "3", "{host}"}}, true},
{"inspect", HostCommand{Args: []string{"echo", "{target}"}}, true},
{"", HostCommand{Args: []string{"echo", "{host}"}}, false},
{"bad name", HostCommand{Args: []string{"echo", "{host}"}}, false},
{"netssh", HostCommand{Args: []string{"echo", "{host}"}}, false},
{"bad", HostCommand{AliasPrefix: "m;", Args: []string{"mtr", "{address}"}}, false},
{"bad", HostCommand{}, false},
{"bad", HostCommand{Args: []string{"", "{host}"}}, false},
{"bad", HostCommand{Args: []string{"{host}", "{address}"}}, false},
{"bad", HostCommand{Args: []string{"mtr", "{adress}"}}, false},
{"bad", HostCommand{Args: []string{"mtr"}}, false},
{"bad", HostCommand{Args: []string{"mtr", "{host}\x00"}}, false},
} {
cfg := Config{Commands: map[string]HostCommand{tc.name: tc.command}}
if err := cfg.ValidateCommands(); (err == nil) != tc.valid {
t.Errorf("%+v: %v", tc, err)
}
}
cfg := Config{Commands: map[string]HostCommand{
"mtr": {AliasPrefix: "m", Args: []string{"mtr", "{address}"}},
"ping": {AliasPrefix: "m", Args: []string{"ping", "{address}"}},
}}
if cfg.ValidateCommands() == nil {
t.Fatal("duplicate prefixes accepted")
}
}
+153 -22
View File
@@ -6,19 +6,32 @@ import (
"path/filepath"
"regexp"
"strings"
"time"
"github.com/spf13/viper"
)
type Config struct {
Shell ShellConfig `mapstructure:"shell"`
NetBox NetBoxConfig `mapstructure:"netbox"`
NetBoxes []NetBoxConfig `mapstructure:"netboxes"`
Resolver ResolverConfig `mapstructure:"resolver"`
Cache CacheConfig `mapstructure:"cache"`
SSH SSHConfig `mapstructure:"ssh"`
Shortcuts ShortcutsConfig `mapstructure:"shortcuts"`
Completion CompletionConfig `mapstructure:"completion"`
TUI TUIConfig `mapstructure:"tui"`
Activity ActivityConfig `mapstructure:"activity"`
Commands map[string]HostCommand `mapstructure:"commands"`
Shell ShellConfig `mapstructure:"shell"`
NetBox NetBoxConfig `mapstructure:"netbox"`
NetBoxes []NetBoxConfig `mapstructure:"netboxes"`
Resolver ResolverConfig `mapstructure:"resolver"`
Cache CacheConfig `mapstructure:"cache"`
SSH SSHConfig `mapstructure:"ssh"`
Shortcuts ShortcutsConfig `mapstructure:"shortcuts"`
Completion CompletionConfig `mapstructure:"completion"`
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"`
}
type ShellConfig struct {
@@ -26,17 +39,25 @@ type ShellConfig struct {
}
type NetBoxConfig struct {
Name string `mapstructure:"name"`
URL string `mapstructure:"url"`
Token string `mapstructure:"token"`
TokenVersion int `mapstructure:"token_version"`
SSH SSHOptions `mapstructure:"ssh"`
DisablePrefix bool `mapstructure:"disable_prefix"`
Name string `mapstructure:"name"`
URL string `mapstructure:"url"`
Token string `mapstructure:"token"`
TokenVersion int `mapstructure:"token_version"`
SSH SSHOptions `mapstructure:"ssh"`
}
type ResolverConfig struct {
// Fallback tries the addresses of the other strategies when the chosen
// address does not accept TCP connections on the SSH port.
Fallback bool `mapstructure:"fallback"`
// FallbackTimeout is the per-address connect timeout in milliseconds; 0 = 1000.
FallbackTimeout int `mapstructure:"fallback_timeout"`
Strategies []string `mapstructure:"strategies"`
ManagementSubnets []string `mapstructure:"management_subnets"`
InterfaceName string `mapstructure:"interface_name"`
// HostnameDomain is appended by the hostname strategy to names without a dot.
HostnameDomain string `mapstructure:"hostname_domain"`
}
type CacheConfig struct {
@@ -47,8 +68,11 @@ type CacheConfig struct {
type SSHConfig struct {
DefaultUser string `mapstructure:"default_user"`
DefaultPort int `mapstructure:"default_port"`
SSHOptions `mapstructure:",squash"`
Rules []SSHRule `mapstructure:"rules"`
// WarnStatus lists NetBox status values that ask before connecting;
// nil means DefaultWarnStatus, an empty list disables the question.
WarnStatus []string `mapstructure:"warn_status"`
SSHOptions `mapstructure:",squash"`
Rules []SSHRule `mapstructure:"rules"`
}
type CompletionConfig struct {
@@ -57,8 +81,82 @@ type CompletionConfig struct {
}
type ShortcutsConfig struct {
Domains []string `mapstructure:"domains"`
StripHyphens bool `mapstructure:"strip_hyphens"`
Domains []string `mapstructure:"domains"`
StripHyphens bool `mapstructure:"strip_hyphens"`
Rewrites []ShortcutRewrite `mapstructure:"rewrites"`
// Show displays each host's shortcut alias in the TUI and in host lists, and
// offers shortcuts in Tab completion even when the full name matches.
Show bool `mapstructure:"show"`
}
// ShortcutRewrite replaces every match of Pattern (Go regexp syntax) with
// Replace, which may reference groups as $1. Applied after domain stripping.
type ShortcutRewrite struct {
Pattern string `mapstructure:"pattern"`
Replace string `mapstructure:"replace"`
}
// Enabled reports whether any shortcut normalization is configured.
func (s ShortcutsConfig) Enabled() bool {
return len(s.Domains) > 0 || s.StripHyphens || len(s.Rewrites) > 0
}
// Validate rejects rewrite rules that cannot be compiled.
func (s ShortcutsConfig) Validate() error {
for i, rewrite := range s.Rewrites {
if rewrite.Pattern == "" {
return fmt.Errorf("shortcuts.rewrites[%d]: pattern is required", i)
}
if _, err := regexp.Compile(rewrite.Pattern); err != nil {
return fmt.Errorf("shortcuts.rewrites[%d]: invalid pattern %q: %v", i, rewrite.Pattern, err)
}
}
return nil
}
// DefaultWarnStatus are the NetBox status values that ask before connecting.
var DefaultWarnStatus = []string{"offline", "planned", "staged", "failed", "inventory", "decommissioning"}
// KeyringToken as a token value reads the token from the system keyring.
const KeyringToken = "keyring"
// IsKeyringToken reports whether token refers to the system keyring.
func IsKeyringToken(token string) bool {
return strings.EqualFold(strings.TrimSpace(token), KeyringToken)
}
// KeyringAccount is the keyring entry of a NetBox instance; the unnamed
// single-instance configuration uses "default".
func (n NetBoxConfig) KeyringAccount() string {
if n.Name == "" {
return "default"
}
return strings.ToLower(n.Name)
}
// WarnsStatus reports whether status is configured to ask before connecting.
func (s SSHConfig) WarnsStatus(status string) bool {
if status == "" {
return false
}
list := s.WarnStatus
if list == nil {
list = DefaultWarnStatus
}
for _, warn := range list {
if strings.EqualFold(strings.TrimSpace(warn), status) {
return true
}
}
return false
}
// FallbackTimeoutDuration returns resolver.fallback_timeout, 1s by default.
func (r ResolverConfig) FallbackTimeoutDuration() time.Duration {
if r.FallbackTimeout <= 0 {
return time.Second
}
return time.Duration(r.FallbackTimeout) * time.Millisecond
}
// Path returns the canonical config file path.
@@ -76,19 +174,23 @@ func Load() (*Config, error) {
v.SetDefault("resolver.strategies", []string{"management_subnet", "primary_ip"})
v.SetDefault("resolver.management_subnets", []string{})
v.SetDefault("cache.ttl", 3600)
v.SetDefault("tui.history_limit", 10)
v.SetDefault("activity.retention_days", 30)
v.SetDefault("activity.max_entries", 1000)
configDir, err := os.UserConfigDir()
if err == nil {
v.SetConfigName("netssh")
v.SetConfigType("yaml")
v.AddConfigPath(filepath.Join(configDir))
v.AddConfigPath(".")
// Only the user's own directory: a netssh.yaml in the working directory
// (e.g. of a cloned repository) could inject ssh options and a NetBox URL.
v.AddConfigPath(configDir)
}
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", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shell.alias", "ssh.proxy_jump", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results"} {
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
}
@@ -104,6 +206,14 @@ func Load() (*Config, error) {
if err := v.Unmarshal(&cfg); err != nil {
return nil, fmt.Errorf("parsing config: %w", err)
}
// "columns: []" shows only the hostname; only a missing key means the default.
if cfg.TUI.Columns == nil && v.IsSet("tui.columns") {
cfg.TUI.Columns = []string{}
}
// "warn_status: []" disables the question; only a missing key means the default.
if cfg.SSH.WarnStatus == nil && v.IsSet("ssh.warn_status") {
cfg.SSH.WarnStatus = []string{}
}
// Legacy environment variables must not invent an additional unnamed source
// when a file explicitly configures named instances (including wizard migration).
if len(cfg.NetBoxes) > 0 && !v.InConfig("netbox.url") {
@@ -114,7 +224,7 @@ func Load() (*Config, error) {
return nil, err
}
if cfg.NetBox.TokenVersion == 0 && cfg.NetBox.Token != "" {
if cfg.NetBox.TokenVersion == 0 && cfg.NetBox.Token != "" && !IsKeyringToken(cfg.NetBox.Token) {
if strings.HasPrefix(cfg.NetBox.Token, "nbt_") {
cfg.NetBox.TokenVersion = 2
} else {
@@ -128,10 +238,31 @@ func Load() (*Config, error) {
if err := cfg.ValidateSSH(); err != nil {
return nil, err
}
if err := cfg.Shortcuts.Validate(); err != nil {
return nil, err
}
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
}
if err := cfg.ValidateCommands(); err != nil {
return nil, err
}
if err := cfg.ValidateMulti(); err != nil {
return nil, err
}
for i := range cfg.NetBoxes {
source := &cfg.NetBoxes[i]
source.Name = strings.ToLower(source.Name)
if source.TokenVersion == 0 && source.Token != "" {
if source.TokenVersion == 0 && source.Token != "" && !IsKeyringToken(source.Token) {
source.TokenVersion = 1
if strings.HasPrefix(source.Token, "nbt_") {
source.TokenVersion = 2
+43
View File
@@ -3,6 +3,7 @@ package config
import (
"os"
"path/filepath"
"strings"
"testing"
)
@@ -177,3 +178,45 @@ func TestCommandAliasEnvironmentAndValidation(t *testing.T) {
}
}
}
func TestLoad_ShortcutRewrites(t *testing.T) {
dir := writeConfig(t, "shortcuts:\n rewrites:\n - pattern: '^([a-z]+)[0-9]+-'\n replace: '$1'\n")
cfg := loadFromDir(t, dir)
want := []ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}}
if len(cfg.Shortcuts.Rewrites) != 1 || cfg.Shortcuts.Rewrites[0] != want[0] || !cfg.Shortcuts.Enabled() {
t.Fatalf("rewrites: %+v", cfg.Shortcuts)
}
}
func TestLoad_InvalidShortcutRewrite(t *testing.T) {
for _, rule := range []string{"pattern: '[a-'", "replace: x"} {
t.Setenv("XDG_CONFIG_HOME", writeConfig(t, "shortcuts:\n rewrites:\n - "+rule+"\n"))
if _, err := Load(); err == nil || !strings.Contains(err.Error(), "shortcuts.rewrites[0]") {
t.Errorf("%s: got %v", rule, err)
}
}
}
// A netssh.yaml in the working directory (e.g. of a cloned repository) must
// not be loaded: it could inject ssh options such as ProxyCommand.
func TestLoad_IgnoresConfigInWorkingDirectory(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("NETSSH_NETBOX_URL", "")
t.Chdir(writeConfig(t, "hosts:\n - name: evil\n address: 10.0.0.1\nssh:\n options:\n ProxyCommand: touch /tmp/pwned\n"))
cfg, err := Load()
if err != nil {
t.Fatalf("Load: %v", err)
}
if len(cfg.Hosts) != 0 || len(cfg.SSH.Options) != 0 {
t.Errorf("config from the working directory was loaded: %+v", cfg)
}
}
func TestLoad_RejectsInvalidLegacyNetBoxURL(t *testing.T) {
for _, bad := range []string{"netbox.example.com", "ftp://netbox.example.com", "https://netbox.example.com/?x=1"} {
t.Setenv("XDG_CONFIG_HOME", writeConfig(t, "netbox:\n url: \""+bad+"\"\n token: t\n"))
if _, err := Load(); err == nil || !strings.Contains(err.Error(), "netbox.url") {
t.Errorf("%s: got %v, want a netbox.url error", bad, 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
}
+93
View File
@@ -0,0 +1,93 @@
package config
import (
"fmt"
"regexp"
"strings"
)
// StaticKind is the kind of hosts defined under hosts: instead of NetBox.
const StaticKind = "static"
// StaticHost is a host that is not in NetBox, defined in the config.
type StaticHost struct {
Name string `mapstructure:"name"`
Address string `mapstructure:"address"` // IP address or DNS name
User string `mapstructure:"user"`
Port int `mapstructure:"port"`
Tags []string `mapstructure:"tags"`
SSH SSHOptions `mapstructure:"ssh"`
}
var staticHostName = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)
// ValidateHosts keeps static host names usable as selectors and addresses
// safe to pass to ssh.
func (c *Config) ValidateHosts() error {
seen := make(map[string]bool)
for i, host := range c.Hosts {
scope := fmt.Sprintf("hosts[%d]", i)
if !staticHostName.MatchString(host.Name) {
return fmt.Errorf("%s: name %q must start with a letter or digit and contain only letters, digits, dots, underscores, or hyphens", scope, host.Name)
}
name := strings.ToLower(host.Name)
if seen[name] {
return fmt.Errorf("%s: duplicate host name %q", scope, host.Name)
}
seen[name] = true
if host.Address == "" || strings.HasPrefix(host.Address, "-") || strings.ContainsAny(host.Address, " \t\n\r/@") {
return fmt.Errorf("%s: address %q must be an IP address or hostname", scope, host.Address)
}
if host.Port < 0 || host.Port > 65535 {
return fmt.Errorf("%s: port must be between 1 and 65535", scope)
}
if strings.HasPrefix(host.User, "-") || strings.ContainsAny(host.User, " \t\n\r@") {
return fmt.Errorf("%s: invalid user %q", scope, host.User)
}
if err := host.SSH.Validate(scope + ".ssh"); err != nil {
return err
}
}
return nil
}
// StaticHost returns the static host with the given name, or nil.
func (c *Config) StaticHost(name string) *StaticHost {
for i := range c.Hosts {
if strings.EqualFold(c.Hosts[i].Name, name) {
return &c.Hosts[i]
}
}
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
}
+120
View File
@@ -0,0 +1,120 @@
package config
import (
"os"
"strings"
"testing"
)
func TestSSHRuleMatchesNetBoxAttributes(t *testing.T) {
host := SSHHost{Name: "sw1", Kind: "device", Status: "active",
Site: Ref{Name: "Falkenstein 1", Slug: "fsn1"}, Role: Ref{Name: "Core Switch", Slug: "core-switch"},
Platform: Ref{Name: "Juniper Junos", Slug: "junos"}, Tenant: Ref{Name: "ACME"}}
for _, tc := range []struct {
match SSHMatch
want bool
}{
{SSHMatch{Platform: "junos"}, true},
{SSHMatch{Platform: "juniper junos"}, true},
{SSHMatch{Platform: "eos"}, false},
{SSHMatch{Site: "fsn1", Role: "core-switch"}, true},
{SSHMatch{Role: "Core Switch"}, true},
{SSHMatch{Site: "falkenstein-1"}, true},
{SSHMatch{Tenant: "acme"}, true},
{SSHMatch{Status: "ACTIVE"}, true},
{SSHMatch{Status: "offline"}, false},
{SSHMatch{Platform: "junos", Kind: "vm"}, false},
} {
if got := tc.match.matches(host); got != tc.want {
t.Errorf("%+v: got %v, want %v", tc.match, got, tc.want)
}
}
if err := (SSHMatch{Platform: "junos"}).Validate("rule"); err != nil {
t.Fatalf("platform-only match rejected: %v", err)
}
}
func TestSSHOptionsForPlatformRule(t *testing.T) {
cfg := &Config{SSH: SSHConfig{Rules: []SSHRule{{Match: SSHMatch{Platform: "junos"}, SSHOptions: SSHOptions{Options: map[string]string{"KexAlgorithms": "+diffie-hellman-group14-sha1"}}}}}}
opts := cfg.SSHOptionsFor(SSHHost{Name: "sw1", Kind: "device", Platform: Ref{Slug: "junos"}})
if opts.Options["kexalgorithms"] != "+diffie-hellman-group14-sha1" {
t.Fatalf("platform rule not applied: %+v", opts.Options)
}
if opts := cfg.SSHOptionsFor(SSHHost{Name: "web", Kind: "vm"}); len(opts.Options) != 0 {
t.Fatalf("rule applied to other platform: %+v", opts.Options)
}
}
func TestWarnStatusDefaultsAndOverrides(t *testing.T) {
cfg := loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\n"))
if cfg.SSH.WarnStatus != nil || !cfg.SSH.WarnsStatus("offline") || cfg.SSH.WarnsStatus("active") || cfg.SSH.WarnsStatus("") {
t.Fatalf("default warn_status wrong: %#v", cfg.SSH.WarnStatus)
}
cfg = loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\nssh:\n warn_status: []\n"))
if cfg.SSH.WarnStatus == nil || cfg.SSH.WarnsStatus("offline") {
t.Fatalf("empty warn_status should disable the question: %#v", cfg.SSH.WarnStatus)
}
cfg = loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\nssh:\n warn_status: [planned]\n"))
if !cfg.SSH.WarnsStatus("Planned") || cfg.SSH.WarnsStatus("offline") {
t.Fatalf("custom warn_status wrong: %#v", cfg.SSH.WarnStatus)
}
}
func TestReachabilityAndFallbackDefaults(t *testing.T) {
cfg := loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\n"))
if cfg.TUI.ReachabilityEnabled() || cfg.TUI.ReachabilityTimeoutDuration().Milliseconds() != 300 {
t.Fatalf("reachability must be opt-in: %+v", cfg.TUI)
}
if strings.Join(cfg.TUI.EffectiveColumns(), ",") != "alias,ip,source,status" {
t.Fatalf("default columns: %v", cfg.TUI.EffectiveColumns())
}
if cfg.Resolver.Fallback || cfg.Resolver.FallbackTimeoutDuration().Milliseconds() != 1000 {
t.Fatalf("fallback defaults wrong: %+v", cfg.Resolver)
}
cfg = loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\ntui:\n columns: [Reachability, ip, platform]\n reachability_timeout: 800\nresolver:\n fallback: true\n fallback_timeout: 250\n"))
if !cfg.TUI.ReachabilityEnabled() || cfg.TUI.ReachabilityTimeoutDuration().Milliseconds() != 800 || strings.Join(cfg.TUI.Columns, ",") != "reachability,ip,platform" {
t.Fatalf("reachability settings ignored: %+v", cfg.TUI)
}
if !cfg.Resolver.Fallback || cfg.Resolver.FallbackTimeoutDuration().Milliseconds() != 250 {
t.Fatalf("fallback settings ignored: %+v", cfg.Resolver)
}
}
func TestKeyringTokenKeepsVersionUndetected(t *testing.T) {
cfg := loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\n token: keyring\nnetboxes: []\n"))
if !IsKeyringToken(cfg.NetBox.Token) || cfg.NetBox.TokenVersion != 0 {
t.Fatalf("keyring token treated as literal: %+v", cfg.NetBox)
}
if cfg.NetBox.KeyringAccount() != "default" || (NetBoxConfig{Name: "Prod"}).KeyringAccount() != "prod" {
t.Fatal("unexpected keyring account names")
}
}
func TestTUIColumnsValidation(t *testing.T) {
cfg := loadFromDir(t, writeConfig(t, "netbox:\n url: https://nb\ntui:\n columns: []\n"))
if cfg.TUI.Columns == nil || len(cfg.TUI.EffectiveColumns()) != 0 {
t.Fatalf("empty columns should show only the hostname: %#v", cfg.TUI.Columns)
}
for _, bad := range []string{"[ip, colour]", "[ip, ip]"} {
dir := writeConfig(t, "netbox:\n url: https://nb\ntui:\n columns: "+bad+"\n")
orig := os.Getenv("XDG_CONFIG_HOME")
os.Setenv("XDG_CONFIG_HOME", dir)
_, err := Load()
os.Setenv("XDG_CONFIG_HOME", orig)
if err == nil || !strings.Contains(err.Error(), "tui.columns") {
t.Errorf("%s accepted: %v", bad, err)
}
}
}
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)
}
}
}
+27 -2
View File
@@ -17,6 +17,9 @@ func (c *Config) ValidateNetBoxes() error {
if len(c.NetBoxes) > 0 && c.NetBox.URL != "" {
return fmt.Errorf("configure either netbox or netboxes, not both")
}
if c.NetBox.URL != "" && !validNetBoxURL(c.NetBox.URL) {
return fmt.Errorf("netbox.url %q must be an HTTP(S) URL without query or fragment", c.NetBox.URL)
}
seen := make(map[string]bool)
for _, source := range c.NetBoxes {
if !instanceName.MatchString(source.Name) {
@@ -27,8 +30,7 @@ func (c *Config) ValidateNetBoxes() error {
return fmt.Errorf("duplicate NetBox instance name %q", source.Name)
}
seen[name] = true
u, err := url.Parse(source.URL)
if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" || u.RawQuery != "" || u.Fragment != "" {
if !validNetBoxURL(source.URL) {
return fmt.Errorf("NetBox %q requires an HTTP(S) URL without query or fragment", source.Name)
}
if source.TokenVersion < 0 || source.TokenVersion > 2 {
@@ -38,8 +40,17 @@ func (c *Config) ValidateNetBoxes() error {
return nil
}
// validNetBoxURL accepts base URLs that API paths can be appended to.
func validNetBoxURL(raw string) bool {
u, err := url.Parse(raw)
return err == nil && (u.Scheme == "http" || u.Scheme == "https") && u.Host != "" && u.RawQuery == "" && u.Fragment == ""
}
func (c *Config) HasNetBox() bool { return c.NetBox.URL != "" || len(c.NetBoxes) > 0 }
// HasHosts reports whether netssh has anything to connect to: NetBox or static hosts.
func (c *Config) HasHosts() bool { return c.HasNetBox() || len(c.Hosts) > 0 }
// CachePath isolates named sources from legacy caches and from changed endpoints.
// Rotating a token or reordering the sources does not discard usage history.
func (c *Config) CachePath() string {
@@ -54,3 +65,17 @@ func (c *Config) CachePath() string {
sum := sha256.Sum256([]byte(strings.Join(identities, "\x00")))
return filepath.Join(filepath.Dir(c.Cache.Path), fmt.Sprintf("instances-%x", sum[:8]), filepath.Base(c.Cache.Path))
}
// HostLabel omits the configured instance prefix for display only. Callers
// must retain the canonical target for connections and handle label collisions.
func (c *Config) HostLabel(target string) string {
source, host, qualified := strings.Cut(target, "/")
if qualified {
for _, instance := range c.NetBoxes {
if instance.DisablePrefix && strings.EqualFold(instance.Name, source) {
return host
}
}
}
return target
}
+8
View File
@@ -15,6 +15,7 @@ func TestLoadNamedNetBoxes(t *testing.T) {
- name: Office
url: https://office.example/netbox
token: nbt_office
disable_prefix: true
- name: lab
url: https://lab.example
token: legacy-token
@@ -34,7 +35,14 @@ cache:
if cfg.NetBox.URL != "" {
t.Fatal("legacy environment variables added an unnamed instance")
}
if !cfg.NetBoxes[0].DisablePrefix || cfg.NetBoxes[1].DisablePrefix {
t.Fatal("per-instance alias prefix setting was not loaded")
}
first := cfg.CachePath()
cfg.NetBoxes[0].DisablePrefix = false
if cfg.CachePath() != first {
t.Fatal("alias prefix setting discarded cache")
}
if first == cfg.Cache.Path {
t.Fatal("named sources reuse legacy cache")
}
+92
View File
@@ -0,0 +1,92 @@
package config
import (
"fmt"
"regexp"
"sort"
"strings"
)
// MultiConfig controls netssh multi.
type MultiConfig struct {
// Multiplexer is auto, tmux, or zellij; empty means auto.
Multiplexer string `mapstructure:"multiplexer"`
// PanesPerWindow splits larger host lists into more windows or tabs; 0 = 9.
PanesPerWindow int `mapstructure:"panes_per_window"`
// SyncKey and SoloKey are tmux prefix keys for broadcast to all panes and
// for excluding the current pane; empty = default (S, e), "none" = off.
SyncKey string `mapstructure:"sync_key"`
SoloKey string `mapstructure:"solo_key"`
}
// Default tmux keys: unbound in a stock tmux (E would be "spread evenly").
const (
DefaultSyncKey = "S"
DefaultSoloKey = "e"
)
// Keys returns the tmux keys to bind; "" for a disabled one.
func (m MultiConfig) Keys() (sync, solo string) {
pick := func(key, fallback string) string {
switch key {
case "":
return fallback
case "none":
return ""
}
return key
}
return pick(m.SyncKey, DefaultSyncKey), pick(m.SoloKey, DefaultSoloKey)
}
var tmuxKey = regexp.MustCompile(`^([CMS]-)*([A-Za-z0-9]|F[0-9]{1,2}|[-_=+!@#$%^&*,./?<>\[\]]|Tab|Space|Enter|BSpace|Up|Down|Left|Right|Home|End|PPage|NPage)$`)
// DefaultPanesPerWindow keeps panes readable on a normal screen (3×3).
const DefaultPanesPerWindow = 9
// ValidateMulti checks groups and the multi settings.
func (c *Config) ValidateMulti() error {
switch c.Multi.Multiplexer {
case "", "auto", "tmux", "zellij":
default:
return fmt.Errorf("multi.multiplexer must be auto, tmux, or zellij")
}
if c.Multi.PanesPerWindow < 0 || c.Multi.PanesPerWindow > 64 {
return fmt.Errorf("multi.panes_per_window must be between 1 and 64")
}
for name, key := range map[string]string{"sync_key": c.Multi.SyncKey, "solo_key": c.Multi.SoloKey} {
if key != "" && key != "none" && !tmuxKey.MatchString(key) {
return fmt.Errorf("multi.%s %q is not a tmux key (e.g. S, e, C-s, F5) or none", name, key)
}
}
if sync, solo := c.Multi.Keys(); sync != "" && sync == solo {
return fmt.Errorf("multi.sync_key and multi.solo_key must differ")
}
names := make([]string, 0, len(c.Groups))
for name := range c.Groups {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
if !instanceName.MatchString(name) {
return fmt.Errorf("groups: name %q must contain only letters, digits, underscores, or hyphens", name)
}
if len(c.Groups[name]) == 0 {
return fmt.Errorf("groups.%s: needs at least one host or selector", name)
}
for _, selector := range c.Groups[name] {
if strings.TrimSpace(selector) == "" || strings.ContainsAny(selector, " \t\n") || strings.HasPrefix(selector, "-") {
return fmt.Errorf("groups.%s: invalid entry %q", name, selector)
}
}
}
return nil
}
// PanesPerWindowOrDefault returns the configured value or the default.
func (m MultiConfig) PanesPerWindowOrDefault() int {
if m.PanesPerWindow > 0 {
return m.PanesPerWindow
}
return DefaultPanesPerWindow
}
+101
View File
@@ -0,0 +1,101 @@
package config
import (
"fmt"
"strings"
"time"
)
type TUIConfig struct {
HistoryLimit int `mapstructure:"history_limit"`
// Columns selects what the TUI shows next to each hostname, in order;
// nil means DefaultTUIColumns. "reachability" enables the TCP check.
Columns []string `mapstructure:"columns"`
// ReachabilityTimeout is the probe timeout in milliseconds; 0 = 300.
ReachabilityTimeout int `mapstructure:"reachability_timeout"`
}
// TUIColumns are the values tui.columns accepts.
var TUIColumns = []string{"alias", "ip", "kind", "source", "status", "site", "location", "role", "platform", "tenant", "cluster", "tags", "reachability"}
// DefaultTUIColumns is the layout without tui.columns. The TCP reachability
// check is opt-in, since it opens connections to every listed host.
var DefaultTUIColumns = []string{"alias", "ip", "source", "status"}
// EffectiveColumns returns tui.columns, or the default layout.
func (t TUIConfig) EffectiveColumns() []string {
if t.Columns == nil {
return DefaultTUIColumns
}
return t.Columns
}
// ReachabilityEnabled reports whether the TUI probes listed hosts.
func (t TUIConfig) ReachabilityEnabled() bool {
for _, column := range t.EffectiveColumns() {
if column == "reachability" {
return true
}
}
return false
}
// ReachabilityTimeoutDuration returns tui.reachability_timeout, 300ms by default.
func (t TUIConfig) ReachabilityTimeoutDuration() time.Duration {
if t.ReachabilityTimeout <= 0 {
return 300 * time.Millisecond
}
return time.Duration(t.ReachabilityTimeout) * time.Millisecond
}
type ActivityConfig struct {
Enabled bool `mapstructure:"enabled"`
RetentionDays int `mapstructure:"retention_days"`
MaxEntries int `mapstructure:"max_entries"`
}
func (c *Config) ValidateOperations() error {
if c.TUI.HistoryLimit < 0 {
return fmt.Errorf("tui.history_limit must be >= 0 (0 = all)")
}
if c.Activity.RetentionDays < 0 || c.Activity.MaxEntries < 0 {
return fmt.Errorf("activity retention_days and max_entries must be >= 0")
}
seen := map[string]bool{}
for i, column := range c.TUI.Columns {
column = strings.ToLower(strings.TrimSpace(column))
c.TUI.Columns[i] = column
known := false
for _, valid := range TUIColumns {
known = known || column == valid
}
if !known {
return fmt.Errorf("tui.columns: unknown column %q; use %s", column, strings.Join(TUIColumns, ", "))
}
if seen[column] {
return fmt.Errorf("tui.columns: %q is listed twice", column)
}
seen[column] = true
}
if c.TUI.ReachabilityTimeout < 0 || c.TUI.ReachabilityTimeout > 10000 {
return fmt.Errorf("tui.reachability_timeout must be between 0 and 10000 milliseconds")
}
if c.Resolver.FallbackTimeout < 0 || c.Resolver.FallbackTimeout > 30000 {
return fmt.Errorf("resolver.fallback_timeout must be between 0 and 30000 milliseconds")
}
for _, status := range c.SSH.WarnStatus {
if strings.TrimSpace(status) == "" || strings.ContainsAny(status, " \t\n") {
return fmt.Errorf("ssh.warn_status: invalid status %q", status)
}
}
return nil
}
func (m SSHMatch) Matches(host SSHHost) bool { return m == (SSHMatch{}) || m.matches(host) }
func (c HostCommand) Allowed(host SSHHost) bool { return c.Match.Matches(host) }
func HookCommand(s string) string {
s = strings.TrimSpace(s)
if strings.EqualFold(s, "none") {
return ""
}
return s
}
+55
View File
@@ -0,0 +1,55 @@
package config
import (
"os"
"path/filepath"
"testing"
)
func TestOperationsDefaultsEnvironmentAndValidation(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
if err := os.WriteFile(filepath.Join(os.Getenv("XDG_CONFIG_HOME"), "netssh.yaml"), []byte("hosts:\n - name: router\n address: 192.0.2.1\n"), 0600); err != nil {
t.Fatal(err)
}
cfg, err := Load()
if err != nil {
t.Fatal(err)
}
if cfg.TUI.HistoryLimit != 10 || cfg.Activity.Enabled || cfg.Activity.RetentionDays != 30 || cfg.Activity.MaxEntries != 1000 {
t.Fatalf("%+v %+v", cfg.TUI, cfg.Activity)
}
t.Setenv("NETSSH_TUI_HISTORY_LIMIT", "25")
t.Setenv("NETSSH_SSH_POST_DISCONNECT", "echo done")
cfg, err = Load()
if err != nil || cfg.TUI.HistoryLimit != 25 || cfg.SSH.PostDisconnect != "echo done" {
t.Fatalf("%+v %v", cfg, err)
}
cfg.TUI.HistoryLimit = -1
if cfg.ValidateOperations() == nil {
t.Fatal("negative history accepted")
}
for _, timeout := range []string{"-1s", "0s", "invalid"} {
cfg.Commands = map[string]HostCommand{"check": {Args: []string{"echo", "{host}"}, Timeout: timeout}}
if cfg.ValidateCommands() == nil {
t.Fatalf("accepted %q", timeout)
}
}
}
func TestPostDisconnectLayering(t *testing.T) {
cfg := Config{
SSH: SSHConfig{SSHOptions: SSHOptions{PostDisconnect: "global"}, Rules: []SSHRule{{Match: SSHMatch{Tag: "lab"}, SSHOptions: SSHOptions{PostDisconnect: "none"}}}},
NetBoxes: []NetBoxConfig{{Name: "prod", SSH: SSHOptions{PostDisconnect: "instance"}}},
}
for _, tc := range []struct {
host SSHHost
want string
}{
{SSHHost{Name: "web"}, "global"},
{SSHHost{Name: "web", Instance: "prod"}, "instance"},
{SSHHost{Name: "web", Instance: "prod", Tags: []string{"lab"}}, ""},
} {
if got := HookCommand(cfg.SSHOptionsFor(tc.host).PostDisconnect); got != tc.want {
t.Fatalf("%q want %q", got, tc.want)
}
}
}
+183 -12
View File
@@ -22,6 +22,64 @@ type SSHOptions struct {
ExtraArgs []string `mapstructure:"extra_args"`
// Options are passed as -o Key=Value.
Options map[string]string `mapstructure:"options"`
// Forwards are named port forwards, selected with --forward or netssh tunnel.
Forwards map[string]Forward `mapstructure:"forwards"`
// PreConnect is a shell command run locally before connecting; a non-zero
// exit aborts the connection. "none" disables a hook set by a broader layer.
PreConnect string `mapstructure:"pre_connect"`
PostDisconnect string `mapstructure:"post_disconnect"`
}
// PreConnectNone disables an inherited pre_connect hook.
const PreConnectNone = "none"
// PreConnectCommand returns the hook to run, or "" when none is configured.
func (o SSHOptions) PreConnectCommand() string {
command := strings.TrimSpace(o.PreConnect)
if strings.EqualFold(command, PreConnectNone) {
return ""
}
return command
}
// Forward is one port forward; exactly one of the fields is set.
type Forward struct {
Local string `mapstructure:"local"` // -L [bind:]port:host:hostport
Remote string `mapstructure:"remote"` // -R [bind:]port:host:hostport
Dynamic string `mapstructure:"dynamic"` // -D [bind:]port (SOCKS proxy)
}
// Flag returns the ssh arguments for the forward, e.g. -L 8080:localhost:80.
func (f Forward) Flag() []string {
switch {
case f.Local != "":
return []string{"-L", f.Local}
case f.Remote != "":
return []string{"-R", f.Remote}
case f.Dynamic != "":
return []string{"-D", f.Dynamic}
}
return nil
}
// String renders the forward as its ssh flag, e.g. "-L 8080:localhost:80".
func (f Forward) String() string { return strings.Join(f.Flag(), " ") }
func (f Forward) validate() error {
set := 0
for _, spec := range []string{f.Local, f.Remote, f.Dynamic} {
if spec == "" {
continue
}
set++
if strings.HasPrefix(spec, "-") || strings.ContainsAny(spec, " \t\n\r") {
return fmt.Errorf("invalid forward %q", spec)
}
}
if set != 1 {
return fmt.Errorf("set exactly one of local, remote, dynamic")
}
return nil
}
// SSHRule applies SSH options to hosts that match every non-empty field.
@@ -36,6 +94,57 @@ type SSHMatch struct {
Instance string `mapstructure:"instance"`
Kind string `mapstructure:"kind"`
Name string `mapstructure:"name"` // shell-style glob, e.g. "*.dmz.example.com"
// Site, Role, Platform and Tenant match the NetBox name or slug.
Site string `mapstructure:"site"`
Role string `mapstructure:"role"`
Platform string `mapstructure:"platform"`
Tenant string `mapstructure:"tenant"`
// Status matches the NetBox status value, e.g. active or offline.
Status string `mapstructure:"status"`
}
// Ref is a NetBox object referenced by a host, such as its site or platform.
type Ref struct {
Name string `json:"name,omitempty"`
Slug string `json:"slug,omitempty"`
}
// Matches compares want with the name or slug, ignoring case.
func (r Ref) Matches(want string) bool {
return want != "" && (strings.EqualFold(r.Name, want) || strings.EqualFold(r.Slug, want) || strings.EqualFold(tagSlug(r.Name), want))
}
// Key returns the slug, or the name when NetBox sent no slug.
func (r Ref) Key() string {
if r.Slug != "" {
return r.Slug
}
return r.Name
}
// LocationPath renders a host's place as "site › location › … › rack › U20",
// leaving out levels that are not set.
func LocationPath(site Ref, locations []Ref, rack, position string) string {
var parts []string
if site.Name != "" {
parts = append(parts, site.Name)
} else if site.Slug != "" {
parts = append(parts, site.Slug)
}
for _, location := range locations {
if location.Name != "" {
parts = append(parts, location.Name)
} else if location.Slug != "" {
parts = append(parts, location.Slug)
}
}
if rack != "" {
parts = append(parts, rack)
}
if position != "" {
parts = append(parts, "U"+position)
}
return strings.Join(parts, " › ")
}
// SSHHost identifies the resolved host that SSH options are computed for.
@@ -44,38 +153,57 @@ type SSHHost struct {
Name string // NetBox name without the instance prefix
Kind string
Tags []string
Status string
Site Ref
Role Ref
Platform Ref
Tenant Ref
}
var sshOptionKey = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9]*$`)
// ValidateSSH rejects values that would be passed to ssh in an unexpected form.
func (c *Config) ValidateSSH() error {
if err := c.SSH.SSHOptions.validate("ssh"); err != nil {
if err := c.SSH.SSHOptions.Validate("ssh"); err != nil {
return err
}
for i, rule := range c.SSH.Rules {
if err := rule.SSHOptions.validate(fmt.Sprintf("ssh.rules[%d]", i)); err != nil {
if err := rule.Validate(fmt.Sprintf("ssh.rules[%d]", i)); err != nil {
return err
}
if rule.Match == (SSHMatch{}) {
return fmt.Errorf("ssh.rules[%d]: match must set at least one of tag, instance, kind, name", i)
}
if _, err := path.Match(rule.Match.Name, ""); err != nil {
return fmt.Errorf("ssh.rules[%d]: invalid name pattern %q", i, rule.Match.Name)
}
}
if err := c.NetBox.SSH.validate("netbox.ssh"); err != nil {
if err := c.NetBox.SSH.Validate("netbox.ssh"); err != nil {
return err
}
for _, source := range c.NetBoxes {
if err := source.SSH.validate("netboxes." + source.Name + ".ssh"); err != nil {
if err := source.SSH.Validate("netboxes." + source.Name + ".ssh"); err != nil {
return err
}
}
return nil
}
func (o SSHOptions) validate(scope string) error {
// Validate checks the match and options of a single rule.
func (r SSHRule) Validate(scope string) error {
if err := r.SSHOptions.Validate(scope); err != nil {
return err
}
return r.Match.Validate(scope)
}
// Validate requires at least one selector and a well-formed name pattern.
func (m SSHMatch) Validate(scope string) error {
if m == (SSHMatch{}) {
return fmt.Errorf("%s: match must set at least one of tag, instance, kind, name, site, role, platform, tenant, status", scope)
}
if _, err := path.Match(m.Name, ""); err != nil {
return fmt.Errorf("%s: invalid name pattern %q", scope, m.Name)
}
return nil
}
// Validate rejects values that ssh would not accept or would misinterpret.
func (o SSHOptions) Validate(scope string) error {
switch o.HostKeyChecking {
case "", "strict", "accept-new", "off":
default:
@@ -99,13 +227,31 @@ func (o SSHOptions) validate(scope string) error {
return fmt.Errorf("%s.options: invalid option %q", scope, key)
}
}
if strings.ContainsRune(o.PostDisconnect, 0) {
return fmt.Errorf("%s.post_disconnect must not contain NUL bytes", scope)
}
if strings.ContainsRune(o.PreConnect, 0) {
return fmt.Errorf("%s.pre_connect must not contain NUL bytes", scope)
}
for name, forward := range o.Forwards {
if !instanceName.MatchString(name) {
return fmt.Errorf("%s.forwards: name %q must contain only letters, digits, underscores, or hyphens", scope, name)
}
if err := forward.validate(); err != nil {
return fmt.Errorf("%s.forwards.%s: %v", scope, name, err)
}
}
return nil
}
// SSHOptionsFor merges global, instance, and matching rule options for host.
func (c *Config) SSHOptionsFor(host SSHHost) SSHOptions {
merged := c.SSH.SSHOptions.merge(SSHOptions{})
if host.Instance == "" {
if host.Kind == StaticKind {
if static := c.StaticHost(host.Name); static != nil {
merged = merged.merge(static.SSH)
}
} else if host.Instance == "" {
merged = merged.merge(c.NetBox.SSH)
}
for _, source := range c.NetBoxes {
@@ -133,6 +279,14 @@ func (o SSHOptions) merge(override SSHOptions) SSHOptions {
for key, value := range override.Options {
out.Options[strings.ToLower(key)] = value
}
// Forwards override per name, so a rule can redefine a global "web" forward.
out.Forwards = make(map[string]Forward, len(o.Forwards)+len(override.Forwards))
for name, forward := range o.Forwards {
out.Forwards[strings.ToLower(name)] = forward
}
for name, forward := range override.Forwards {
out.Forwards[strings.ToLower(name)] = forward
}
if override.ProxyJump != "" {
out.ProxyJump = override.ProxyJump
}
@@ -145,6 +299,12 @@ func (o SSHOptions) merge(override SSHOptions) SSHOptions {
if override.AddressFamily != "" {
out.AddressFamily = override.AddressFamily
}
if strings.TrimSpace(override.PostDisconnect) != "" {
out.PostDisconnect = override.PostDisconnect
}
if strings.TrimSpace(override.PreConnect) != "" {
out.PreConnect = override.PreConnect
}
return out
}
@@ -160,6 +320,17 @@ func (m SSHMatch) matches(host SSHHost) bool {
return false
}
}
for _, ref := range []struct {
want string
have Ref
}{{m.Site, host.Site}, {m.Role, host.Role}, {m.Platform, host.Platform}, {m.Tenant, host.Tenant}} {
if ref.want != "" && !ref.have.Matches(ref.want) {
return false
}
}
if m.Status != "" && !strings.EqualFold(m.Status, host.Status) {
return false
}
if m.Tag != "" {
found := false
for _, tag := range host.Tags {
+169
View File
@@ -88,3 +88,172 @@ func TestSSHOptionsValidation(t *testing.T) {
}
}
}
func TestForwardsLayering(t *testing.T) {
cfg, err := loadYAML(t, `
netboxes:
- name: prod
url: https://prod.example
token: t
ssh:
forwards:
db: {local: "5432:localhost:5432"}
ssh:
forwards:
web: {local: "8080:localhost:80"}
socks: {dynamic: "1080"}
rules:
- match: {tag: dmz}
forwards:
web: {local: "8443:localhost:443"}
`)
if err != nil {
t.Fatal(err)
}
got := cfg.SSHOptionsFor(SSHHost{Instance: "prod", Name: "web01", Tags: []string{"dmz"}}).Forwards
want := map[string]Forward{"web": {Local: "8443:localhost:443"}, "socks": {Dynamic: "1080"}, "db": {Local: "5432:localhost:5432"}}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %+v", got)
}
if got := cfg.SSHOptionsFor(SSHHost{Instance: "other", Name: "web01"}).Forwards; len(got) != 2 || got["web"].Local != "8080:localhost:80" {
t.Fatalf("other instance: %+v", got)
}
if f := (Forward{Remote: "9000:localhost:9000"}); f.String() != "-R 9000:localhost:9000" {
t.Fatal(f.String())
}
}
func TestForwardsValidation(t *testing.T) {
for _, forwards := range []string{
`web: {local: "8080:a:80", dynamic: "1080"}`,
`web: {local: "-oProxyCommand=x"}`,
`web: {local: "8080 a:80"}`,
`"bad name": {local: "8080:a:80"}`,
} {
if _, err := loadYAML(t, "ssh:\n forwards:\n "+forwards+"\n"); err == nil || !strings.Contains(err.Error(), "forwards") {
t.Errorf("%s: got %v", forwards, err)
}
}
}
func TestStaticHosts(t *testing.T) {
cfg, err := loadYAML(t, `
resolver:
hostname_domain: example.com
ssh:
proxy_jump: jh
rules:
- match: {kind: static, tag: home}
host_key_checking: off
hosts:
- name: Router
address: 192.168.1.1
user: admin
port: 2222
tags: [home]
ssh:
proxy_jump: none
`)
if err != nil {
t.Fatal(err)
}
if !cfg.HasHosts() || cfg.HasNetBox() || cfg.Resolver.HostnameDomain != "example.com" {
t.Fatalf("got %+v", cfg)
}
host := cfg.StaticHost("router")
if host == nil || host.Address != "192.168.1.1" || host.User != "admin" || host.Port != 2222 {
t.Fatalf("host: %+v", host)
}
opts := cfg.SSHOptionsFor(SSHHost{Name: "Router", Kind: StaticKind, Tags: []string{"home"}})
if opts.ProxyJump != "none" || opts.HostKeyChecking != "off" {
t.Fatalf("static host options: %+v", opts)
}
// A NetBox host of the same name does not get the static host's options.
if got := cfg.SSHOptionsFor(SSHHost{Name: "Router", Kind: "device"}); got.ProxyJump != "jh" {
t.Fatalf("netbox host: %+v", got)
}
}
func TestStaticHostsValidation(t *testing.T) {
for _, hosts := range []string{
"- {name: a, address: 10.0.0.1}\n - {name: A, address: 10.0.0.2}",
"- {name: 'bad name', address: 10.0.0.1}",
"- {name: prod/a, address: 10.0.0.1}",
"- {name: a}",
"- {name: a, address: '-oProxyCommand=x'}",
"- {name: a, address: 10.0.0.1, port: 70000}",
"- {name: a, address: 10.0.0.1, user: 'a b'}",
"- {name: a, address: 10.0.0.1, ssh: {target: nope}}",
} {
if _, err := loadYAML(t, "hosts:\n "+hosts+"\n"); err == nil || !strings.Contains(err.Error(), "hosts[") {
t.Errorf("%s: got %v", hosts, err)
}
}
}
func TestMultiConfig(t *testing.T) {
cfg, err := loadYAML(t, "groups:\n K8s: [master1, \"tag:worker\"]\nmulti:\n multiplexer: zellij\n")
if err != nil || len(cfg.Groups["k8s"]) != 2 || cfg.Multi.Multiplexer != "zellij" || cfg.Multi.PanesPerWindowOrDefault() != 9 {
t.Fatalf("%+v %v", cfg, err)
}
if sync, solo := cfg.Multi.Keys(); sync != "S" || solo != "e" {
t.Fatalf("default keys %q %q", sync, solo)
}
custom, err := loadYAML(t, "multi: {sync_key: C-s, solo_key: none}\n")
if sync, solo := custom.Multi.Keys(); err != nil || sync != "C-s" || solo != "" {
t.Fatalf("custom keys %q %q %v", sync, solo, err)
}
for _, bad := range []string{"multi: {multiplexer: screen}", "multi: {panes_per_window: 100}", "groups: {web: []}", "groups: {web: [\"a b\"]}",
"multi: {sync_key: \"x y\"}", "multi: {sync_key: \"{\"}", "multi: {sync_key: e}"} {
if _, err := loadYAML(t, bad+"\n"); err == nil {
t.Errorf("%s accepted", bad)
}
}
}
func TestPreConnectLayeringAndNone(t *testing.T) {
cfg, err := loadYAML(t, `
netboxes:
- name: prod
url: https://prod.example.com
ssh:
pre_connect: vpn-up prod
- name: lab
url: https://lab.example.com
ssh:
pre_connect: check-vpn
rules:
- match: {tag: dmz}
pre_connect: none
`)
if err != nil {
t.Fatal(err)
}
for _, tc := range []struct {
host SSHHost
want string
}{
{SSHHost{Instance: "lab", Name: "web01"}, "check-vpn"},
{SSHHost{Instance: "prod", Name: "web01"}, "vpn-up prod"},
{SSHHost{Instance: "prod", Name: "gw", Tags: []string{"dmz"}}, ""},
} {
if got := cfg.SSHOptionsFor(tc.host).PreConnectCommand(); got != tc.want {
t.Errorf("%+v: got %q, want %q", tc.host, got, tc.want)
}
}
if err := (SSHOptions{PreConnect: "a\x00b"}).Validate("ssh"); err == nil {
t.Error("NUL byte in pre_connect accepted")
}
}
func TestPreConnectFromEnvironment(t *testing.T) {
t.Setenv("NETSSH_SSH_PRE_CONNECT", "true")
t.Setenv("NETSSH_SHORTCUTS_SHOW", "true")
cfg, err := loadYAML(t, "")
if err != nil {
t.Fatal(err)
}
if cfg.SSH.PreConnect != "true" || !cfg.Shortcuts.Show {
t.Fatalf("env not applied: pre_connect=%q show=%v", cfg.SSH.PreConnect, cfg.Shortcuts.Show)
}
}
+93 -5
View File
@@ -16,8 +16,9 @@ import (
// AliasEntry holds a single shell alias mapping.
type AliasEntry struct {
Name string // short alias name (e.g. "web01")
Host string // canonical NetBox hostname (e.g. "web01.example.com")
Command string // configured host command; empty means the default SSH alias
Name string // short alias name (e.g. "web01")
Host string // canonical NetBox hostname (e.g. "web01.example.com")
}
// AliasesPath returns the path for the bash/zsh aliases file.
@@ -51,7 +52,7 @@ func WriteAliasFiles(entries []AliasEntry) error {
writeFishAliasFile(entries) // best-effort — never blocks the caller on failure
alias := ""
for _, entry := range entries {
if entry.Host == "" {
if entry.Host == "" && entry.Command == "" {
alias = entry.Name
break
}
@@ -94,6 +95,9 @@ func writeFishAliasFile(entries []AliasEntry) {
// Empty Host represents an alias for the netssh command itself.
func (e AliasEntry) Definition(shell string) string {
command := "netssh"
if e.Command != "" {
command += " run " + shellQuote(e.Command, shell) + " --"
}
if e.Host != "" {
host := e.Host
if !regexp.MustCompile(`^[a-zA-Z0-9_.:-]+$`).MatchString(host) {
@@ -124,14 +128,98 @@ func BuildAliasEntries(entries []cache.Entry, cfg config.Config) []AliasEntry {
seen[cfg.Shell.Alias] = true
out = append(out, AliasEntry{Name: cfg.Shell.Alias})
}
for _, e := range entries {
// Links are names the user chose explicitly: they come before host aliases.
validLink := regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_-]*$`)
links := make([]string, 0, len(cfg.Links))
for name := range cfg.Links {
links = append(links, strings.ToLower(name))
}
sort.Strings(links)
for _, name := range links {
if !seen[name] && validLink.MatchString(name) {
seen[name] = true
out = append(out, AliasEntry{Name: name, Host: name})
}
}
withoutPrefix := make(map[string]bool, len(cfg.NetBoxes))
for _, source := range cfg.NetBoxes {
withoutPrefix[strings.ToLower(source.Name)] = source.DisablePrefix
}
// Reserve canonical aliases as well as requested bare aliases before
// generating any output, so cache ordering cannot redirect a collision.
canonical := make(map[string]bool, len(entries))
counts := make(map[string]int, len(entries))
candidates := make([]string, len(entries))
for i, e := range entries {
name := shortcuts.AliasName(e.Name, cfg.Shortcuts)
if seen[name] || name == "" || !regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_-]*$`).MatchString(name) {
canonical[name] = true
source, host, qualified := strings.Cut(e.Name, "/")
if qualified && withoutPrefix[strings.ToLower(source)] {
name = shortcuts.AliasName(host, cfg.Shortcuts)
}
candidates[i] = name
counts[name]++
}
validAlias := regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_-]*$`)
for i, e := range entries {
name := candidates[i]
full := shortcuts.AliasName(e.Name, cfg.Shortcuts)
if name != full && (counts[name] > 1 || canonical[name] || seen[name] || !validAlias.MatchString(name)) {
name = full
}
if seen[name] || name == "" || !validAlias.MatchString(name) {
continue
}
seen[name] = true
out = append(out, AliasEntry{Name: name, Host: e.Name})
}
// Build from the final SSH aliases, preserving per-instance prefix and
// collision handling. Never replace an existing SSH or command alias.
hostAliases := append([]AliasEntry(nil), out...)
hostMetadata := map[string]config.SSHHost{}
for _, e := range entries {
instance, hostname, ok := strings.Cut(e.Name, "/")
if !ok {
hostname = instance
instance = ""
}
hostMetadata[e.Name] = config.SSHHost{Instance: instance, Name: hostname, Kind: e.Kind, Tags: e.Tags, Status: e.Status,
Site: cache.RefOf(e.Site), Role: cache.RefOf(e.Role), Platform: cache.RefOf(e.Platform), Tenant: cache.RefOf(e.Tenant)}
}
var commands []string
for name := range cfg.Commands {
commands = append(commands, name)
}
sort.Strings(commands)
var candidatesForCommands []AliasEntry
commandCounts := make(map[string]int)
for _, name := range commands {
prefix := cfg.Commands[name].AliasPrefix
if prefix == "" {
continue
}
for _, host := range hostAliases {
if host.Host == "" {
continue
}
if !cfg.Commands[name].Allowed(hostMetadata[host.Host]) {
continue
}
alias := prefix + host.Name
commandCounts[alias]++
candidatesForCommands = append(candidatesForCommands, AliasEntry{Name: alias, Host: host.Host, Command: name})
}
}
for _, c := range candidatesForCommands {
if seen[c.Name] || commandCounts[c.Name] != 1 {
continue
}
seen[c.Name] = true
out = append(out, c)
}
return out
}
+193
View File
@@ -2,6 +2,7 @@ package hook_test
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
@@ -242,3 +243,195 @@ func TestAliasesIncludeInstanceName(t *testing.T) {
t.Fatalf("alias lost source: %+v", entries)
}
}
func TestAliasesUseRewriteRules(t *testing.T) {
cfg := config.Config{Shortcuts: config.ShortcutsConfig{
Domains: []string{".hoster.de"},
Rewrites: []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}},
}}
entries := hook.BuildAliasEntries([]cache.Entry{{Name: "fsn1-bx1.hoster.de"}}, cfg)
if len(entries) != 1 || entries[0].Definition("bash") != "alias fsnbx1='netssh fsn1-bx1.hoster.de'" {
t.Fatalf("entries: %+v", entries)
}
}
func TestAliasesOptionalInstancePrefix(t *testing.T) {
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{
{Name: "OFFICE", DisablePrefix: true},
{Name: "lab"},
},
Shortcuts: config.ShortcutsConfig{
Domains: []string{".example.com"},
Rewrites: []config.ShortcutRewrite{{Pattern: "^web-", Replace: "app"}},
},
}
entries := hook.BuildAliasEntries([]cache.Entry{
{Name: "office/web-01.example.com"},
{Name: "lab/web-01.example.com"},
}, cfg)
got := map[string]string{}
for _, e := range entries {
got[e.Name] = e.Host
// Both output formats must keep the fully qualified destination.
for _, shell := range []string{"bash", "zsh", "fish"} {
if !strings.Contains(e.Definition(shell), e.Host) {
t.Fatalf("%s alias lost its target: %s", shell, e.Definition(shell))
}
}
}
if len(got) != 2 || got["app01"] != "office/web-01.example.com" || got["lab_app01"] != "lab/web-01.example.com" {
t.Fatalf("unexpected aliases: %+v", entries)
}
}
func TestAliasesWithoutPrefixCollisions(t *testing.T) {
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{
{Name: "office", DisablePrefix: true},
{Name: "lab", DisablePrefix: true},
},
Shell: config.ShellConfig{Alias: "j"},
Shortcuts: config.ShortcutsConfig{Domains: []string{".example.com"}},
}
for _, tc := range []struct {
name string
hosts []string
want map[string]string
}{
{"two instances", []string{"office/web.example.com", "lab/web.example.com"},
map[string]string{"j": "", "office_web": "office/web.example.com", "lab_web": "lab/web.example.com"}},
{"static host", []string{"office/web.example.com", "web"},
map[string]string{"j": "", "office_web": "office/web.example.com", "web": "web"}},
{"command aliases", []string{"office/j", "office/netssh"},
map[string]string{"j": "", "office_j": "office/j", "office_netssh": "office/netssh"}},
{"reserved qualified alias", []string{"office/lab_web", "lab/web"},
map[string]string{"j": "", "office_lab_web": "office/lab_web", "web": "lab/web"}},
{"invalid bare alias", []string{"office/123.example.com"},
map[string]string{"j": "", "office_123": "office/123.example.com"}},
{"normalized names", []string{"office/web.example.com", "office/web"},
map[string]string{"j": "", "office_web": "office/web"}},
} {
t.Run(tc.name, func(t *testing.T) {
var input []cache.Entry
for _, host := range tc.hosts {
input = append(input, cache.Entry{Name: host})
}
entries := hook.BuildAliasEntries(input, cfg)
if len(entries) != len(tc.want) {
t.Fatalf("aliases: %+v, want %+v", entries, tc.want)
}
for _, e := range entries {
if host, ok := tc.want[e.Name]; !ok || host != e.Host {
t.Fatalf("unexpected alias: %+v", e)
}
}
})
}
}
func TestCustomCommandAliases(t *testing.T) {
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "office", DisablePrefix: true}},
Shortcuts: config.ShortcutsConfig{Rewrites: []config.ShortcutRewrite{{Pattern: "^xzi-groß", Replace: "xg"}}},
Commands: map[string]config.HostCommand{
"mtr": {AliasPrefix: "m", Args: []string{"mtr", "{address}"}},
"ping": {AliasPrefix: "p", Args: []string{"ping", "{address}"}},
"manual": {Args: []string{"echo", "{host}"}},
},
}
entries := hook.BuildAliasEntries([]cache.Entry{{Name: "office/xzi-groß1", IP: "10.0.0.1"}}, cfg)
got := map[string]hook.AliasEntry{}
for _, e := range entries {
got[e.Name] = e
}
if len(entries) != 3 || got["mxg1"].Command != "mtr" || got["pxg1"].Command != "ping" {
t.Fatalf("unexpected aliases: %+v", entries)
}
if got["mxg1"].Host != "office/xzi-groß1" {
t.Fatal("instance lost")
}
for _, shell := range []string{"bash", "zsh", "fish"} {
def := got["mxg1"].Definition(shell)
if !strings.Contains(def, "netssh run") || !strings.Contains(def, "office/xzi-groß1") || strings.Contains(def, "10.0.0.1") {
t.Fatalf("%s alias must resolve at invocation: %s", shell, def)
}
}
}
func TestCustomCommandAliasesPreserveExistingNames(t *testing.T) {
cfg := config.Config{
Shell: config.ShellConfig{Alias: "mfoo"},
Commands: map[string]config.HostCommand{
"mtr": {AliasPrefix: "m", Args: []string{"mtr", "{address}"}},
"ping": {AliasPrefix: "mp", Args: []string{"ping", "{address}"}},
},
}
entries := hook.BuildAliasEntries([]cache.Entry{
{Name: "foo"}, {Name: "web"}, {Name: "mweb"}, {Name: "x"}, {Name: "px"},
}, cfg)
for _, e := range entries {
if e.Name == "mfoo" && (e.Host != "" || e.Command != "") {
t.Fatal("command alias overwritten")
}
if e.Name == "mweb" && (e.Host != "mweb" || e.Command != "") {
t.Fatal("SSH alias overwritten")
}
if e.Name == "mpx" {
t.Fatal("ambiguous custom alias generated")
}
}
}
func TestCustomAliasShellArgumentQuoting(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "netssh"), []byte("#!/bin/sh\nprintf '%s\\n' \"$@\"\n"), 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH"))
entry := hook.AliasEntry{Name: "mxg1", Host: "office/xzi-groß1'$(oops)", Command: "mtr"}
for _, shell := range []string{"bash", "zsh", "fish"} {
t.Run(shell, func(t *testing.T) {
path, err := exec.LookPath(shell)
if err != nil {
t.Skip("shell not installed")
}
// A separate parse models invoking an alias after sourcing the file.
script := entry.Definition(shell) + "\neval 'mxg1 --report'\n"
args := []string{"-c", script}
if shell == "bash" {
args = []string{"--noprofile", "--norc", "-O", "expand_aliases", "-c", script}
}
if shell == "zsh" {
args = []string{"-f", "-c", script}
}
if shell == "fish" {
args = []string{"--no-config", "-c", script}
}
out, err := exec.Command(path, args...).CombinedOutput()
want := "run\nmtr\n--\n" + entry.Host + "\n--report\n"
if err != nil || string(out) != want {
t.Fatalf("%q (%v), want %q", out, err, want)
}
})
}
}
func TestCommandAliasesHonourNetBoxAttributes(t *testing.T) {
cfg := config.Config{Commands: map[string]config.HostCommand{
"cli": {AliasPrefix: "c", Args: []string{"cli", "{address}"}, Match: config.SSHMatch{Platform: "junos"}},
}}
entries := []cache.Entry{
{Name: "sw1", Kind: "device", Platform: &config.Ref{Name: "Junos", Slug: "junos"}},
{Name: "web1", Kind: "vm", Platform: &config.Ref{Slug: "ubuntu"}},
}
var got []string
for _, a := range hook.BuildAliasEntries(entries, cfg) {
if a.Command == "cli" {
got = append(got, a.Name)
}
}
if len(got) != 1 || got[0] != "csw1" {
t.Fatalf("command aliases %v", got)
}
}
+251
View File
@@ -0,0 +1,251 @@
// Package multiplex opens several commands side by side in tmux or zellij.
package multiplex
import (
"errors"
"fmt"
"io"
"os"
"os/exec"
"strings"
"syscall"
)
// Pane is one command shown in its own pane.
type Pane struct {
Title string
Argv []string
}
// Options control how panes are laid out.
type Options struct {
Label string // window, session, and tab name
Sync bool // type into all panes of a window at once
PerWindow int // panes per tmux window or zellij tab
LayoutDir string // where zellij layout files and tmux key bindings are written
// SyncKey and SoloKey are tmux prefix keys that toggle broadcast for the
// window and exclude the current pane from it; empty means no binding.
SyncKey, SoloKey string
// Hint receives notes for the user before the process is replaced.
Hint func(string)
}
// Runner executes multiplexer commands; tests and --dry-run replace it.
type Runner interface {
// Output runs argv and returns its trimmed standard output.
Output(argv ...string) (string, error)
// Exec replaces the current process with argv.
Exec(argv ...string) error
LookPath(name string) (string, error)
Getenv(key string) string
WriteFile(path string, data []byte) error
}
// Supported multiplexers.
const (
Tmux = "tmux"
Zellij = "zellij"
)
// ErrNone means neither tmux nor zellij is available.
var ErrNone = errors.New("netssh multi needs tmux or zellij; install one of them (e.g. apt install tmux)")
// Detect picks the multiplexer: the requested one, else the one netssh runs
// in, else tmux, else zellij.
func Detect(requested string, r Runner) (string, error) {
switch requested {
case Tmux, Zellij:
if _, err := r.LookPath(requested); err != nil {
return "", fmt.Errorf("%s is not installed", requested)
}
return requested, nil
case "", "auto":
default:
return "", fmt.Errorf("unknown multiplexer %q", requested)
}
if r.Getenv("TMUX") != "" {
return Tmux, nil
}
if r.Getenv("ZELLIJ") != "" {
return Zellij, nil
}
for _, name := range []string{Tmux, Zellij} {
if _, err := r.LookPath(name); err == nil {
return name, nil
}
}
return "", ErrNone
}
// Open shows panes in the multiplexer. Outside of it, Open replaces the
// process with the multiplexer client and only returns on error.
func Open(kind string, panes []Pane, opts Options, r Runner) error {
if len(panes) == 0 {
return errors.New("no hosts to open")
}
if opts.Hint == nil {
opts.Hint = func(string) {}
}
if opts.PerWindow <= 0 {
opts.PerWindow = 9
}
if opts.Label == "" {
opts.Label = "netssh"
}
switch kind {
case Tmux:
return openTmux(panes, opts, r)
case Zellij:
return openZellij(panes, opts, r)
}
return fmt.Errorf("unknown multiplexer %q", kind)
}
// ToggleSync switches broadcast input in the current tmux window or zellij
// tab; with pane it excludes the current tmux pane from it or includes it again.
func ToggleSync(r Runner, pane bool) (string, error) {
if pane {
if r.Getenv("TMUX") == "" {
if r.Getenv("ZELLIJ") != "" {
return "", errors.New("zellij broadcasts to a whole tab; single panes cannot be excluded")
}
return "", errors.New("netssh sync --pane works inside tmux")
}
solo, err := r.Output("tmux", "display-message", "-p", "#{@netssh_solo}")
if err != nil {
return "", err
}
for _, argv := range soloToggle(solo == "1") {
if _, err := r.Output(argv...); err != nil {
return "", err
}
}
if solo == "1" {
return "pane included in broadcast", nil
}
return "pane excluded from broadcast", nil
}
switch {
case r.Getenv("TMUX") != "":
current, err := r.Output("tmux", "show-window-options", "-v", "synchronize-panes")
if err != nil {
return "", err
}
next := "on"
if current == "on" {
next = "off"
}
if _, err := r.Output("tmux", "set-window-option", "synchronize-panes", next); err != nil {
return "", err
}
return "broadcast " + next, nil
case r.Getenv("ZELLIJ") != "":
if _, err := r.Output("zellij", "action", "toggle-active-sync-tab"); err != nil {
return "", err
}
return "broadcast toggled", nil
}
return "", errors.New("netssh sync works inside tmux or zellij")
}
// chunks splits panes into groups of at most n.
func chunks(panes []Pane, n int) [][]Pane {
var out [][]Pane
for len(panes) > n {
out = append(out, panes[:n])
panes = panes[n:]
}
return append(out, panes)
}
// windowLabel numbers windows when the panes need more than one.
func windowLabel(label string, i, total int) string {
if total == 1 {
return label
}
return fmt.Sprintf("%s-%d", label, i+1)
}
// System runs real commands.
type System struct{}
func (System) Output(argv ...string) (string, error) {
cmd := exec.Command(argv[0], argv[1:]...)
var stderr strings.Builder
cmd.Stderr = &stderr
out, err := cmd.Output()
if err != nil {
if msg := strings.TrimSpace(stderr.String()); msg != "" {
return "", fmt.Errorf("%s: %s", argv[0], msg)
}
return "", fmt.Errorf("%s: %w", argv[0], err)
}
return strings.TrimSpace(string(out)), nil
}
func (System) Exec(argv ...string) error {
path, err := exec.LookPath(argv[0])
if err != nil {
return err
}
return syscall.Exec(path, argv, os.Environ())
}
func (System) LookPath(name string) (string, error) { return exec.LookPath(name) }
func (System) Getenv(key string) string { return os.Getenv(key) }
func (System) WriteFile(path string, data []byte) error {
return os.WriteFile(path, data, 0o600)
}
// DryRun prints commands instead of running them; Output returns fake IDs.
type DryRun struct {
W io.Writer
Env map[string]string // values for Getenv, e.g. TMUX
n int
}
func (d *DryRun) Output(argv ...string) (string, error) {
fmt.Fprintln(d.W, shellJoin(argv))
d.n++
switch {
case len(argv) > 1 && (argv[1] == "new-window" || argv[1] == "new-session"):
return fmt.Sprintf("@%d %%%d", d.n, d.n), nil
case len(argv) > 1 && argv[1] == "split-window":
return fmt.Sprintf("%%%d", d.n), nil
case len(argv) > 1 && argv[1] == "has-session":
return "", errors.New("no session")
}
return "", nil
}
func (d *DryRun) Exec(argv ...string) error {
fmt.Fprintln(d.W, shellJoin(argv))
return nil
}
// LookPath pretends every multiplexer is installed, so --dry-run shows the
// commands on machines without tmux or zellij.
func (d *DryRun) LookPath(name string) (string, error) { return name, nil }
func (d *DryRun) Getenv(key string) string {
if v, ok := d.Env[key]; ok {
return v
}
return os.Getenv(key)
}
func (d *DryRun) WriteFile(path string, data []byte) error {
fmt.Fprintf(d.W, "# %s\n%s", path, data)
return nil
}
// shellJoin quotes argv for display.
func shellJoin(argv []string) string {
quoted := make([]string, len(argv))
for i, arg := range argv {
if arg != "" && strings.Trim(arg, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@%+=:,./_-") == "" {
quoted[i] = arg
continue
}
quoted[i] = "'" + strings.ReplaceAll(arg, "'", `'\''`) + "'"
}
return strings.Join(quoted, " ")
}
+317
View File
@@ -0,0 +1,317 @@
package multiplex
import (
"errors"
"fmt"
"strings"
"testing"
)
// fake records commands and answers like tmux and zellij would.
type fake struct {
env map[string]string
installed map[string]bool
sessions map[string]bool
calls []string
exec []string
files map[string]string
syncState string
keys map[string]string // existing prefix bindings by key
solo string
prefix string
n int
}
func newFake(env map[string]string, installed ...string) *fake {
f := &fake{env: env, installed: map[string]bool{}, sessions: map[string]bool{}, files: map[string]string{}, syncState: "off"}
for _, name := range installed {
f.installed[name] = true
}
return f
}
func (f *fake) Output(argv ...string) (string, error) {
f.calls = append(f.calls, strings.Join(argv, " "))
f.n++
switch argv[1] {
case "show-options":
return f.prefix, nil
case "new-window", "new-session":
return fmt.Sprintf("@%d %%%d", f.n, f.n), nil
case "split-window":
return fmt.Sprintf("%%%d", f.n), nil
case "has-session":
if f.sessions[strings.TrimPrefix(argv[3], "=")] {
return "", nil
}
return "", errors.New("can't find session")
case "show-window-options":
return f.syncState, nil
case "list-keys":
return f.keys[argv[4]], nil
case "display-message":
return f.solo, nil
}
return "", nil
}
func (f *fake) Exec(argv ...string) error { f.exec = argv; return nil }
func (f *fake) LookPath(name string) (string, error) {
if f.installed[name] {
return "/usr/bin/" + name, nil
}
return "", errors.New("not found")
}
func (f *fake) Getenv(key string) string { return f.env[key] }
func (f *fake) WriteFile(path string, data []byte) error {
f.files[path] = string(data)
return nil
}
func panes(names ...string) []Pane {
out := make([]Pane, 0, len(names))
for _, name := range names {
out = append(out, Pane{Title: name, Argv: []string{"/usr/bin/netssh", name}})
}
return out
}
func TestDetect(t *testing.T) {
for _, tc := range []struct {
requested string
env map[string]string
installed []string
want string
}{
{"", map[string]string{"TMUX": "/tmp/tmux"}, []string{"tmux", "zellij"}, Tmux},
{"auto", map[string]string{"ZELLIJ": "0"}, []string{"tmux", "zellij"}, Zellij},
{"", nil, []string{"tmux", "zellij"}, Tmux},
{"", nil, []string{"zellij"}, Zellij},
{"zellij", map[string]string{"TMUX": "x"}, []string{"tmux", "zellij"}, Zellij},
} {
got, err := Detect(tc.requested, newFake(tc.env, tc.installed...))
if err != nil || got != tc.want {
t.Errorf("%+v: got %q %v", tc, got, err)
}
}
if _, err := Detect("", newFake(nil)); !errors.Is(err, ErrNone) {
t.Errorf("nothing installed: %v", err)
}
if _, err := Detect("tmux", newFake(nil, "zellij")); err == nil {
t.Error("missing requested multiplexer accepted")
}
}
func TestTmuxInside(t *testing.T) {
f := newFake(map[string]string{"TMUX": "/tmp/tmux-1/default"}, "tmux")
if err := Open(Tmux, panes("a", "b", "c"), Options{Label: "pve", Sync: true, SyncKey: "S", SoloKey: "e", LayoutDir: "/tmp/l"}, f); err != nil {
t.Fatal(err)
}
script := "sh -c " + paneScript + " netssh-pane /usr/bin/netssh "
want := []string{
"tmux new-window -P -F #{window_id} #{pane_id} -n pve " + script + "a",
"tmux split-window -t @1 -P -F #{pane_id} " + script + "b",
"tmux select-layout -t @1 tiled",
"tmux split-window -t @1 -P -F #{pane_id} " + script + "c",
"tmux select-layout -t @1 tiled",
"tmux set-option -p -t %1 @netssh_host a",
"tmux set-option -p -t %2 @netssh_host b",
"tmux set-option -p -t %4 @netssh_host c",
"tmux set-window-option -t @1 @netssh 1",
"tmux set-window-option -t @1 pane-border-status top",
"tmux set-window-option -t @1 pane-border-format #{@netssh_host}#{?pane_synchronized, [SYNC],#{?@netssh_solo, [SOLO],}} ",
"tmux set-window-option -t @1 synchronize-panes on",
"tmux show-options -gv prefix",
"tmux list-keys -T prefix S",
"tmux list-keys -T prefix e",
"tmux source-file /tmp/l/netssh-multi.tmux.conf",
"tmux set-window-option -t @1 @netssh_keys keys: Ctrl+b then S: sync on/off | Ctrl+b then e: solo on/off",
"tmux set-window-option -t @1 pane-border-format #{@netssh_host}#{?pane_synchronized, [SYNC],#{?@netssh_solo, [SOLO],}} #{?pane_active, | #{@netssh_keys},} ",
"tmux select-window -t @1",
}
if strings.Join(f.calls, "\n") != strings.Join(want, "\n") {
t.Fatalf("calls:\n%s\nwant:\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n"))
}
if f.exec != nil {
t.Fatal("inside tmux must not attach")
}
}
func TestTmuxOutsideSplitsWindowsAndAvoidsSessionNames(t *testing.T) {
f := newFake(nil, "tmux")
f.sessions["netssh-pve"] = true
var hints []string
err := Open(Tmux, panes("a", "b", "c"), Options{Label: "pve", PerWindow: 2, Hint: func(s string) { hints = append(hints, s) }}, f)
if err != nil {
t.Fatal(err)
}
joined := strings.Join(f.calls, "\n")
for _, want := range []string{
"tmux has-session -t =netssh-pve-2",
"tmux new-session -d -x 240 -y 70 -s netssh-pve-2 -P -F #{window_id} #{pane_id} -n pve-1 ",
"tmux new-window -t netssh-pve-2: -P -F #{window_id} #{pane_id} -n pve-2 ",
"tmux set-option -t netssh-pve-2 status-left-length 40",
} {
if !strings.Contains(joined, want) {
t.Errorf("missing %q in\n%s", want, joined)
}
}
if strings.Contains(joined, "synchronize-panes") {
t.Error("sync set without --sync")
}
if strings.Join(f.exec, " ") != "tmux attach-session -t netssh-pve-2" || len(hints) != 1 {
t.Fatalf("exec %v hints %v", f.exec, hints)
}
}
func TestZellijOutsideWritesGridLayout(t *testing.T) {
f := newFake(nil, "zellij")
if err := Open(Zellij, panes("a", "b", "c", `q"x`), Options{Label: "pve", LayoutDir: "/tmp/l"}, f); err != nil {
t.Fatal(err)
}
layout := f.files["/tmp/l/netssh-multi.kdl"]
for _, want := range []string{
`plugin location="zellij:tab-bar"`,
`tab name="pve" focus=true {`,
`pane split_direction="vertical" {`,
`pane name="a" command="/usr/bin/netssh" {`,
`args "a"`,
`pane name="q\"x" command="/usr/bin/netssh" {`,
} {
if !strings.Contains(layout, want) {
t.Errorf("layout lacks %q:\n%s", want, layout)
}
}
// 4 panes → 2 columns × 2 rows.
if n := strings.Count(layout, `split_direction="vertical"`); n != 2 {
t.Errorf("%d rows, want 2:\n%s", n, layout)
}
if strings.Join(f.exec, " ") != "zellij --layout /tmp/l/netssh-multi.kdl" {
t.Fatalf("exec %v", f.exec)
}
}
func TestZellijInsideAddsTabs(t *testing.T) {
f := newFake(map[string]string{"ZELLIJ": "0"}, "zellij")
if err := Open(Zellij, panes("a", "b", "c"), Options{Label: "pve", PerWindow: 2, Sync: true, LayoutDir: "/tmp/l"}, f); err != nil {
t.Fatal(err)
}
want := []string{
"zellij action new-tab --layout /tmp/l/netssh-multi-1.kdl",
"zellij action toggle-active-sync-tab",
"zellij action new-tab --layout /tmp/l/netssh-multi-2.kdl",
"zellij action toggle-active-sync-tab",
}
if strings.Join(f.calls, "\n") != strings.Join(want, "\n") {
t.Fatalf("calls:\n%s", strings.Join(f.calls, "\n"))
}
if !strings.Contains(f.files["/tmp/l/netssh-multi-2.kdl"], `tab name="pve-2"`) {
t.Fatalf("second tab: %s", f.files["/tmp/l/netssh-multi-2.kdl"])
}
}
func TestToggleSync(t *testing.T) {
f := newFake(map[string]string{"TMUX": "x"})
if state, err := ToggleSync(f, false); err != nil || state != "broadcast on" || f.calls[1] != "tmux set-window-option synchronize-panes on" {
t.Fatalf("%q %v %v", state, err, f.calls)
}
f.syncState = "on"
if state, _ := ToggleSync(f, false); state != "broadcast off" {
t.Fatalf("%q", state)
}
z := newFake(map[string]string{"ZELLIJ": "0"})
if _, err := ToggleSync(z, false); err != nil || z.calls[0] != "zellij action toggle-active-sync-tab" {
t.Fatalf("%v %v", err, z.calls)
}
if _, err := ToggleSync(newFake(nil), false); err == nil {
t.Fatal("outside a multiplexer accepted")
}
}
func TestTmuxKeyBindings(t *testing.T) {
f := newFake(map[string]string{"TMUX": "x"}, "tmux")
var hint string
if err := Open(Tmux, panes("a"), Options{SyncKey: "S", SoloKey: "e", LayoutDir: "/tmp/l", Hint: func(s string) { hint = s }}, f); err != nil {
t.Fatal(err)
}
conf := f.files["/tmp/l/netssh-multi.tmux.conf"]
for _, want := range []string{"bind-key -T prefix S if-shell -F '#{@netssh}'", "bind-key -T prefix e if-shell", "set-option -p synchronize-panes off"} {
if !strings.Contains(conf, want) {
t.Errorf("conf lacks %q:\n%s", want, conf)
}
}
if hint != "keys: Ctrl+b then S: sync on/off | Ctrl+b then e: solo on/off" {
t.Errorf("hint %q", hint)
}
// A key bound in the user's tmux.conf is left alone; netssh's own is replaced.
f = newFake(map[string]string{"TMUX": "x"}, "tmux")
f.keys = map[string]string{"S": "bind-key -T prefix S kill-server", "e": "bind-key -T prefix e if-shell -F #{@netssh} …"}
if err := Open(Tmux, panes("a"), Options{SyncKey: "S", SoloKey: "e", LayoutDir: "/tmp/l", Hint: func(s string) { hint = s }}, f); err != nil {
t.Fatal(err)
}
conf = f.files["/tmp/l/netssh-multi.tmux.conf"]
if strings.Contains(conf, "prefix S ") || !strings.Contains(conf, "prefix e ") {
t.Errorf("user binding overwritten or own binding not refreshed:\n%s", conf)
}
if !strings.Contains(hint, "C-b S kept your own binding") {
t.Errorf("hint %q", hint)
}
// No keys configured: nothing is bound.
f = newFake(map[string]string{"TMUX": "x"}, "tmux")
if err := Open(Tmux, panes("a"), Options{LayoutDir: "/tmp/l"}, f); err != nil {
t.Fatal(err)
}
if len(f.files) != 0 || strings.Contains(strings.Join(f.calls, "\n"), "source-file") {
t.Errorf("bound keys although disabled: %v", f.calls)
}
}
func TestToggleSyncPane(t *testing.T) {
f := newFake(map[string]string{"TMUX": "x"})
if state, err := ToggleSync(f, true); err != nil || state != "pane excluded from broadcast" {
t.Fatalf("%q %v", state, err)
}
if got := strings.Join(f.calls[1:], "; "); got != "tmux set-option -p synchronize-panes off; tmux set-option -p @netssh_solo 1" {
t.Fatalf("exclude: %s", got)
}
f = newFake(map[string]string{"TMUX": "x"})
f.solo = "1"
if state, _ := ToggleSync(f, true); state != "pane included in broadcast" || f.calls[1] != "tmux set-option -pu synchronize-panes" {
t.Fatalf("include: %q %v", state, f.calls)
}
if _, err := ToggleSync(newFake(map[string]string{"ZELLIJ": "0"}), true); err == nil || !strings.Contains(err.Error(), "whole tab") {
t.Fatalf("zellij: %v", err)
}
}
func TestTmuxPersistentHints(t *testing.T) {
for _, tc := range []struct {
name string
keys map[string]string
want string
}{
{"custom prefix", nil, "keys: Ctrl+a then Ctrl+s: sync on/off | Ctrl+a then e: solo on/off"},
{"occupied key", map[string]string{"C-s": "bind-key -T prefix C-s display-time"}, "keys: Ctrl+a then e: solo on/off; C-a C-s kept your own binding (use netssh sync)"},
} {
t.Run(tc.name, func(t *testing.T) {
f := newFake(nil, "tmux")
f.prefix, f.keys = "C-a", tc.keys
if err := Open(Tmux, panes("a", "b"), Options{PerWindow: 1, SyncKey: "C-s", SoloKey: "e"}, f); err != nil {
t.Fatal(err)
}
n := 0
for _, call := range f.calls {
if strings.Contains(call, " @netssh_keys ") {
n++
if !strings.HasSuffix(call, " @netssh_keys "+tc.want) {
t.Fatalf("wrong persistent hint: %s", call)
}
}
}
if n != 2 {
t.Fatalf("hints installed in %d windows, want 2", n)
}
})
}
}
+213
View File
@@ -0,0 +1,213 @@
package multiplex
import (
"fmt"
"path/filepath"
"strconv"
"strings"
)
// paneScript runs the pane's command and keeps a failed one on screen, so an
// unreachable host shows its error instead of the pane vanishing.
const paneScript = `"$@"; status=$?; if [ "$status" -ne 0 ]; then echo; echo "netssh exited with status $status, press Enter to close"; read -r _; fi`
// tmuxArgv runs the pane through sh with argv as arguments: no quoting, and
// independent of the user's default-shell (which may be fish).
func tmuxArgv(p Pane) []string {
return append([]string{"sh", "-c", paneScript, "netssh-pane"}, p.Argv...)
}
// openTmux adds a window per chunk of panes: to the current session inside
// tmux, else to a new detached session that is attached at the end.
func openTmux(panes []Pane, opts Options, r Runner) error {
inside := r.Getenv("TMUX") != ""
session := ""
if !inside {
session = freeSession(r, "netssh-"+opts.Label)
}
groups := chunks(panes, opts.PerWindow)
first := ""
var windows []string
for i, group := range groups {
name := windowLabel(opts.Label, i, len(groups))
format := []string{"-P", "-F", "#{window_id} #{pane_id}", "-n", name}
var create []string
switch {
case inside:
create = append([]string{"tmux", "new-window"}, format...)
case i == 0:
// A large virtual size leaves room for the splits; attaching resizes it.
create = append([]string{"tmux", "new-session", "-d", "-x", "240", "-y", "70", "-s", session}, format...)
default:
create = append([]string{"tmux", "new-window", "-t", session + ":"}, format...)
}
out, err := r.Output(append(create, tmuxArgv(group[0])...)...)
if err != nil {
return err
}
if !inside && i == 0 {
// tmux cuts the status bar's session name at 10 characters
// ("[netssh-pv"); widen it for this session only.
if _, err := r.Output("tmux", "set-option", "-t", session, "status-left-length", "40"); err != nil {
return err
}
}
window, pane, _ := strings.Cut(out, " ")
windows = append(windows, window)
if first == "" {
first = window
}
paneIDs := []string{pane}
for _, p := range group[1:] {
id, err := r.Output(append([]string{"tmux", "split-window", "-t", window, "-P", "-F", "#{pane_id}"}, tmuxArgv(p)...)...)
if err != nil {
return err
}
paneIDs = append(paneIDs, id)
// Re-tile after every split so the next one still has room.
if _, err := r.Output("tmux", "select-layout", "-t", window, "tiled"); err != nil {
return err
}
}
for j, id := range paneIDs {
// A pane may already be gone (host unreachable and closed); not fatal.
_, _ = r.Output("tmux", "set-option", "-p", "-t", id, "@netssh_host", group[j].Title)
}
windowOptions := [][]string{
{"@netssh", "1"}, // the key bindings act only in these windows
{"pane-border-status", "top"},
{"pane-border-format", " #{@netssh_host}#{?pane_synchronized, [SYNC],#{?@netssh_solo, [SOLO],}} "},
}
if opts.Sync {
windowOptions = append(windowOptions, []string{"synchronize-panes", "on"})
}
for _, option := range windowOptions {
if _, err := r.Output("tmux", "set-window-option", "-t", window, option[0], option[1]); err != nil {
return err
}
}
}
keys, err := bindKeys(r, opts)
if err != nil {
return err
}
if keys != "" {
opts.Hint(keys)
// Window-local hints remain visible after attaching, including in an
// existing session. Keep other windows and the user's status bar intact.
for _, window := range windows {
if _, err := r.Output("tmux", "set-window-option", "-t", window, "@netssh_keys", keys); err != nil {
return err
}
if _, err := r.Output("tmux", "set-window-option", "-t", window, "pane-border-format",
" #{@netssh_host}#{?pane_synchronized, [SYNC],#{?@netssh_solo, [SOLO],}} #{?pane_active, | #{@netssh_keys},} "); err != nil {
return err
}
}
}
if inside {
_, err := r.Output("tmux", "select-window", "-t", first)
return err
}
return r.Exec("tmux", "attach-session", "-t", session)
}
// soloToggle excludes the current pane from broadcast (a pane-level
// synchronize-panes off) or includes it again by removing that override.
func soloToggle(solo bool) [][]string {
if solo {
return [][]string{
{"tmux", "set-option", "-pu", "synchronize-panes"},
{"tmux", "set-option", "-pu", "@netssh_solo"},
}
}
return [][]string{
{"tmux", "set-option", "-p", "synchronize-panes", "off"},
{"tmux", "set-option", "-p", "@netssh_solo", "1"},
}
}
// keyBindings toggle broadcast in netssh multi windows; elsewhere they only
// show a message, so they do not change what the keys mean to other windows.
const syncBinding = `bind-key -T prefix %s if-shell -F '#{@netssh}' {
set-window-option synchronize-panes
display-message 'netssh: broadcast #{?synchronize-panes,on,off}'
} {
display-message 'netssh: not a netssh multi window'
}
`
const soloBinding = `bind-key -T prefix %s if-shell -F '#{@netssh}' {
if-shell -F '#{@netssh_solo}' {
set-option -pu synchronize-panes
set-option -pu @netssh_solo
display-message 'netssh: pane included in broadcast'
} {
set-option -p synchronize-panes off
set-option -p @netssh_solo 1
display-message 'netssh: pane excluded from broadcast'
}
} {
display-message 'netssh: not a netssh multi window'
}
`
// bindKeys installs the broadcast keys in the tmux server unless the user's
// own configuration already uses them, and returns a hint naming the keys.
func bindKeys(r Runner, opts Options) (string, error) {
prefix, err := r.Output("tmux", "show-options", "-gv", "prefix")
if err != nil || prefix == "" {
prefix = "C-b"
}
var conf strings.Builder
var hints, taken []string
for _, key := range []struct{ key, binding, what string }{
{opts.SyncKey, syncBinding, "sync on/off"},
{opts.SoloKey, soloBinding, "solo on/off"},
} {
if key.key == "" {
continue
}
// An existing binding is replaced only if netssh made it.
if existing, _ := r.Output("tmux", "list-keys", "-T", "prefix", key.key); existing != "" && !strings.Contains(existing, "@netssh") {
taken = append(taken, prefix+" "+key.key)
continue
}
fmt.Fprintf(&conf, key.binding, key.key)
hints = append(hints, displayKey(prefix)+" then "+displayKey(key.key)+": "+key.what)
}
if conf.Len() > 0 {
path := filepath.Join(opts.LayoutDir, "netssh-multi.tmux.conf")
if err := r.WriteFile(path, []byte(conf.String())); err != nil {
return "", err
}
if _, err := r.Output("tmux", "source-file", path); err != nil {
return "", err
}
}
hint := "keys: " + strings.Join(hints, " | ")
if len(hints) == 0 {
hint = "toggle broadcast with: netssh sync, netssh sync --pane"
}
if len(taken) > 0 {
hint += "; " + strings.Join(taken, " and ") + " kept your own binding (use netssh sync)"
}
return hint, nil
}
// freeSession returns name, or name-2, name-3, … if a session already uses it.
func freeSession(r Runner, name string) string {
candidate := name
for n := 2; ; n++ {
if _, err := r.Output("tmux", "has-session", "-t", "="+candidate); err != nil {
return candidate
}
candidate = name + "-" + strconv.Itoa(n)
}
}
// displayKey expands tmux's modifier notation for the on-screen legend.
func displayKey(key string) string {
key = strings.ReplaceAll(key, "C-", "Ctrl+")
return strings.ReplaceAll(key, "M-", "Alt+")
}
+101
View File
@@ -0,0 +1,101 @@
package multiplex
import (
"fmt"
"math"
"path/filepath"
"strings"
)
// openZellij writes a layout with one tab per chunk of panes. Inside zellij
// each tab is added to the current session; outside, a new session starts.
func openZellij(panes []Pane, opts Options, r Runner) error {
groups := chunks(panes, opts.PerWindow)
if r.Getenv("ZELLIJ") != "" {
for i, group := range groups {
path := filepath.Join(opts.LayoutDir, fmt.Sprintf("netssh-multi-%d.kdl", i+1))
tab := zellijTab(windowLabel(opts.Label, i, len(groups)), group, true)
if err := r.WriteFile(path, []byte(zellijLayout(tab))); err != nil {
return err
}
if _, err := r.Output("zellij", "action", "new-tab", "--layout", path); err != nil {
return err
}
if opts.Sync {
if _, err := r.Output("zellij", "action", "toggle-active-sync-tab"); err != nil {
return err
}
}
}
return nil
}
var tabs strings.Builder
for i, group := range groups {
tabs.WriteString(zellijTab(windowLabel(opts.Label, i, len(groups)), group, i == 0))
}
path := filepath.Join(opts.LayoutDir, "netssh-multi.kdl")
if err := r.WriteFile(path, []byte(zellijLayout(tabs.String()))); err != nil {
return err
}
if opts.Sync {
opts.Hint("zellij starts without broadcast: press Ctrl+t, then s, to type into all panes")
} else {
opts.Hint("toggle broadcast with Ctrl+t, then s (or netssh sync)")
}
return r.Exec("zellij", "--layout", path)
}
// zellijLayout wraps tabs with zellij's tab and status bars.
func zellijLayout(tabs string) string {
return `layout {
default_tab_template {
pane size=1 borderless=true {
plugin location="zellij:tab-bar"
}
children
pane size=2 borderless=true {
plugin location="zellij:status-bar"
}
}
` + tabs + "}\n"
}
// zellijTab arranges panes in a grid: rows of ceil(sqrt(n)) columns.
func zellijTab(name string, panes []Pane, focus bool) string {
cols := int(math.Ceil(math.Sqrt(float64(len(panes)))))
var b strings.Builder
fmt.Fprintf(&b, " tab name=%s", kdlString(name))
if focus {
b.WriteString(" focus=true")
}
b.WriteString(" {\n")
for start := 0; start < len(panes); start += cols {
row := panes[start:min(start+cols, len(panes))]
indent := " "
if len(row) > 1 {
b.WriteString(indent + "pane split_direction=\"vertical\" {\n")
indent += " "
}
for _, p := range row {
fmt.Fprintf(&b, "%spane name=%s command=%s {\n", indent, kdlString(p.Title), kdlString(p.Argv[0]))
if len(p.Argv) > 1 {
args := make([]string, 0, len(p.Argv)-1)
for _, arg := range p.Argv[1:] {
args = append(args, kdlString(arg))
}
fmt.Fprintf(&b, "%s args %s\n", indent, strings.Join(args, " "))
}
b.WriteString(indent + "}\n")
}
if len(row) > 1 {
b.WriteString(" }\n")
}
}
b.WriteString(" }\n")
return b.String()
}
// kdlString quotes s as a KDL string.
func kdlString(s string) string {
return `"` + strings.NewReplacer(`\`, `\\`, `"`, `\"`, "\n", `\n`).Replace(s) + `"`
}
+111 -36
View File
@@ -12,6 +12,8 @@ import (
"strings"
"sync"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
type Client struct {
@@ -20,6 +22,9 @@ type Client struct {
token string
tokenVersion int
httpClient *http.Client
locMu sync.Mutex
locations map[int]locationNode // location ID → name and parent, per client
}
// NewClient creates a NetBox API client. Pass tokenVersion=0 to auto-detect
@@ -105,6 +110,22 @@ func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions
if opts.Kind != "" && opts.Kind != "device" && opts.Kind != "vm" {
return nil, fmt.Errorf("invalid host kind %q", opts.Kind)
}
filters := ""
if opts.Tag != "" {
filters += "&tag=" + url.QueryEscape(opts.Tag)
}
if opts.Cluster != "" {
ids, err := c.clusterIDs(ctx, opts.Cluster)
if err != nil {
return nil, fmt.Errorf("clusters: %w", err)
}
if len(ids) == 0 {
return nil, nil // no such cluster in this NetBox
}
for _, id := range ids {
filters += fmt.Sprintf("&cluster_id=%d", id)
}
}
var (
mu sync.Mutex
results []HostEntry
@@ -116,7 +137,7 @@ func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions
wg.Add(1)
go func() {
defer wg.Done()
devices, err := c.fetchAllDevices(ctx, query, opts.Tag)
devices, err := c.fetchAllDevices(ctx, query, filters)
mu.Lock()
defer mu.Unlock()
if err != nil {
@@ -131,7 +152,7 @@ func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions
wg.Add(1)
go func() {
defer wg.Done()
vms, err := c.fetchAllVMs(ctx, query, opts.Tag)
vms, err := c.fetchAllVMs(ctx, query, filters)
mu.Lock()
defer mu.Unlock()
if err != nil {
@@ -160,24 +181,32 @@ func (c *Client) GetIPs(ctx context.Context, entry HostEntry) ([]string, error)
}
return source.GetIPs(ctx, host)
}
var apiURL string
switch entry.Kind {
case "device":
apiURL = fmt.Sprintf("%s/api/ipam/ip-addresses/?device_id=%d&limit=100", c.baseURL, entry.ID)
return c.fetchAllIPs(ctx, fmt.Sprintf("device_id=%d", entry.ID))
case "vm":
apiURL = fmt.Sprintf("%s/api/ipam/ip-addresses/?virtual_machine_id=%d&limit=100", c.baseURL, entry.ID)
default:
return nil, fmt.Errorf("unknown host kind: %q", entry.Kind)
return c.fetchAllIPs(ctx, fmt.Sprintf("virtual_machine_id=%d", entry.ID))
}
return nil, fmt.Errorf("unknown host kind: %q", entry.Kind)
}
var resp netboxIPListResponse
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
}
ips := make([]string, 0, len(resp.Results))
for _, r := range resp.Results {
ips = append(ips, stripPrefix(r.Address))
// fetchAllIPs pages through the IP addresses matching filterParams, so hosts
// with more addresses than one page do not lose their management address.
func (c *Client) fetchAllIPs(ctx context.Context, filterParams string) ([]string, error) {
const pageSize = 100
var ips []string
for offset := 0; ; offset += pageSize {
apiURL := fmt.Sprintf("%s/api/ipam/ip-addresses/?%s&limit=%d&offset=%d", c.baseURL, filterParams, pageSize, offset)
var resp netboxIPListResponse
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
}
for _, r := range resp.Results {
ips = append(ips, stripPrefix(r.Address))
}
if len(resp.Results) < pageSize || len(ips) >= resp.Count {
break
}
}
return ips, nil
}
@@ -187,16 +216,7 @@ func (c *Client) GetIPsWithFilter(ctx context.Context, filterParams string) ([]s
if c.sources != nil {
return nil, fmt.Errorf("IP filters require a host instance; use GetIPsWithFilterForHost")
}
apiURL := fmt.Sprintf("%s/api/ipam/ip-addresses/?%s&limit=100", c.baseURL, filterParams)
var resp netboxIPListResponse
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
}
ips := make([]string, 0, len(resp.Results))
for _, r := range resp.Results {
ips = append(ips, stripPrefix(r.Address))
}
return ips, nil
return c.fetchAllIPs(ctx, filterParams)
}
func (c *Client) searchDevices(ctx context.Context, query, tag string) ([]HostEntry, error) {
@@ -212,6 +232,7 @@ func (c *Client) searchDevices(ctx context.Context, query, tag string) ([]HostEn
for _, d := range resp.Results {
entries = append(entries, deviceToEntry(d))
}
c.fillLocations(ctx, entries)
return entries, nil
}
@@ -231,15 +252,27 @@ func (c *Client) searchVMs(ctx context.Context, query, tag string) ([]HostEntry,
return entries, nil
}
func (c *Client) fetchAllDevices(ctx context.Context, query, tag string) ([]HostEntry, error) {
// clusterIDs returns the IDs of the clusters named name (case-insensitive).
func (c *Client) clusterIDs(ctx context.Context, name string) ([]int, error) {
var resp netboxListResponse[netboxCluster]
apiURL := fmt.Sprintf("%s/api/virtualization/clusters/?name__ie=%s&limit=50", c.baseURL, url.QueryEscape(name))
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
}
ids := make([]int, 0, len(resp.Results))
for _, cluster := range resp.Results {
ids = append(ids, cluster.ID)
}
return ids, nil
}
// fetchAllDevices pages through devices; filters are extra "&key=value" parameters.
func (c *Client) fetchAllDevices(ctx context.Context, query, filters string) ([]HostEntry, error) {
const pageSize = 50
var all []HostEntry
for offset := 0; ; offset += pageSize {
apiURL := fmt.Sprintf("%s/api/dcim/devices/?name__ic=%s&limit=%d&offset=%d",
c.baseURL, url.QueryEscape(query), pageSize, offset)
if tag != "" {
apiURL += "&tag=" + url.QueryEscape(tag)
}
c.baseURL, url.QueryEscape(query), pageSize, offset) + filters
var resp netboxListResponse[netboxDevice]
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
@@ -251,18 +284,16 @@ func (c *Client) fetchAllDevices(ctx context.Context, query, tag string) ([]Host
break
}
}
c.fillLocations(ctx, all)
return all, nil
}
func (c *Client) fetchAllVMs(ctx context.Context, query, tag string) ([]HostEntry, error) {
func (c *Client) fetchAllVMs(ctx context.Context, query, filters string) ([]HostEntry, error) {
const pageSize = 50
var all []HostEntry
for offset := 0; ; offset += pageSize {
apiURL := fmt.Sprintf("%s/api/virtualization/virtual-machines/?name__ic=%s&limit=%d&offset=%d",
c.baseURL, url.QueryEscape(query), pageSize, offset)
if tag != "" {
apiURL += "&tag=" + url.QueryEscape(tag)
}
c.baseURL, url.QueryEscape(query), pageSize, offset) + filters
var resp netboxListResponse[netboxVM]
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
@@ -323,7 +354,7 @@ func (c *Client) request(ctx context.Context, method, apiURL string, body io.Rea
}
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("netbox returned %d for %s", resp.StatusCode, apiURL)
return "", &StatusError{Code: resp.StatusCode, URL: apiURL}
}
if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
@@ -343,6 +374,23 @@ func deviceToEntry(d netboxDevice) HostEntry {
for _, t := range d.Tags {
e.Tags = append(e.Tags, t.Name)
}
if d.Cluster != nil {
e.Cluster = d.Cluster.Name
}
e.Status = d.Status.value()
e.Site, e.Platform, e.Tenant = d.Site.ref(), d.Platform.ref(), d.Tenant.ref()
e.Role = d.Role.ref()
if d.Role == nil {
e.Role = d.DeviceRole.ref()
}
if d.Location != nil {
e.locationID = d.Location.ID
e.Location = []config.Ref{{Name: d.Location.Name, Slug: d.Location.Slug}}
}
if d.Rack != nil {
e.Rack = d.Rack.Name
}
e.Position = rackUnit(d.Position)
return e
}
@@ -357,6 +405,23 @@ func vmToEntry(v netboxVM) HostEntry {
for _, t := range v.Tags {
e.Tags = append(e.Tags, t.Name)
}
if v.Cluster != nil {
e.Cluster = v.Cluster.Name
}
e.Status = v.Status.value()
e.Site, e.Platform, e.Tenant = v.Site.ref(), v.Platform.ref(), v.Tenant.ref()
e.Role = v.Role.ref()
if v.Role == nil {
e.Role = v.DeviceRole.ref()
}
if v.Location != nil {
e.locationID = v.Location.ID
e.Location = []config.Ref{{Name: v.Location.Name, Slug: v.Location.Slug}}
}
if v.Rack != nil {
e.Rack = v.Rack.Name
}
e.Position = rackUnit(v.Position)
return e
}
@@ -368,6 +433,16 @@ func stripPrefix(cidr string) string {
return cidr
}
// StatusError is an unexpected HTTP status from NetBox.
type StatusError struct {
Code int
URL string
}
func (e *StatusError) Error() string {
return fmt.Sprintf("netbox returned %d for %s", e.Code, e.URL)
}
// ErrHostNotFound distinguishes a missing exact match from API failures or ambiguity.
var ErrHostNotFound = errors.New("host not found")
+46 -1
View File
@@ -3,8 +3,11 @@ package netbox
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
)
@@ -235,7 +238,7 @@ func TestGetIPsWithFilter(t *testing.T) {
defer srv.Close()
c := NewClient(srv.URL, "token", 0)
ips, err := c.GetIPsWithFilter(context.Background(), "device_id=1&interface_name=mgmt0")
ips, err := c.GetIPsWithFilter(context.Background(), "device_id=1&interface=mgmt0")
if err != nil {
t.Fatalf("GetIPsWithFilter: %v", err)
}
@@ -499,3 +502,45 @@ func TestCommentConflictIsReported(t *testing.T) {
t.Fatal("conflict ignored")
}
}
// Hosts with more addresses than one page must not lose the later ones.
func TestGetIPs_Paginates(t *testing.T) {
const total = 230
var offsets []string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
offsets = append(offsets, r.URL.Query().Get("offset"))
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
var addrs []string
for i := offset; i < offset+limit && i < total; i++ {
addrs = append(addrs, fmt.Sprintf("10.0.%d.%d/24", i/250, i%250+1))
}
resp := ipListResponse(addrs...)
resp.Count = total
json.NewEncoder(w).Encode(resp)
}))
defer srv.Close()
ips, err := NewClient(srv.URL, "token", 0).GetIPs(context.Background(), HostEntry{ID: 1, Kind: "device"})
if err != nil {
t.Fatalf("GetIPs: %v", err)
}
if len(ips) != total || ips[total-1] != "10.0.0.230" {
t.Errorf("got %d IPs (last %q), want %d", len(ips), ips[len(ips)-1], total)
}
if strings.Join(offsets, ",") != "0,100,200" {
t.Errorf("offsets %v, want 0,100,200", offsets)
}
}
func TestRequest_StatusErrorCarriesCode(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadRequest)
}))
defer srv.Close()
_, err := NewClient(srv.URL, "token", 0).GetIPsWithFilter(context.Background(), "device_id=1&interface=nope")
var status *StatusError
if !errors.As(err, &status) || status.Code != http.StatusBadRequest {
t.Fatalf("got %v, want a StatusError with code 400", err)
}
}
+51
View File
@@ -0,0 +1,51 @@
package netbox
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"testing"
)
func TestSearchAllByCluster(t *testing.T) {
var deviceQuery, vmQuery string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch r.URL.Path {
case "/api/virtualization/clusters/":
if r.URL.Query().Get("name__ie") == "PVE" {
fmt.Fprint(w, `{"count":2,"results":[{"id":3,"name":"pve"},{"id":4,"name":"pve"}]}`)
return
}
fmt.Fprint(w, `{"count":0,"results":[]}`)
case "/api/dcim/devices/":
deviceQuery = r.URL.RawQuery
fmt.Fprint(w, `{"count":1,"results":[{"id":1,"name":"node1","cluster":{"id":3,"name":"pve"}}]}`)
case "/api/virtualization/virtual-machines/":
vmQuery = r.URL.RawQuery
fmt.Fprint(w, `{"count":1,"results":[{"id":2,"name":"vm1","cluster":{"id":4,"name":"pve"}}]}`)
}
}))
defer srv.Close()
c := NewClient(srv.URL, "t", 1)
hosts, err := c.SearchAll(context.Background(), "", SearchOptions{Cluster: "PVE", Kind: "device"})
if err != nil || len(hosts) != 1 || hosts[0].Name != "node1" || hosts[0].Cluster != "pve" {
t.Fatalf("got %+v %v", hosts, err)
}
if want := "name__ic=&limit=50&offset=0&cluster_id=3&cluster_id=4"; deviceQuery != want {
t.Errorf("device query %q, want %q", deviceQuery, want)
}
if vmQuery != "" {
t.Error("VMs queried for kind device")
}
all, err := c.SearchAll(context.Background(), "", SearchOptions{Cluster: "PVE"})
if err != nil || len(all) != 2 {
t.Fatalf("all kinds: %+v %v", all, err)
}
none, err := c.SearchAll(context.Background(), "", SearchOptions{Cluster: "missing"})
if err != nil || len(none) != 0 {
t.Fatalf("unknown cluster: %+v %v", none, err)
}
}
+365
View File
@@ -0,0 +1,365 @@
package netbox
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/url"
"sort"
"strconv"
"strings"
)
// HostDetails is everything netssh info shows about a device or VM.
type HostDetails struct {
HostEntry
URL string `json:"url"`
StatusLabel string `json:"status_label,omitempty"`
HeightU string `json:"height_u,omitempty"` // rack units the device occupies
Face string `json:"face,omitempty"` // front | rear
DeviceType string `json:"device_type,omitempty"`
Serial string `json:"serial,omitempty"`
AssetTag string `json:"asset_tag,omitempty"`
Description string `json:"description,omitempty"`
VCPUs string `json:"vcpus,omitempty"`
MemoryMB int `json:"memory_mb,omitempty"`
DiskGB int `json:"disk_gb,omitempty"`
IPs []IPAssignment `json:"ips"`
}
// IPAssignment is one IP address of a host with the interface it is on.
type IPAssignment struct {
Address string `json:"address"` // CIDR notation
Interface string `json:"interface,omitempty"`
DNSName string `json:"dns_name,omitempty"`
Status string `json:"status,omitempty"`
Role string `json:"role,omitempty"`
VRF string `json:"vrf,omitempty"`
Primary bool `json:"primary,omitempty"`
}
// IPOwner is a NetBox IP address found by LookupIP, with the host and
// interface it is assigned to.
type IPOwner struct {
Source string `json:"instance,omitempty"`
Address string `json:"address"`
Status string `json:"status,omitempty"`
DNSName string `json:"dns_name,omitempty"`
Description string `json:"description,omitempty"`
VRF string `json:"vrf,omitempty"`
Interface string `json:"interface,omitempty"`
HostKind string `json:"kind,omitempty"` // device | vm; empty when unassigned
HostName string `json:"host,omitempty"`
HostID int `json:"host_id,omitempty"`
}
// Target returns the selector of the owning host, or "" when unassigned.
func (o IPOwner) Target() string {
if o.HostName == "" {
return ""
}
return HostEntry{Source: o.Source, Name: o.HostName}.Target()
}
// PrefixInfo is a NetBox prefix that contains an address.
type PrefixInfo struct {
Source string `json:"instance,omitempty"`
Prefix string `json:"prefix"`
Status string `json:"status,omitempty"`
Role string `json:"role,omitempty"`
Site string `json:"site,omitempty"`
VLAN string `json:"vlan,omitempty"`
VRF string `json:"vrf,omitempty"`
Description string `json:"description,omitempty"`
}
type netboxHostDetail struct {
netboxDevice
Face *netboxStatus `json:"face"`
Serial string `json:"serial"`
AssetTag *string `json:"asset_tag"`
DeviceType *struct {
ID int `json:"id"`
Model string `json:"model"`
Manufacturer *netboxRef `json:"manufacturer"`
} `json:"device_type"`
Description string `json:"description"`
VCPUs json.Number `json:"vcpus"`
Memory *int `json:"memory"`
Disk *int `json:"disk"`
}
type netboxIPAddress struct {
Address string `json:"address"`
Status *netboxStatus `json:"status"`
Role *netboxStatus `json:"role"`
DNSName string `json:"dns_name"`
Description string `json:"description"`
VRF *netboxRef `json:"vrf"`
ObjectType string `json:"assigned_object_type"`
Object *struct {
Name string `json:"name"`
Device *struct {
ID int `json:"id"`
Name string `json:"name"`
} `json:"device"`
VirtualMachine *struct {
ID int `json:"id"`
Name string `json:"name"`
} `json:"virtual_machine"`
} `json:"assigned_object"`
}
type netboxPrefix struct {
Prefix string `json:"prefix"`
Status *netboxStatus `json:"status"`
Role *netboxRef `json:"role"`
Site *netboxRef `json:"site"`
Scope *netboxRef `json:"scope"`
VRF *netboxRef `json:"vrf"`
Description string `json:"description"`
VLAN *struct {
VID int `json:"vid"`
Name string `json:"name"`
} `json:"vlan"`
}
func hostPath(kind string) (string, error) {
switch kind {
case "device":
return "dcim/devices", nil
case "vm":
return "virtualization/virtual-machines", nil
}
return "", fmt.Errorf("invalid host kind %q", kind)
}
// WebURL returns the page of a host in the NetBox web interface.
func (c *Client) WebURL(host HostEntry) (string, error) {
source, host, err := c.sourceForHost(host)
if err != nil {
return "", err
}
path, err := hostPath(host.Kind)
if err != nil {
return "", err
}
if host.ID <= 0 {
return "", fmt.Errorf("NetBox ID of %s is unknown", host.Target())
}
return fmt.Sprintf("%s/%s/%d/", source.baseURL, path, host.ID), nil
}
// GetDetails fetches the full record and all IP addresses of a host.
func (c *Client) GetDetails(ctx context.Context, host HostEntry) (HostDetails, error) {
source, host, err := c.sourceForHost(host)
if err != nil {
return HostDetails{}, err
}
apiURL, err := source.hostURL(host)
if err != nil {
return HostDetails{}, err
}
var raw netboxHostDetail
if err := source.get(ctx, apiURL, &raw); err != nil {
return HostDetails{}, err
}
entry := deviceToEntry(raw.netboxDevice)
entry.Kind, entry.Source = host.Kind, host.Source
entries := []HostEntry{entry}
source.fillLocations(ctx, entries)
entry = entries[0]
d := HostDetails{HostEntry: entry, Serial: raw.Serial, Description: raw.Description}
d.URL, _ = c.WebURL(entry)
if raw.Status != nil {
d.StatusLabel = raw.Status.Label
}
if raw.Face != nil {
d.Face = raw.Face.Value
}
if raw.AssetTag != nil {
d.AssetTag = *raw.AssetTag
}
if raw.DeviceType != nil && entry.Position != "" && raw.DeviceType.ID > 0 {
var deviceType struct {
UHeight json.Number `json:"u_height"`
}
if err := source.get(ctx, fmt.Sprintf("%s/api/dcim/device-types/%d/", source.baseURL, raw.DeviceType.ID), &deviceType); err == nil {
d.HeightU = rackUnit(deviceType.UHeight)
}
}
if raw.DeviceType != nil {
d.DeviceType = raw.DeviceType.Model
if raw.DeviceType.Manufacturer != nil && raw.DeviceType.Manufacturer.Name != "" {
d.DeviceType = raw.DeviceType.Manufacturer.Name + " " + d.DeviceType
}
}
if raw.VCPUs != "" {
d.VCPUs = strings.TrimSuffix(strings.TrimSuffix(raw.VCPUs.String(), ".00"), ".0")
}
if raw.Memory != nil {
d.MemoryMB = *raw.Memory
}
if raw.Disk != nil {
d.DiskGB = *raw.Disk
}
filter := fmt.Sprintf("device_id=%d", host.ID)
if host.Kind == "vm" {
filter = fmt.Sprintf("virtual_machine_id=%d", host.ID)
}
addresses, err := source.fetchIPAddresses(ctx, filter)
if err != nil {
return d, fmt.Errorf("IP addresses: %w", err)
}
for _, a := range addresses {
ip := IPAssignment{Address: a.Address, DNSName: a.DNSName, Status: a.Status.value(), Role: a.Role.value()}
if a.VRF != nil {
ip.VRF = a.VRF.Name
}
if a.Object != nil {
ip.Interface = a.Object.Name
}
addr := stripPrefix(a.Address)
ip.Primary = addr == entry.PrimaryIP4 || addr == entry.PrimaryIP6
d.IPs = append(d.IPs, ip)
}
sort.SliceStable(d.IPs, func(i, j int) bool {
if d.IPs[i].Primary != d.IPs[j].Primary {
return d.IPs[i].Primary
}
return d.IPs[i].Interface < d.IPs[j].Interface
})
return d, nil
}
func (c *Client) fetchIPAddresses(ctx context.Context, filter string) ([]netboxIPAddress, error) {
const pageSize = 100
var out []netboxIPAddress
for offset := 0; ; offset += pageSize {
apiURL := fmt.Sprintf("%s/api/ipam/ip-addresses/?%s&limit=%d&offset=%d", c.baseURL, filter, pageSize, offset)
var resp netboxListResponse[netboxIPAddress]
if err := c.get(ctx, apiURL, &resp); err != nil {
return nil, err
}
out = append(out, resp.Results...)
if len(resp.Results) < pageSize || len(out) >= resp.Count {
return out, nil
}
}
}
// eachSource runs fn for every configured instance in name order, or once
// for a single-instance client. It keeps going after an error, so one
// unreachable instance does not hide answers from the others.
func (c *Client) eachSource(fn func(name string, source *Client) error) error {
if c.sources == nil {
return fn("", c)
}
names := make([]string, 0, len(c.sources))
for name := range c.sources {
names = append(names, name)
}
sort.Strings(names)
var errs []error
for _, name := range names {
if err := fn(name, c.sources[name]); err != nil {
errs = append(errs, fmt.Errorf("NetBox %s: %w", name, err))
}
}
return errors.Join(errs...)
}
// LookupIP finds the NetBox IP address records of ip in every instance.
func (c *Client) LookupIP(ctx context.Context, ip string) ([]IPOwner, error) {
var out []IPOwner
err := c.eachSource(func(name string, source *Client) error {
found, err := source.fetchIPAddresses(ctx, "address="+url.QueryEscape(ip))
if err != nil {
return err
}
for _, a := range found {
owner := IPOwner{Source: name, Address: a.Address, Status: a.Status.value(), DNSName: a.DNSName, Description: a.Description}
if a.VRF != nil {
owner.VRF = a.VRF.Name
}
if a.Object != nil {
owner.Interface = a.Object.Name
switch {
case a.Object.Device != nil:
owner.HostKind, owner.HostName, owner.HostID = "device", a.Object.Device.Name, a.Object.Device.ID
case a.Object.VirtualMachine != nil:
owner.HostKind, owner.HostName, owner.HostID = "vm", a.Object.VirtualMachine.Name, a.Object.VirtualMachine.ID
}
}
out = append(out, owner)
}
return nil
})
return out, err
}
// PrefixesContaining returns the prefixes containing ip, most specific last.
func (c *Client) PrefixesContaining(ctx context.Context, ip string) ([]PrefixInfo, error) {
var out []PrefixInfo
err := c.eachSource(func(name string, source *Client) error {
apiURL := fmt.Sprintf("%s/api/ipam/prefixes/?contains=%s&limit=100", source.baseURL, url.QueryEscape(ip))
var resp netboxListResponse[netboxPrefix]
if err := source.get(ctx, apiURL, &resp); err != nil {
return err
}
for _, p := range resp.Results {
info := PrefixInfo{Source: name, Prefix: p.Prefix, Status: p.Status.value(), Description: p.Description}
if p.Role != nil {
info.Role = p.Role.Name
}
if p.Site != nil {
info.Site = p.Site.Name
} else if p.Scope != nil {
info.Site = p.Scope.Name
}
if p.VRF != nil {
info.VRF = p.VRF.Name
}
if p.VLAN != nil {
info.VLAN = strconv.Itoa(p.VLAN.VID)
if p.VLAN.Name != "" {
info.VLAN += " (" + p.VLAN.Name + ")"
}
}
out = append(out, info)
}
return nil
})
sort.SliceStable(out, func(i, j int) bool { return prefixLen(out[i].Prefix) < prefixLen(out[j].Prefix) })
return out, err
}
func prefixLen(prefix string) int {
_, bits, _ := strings.Cut(prefix, "/")
n, _ := strconv.Atoi(bits)
return n
}
// RackUnits renders the occupied units, e.g. "U20-21 (2U, front)".
func (d HostDetails) RackUnits() string {
if d.Position == "" {
return ""
}
units := "U" + d.Position
var extra []string
if height, err := strconv.ParseFloat(d.HeightU, 64); err == nil && height > 0 {
if start, err := strconv.ParseFloat(d.Position, 64); err == nil && height > 1 {
units += "-" + strconv.FormatFloat(start+height-1, 'f', -1, 64)
}
extra = append(extra, d.HeightU+"U")
}
if d.Face != "" {
extra = append(extra, d.Face)
}
if len(extra) > 0 {
units += " (" + strings.Join(extra, ", ") + ")"
}
return units
}
+101
View File
@@ -0,0 +1,101 @@
package netbox
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func detailServer(t *testing.T) *httptest.Server {
t.Helper()
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch {
case r.URL.Path == "/api/dcim/devices/7/":
fmt.Fprint(w, `{"id":7,"name":"sw1","status":{"value":"offline","label":"Offline"},
"site":{"name":"Falkenstein 1","slug":"fsn1"},"rack":{"name":"R12"},"position":20.0,
"device_role":{"name":"Core Switch","slug":"core-switch"},"platform":{"name":"Junos","slug":"junos"},
"tenant":null,"serial":"ABC","asset_tag":null,"device_type":{"model":"QFX5120","manufacturer":{"name":"Juniper"}},
"primary_ip4":{"address":"10.0.0.7/24"},"tags":[{"name":"core"}]}`)
case r.URL.Path == "/api/ipam/ip-addresses/" && r.URL.Query().Get("device_id") == "7":
fmt.Fprint(w, `{"count":2,"results":[
{"address":"192.0.2.7/24","assigned_object":{"name":"xe-0/0/1"},"status":{"value":"active"}},
{"address":"10.0.0.7/24","assigned_object":{"name":"em0"},"dns_name":"sw1.example.com","status":{"value":"active"}}]}`)
case r.URL.Path == "/api/ipam/ip-addresses/" && r.URL.Query().Get("address") != "":
fmt.Fprint(w, `{"count":1,"results":[{"address":"10.0.0.7/24","status":{"value":"active"},
"assigned_object_type":"dcim.interface","assigned_object":{"name":"em0","device":{"id":7,"name":"sw1"}}}]}`)
case r.URL.Path == "/api/ipam/prefixes/":
if r.URL.Query().Get("contains") != "10.0.0.7" {
t.Errorf("unexpected contains %q", r.URL.Query().Get("contains"))
}
fmt.Fprint(w, `{"count":2,"results":[
{"prefix":"10.0.0.0/24","status":{"value":"active"},"vlan":{"vid":100,"name":"mgmt"},"site":{"name":"FSN1"}},
{"prefix":"10.0.0.0/8","description":"internal"}]}`)
default:
http.NotFound(w, r)
}
}))
t.Cleanup(srv.Close)
return srv
}
func TestDeviceAttributesAndDetails(t *testing.T) {
srv := detailServer(t)
c := NewClient(srv.URL, "token", 0)
d, err := c.GetDetails(context.Background(), HostEntry{ID: 7, Name: "sw1", Kind: "device"})
if err != nil {
t.Fatal(err)
}
if d.Status != "offline" || d.StatusLabel != "Offline" || d.Site.Slug != "fsn1" || d.Role.Slug != "core-switch" || d.Platform.Slug != "junos" {
t.Fatalf("attributes not parsed: %+v", d.HostEntry)
}
if d.Rack != "R12" || d.Position != "20" || d.DeviceType != "Juniper QFX5120" || d.Serial != "ABC" {
t.Fatalf("details not parsed: %+v", d)
}
if d.URL != srv.URL+"/dcim/devices/7/" {
t.Fatalf("web URL %q", d.URL)
}
if len(d.IPs) != 2 || !d.IPs[0].Primary || d.IPs[0].Interface != "em0" || d.IPs[0].DNSName != "sw1.example.com" {
t.Fatalf("IPs not sorted primary first: %+v", d.IPs)
}
}
func TestWebURLForInstances(t *testing.T) {
c := NewMultiClient([]Source{{Name: "prod", URL: "https://nb.example/", Token: "t"}})
got, err := c.WebURL(HostEntry{Source: "prod", Name: "web", Kind: "vm", ID: 3})
if err != nil || got != "https://nb.example/virtualization/virtual-machines/3/" {
t.Fatalf("got %q, %v", got, err)
}
if _, err := c.WebURL(HostEntry{Source: "prod", Name: "web", Kind: "vm"}); err == nil {
t.Fatal("missing ID accepted")
}
}
func TestLookupIPAndPrefixes(t *testing.T) {
srv := detailServer(t)
c := NewMultiClient([]Source{{Name: "prod", URL: srv.URL, Token: "t"}})
owners, err := c.LookupIP(context.Background(), "10.0.0.7")
if err != nil || len(owners) != 1 || owners[0].Target() != "prod/sw1" || owners[0].Interface != "em0" || owners[0].HostKind != "device" {
t.Fatalf("owners %+v, %v", owners, err)
}
prefixes, err := c.PrefixesContaining(context.Background(), "10.0.0.7")
if err != nil || len(prefixes) != 2 || prefixes[0].Prefix != "10.0.0.0/8" || prefixes[1].VLAN != "100 (mgmt)" || prefixes[1].Source != "prod" {
t.Fatalf("prefixes %+v, %v", prefixes, err)
}
}
func TestLookupIPReportsFailingInstanceButKeepsOthers(t *testing.T) {
good := detailServer(t)
bad := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "down", http.StatusBadGateway)
}))
defer bad.Close()
c := NewMultiClient([]Source{{Name: "a", URL: bad.URL, Token: "t"}, {Name: "b", URL: good.URL, Token: "t"}})
owners, err := c.LookupIP(context.Background(), "10.0.0.7")
if err == nil || !strings.Contains(err.Error(), "NetBox a") || len(owners) != 1 {
t.Fatalf("owners %+v, err %v", owners, err)
}
}
+92
View File
@@ -0,0 +1,92 @@
package netbox
import (
"context"
"encoding/json"
"fmt"
"strings"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// maxLocationDepth stops walking up a broken (cyclic) location tree.
const maxLocationDepth = 16
type locationNode struct {
ref config.Ref
parent int
}
type netboxLocation struct {
ID int `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Parent *struct {
ID int `json:"id"`
} `json:"parent"`
}
// rackUnit formats a NetBox rack position (a decimal such as 20.0 or 20.5).
func rackUnit(n json.Number) string {
if n == "" {
return ""
}
s := n.String()
if strings.Contains(s, ".") {
s = strings.TrimRight(strings.TrimRight(s, "0"), ".")
}
return s
}
// locationChain returns the locations from the outermost to id. NetBox nests
// locations through "parent"; each location is fetched once per client.
func (c *Client) locationChain(ctx context.Context, id int) ([]config.Ref, error) {
var chain []config.Ref
for depth := 0; id > 0 && depth < maxLocationDepth; depth++ {
node, err := c.location(ctx, id)
if err != nil {
return nil, err
}
chain = append([]config.Ref{node.ref}, chain...)
id = node.parent
}
return chain, nil
}
func (c *Client) location(ctx context.Context, id int) (locationNode, error) {
c.locMu.Lock()
node, ok := c.locations[id]
c.locMu.Unlock()
if ok {
return node, nil
}
var raw netboxLocation
if err := c.get(ctx, fmt.Sprintf("%s/api/dcim/locations/%d/", c.baseURL, id), &raw); err != nil {
return locationNode{}, err
}
node = locationNode{ref: config.Ref{Name: raw.Name, Slug: raw.Slug}}
if raw.Parent != nil {
node.parent = raw.Parent.ID
}
c.locMu.Lock()
if c.locations == nil {
c.locations = map[int]locationNode{}
}
c.locations[id] = node
c.locMu.Unlock()
return node, nil
}
// fillLocations replaces each device's own location with the full chain of
// parent locations. A failed lookup keeps the device's own location: the
// location is informational and must not break a search or a connection.
func (c *Client) fillLocations(ctx context.Context, entries []HostEntry) {
for i := range entries {
if entries[i].locationID <= 0 {
continue
}
if chain, err := c.locationChain(ctx, entries[i].locationID); err == nil && len(chain) > 0 {
entries[i].Location = chain
}
}
}
+101
View File
@@ -0,0 +1,101 @@
package netbox
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
)
// locationServer serves a site with Building A › Floor 2 › Room 2.04 and two
// racked devices in Room 2.04, plus a location loop 90 ↔ 91.
func locationServer(t *testing.T, calls *int32) *httptest.Server {
t.Helper()
locations := map[string]string{
"1": `{"id":1,"name":"Building A","slug":"building-a","parent":null}`,
"2": `{"id":2,"name":"Floor 2","slug":"floor-2","parent":{"id":1}}`,
"3": `{"id":3,"name":"Room 2.04","slug":"room-2-04","parent":{"id":2}}`,
"90": `{"id":90,"name":"Loop A","slug":"loop-a","parent":{"id":91}}`,
"91": `{"id":91,"name":"Loop B","slug":"loop-b","parent":{"id":90}}`,
}
device := func(id int, name string, location int, position string) string {
return fmt.Sprintf(`{"id":%d,"name":%q,"site":{"name":"FSN1","slug":"fsn1"},"location":{"id":%d,"name":"x","slug":"x"},
"rack":{"name":"R12"},"position":%s,"face":{"value":"front"},"device_type":{"id":9,"model":"R640"}}`, id, name, location, position)
}
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case strings.HasPrefix(r.URL.Path, "/api/dcim/locations/"):
atomic.AddInt32(calls, 1)
id := strings.Trim(strings.TrimPrefix(r.URL.Path, "/api/dcim/locations/"), "/")
if body, ok := locations[id]; ok {
fmt.Fprint(w, body)
return
}
http.NotFound(w, r)
case r.URL.Path == "/api/dcim/devices/":
fmt.Fprintf(w, `{"count":3,"results":[%s,%s,%s]}`, device(1, "srv1", 3, "20.0"), device(2, "srv2", 3, "22"), device(3, "loopy", 90, "null"))
case r.URL.Path == "/api/dcim/devices/1/":
fmt.Fprint(w, device(1, "srv1", 3, "20.0"))
case r.URL.Path == "/api/dcim/device-types/9/":
fmt.Fprint(w, `{"id":9,"u_height":2.0}`)
case r.URL.Path == "/api/virtualization/virtual-machines/", r.URL.Path == "/api/ipam/ip-addresses/":
fmt.Fprint(w, `{"count":0,"results":[]}`)
default:
http.NotFound(w, r)
}
}))
t.Cleanup(srv.Close)
return srv
}
func TestSearchAllResolvesNestedLocations(t *testing.T) {
var calls int32
srv := locationServer(t, &calls)
entries, err := NewClient(srv.URL, "t", 0).SearchAll(context.Background(), "", SearchOptions{Kind: "device"})
if err != nil {
t.Fatal(err)
}
byName := map[string]HostEntry{}
for _, e := range entries {
byName[e.Name] = e
}
srv1 := byName["srv1"]
if got := srv1.LocationPath(); got != "FSN1 › Building A › Floor 2 › Room 2.04 › R12 › U20" {
t.Fatalf("path %q", got)
}
if srv1.Location[0].Slug != "building-a" || srv1.Location[2].Slug != "room-2-04" {
t.Fatalf("chain order: %+v", srv1.Location)
}
// Room, floor and building are fetched once for both devices, the loop
// stops at the depth limit instead of hanging.
if n := atomic.LoadInt32(&calls); n != 5 {
t.Fatalf("location requests: %d", n)
}
if len(byName["loopy"].Location) != maxLocationDepth || byName["loopy"].Position != "" {
t.Fatalf("loop not bounded: %d", len(byName["loopy"].Location))
}
}
func TestDetailsShowRackUnits(t *testing.T) {
var calls int32
srv := locationServer(t, &calls)
d, err := NewClient(srv.URL, "t", 0).GetDetails(context.Background(), HostEntry{ID: 1, Name: "srv1", Kind: "device"})
if err != nil {
t.Fatal(err)
}
if d.Rack != "R12" || d.Position != "20" || d.HeightU != "2" || d.RackUnits() != "U20-21 (2U, front)" {
t.Fatalf("rack: %q %q %q %q", d.Rack, d.Position, d.HeightU, d.RackUnits())
}
if len(d.Location) != 3 {
t.Fatalf("details lack location chain: %+v", d.Location)
}
if (HostDetails{HostEntry: HostEntry{Position: "7"}, HeightU: "1"}).RackUnits() != "U7 (1U)" {
t.Fatal("single unit")
}
if (HostDetails{}).RackUnits() != "" {
t.Fatal("unracked device should have no units")
}
}
+98 -5
View File
@@ -1,16 +1,27 @@
package netbox
import "strings"
import (
"encoding/json"
"strings"
"time"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// SearchOptions filters a Search or SearchAll query.
// Zero value means no filtering (return all kinds, no tag filter).
type SearchOptions struct {
Tag string // filter by tag slug; empty = no filter
Kind string // "device" | "vm" | "" (both)
// Cluster filters SearchAll by virtualization cluster name (case-insensitive).
Cluster string
}
// HostEntry is a unified model for both devices and virtual machines from NetBox.
type HostEntry struct {
Cached bool
CachedAt time.Time
Static bool
Source string // named NetBox instance; empty for the legacy single-instance config
ID int
Name string
@@ -18,6 +29,56 @@ type HostEntry struct {
PrimaryIP4 string // e.g. "10.0.1.5" (prefix length stripped)
PrimaryIP6 string
Tags []string
Cluster string // virtualization cluster name, if assigned
Status string // NetBox status value, e.g. "active"
Site config.Ref
Role config.Ref
Platform config.Ref
Tenant config.Ref
// Location is the chain of nested NetBox locations from the outermost
// (directly below the site) to the device's own location.
Location []config.Ref
Rack string
Position string // lowest rack unit, e.g. "20"; empty when not racked
locationID int // the device's own location, before the chain is resolved
}
// LocationPath renders site › locations › rack › U position.
func (h HostEntry) LocationPath() string {
return config.LocationPath(h.Site, h.Location, h.Rack, h.Position)
}
// netboxRef is a nested NetBox object with a name and slug.
type netboxRef struct {
Name string `json:"name"`
Slug string `json:"slug"`
}
func (r *netboxRef) ref() config.Ref {
if r == nil {
return config.Ref{}
}
return config.Ref{Name: r.Name, Slug: r.Slug}
}
// netboxStatus is a NetBox choice field such as status.
type netboxStatus struct {
Value string `json:"value"`
Label string `json:"label"`
}
func (s *netboxStatus) value() string {
if s == nil {
return ""
}
return s.Value
}
// netboxCluster is the nested cluster of a device or virtual machine.
type netboxCluster struct {
ID int `json:"id"`
Name string `json:"name"`
}
// netboxIP represents an IP address as returned by the NetBox API.
@@ -32,8 +93,24 @@ type netboxDevice struct {
Tags []struct {
Name string `json:"name"`
} `json:"tags"`
PrimaryIP4 *netboxIP `json:"primary_ip4"`
PrimaryIP6 *netboxIP `json:"primary_ip6"`
PrimaryIP4 *netboxIP `json:"primary_ip4"`
PrimaryIP6 *netboxIP `json:"primary_ip6"`
Cluster *netboxCluster `json:"cluster"`
Status *netboxStatus `json:"status"`
Site *netboxRef `json:"site"`
Role *netboxRef `json:"role"`
DeviceRole *netboxRef `json:"device_role"` // NetBox < 3.6
Platform *netboxRef `json:"platform"`
Tenant *netboxRef `json:"tenant"`
Location *struct {
ID int `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
} `json:"location"`
Rack *struct {
Name string `json:"name"`
} `json:"rack"`
Position json.Number `json:"position"`
}
// netboxVM matches the relevant fields of the NetBox /virtualization/virtual-machines/ response.
@@ -43,8 +120,24 @@ type netboxVM struct {
Tags []struct {
Name string `json:"name"`
} `json:"tags"`
PrimaryIP4 *netboxIP `json:"primary_ip4"`
PrimaryIP6 *netboxIP `json:"primary_ip6"`
PrimaryIP4 *netboxIP `json:"primary_ip4"`
PrimaryIP6 *netboxIP `json:"primary_ip6"`
Cluster *netboxCluster `json:"cluster"`
Status *netboxStatus `json:"status"`
Site *netboxRef `json:"site"`
Role *netboxRef `json:"role"`
DeviceRole *netboxRef `json:"device_role"` // NetBox < 3.6
Platform *netboxRef `json:"platform"`
Tenant *netboxRef `json:"tenant"`
Location *struct {
ID int `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
} `json:"location"`
Rack *struct {
Name string `json:"name"`
} `json:"rack"`
Position json.Number `json:"position"`
}
type netboxListResponse[T any] struct {
+1 -1
View File
@@ -78,7 +78,7 @@ func TestMultiSourceSearchAndRouting(t *testing.T) {
if err != nil || len(ips) != 1 || ips[0] != tc.ip {
t.Fatalf("wrong IP source: %v, %v", ips, err)
}
ips, err = c.GetIPsWithFilterForHost(ctx, host, "device_id=1&interface_name=mgmt0")
ips, err = c.GetIPsWithFilterForHost(ctx, host, "device_id=1&interface=mgmt0")
if err != nil || len(ips) != 1 || ips[0] != tc.ip {
t.Fatalf("wrong interface source: %v, %v", ips, err)
}
+30
View File
@@ -0,0 +1,30 @@
package resolver
import (
"context"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
)
func TestCandidatesListsEveryStrategyOnce(t *testing.T) {
chain, err := New(config.ResolverConfig{Strategies: []string{"primary_ip", "hostname"}, HostnameDomain: "example.com"})
if err != nil {
t.Fatal(err)
}
entry := &netbox.HostEntry{Name: "web", Kind: "vm", PrimaryIP4: "10.0.0.1", PrimaryIP6: "2001:db8::1"}
got, err := chain.Candidates(context.Background(), entry, nil)
if err != nil {
t.Fatal(err)
}
want := []Candidate{{"10.0.0.1", "primary_ip"}, {"web.example.com", "hostname"}, {"2001:db8::1", "primary_ip"}}
if len(got) != len(want) {
t.Fatalf("got %+v", got)
}
for i := range want {
if got[i] != want[i] {
t.Fatalf("got %+v, want %+v", got, want)
}
}
}
+56 -2
View File
@@ -2,6 +2,7 @@ package resolver
import (
"context"
"errors"
"fmt"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
@@ -27,13 +28,24 @@ func New(cfg config.ResolverConfig) (*Chain, error) {
}
func (c *Chain) Resolve(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) (string, error) {
address, _, err := c.ResolveWithStrategy(ctx, entry, client)
return address, err
}
func (c *Chain) ResolveWithStrategy(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) (string, string, error) {
for _, s := range c.strategies {
ip, err := s.Resolve(ctx, entry, client)
if err == nil {
return ip, nil
return ip, s.Name(), nil
}
// Only "this strategy has no address" moves on. After an API failure
// the next strategy would connect to (and cache) a different address
// than the configured order asks for.
if !errors.Is(err, ErrNoIP) {
return "", "", fmt.Errorf("resolver strategy %q for %q: %w", s.Name(), entry.Name, err)
}
}
return "", fmt.Errorf("no strategy resolved an IP for %q", entry.Name)
return "", "", fmt.Errorf("no strategy resolved an IP for %q", entry.Name)
}
func newStrategy(name string, cfg config.ResolverConfig) (Strategy, error) {
@@ -46,6 +58,8 @@ func newStrategy(name string, cfg config.ResolverConfig) (Strategy, error) {
return nil, err
}
return s, nil
case "hostname":
return &HostnameStrategy{domain: cfg.HostnameDomain}, nil
case "interface_name":
if cfg.InterfaceName == "" {
return nil, fmt.Errorf("interface_name strategy requires resolver.interface_name to be set")
@@ -55,3 +69,43 @@ func newStrategy(name string, cfg config.ResolverConfig) (Strategy, error) {
return nil, fmt.Errorf("unknown strategy %q", name)
}
}
// Candidate is an address one strategy resolved for a host.
type Candidate struct {
Address string
Strategy string
}
// Candidates runs every strategy and returns their distinct addresses in the
// configured order. Unlike Resolve, an API failure of one strategy does not
// stop the others: candidates are only used as fallbacks for an address that
// was already chosen by Resolve and turned out to be unreachable.
func (c *Chain) Candidates(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) ([]Candidate, error) {
var out []Candidate
var errs []error
seen := map[string]bool{}
for _, s := range c.strategies {
ip, err := s.Resolve(ctx, entry, client)
if err != nil {
if !errors.Is(err, ErrNoIP) {
errs = append(errs, fmt.Errorf("%s: %w", s.Name(), err))
}
continue
}
if !seen[ip] {
seen[ip] = true
out = append(out, Candidate{Address: ip, Strategy: s.Name()})
}
}
// Both addresses of a dual-stack host are worth trying.
for _, ip := range []string{entry.PrimaryIP4, entry.PrimaryIP6} {
if ip != "" && !seen[ip] {
seen[ip] = true
out = append(out, Candidate{Address: ip, Strategy: "primary_ip"})
}
}
if len(out) == 0 {
return nil, errors.Join(errs...)
}
return out, nil
}
+14
View File
@@ -153,3 +153,17 @@ func TestNew_MultipleStrategies(t *testing.T) {
t.Errorf("got %d strategies, want 2", len(c.strategies))
}
}
// An API failure must not fall through: the next strategy would connect to
// and cache a different address than the configured order asks for.
func TestChain_APIErrorStopsTheChain(t *testing.T) {
apiErr := errors.New("connection refused")
c := &Chain{strategies: []Strategy{
&stubStrategy{name: "management_subnet", err: apiErr},
&stubStrategy{name: "primary_ip", ip: "10.0.0.2"},
}}
ip, err := c.Resolve(context.Background(), &netbox.HostEntry{Name: "host"}, nil)
if !errors.Is(err, apiErr) || ip != "" {
t.Fatalf("got %q, %v; want the API error and no address", ip, err)
}
}
+31
View File
@@ -0,0 +1,31 @@
package resolver
import (
"context"
"regexp"
"strings"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
)
var validHostname = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)*$`)
// HostnameStrategy connects by the NetBox name instead of an IP, so DNS or
// ~/.ssh/config resolves it. Names without a dot get the optional domain.
// Names that are no valid hostname fall through to the next strategy.
type HostnameStrategy struct {
domain string
}
func (s *HostnameStrategy) Name() string { return "hostname" }
func (s *HostnameStrategy) Resolve(_ context.Context, entry *netbox.HostEntry, _ *netbox.Client) (string, error) {
name := strings.ToLower(entry.Name)
if domain := strings.Trim(s.domain, "."); domain != "" && !strings.Contains(name, ".") {
name += "." + strings.ToLower(domain)
}
if !validHostname.MatchString(name) {
return "", ErrNoIP
}
return name, nil
}
+43
View File
@@ -0,0 +1,43 @@
package resolver
import (
"context"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
)
func TestHostnameStrategy(t *testing.T) {
for _, tc := range []struct {
name, domain, want string
}{
{"Web01.Example.com", "", "web01.example.com"},
{"web01", "example.com", "web01.example.com"},
{"web01", ".example.com.", "web01.example.com"},
{"web01.lab", "example.com", "web01.lab"}, // already qualified
} {
got, err := (&HostnameStrategy{domain: tc.domain}).Resolve(context.Background(), &netbox.HostEntry{Name: tc.name}, nil)
if err != nil || got != tc.want {
t.Errorf("%q + %q: got %q, %v; want %q", tc.name, tc.domain, got, err, tc.want)
}
}
for _, name := range []string{"Core Switch 1", "-x", "a..b", "web_01"} {
if _, err := (&HostnameStrategy{}).Resolve(context.Background(), &netbox.HostEntry{Name: name}, nil); err != ErrNoIP {
t.Errorf("%q: got %v, want ErrNoIP", name, err)
}
}
}
func TestHostnameAsFallback(t *testing.T) {
chain, err := New(config.ResolverConfig{Strategies: []string{"primary_ip", "hostname"}, HostnameDomain: "example.com"})
if err != nil {
t.Fatal(err)
}
if ip, _ := chain.Resolve(context.Background(), &netbox.HostEntry{Name: "web01", PrimaryIP4: "192.0.2.1"}, nil); ip != "192.0.2.1" {
t.Fatalf("primary IP first: %q", ip)
}
if ip, _ := chain.Resolve(context.Background(), &netbox.HostEntry{Name: "web02"}, nil); ip != "web02.example.com" {
t.Fatalf("hostname fallback: %q", ip)
}
}
+12 -3
View File
@@ -2,7 +2,9 @@ package resolver
import (
"context"
"errors"
"fmt"
"net/http"
"net/url"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
@@ -16,18 +18,25 @@ type InterfaceNameStrategy struct {
func (s *InterfaceNameStrategy) Name() string { return "interface_name" }
func (s *InterfaceNameStrategy) Resolve(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) (string, error) {
// Build filter parameters for IP addresses attached to the named interface.
// NetBox filters IP addresses by interface name with interface= (devices)
// and vminterface= (VMs); unknown parameters would be ignored silently and
// return every address of the host. A missing interface is an HTTP 400,
// which lets the chain try the next strategy.
var filterParam string
switch entry.Kind {
case "device":
filterParam = fmt.Sprintf("device_id=%d&interface_name=%s", entry.ID, url.QueryEscape(s.name))
filterParam = fmt.Sprintf("device_id=%d&interface=%s", entry.ID, url.QueryEscape(s.name))
case "vm":
filterParam = fmt.Sprintf("virtual_machine_id=%d&vminterface_name=%s", entry.ID, url.QueryEscape(s.name))
filterParam = fmt.Sprintf("virtual_machine_id=%d&vminterface=%s", entry.ID, url.QueryEscape(s.name))
default:
return "", fmt.Errorf("unknown kind %q", entry.Kind)
}
ips, err := client.GetIPsWithFilterForHost(ctx, *entry, filterParam)
var status *netbox.StatusError
if errors.As(err, &status) && status.Code == http.StatusBadRequest {
return "", ErrNoIP // the host has no interface of this name
}
if err != nil {
return "", fmt.Errorf("fetching IPs for interface %q: %w", s.name, err)
}
+70
View File
@@ -0,0 +1,70 @@
package resolver
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox"
)
// NetBox ignores unknown filters, so the strategy must use the real filter
// names; otherwise it silently returns the host's first address.
func TestInterfaceNameStrategyFilters(t *testing.T) {
for kind, want := range map[string]string{
"device": "device_id=7&interface=mgmt0",
"vm": "virtual_machine_id=7&vminterface=mgmt0",
} {
var got string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
q.Del("limit")
q.Del("offset")
got = q.Encode()
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{"count":1,"results":[{"address":"10.0.0.7/24"}]}`))
}))
ip, err := (&InterfaceNameStrategy{name: "mgmt0"}).Resolve(context.Background(), &netbox.HostEntry{ID: 7, Kind: kind}, netbox.NewClient(srv.URL, "t", 1))
srv.Close()
if err != nil || ip != "10.0.0.7" {
t.Fatalf("%s: %q %v", kind, ip, err)
}
if parsed, _ := urlQuery(want); got != parsed {
t.Errorf("%s: query %q, want %q", kind, got, parsed)
}
}
}
func TestInterfaceNameStrategyMissingInterfaceFallsThrough(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, `{"vminterface":["Select a valid choice."]}`, http.StatusBadRequest)
}))
defer srv.Close()
client := netbox.NewClient(srv.URL, "t", 1)
chain := &Chain{strategies: []Strategy{&InterfaceNameStrategy{name: "mgmt0"}, &PrimaryIPStrategy{}}}
ip, err := chain.Resolve(context.Background(), &netbox.HostEntry{ID: 7, Kind: "vm", PrimaryIP4: "10.0.0.9"}, client)
if err != nil || ip != "10.0.0.9" {
t.Fatalf("got %q %v", ip, err)
}
}
func urlQuery(s string) (string, error) {
q, err := url.ParseQuery(s)
return q.Encode(), err
}
// Only the HTTP 400 of a missing interface means "no address here"; a server
// error must stop the chain instead of silently using the next strategy.
func TestInterfaceNameStrategyServerErrorIsNotNoIP(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadGateway)
}))
defer srv.Close()
_, err := (&InterfaceNameStrategy{name: "mgmt0"}).Resolve(context.Background(), &netbox.HostEntry{ID: 7, Kind: "device"}, netbox.NewClient(srv.URL, "t", 1))
if err == nil || errors.Is(err, ErrNoIP) {
t.Fatalf("got %v, want an API error", err)
}
}
+146
View File
@@ -0,0 +1,146 @@
// Package runner supervises local commands while retaining terminal I/O.
package runner
import (
"context"
"fmt"
"io"
"os"
"os/exec"
"os/signal"
"syscall"
"time"
"github.com/charmbracelet/x/term"
)
type Options struct {
Stdin io.Reader
Stdout, Stderr io.Writer
Env []string
Timeout time.Duration
Status bool
Label string
}
type Result struct {
Code int
Started bool
Duration time.Duration
}
func Run(ctx context.Context, argv []string, o Options) Result {
if o.Stderr == nil {
o.Stderr = io.Discard
}
if o.Stdout == nil {
o.Stdout = io.Discard
}
start := time.Now()
result := Result{Code: 1}
if ctx.Err() != nil {
result.Code = 130
return result
}
if len(argv) == 0 {
return result
}
cmd := exec.Command(argv[0], argv[1:]...)
cmd.Stdin, cmd.Stdout, cmd.Stderr = o.Stdin, o.Stdout, o.Stderr
cmd.Env = append(os.Environ(), o.Env...)
interactive := false
if f, ok := o.Stdin.(*os.File); ok {
interactive = term.IsTerminal(f.Fd())
}
// Interactive SSH must share the foreground terminal process group.
// Background jobs get an isolated group so cancellation reaches descendants.
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: !interactive}
if err := cmd.Start(); err != nil {
fmt.Fprintf(o.Stderr, "%s: %v\n", argv[0], err)
return result
}
result.Started = true
done := make(chan error, 1)
go func() { done <- cmd.Wait() }()
sigs := make(chan os.Signal, 4)
signal.Notify(sigs, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT)
defer signal.Stop(sigs)
var timeout <-chan time.Time
if o.Timeout > 0 {
timer := time.NewTimer(o.Timeout)
defer timer.Stop()
timeout = timer.C
}
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
var killTimer *time.Timer
var kill <-chan time.Time
defer func() {
if killTimer != nil {
killTimer.Stop()
}
}()
send := func(sig syscall.Signal) {
if interactive {
_ = cmd.Process.Signal(sig)
} else {
_ = syscall.Kill(-cmd.Process.Pid, sig)
}
}
forced := 0
cancelCh := ctx.Done()
stop := func(code int, sig syscall.Signal) {
if forced != 0 {
return
}
forced = code
send(sig)
killTimer = time.NewTimer(2 * time.Second)
kill = killTimer.C
}
for {
select {
case err := <-done:
result.Duration = time.Since(start)
result.Code = 0
if err != nil {
result.Code = 1
if e, ok := err.(*exec.ExitError); ok {
result.Code = e.ExitCode()
if s, ok := e.Sys().(syscall.WaitStatus); ok && s.Signaled() {
result.Code = 128 + int(s.Signal())
}
}
}
if forced != 0 {
result.Code = forced
}
// Kill descendants left behind after cancellation even if the parent exited.
if forced != 0 && !interactive {
send(syscall.SIGKILL)
}
if o.Status {
fmt.Fprintf(o.Stderr, "[%s] finished in %s (exit %d)\n", o.Label, result.Duration.Round(time.Millisecond), result.Code)
}
return result
case sig := <-sigs:
s := sig.(syscall.Signal)
if interactive && (s == syscall.SIGINT || s == syscall.SIGQUIT) {
continue
} // terminal delivered it to child too
stop(128+int(s), s)
case <-cancelCh:
cancelCh = nil
stop(130, syscall.SIGTERM)
case <-timeout:
timeout = nil
stop(124, syscall.SIGTERM)
case <-kill:
kill = nil
send(syscall.SIGKILL)
case <-ticker.C:
if o.Status {
fmt.Fprintf(o.Stderr, "[%s] running %s (Ctrl+C cancels)\n", o.Label, time.Since(start).Round(time.Second))
}
}
}
}
+43
View File
@@ -0,0 +1,43 @@
package runner
import (
"bytes"
"context"
"io"
"strings"
"testing"
"time"
)
func TestExitAndTimeout(t *testing.T) {
var out bytes.Buffer
r := Run(context.Background(), []string{"sh", "-c", "printf result; exit 7"}, Options{Stdout: &out, Stderr: io.Discard})
if !r.Started || r.Code != 7 || out.String() != "result" {
t.Fatalf("%+v %q", r, out.String())
}
start := time.Now()
r = Run(context.Background(), []string{"sh", "-c", "trap '' TERM; sleep 30 & wait"}, Options{Stdout: io.Discard, Stderr: io.Discard, Timeout: 50 * time.Millisecond})
if r.Code != 124 || time.Since(start) > 4*time.Second {
t.Fatalf("timeout: %+v", r)
}
}
func TestCancellationAndNoStart(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
r := Run(ctx, []string{"sh", "-c", "exit 0"}, Options{Stderr: io.Discard})
if r.Started || r.Code != 130 {
t.Fatalf("%+v", r)
}
var errOut bytes.Buffer
r = Run(context.Background(), []string{"/no/such/netssh-test-executable"}, Options{Stderr: &errOut})
if r.Started || r.Code == 0 || !strings.Contains(errOut.String(), "no such") {
t.Fatalf("%+v %s", r, errOut.String())
}
ctx, cancel = context.WithCancel(context.Background())
defer cancel()
time.AfterFunc(50*time.Millisecond, cancel)
r = Run(ctx, []string{"sh", "-c", "sleep 30"}, Options{Stdout: io.Discard, Stderr: io.Discard})
if r.Code != 130 {
t.Fatalf("%+v", r)
}
}
+48
View File
@@ -0,0 +1,48 @@
// Package secret keeps NetBox API tokens in the operating system's keyring
// (Secret Service on Linux, Keychain on macOS) instead of the config file.
package secret
import (
"errors"
"fmt"
"github.com/zalando/go-keyring"
)
// Service is the keyring service name of all netssh entries.
const Service = "netssh"
// ErrNotFound means the keyring has no token for the account.
var ErrNotFound = errors.New("no token in the system keyring")
// Get returns the token stored for account.
func Get(account string) (string, error) {
token, err := keyring.Get(Service, account)
if errors.Is(err, keyring.ErrNotFound) {
return "", fmt.Errorf("%w for %q (store one with: netssh token set %s)", ErrNotFound, account, account)
}
if err != nil {
return "", fmt.Errorf("system keyring: %w", err)
}
return token, nil
}
// Set stores token for account, replacing an existing one.
func Set(account, token string) error {
if err := keyring.Set(Service, account, token); err != nil {
return fmt.Errorf("system keyring: %w", err)
}
return nil
}
// Delete removes the token of account; a missing entry is not an error.
func Delete(account string) error {
err := keyring.Delete(Service, account)
if err != nil && !errors.Is(err, keyring.ErrNotFound) {
return fmt.Errorf("system keyring: %w", err)
}
return nil
}
// MockInit replaces the system keyring with an in-memory one, for tests.
func MockInit() { keyring.MockInit() }
+99
View File
@@ -0,0 +1,99 @@
package setup
import (
"fmt"
"sort"
"strings"
"charm.land/huh/v2"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func editCommands(cfg *config.Config) error {
for {
var names []string
for name := range cfg.Commands {
names = append(names, name)
}
sort.Strings(names)
var options []huh.Option[string]
for _, name := range names {
options = append(options, huh.NewOption("Edit "+name, "edit:"+name), huh.NewOption("Remove "+name, "remove:"+name))
}
options = append(options, huh.NewOption("Add command", "add"), huh.NewOption("Done", "done"))
action := "done"
if err := huh.NewSelect[string]().Title("Custom host commands").Options(options...).Value(&action).Run(); err != nil {
return err
}
if action == "done" {
return nil
}
if name, ok := strings.CutPrefix(action, "remove:"); ok {
remove := false
if err := huh.NewConfirm().Title("Remove " + name + "?").Value(&remove).Run(); err != nil {
return err
}
if remove {
delete(cfg.Commands, name)
}
continue
}
original, _ := strings.CutPrefix(action, "edit:")
if action == "add" {
original = ""
}
name := original
command := cfg.Commands[original]
binary, arguments := "", ""
if len(command.Args) > 0 {
binary = command.Args[0]
arguments = strings.Join(command.Args[1:], "\n")
}
err := huh.NewForm(huh.NewGroup(
huh.NewInput().Title("Command name").Placeholder("mtr").Value(&name).Validate(func(s string) error {
if s == "" {
return fmt.Errorf("required")
}
if s != original {
if _, exists := cfg.Commands[s]; exists {
return fmt.Errorf("name already exists")
}
}
return config.ValidateCommandAlias(s)
}),
huh.NewInput().Title("Alias prefix").Description("m + host shortcut xg1 = mxg1. Empty disables automatic aliases.").Value(&command.AliasPrefix),
huh.NewInput().Title("Program or executable script").Description("Use an absolute script path, or bash/python3 with the script path as the first argument.").Placeholder("mtr or /home/user/bin/check-host").Value(&binary),
huh.NewText().Title("Arguments, one per line").Description("Use {address} for the resolved address, {host} for the hostname, {target} for instance/hostname. No shell quoting needed.").Lines(5).Value(&arguments),
huh.NewConfirm().Title("Confirm before running?").Value(&command.Confirm),
huh.NewInput().Title("Timeout").Description("Optional positive duration, e.g. 30s or 5m.").Value(&command.Timeout),
huh.NewInput().Title("Post-run script").Description("Local command after completion; receives NETSSH_EXIT_CODE.").Value(&command.PostRun),
huh.NewInput().Title("Only for tag").Value(&command.Match.Tag),
huh.NewInput().Title("Only for instance").Value(&command.Match.Instance),
huh.NewInput().Title("Only for kind").Description("device, vm or static; empty means all.").Value(&command.Match.Kind),
huh.NewInput().Title("Only for hostname pattern").Description("For example router*; all specified filters must match.").Value(&command.Match.Name),
huh.NewInput().Title("Only for site").Description("NetBox site name or slug.").Value(&command.Match.Site),
huh.NewInput().Title("Only for role").Description("NetBox device/VM role name or slug.").Value(&command.Match.Role),
huh.NewInput().Title("Only for platform").Description("NetBox platform name or slug, e.g. junos.").Value(&command.Match.Platform),
huh.NewInput().Title("Only for status").Description("NetBox status value, e.g. active.").Value(&command.Match.Status),
).Title("Local command")).Run()
if err != nil {
return err
}
command.Match = trimMatch(command.Match)
command.Args = []string{binary}
if arguments != "" {
command.Args = append(command.Args, strings.Split(arguments, "\n")...)
}
candidate := config.Config{Commands: make(map[string]config.HostCommand)}
for k, v := range cfg.Commands {
if k != original {
candidate.Commands[k] = v
}
}
candidate.Commands[name] = command
if err := candidate.ValidateCommands(); err != nil {
return err
}
cfg.Commands = candidate.Commands
}
}
+140
View File
@@ -0,0 +1,140 @@
package setup
import (
"fmt"
"strconv"
"strings"
"charm.land/huh/v2"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// configureHosts edits a copy of the static hosts; the caller decides whether to keep it.
func configureHosts(hosts []config.StaticHost) ([]config.StaticHost, error) {
hosts = append([]config.StaticHost(nil), hosts...)
for {
action := "done"
var options []huh.Option[string]
for i, host := range hosts {
index := strconv.Itoa(i)
options = append(options,
huh.NewOption("Edit "+host.Name+" ("+host.Address+")", "edit:"+index),
huh.NewOption("SSH options for "+host.Name, "ssh:"+index),
huh.NewOption("Remove "+host.Name, "remove:"+index))
}
options = append(options, huh.NewOption("Add host", "add"), huh.NewOption("Back", "done"))
err := huh.NewForm(huh.NewGroup(huh.NewSelect[string]().
Title("Static hosts").
Description("Hosts that are not in NetBox. They are found before NetBox and work offline.").
Options(options...).
Value(&action))).Run()
if err != nil {
return nil, err
}
if action == "done" {
return hosts, nil
}
if action == "add" {
host, err := editHost(config.StaticHost{}, hosts, -1)
if err != nil {
return nil, err
}
hosts = append(hosts, host)
continue
}
verb, index, _ := strings.Cut(action, ":")
i, _ := strconv.Atoi(index)
switch verb {
case "edit":
host, err := editHost(hosts[i], hosts, i)
if err != nil {
return nil, err
}
hosts[i] = host
case "ssh":
options, err := editSSHOptions("SSH options for "+hosts[i].Name, hosts[i].SSH)
if err != nil {
return nil, err
}
hosts[i].SSH = options
case "remove":
remove := false
if err := huh.NewConfirm().Title("Remove " + hosts[i].Name + "?").Value(&remove).Run(); err != nil {
return nil, err
}
if remove {
hosts = append(hosts[:i], hosts[i+1:]...)
}
}
}
}
func editHost(host config.StaticHost, hosts []config.StaticHost, index int) (config.StaticHost, error) {
name, address, user := host.Name, host.Address, host.User
port := ""
if host.Port > 0 {
port = strconv.Itoa(host.Port)
}
tags := strings.Join(host.Tags, ", ")
candidate := func() config.StaticHost {
out := host
out.Name = strings.TrimSpace(name)
out.Address = strings.TrimSpace(address)
out.User = strings.TrimSpace(user)
out.Port, _ = strconv.Atoi(strings.TrimSpace(port))
out.Tags = splitList(tags)
return out
}
// huh validates the typed value before storing it, so each validator
// checks the host with its own field taken from the argument.
validate := func(set func(*config.StaticHost, string)) func(string) error {
return func(value string) error {
h := candidate()
set(&h, strings.TrimSpace(value))
return validateHostIn(h, hosts, index)
}
}
err := huh.NewForm(huh.NewGroup(
huh.NewInput().Title("Name").Description("What you type: netssh NAME. Letters, digits, dots, hyphens.").Value(&name).
Validate(validate(func(h *config.StaticHost, v string) { h.Name = v })),
huh.NewInput().Title("Address").Description("IP address or DNS name to connect to.").Value(&address).
Validate(validate(func(h *config.StaticHost, v string) {
h.Address = v
if v == "" {
h.Address = "-" // required: reported as invalid address
}
})),
huh.NewInput().Title("User").Description("Leave empty for ssh.default_user.").Value(&user).
Validate(validate(func(h *config.StaticHost, v string) { h.User = v })),
huh.NewInput().Title("Port").Description("Leave empty for ssh.default_port or 22.").Value(&port).Validate(func(s string) error {
if s = strings.TrimSpace(s); s == "" {
return nil
}
if n, err := strconv.Atoi(s); err != nil || n < 1 || n > 65535 {
return fmt.Errorf("must be a port number between 1 and 65535")
}
return nil
}),
huh.NewInput().Title("Tags").Description("Comma-separated, for ssh.rules match: {tag: …}.").Value(&tags),
).Title("Static host")).Run()
if err != nil {
return host, err
}
return candidate(), nil
}
// validateHostIn checks host as entry index of hosts (-1 for a new host).
func validateHostIn(host config.StaticHost, hosts []config.StaticHost, index int) error {
others := make([]config.StaticHost, 0, len(hosts)+1)
for i, other := range hosts {
if i != index {
others = append(others, other)
}
}
if host.Address == "" {
host.Address = "placeholder" // reported once the address field is filled
}
return (&config.Config{Hosts: append(others, host)}).ValidateHosts()
}
+25 -2
View File
@@ -20,6 +20,18 @@ func configureInstances(cfg *config.Config) ([]config.NetBoxConfig, error) {
}
for {
if len(sources) == 0 {
choice := "add"
err := huh.NewForm(huh.NewGroup(huh.NewSelect[string]().
Title("NetBox").
Description("netssh looks up hosts in NetBox. Without NetBox, only static hosts (configured next) are available.").
Options(huh.NewOption("Add a NetBox instance", "add"), huh.NewOption("Continue without NetBox (static hosts only)", "none")).
Value(&choice))).Run()
if err != nil {
return nil, err
}
if choice == "none" {
return nil, nil
}
source, err := editInstance(config.NetBoxConfig{Name: "default"}, sources, "")
if err != nil {
return nil, err
@@ -30,6 +42,7 @@ func configureInstances(cfg *config.Config) ([]config.NetBoxConfig, error) {
var options []huh.Option[string]
for _, source := range sources {
options = append(options, huh.NewOption("Edit "+source.Name+" ("+source.URL+")", "edit:"+source.Name))
options = append(options, huh.NewOption("SSH options for "+source.Name, "ssh:"+source.Name))
options = append(options, huh.NewOption("Remove "+source.Name, "remove:"+source.Name))
}
options = append(options, huh.NewOption("Add another NetBox", "add"), huh.NewOption("Continue with these instances", "done"))
@@ -53,13 +66,20 @@ func configureInstances(cfg *config.Config) ([]config.NetBoxConfig, error) {
if source.Name != name {
continue
}
if verb == "edit" {
switch verb {
case "edit":
edited, err := editInstance(source, sources, name)
if err != nil {
return nil, err
}
sources[i] = edited
} else {
case "ssh":
options, err := editSSHOptions("SSH options for "+name, source.SSH)
if err != nil {
return nil, err
}
sources[i].SSH = options
default:
remove := false
if err := huh.NewConfirm().Title("Remove " + name + "?").Value(&remove).Run(); err != nil {
return nil, err
@@ -88,6 +108,9 @@ func editInstance(source config.NetBoxConfig, sources []config.NetBoxConfig, ori
}
return nil
}),
huh.NewConfirm().Title("Hide instance prefix in aliases and TUI?").
Description("Shorter shell aliases and TUI host names. Conflicting names keep their prefix.").
Value(&source.DisablePrefix),
huh.NewInput().Title("NetBox URL").Placeholder("https://netbox.example.com").Value(&source.URL).Validate(func(value string) error {
return (&config.Config{NetBoxes: []config.NetBoxConfig{{Name: "instance", URL: strings.TrimSpace(value)}}}).ValidateNetBoxes()
}),
+128
View File
@@ -0,0 +1,128 @@
package setup
import (
"errors"
"fmt"
"sort"
"strconv"
"strings"
"charm.land/huh/v2"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func editMulti(cfg *config.Config) error {
multiplexer := cfg.Multi.Multiplexer
if multiplexer == "" {
multiplexer = "auto"
}
perWindow := ""
if cfg.Multi.PanesPerWindow > 0 {
perWindow = strconv.Itoa(cfg.Multi.PanesPerWindow)
}
groups := formatGroups(cfg.Groups)
syncKey, soloKey := cfg.Multi.SyncKey, cfg.Multi.SoloKey
validKey := func(field string) func(string) error {
return func(s string) error {
candidate := config.Config{Multi: cfg.Multi}
if field == "sync" {
candidate.Multi.SyncKey = strings.TrimSpace(s)
} else {
candidate.Multi.SoloKey = strings.TrimSpace(s)
}
return candidate.ValidateMulti()
}
}
err := huh.NewForm(huh.NewGroup(
huh.NewSelect[string]().
Title("Multiplexer").
Description("netssh multi opens hosts side by side. auto uses the one you are in, else tmux, else zellij.").
Options(huh.NewOption("auto", "auto"), huh.NewOption("tmux", "tmux"), huh.NewOption("zellij", "zellij")).
Value(&multiplexer),
huh.NewInput().
Title("Panes per window").
Description(fmt.Sprintf("More hosts open in further windows or tabs. Leave empty for %d.", config.DefaultPanesPerWindow)).
Value(&perWindow).
Validate(func(s string) error {
if s = strings.TrimSpace(s); s == "" {
return nil
}
if n, err := strconv.Atoi(s); err != nil || n < 1 || n > 64 {
return errors.New("must be a number between 1 and 64")
}
return nil
}),
huh.NewInput().
Title("tmux key: broadcast to all panes").
Description(fmt.Sprintf("Pressed after the tmux prefix. Empty = %s, none = no key.", config.DefaultSyncKey)).
Placeholder(config.DefaultSyncKey).
Value(&syncKey).
Validate(validKey("sync")),
huh.NewInput().
Title("tmux key: exclude/include this pane").
Description(fmt.Sprintf("Pressed after the tmux prefix. Empty = %s, none = no key.", config.DefaultSoloKey)).
Placeholder(config.DefaultSoloKey).
Value(&soloKey).
Validate(validKey("solo")),
huh.NewText().
Title("Groups").
Description("One per line: NAME: host, tag:TAG, cluster:NAME, @other — open with netssh multi @NAME.").
Lines(4).
Value(&groups).
Validate(func(s string) error {
_, err := parseGroups(s)
return err
}),
).Title("Multi-session")).Run()
if err != nil {
return err
}
cfg.Multi.Multiplexer = multiplexer
if multiplexer == "auto" {
cfg.Multi.Multiplexer = ""
}
cfg.Multi.PanesPerWindow, _ = strconv.Atoi(strings.TrimSpace(perWindow))
cfg.Multi.SyncKey = strings.TrimSpace(syncKey)
cfg.Multi.SoloKey = strings.TrimSpace(soloKey)
cfg.Groups, _ = parseGroups(groups)
return nil
}
// parseGroups reads "NAME: sel1, sel2" lines into groups:.
func parseGroups(s string) (map[string][]string, error) {
var out map[string][]string
for _, line := range parseLines(s) {
name, members, ok := strings.Cut(line, ":")
name = strings.ToLower(strings.TrimSpace(name))
// "tag:x" alone has no group name before the first colon worth keeping.
if !ok || name == "" || name == "tag" || name == "cluster" {
return nil, fmt.Errorf("%q: expected NAME: host, tag:TAG, …", line)
}
var selectors []string
for _, field := range strings.FieldsFunc(members, func(r rune) bool { return r == ',' || r == ' ' || r == '\t' }) {
selectors = append(selectors, field)
}
if out == nil {
out = make(map[string][]string)
}
out[name] = append(out[name], selectors...)
}
if err := (&config.Config{Groups: out}).ValidateMulti(); err != nil {
return nil, err
}
return out, nil
}
func formatGroups(groups map[string][]string) string {
names := make([]string, 0, len(groups))
for name := range groups {
names = append(names, name)
}
sort.Strings(names)
lines := make([]string, 0, len(names))
for _, name := range names {
lines = append(lines, name+": "+strings.Join(groups[name], ", "))
}
return strings.Join(lines, "\n")
}
+84
View File
@@ -0,0 +1,84 @@
package setup
import (
"fmt"
"strconv"
"charm.land/huh/v2"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func editOperations(cfg *config.Config) error {
history, days, entries := strconv.Itoa(cfg.TUI.HistoryLimit), strconv.Itoa(cfg.Activity.RetentionDays), strconv.Itoa(cfg.Activity.MaxEntries)
enabled := cfg.Activity.Enabled
columns := append([]string(nil), cfg.TUI.EffectiveColumns()...)
timeout := strconv.Itoa(int(cfg.TUI.ReachabilityTimeoutDuration().Milliseconds()))
columnOptions := make([]huh.Option[string], 0, len(config.TUIColumns))
for _, column := range config.TUIColumns {
columnOptions = append(columnOptions, huh.NewOption(columnLabels[column], column).Selected(contains(columns, column)))
}
valid := func(s string) error {
n, err := strconv.Atoi(s)
if err != nil || n < 0 {
return fmt.Errorf("enter a non-negative number")
}
return nil
}
err := huh.NewForm(huh.NewGroup(
huh.NewInput().Title("Recent hosts shown").Description("10 by default; 0 shows all. Favorites are additional.").Value(&history).Validate(valid),
huh.NewConfirm().Title("Record local action history?").Description("Stores host, command name, duration and exit code; no arguments or output.").Value(&enabled),
huh.NewInput().Title("Retention in days").Description("0 = no age limit").Value(&days).Validate(valid),
huh.NewInput().Title("Maximum recorded actions").Description("0 = no count limit").Value(&entries).Validate(valid),
).Title("History & activity"), huh.NewGroup(
huh.NewMultiSelect[string]().Title("Shown in the TUI next to each host").
Description("Reachability opens a TCP connection to every listed host's SSH port.").
Options(columnOptions...).Value(&columns),
huh.NewInput().Title("Reachability timeout (ms)").Description("300 by default").Value(&timeout).Validate(valid),
).Title("TUI display")).Run()
if err != nil {
return err
}
cfg.TUI.Columns = orderColumns(cfg.TUI.EffectiveColumns(), columns)
if ms, _ := strconv.Atoi(timeout); ms != 300 {
cfg.TUI.ReachabilityTimeout = ms
} else {
cfg.TUI.ReachabilityTimeout = 0
}
cfg.TUI.HistoryLimit, _ = strconv.Atoi(history)
cfg.Activity.RetentionDays, _ = strconv.Atoi(days)
cfg.Activity.MaxEntries, _ = strconv.Atoi(entries)
cfg.Activity.Enabled = enabled
return nil
}
var columnLabels = map[string]string{
"alias": "Shortcut alias", "ip": "IP address", "kind": "Kind (device/vm/static)", "source": "Source (live/cache/static)",
"status": "NetBox status (if not active)", "site": "Site", "location": "Location (site › locations › rack › U)", "role": "Role", "platform": "Platform", "tenant": "Tenant",
"cluster": "Cluster", "tags": "Tags", "reachability": "Reachability (TCP check ✓/✗)",
}
func contains(list []string, value string) bool {
for _, item := range list {
if item == value {
return true
}
}
return false
}
// orderColumns keeps an existing custom order and appends new selections in
// the canonical order; the multi-select itself does not preserve order.
func orderColumns(previous, selected []string) []string {
out := []string{}
for _, column := range previous {
if contains(selected, column) {
out = append(out, column)
}
}
for _, column := range config.TUIColumns {
if contains(selected, column) && !contains(out, column) {
out = append(out, column)
}
}
return out
}
+319
View File
@@ -0,0 +1,319 @@
package setup
import (
"fmt"
"sort"
"strconv"
"strings"
"charm.land/huh/v2"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// inheritOption leaves a setting empty so a broader layer (or ssh itself) decides.
func inheritOption() huh.Option[string] { return huh.NewOption("(inherit)", "") }
// editSSHOptions edits one SSH option layer: global, per instance, or per rule.
func editSSHOptions(title string, o config.SSHOptions) (config.SSHOptions, error) {
proxyJump := o.ProxyJump
hostKeyChecking := o.HostKeyChecking
target := o.Target
addressFamily := o.AddressFamily
extraArgs := strings.Join(o.ExtraArgs, "\n")
options := formatOptions(o.Options)
forwards := formatForwards(o.Forwards)
preConnect := o.PreConnect
postDisconnect := o.PostDisconnect
err := huh.NewForm(huh.NewGroup(
huh.NewInput().
Title("Jump host").
Description("Passed as -J, e.g. admin@bastion.example.com.\nLeave empty to inherit; 'none' disables a jump host set elsewhere.").
Value(&proxyJump).
Validate(func(s string) error {
return config.SSHOptions{ProxyJump: strings.TrimSpace(s)}.Validate("ssh")
}),
huh.NewSelect[string]().
Title("Host key checking").
Options(inheritOption(), huh.NewOption("strict", "strict"), huh.NewOption("accept-new", "accept-new"), huh.NewOption("off", "off")).
Value(&hostKeyChecking),
huh.NewSelect[string]().
Title("Connection target").
Description("What is passed to ssh as destination.").
Options(inheritOption(), huh.NewOption("ip — resolved address", "ip"), huh.NewOption("name — NetBox name", "name"), huh.NewOption("hostname — name as typed", "hostname")).
Value(&target),
huh.NewSelect[string]().
Title("Address family").
Options(inheritOption(), huh.NewOption("any", "any"), huh.NewOption("inet (IPv4)", "inet"), huh.NewOption("inet6 (IPv6)", "inet6")).
Value(&addressFamily),
huh.NewText().
Title("Extra arguments").
Description("One argument per line, inserted before the destination, e.g. -A").
Lines(3).
Value(&extraArgs),
huh.NewText().
Title("SSH options").
Description("One Key=Value per line, passed as -o, e.g. ServerAliveInterval=60").
Lines(4).
Value(&options).
Validate(func(s string) error {
_, err := parseOptions(s)
return err
}),
huh.NewText().
Title("Port forwards").
Description("One per line: NAME L|R|D SPEC, e.g. web L 8080:localhost:80 or socks D 1080.\n"+
"Use with netssh tunnel HOST NAME or netssh --forward NAME HOST.").
Lines(3).
Value(&forwards).
Validate(func(s string) error {
_, err := parseForwards(s)
return err
}),
huh.NewInput().Title("Post-disconnect script").Description("Local command after the client exits; none disables inheritance.").Value(&postDisconnect),
huh.NewInput().
Title("Pre-connect hook").
Description("Shell command run locally before connecting, e.g. vpn-check.sh \"$NETSSH_HOST\".\n"+
"A non-zero exit aborts. Leave empty to inherit; 'none' disables a hook set elsewhere.").
Value(&preConnect).
Validate(func(s string) error {
return config.SSHOptions{PreConnect: s}.Validate("ssh")
}),
).Title(title)).Run()
if err != nil {
return o, err
}
parsed, _ := parseOptions(options)
parsedForwards, _ := parseForwards(forwards)
return config.SSHOptions{
Forwards: parsedForwards,
ProxyJump: strings.TrimSpace(proxyJump),
HostKeyChecking: hostKeyChecking,
Target: target,
AddressFamily: addressFamily,
ExtraArgs: parseLines(extraArgs),
Options: parsed,
PreConnect: strings.TrimSpace(preConnect),
PostDisconnect: strings.TrimSpace(postDisconnect),
}, nil
}
// parseLines returns the non-empty, trimmed lines of s.
func parseLines(s string) []string {
var out []string
for _, line := range strings.Split(s, "\n") {
if line = strings.TrimSpace(line); line != "" {
out = append(out, line)
}
}
return out
}
// parseOptions reads Key=Value lines into the map stored under ssh.options.
func parseOptions(s string) (map[string]string, error) {
var out map[string]string
for _, line := range parseLines(s) {
key, value, ok := strings.Cut(line, "=")
key = strings.TrimSpace(key)
if !ok || key == "" {
return nil, fmt.Errorf("%q: expected Key=Value", line)
}
if out == nil {
out = make(map[string]string)
}
out[key] = strings.TrimSpace(value)
}
if err := (config.SSHOptions{Options: out}).Validate("ssh"); err != nil {
return nil, err
}
return out, nil
}
// forwardKinds maps the letters used in the form to the ssh flags.
var forwardKinds = map[string]func(spec string) config.Forward{
"L": func(spec string) config.Forward { return config.Forward{Local: spec} },
"R": func(spec string) config.Forward { return config.Forward{Remote: spec} },
"D": func(spec string) config.Forward { return config.Forward{Dynamic: spec} },
}
// parseForwards reads "NAME L|R|D SPEC" lines into ssh.forwards.
func parseForwards(s string) (map[string]config.Forward, error) {
var out map[string]config.Forward
for _, line := range parseLines(s) {
fields := strings.Fields(line)
if len(fields) != 3 || forwardKinds[strings.ToUpper(fields[1])] == nil {
return nil, fmt.Errorf("%q: expected NAME L|R|D SPEC", line)
}
if out == nil {
out = make(map[string]config.Forward)
}
out[strings.ToLower(fields[0])] = forwardKinds[strings.ToUpper(fields[1])](fields[2])
}
if err := (config.SSHOptions{Forwards: out}).Validate("ssh"); err != nil {
return nil, err
}
return out, nil
}
func formatForwards(forwards map[string]config.Forward) string {
names := make([]string, 0, len(forwards))
for name := range forwards {
names = append(names, name)
}
sort.Strings(names)
lines := make([]string, 0, len(names))
for _, name := range names {
flag := forwards[name].Flag()
if len(flag) == 2 {
lines = append(lines, name+" "+strings.TrimPrefix(flag[0], "-")+" "+flag[1])
}
}
return strings.Join(lines, "\n")
}
func formatOptions(options map[string]string) string {
keys := make([]string, 0, len(options))
for key := range options {
keys = append(keys, key)
}
sort.Strings(keys)
lines := make([]string, 0, len(keys))
for _, key := range keys {
lines = append(lines, key+"="+options[key])
}
return strings.Join(lines, "\n")
}
// configureRules edits a copy of the rules; the caller decides whether to keep it.
func configureRules(rules []config.SSHRule, sources []config.NetBoxConfig) ([]config.SSHRule, error) {
rules = append([]config.SSHRule(nil), rules...)
for {
action := "done"
var options []huh.Option[string]
for i, rule := range rules {
index := strconv.Itoa(i)
options = append(options, huh.NewOption("Edit rule "+describeMatch(rule.Match), "edit:"+index))
options = append(options, huh.NewOption("Remove rule "+describeMatch(rule.Match), "remove:"+index))
}
options = append(options, huh.NewOption("Add rule", "add"), huh.NewOption("Back", "done"))
err := huh.NewForm(huh.NewGroup(huh.NewSelect[string]().
Title("SSH rules").
Description("Rules apply SSH options to hosts matching every set field. Later rules win.").
Options(options...).
Value(&action))).Run()
if err != nil {
return nil, err
}
if action == "done" {
return rules, nil
}
if action == "add" {
rule, err := editRule(config.SSHRule{}, sources)
if err != nil {
return nil, err
}
rules = append(rules, rule)
continue
}
verb, index, _ := strings.Cut(action, ":")
i, _ := strconv.Atoi(index)
if verb == "edit" {
rule, err := editRule(rules[i], sources)
if err != nil {
return nil, err
}
rules[i] = rule
continue
}
remove := false
if err := huh.NewConfirm().Title("Remove rule " + describeMatch(rules[i].Match) + "?").Value(&remove).Run(); err != nil {
return nil, err
}
if remove {
rules = append(rules[:i], rules[i+1:]...)
}
}
}
func editRule(rule config.SSHRule, sources []config.NetBoxConfig) (config.SSHRule, error) {
match := rule.Match
instances := []huh.Option[string]{huh.NewOption("(any)", "")}
known := false
for _, source := range sources {
instances = append(instances, huh.NewOption(source.Name, source.Name))
known = known || strings.EqualFold(source.Name, match.Instance)
}
if match.Instance != "" && !known {
instances = append(instances, huh.NewOption(match.Instance+" (not configured)", match.Instance))
}
err := huh.NewForm(huh.NewGroup(
huh.NewInput().
Title("Tag").
Description("NetBox tag name or slug, e.g. dmz").
Value(&match.Tag),
huh.NewSelect[string]().
Title("Instance").
Options(instances...).
Value(&match.Instance),
huh.NewSelect[string]().
Title("Kind").
Options(huh.NewOption("(any)", ""), huh.NewOption("device", "device"), huh.NewOption("vm", "vm")).
Value(&match.Kind),
huh.NewInput().
Title("Site").
Description("NetBox site name or slug, e.g. fsn1").
Value(&match.Site),
huh.NewInput().
Title("Role").
Description("NetBox device/VM role name or slug, e.g. core-switch").
Value(&match.Role),
huh.NewInput().
Title("Platform").
Description("NetBox platform name or slug, e.g. junos").
Value(&match.Platform),
huh.NewInput().
Title("Status").
Description("NetBox status value, e.g. active").
Value(&match.Status),
huh.NewInput().
Title("Name pattern").
Description("Shell-style glob without instance prefix, e.g. *.dmz.example.com").
Value(&match.Name).
Validate(func(s string) error {
candidate := match
candidate.Name = s
return trimMatch(candidate).Validate("rule")
}),
).Title("Rule match")).Run()
if err != nil {
return rule, err
}
match = trimMatch(match)
options, err := editSSHOptions("SSH options for rule "+describeMatch(match), rule.SSHOptions)
if err != nil {
return rule, err
}
return config.SSHRule{Match: match, SSHOptions: options}, nil
}
func describeMatch(m config.SSHMatch) string {
var parts []string
for _, field := range matchFields(m) {
if field[1] != "" {
parts = append(parts, field[0]+"="+field[1])
}
}
return "[" + strings.Join(parts, " ") + "]"
}
// trimMatch removes surrounding spaces from every selector.
func trimMatch(m config.SSHMatch) config.SSHMatch {
for _, field := range []*string{&m.Tag, &m.Instance, &m.Kind, &m.Name, &m.Site, &m.Role, &m.Platform, &m.Tenant, &m.Status} {
*field = strings.TrimSpace(*field)
}
return m
}
+92
View File
@@ -0,0 +1,92 @@
package setup
import (
"reflect"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func TestParseLines(t *testing.T) {
got := parseLines(" -A \n\n\t-C\n \n")
if want := []string{"-A", "-C"}; !reflect.DeepEqual(got, want) {
t.Fatalf("got %q, want %q", got, want)
}
if got := parseLines(" \n "); got != nil {
t.Fatalf("blank input: got %q, want nil", got)
}
}
func TestParseOptionsRoundtrip(t *testing.T) {
text := "ServerAliveInterval = 60\n\nForwardAgent=yes\nLocalCommand=echo a=b\n"
got, err := parseOptions(text)
if err != nil {
t.Fatal(err)
}
want := map[string]string{"ServerAliveInterval": "60", "ForwardAgent": "yes", "LocalCommand": "echo a=b"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %v, want %v", got, want)
}
again, err := parseOptions(formatOptions(got))
if err != nil || !reflect.DeepEqual(again, want) {
t.Fatalf("roundtrip: got %v (%v)", again, err)
}
if formatOptions(got) != "ForwardAgent=yes\nLocalCommand=echo a=b\nServerAliveInterval=60" {
t.Fatalf("formatOptions not sorted: %q", formatOptions(got))
}
}
func TestParseOptionsEmpty(t *testing.T) {
got, err := parseOptions("\n \n")
if err != nil || got != nil {
t.Fatalf("got %v, %v; want nil, nil", got, err)
}
}
func TestParseOptionsInvalid(t *testing.T) {
for _, text := range []string{"ServerAliveInterval", "=60", "Bad-Key=1", "1Key=1"} {
if _, err := parseOptions(text); err == nil {
t.Errorf("%q: expected error", text)
}
}
}
func TestDescribeMatch(t *testing.T) {
got := describeMatch(config.SSHMatch{Tag: "dmz", Name: "*.dmz"})
if got != "[tag=dmz name=*.dmz]" {
t.Fatalf("got %q", got)
}
}
func TestRuleValidation(t *testing.T) {
if err := (config.SSHMatch{}).Validate("rule"); err == nil || !strings.Contains(err.Error(), "at least one") {
t.Fatalf("empty match: got %v", err)
}
if err := (config.SSHMatch{Name: "[web"}).Validate("rule"); err == nil {
t.Fatal("invalid glob accepted")
}
if err := (config.SSHMatch{Kind: "vm"}).Validate("rule"); err != nil {
t.Fatalf("valid match rejected: %v", err)
}
}
func TestParseForwardsRoundtrip(t *testing.T) {
text := "Web L 8080:localhost:80\n\nsocks d 1080\nback R 9000:localhost:9000\n"
got, err := parseForwards(text)
if err != nil {
t.Fatal(err)
}
want := map[string]config.Forward{"web": {Local: "8080:localhost:80"}, "socks": {Dynamic: "1080"}, "back": {Remote: "9000:localhost:9000"}}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %+v", got)
}
if formatForwards(got) != "back R 9000:localhost:9000\nsocks D 1080\nweb L 8080:localhost:80" {
t.Fatalf("format: %q", formatForwards(got))
}
for _, bad := range []string{"web 8080:localhost:80", "web X 8080", "web L -oFoo", "bad/name L 1:a:2"} {
if _, err := parseForwards(bad); err == nil {
t.Errorf("%q accepted", bad)
}
}
}
+582 -169
View File
@@ -3,6 +3,7 @@ package setup
import (
"errors"
"fmt"
"io"
"os"
"path/filepath"
"sort"
@@ -17,170 +18,26 @@ import (
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
)
// RunWizard runs the interactive setup form, pre-filled with any existing cfg values.
// RunWizard runs the interactive configurator, pre-filled with any existing cfg values.
// It saves the result to the config file on success.
func RunWizard(cfg *config.Config) error {
sources, err := configureInstances(cfg)
if err != nil {
if errors.Is(err, huh.ErrUserAborted) {
fmt.Fprintln(os.Stderr, "Setup cancelled.")
os.Exit(0)
}
return err
return cancelled(err)
}
defaultUser := cfg.SSH.DefaultUser
defaultPort := ""
if cfg.SSH.DefaultPort > 0 {
defaultPort = strconv.Itoa(cfg.SSH.DefaultPort)
}
strategiesRaw := strings.Join(cfg.Resolver.Strategies, ", ")
subnets := strings.Join(cfg.Resolver.ManagementSubnets, ", ")
interfaceName := cfg.Resolver.InterfaceName
cacheTTL := strconv.Itoa(cfg.Cache.TTL)
shortcutDomains := strings.Join(cfg.Shortcuts.Domains, ", ")
stripHyphens := cfg.Shortcuts.StripHyphens
commandAlias := cfg.Shell.Alias
if strategiesRaw == "" {
strategiesRaw = "primary_ip"
}
if cacheTTL == "0" {
cacheTTL = "3600"
work := prepare(*cfg, sources)
if err := runMenu(&work); err != nil {
return cancelled(err)
}
form := huh.NewForm(
huh.NewGroup(
huh.NewInput().
Title("Default SSH user").
Description("Leave empty to use your system user ($USER).").
Value(&defaultUser),
huh.NewInput().
Title("Default SSH port").
Description("Leave empty to use the standard port (22).").
Placeholder("22").
Value(&defaultPort).
Validate(func(s string) error {
if strings.TrimSpace(s) == "" {
return nil
}
n, err := strconv.Atoi(strings.TrimSpace(s))
if err != nil || n < 1 || n > 65535 {
return errors.New("must be a port number between 1 and 65535")
}
return nil
}),
).Title("SSH defaults"),
huh.NewGroup(
huh.NewInput().
Title("Resolver strategies").
Description("Comma-separated, in priority order. First match wins.\nAvailable: primary_ip, management_subnet, interface_name").
Placeholder("primary_ip, management_subnet").
Value(&strategiesRaw).
Validate(validateStrategies),
huh.NewInput().
Title("Management subnets").
Description("Comma-separated CIDRs, e.g. 10.0.0.0/8, 192.168.0.0/16\nOnly used when management_subnet strategy is active.").
Value(&subnets),
huh.NewInput().
Title("Interface name").
Description("Only used when interface_name strategy is active.").
Placeholder("eth0").
Value(&interfaceName),
huh.NewInput().
Title("Cache TTL (seconds)").
Value(&cacheTTL).
Validate(func(s string) error {
if _, err := strconv.Atoi(s); err != nil {
return errors.New("must be a number")
}
return nil
}),
).Title("Resolver & cache"),
huh.NewGroup(
huh.NewInput().
Title("Domain suffixes").
Description("Comma-separated suffixes stripped for shortcuts, e.g. .example.com, .example.de\nAllows typing 'web01' instead of 'web01.example.com'.").
Placeholder(".example.com").
Value(&shortcutDomains),
huh.NewConfirm().
Title("Strip hyphens").
Description("When enabled, fsn1-web01.example.com can be accessed as fsn1web01.\nOnly works for hosts already in the cache.").
Value(&stripHyphens),
huh.NewInput().
Title("Command alias").
Description("Optional alias for netssh itself, e.g. j. Leave empty to disable.").
Placeholder("j").
Value(&commandAlias).
Validate(func(s string) error { return config.ValidateCommandAlias(strings.TrimSpace(s)) }),
).Title("Shortcuts"),
)
if err := form.Run(); err != nil {
if errors.Is(err, huh.ErrUserAborted) {
fmt.Fprintln(os.Stderr, "Setup cancelled.")
os.Exit(0)
}
return err
}
strategies := parseStrategies(strategiesRaw)
ttl, _ := strconv.Atoi(cacheTTL)
port := 0
if p, err := strconv.Atoi(strings.TrimSpace(defaultPort)); err == nil {
port = p
}
var subnetList []string
for _, s := range strings.Split(subnets, ",") {
if s = strings.TrimSpace(s); s != "" {
subnetList = append(subnetList, s)
}
}
var domainList []string
for _, s := range strings.Split(shortcutDomains, ",") {
if s = strings.TrimSpace(s); s != "" {
if !strings.HasPrefix(s, ".") {
s = "." + s
}
domainList = append(domainList, s)
}
}
out := config.Config{
Shell: config.ShellConfig{Alias: strings.TrimSpace(commandAlias)},
NetBoxes: sources,
SSH: config.SSHConfig{
DefaultUser: strings.TrimSpace(defaultUser),
DefaultPort: port,
},
Resolver: config.ResolverConfig{
Strategies: strategies,
ManagementSubnets: subnetList,
InterfaceName: strings.TrimSpace(interfaceName),
},
Cache: config.CacheConfig{
TTL: ttl,
Path: cfg.Cache.Path,
},
Shortcuts: config.ShortcutsConfig{
Domains: domainList,
StripHyphens: stripHyphens,
},
}
if err := save(out); err != nil {
if err := save(work); err != nil {
return err
}
loaded, err := config.Load()
if err != nil {
return err
}
c := cache.New(loaded.CachePath(), loaded.Cache.TTL)
c := cache.New(loaded.CachePath(), loaded.Cache.TTL).WithStatic(loaded.Hosts)
if err := c.Load(); err != nil {
return fmt.Errorf("updating aliases: %w", err)
}
@@ -202,10 +59,361 @@ func RunWizard(cfg *config.Config) error {
return nil
}
func cancelled(err error) error {
if errors.Is(err, huh.ErrUserAborted) {
fmt.Fprintln(os.Stderr, "Setup cancelled.")
os.Exit(0)
}
return err
}
// prepare starts from the loaded config so settings without a menu entry survive
// a rewrite, migrates a legacy single instance, and fills in usable defaults.
func prepare(cfg config.Config, sources []config.NetBoxConfig) config.Config {
cfg.NetBox = config.NetBoxConfig{}
cfg.NetBoxes = sources
if len(cfg.Resolver.Strategies) == 0 {
cfg.Resolver.Strategies = []string{"primary_ip"}
}
if cfg.Cache.TTL == 0 {
cfg.Cache.TTL = 3600
}
return cfg
}
func runMenu(cfg *config.Config) error {
for {
action := "save"
err := huh.NewForm(huh.NewGroup(huh.NewSelect[string]().
Title("netssh configuration").
Description("Choose a section to edit, then save.").
Options(
huh.NewOption("SSH defaults — user, port", "defaults"),
huh.NewOption("SSH options — jump host, host keys, target, -o, forwards", "ssh"),
huh.NewOption(fmt.Sprintf("SSH rules — per tag, instance, kind, name (%d)", len(cfg.SSH.Rules)), "rules"),
huh.NewOption(fmt.Sprintf("Static hosts — hosts not in NetBox (%d)", len(cfg.Hosts)), "hosts"),
huh.NewOption(fmt.Sprintf("Multi-session — groups, tmux/zellij (%d groups)", len(cfg.Groups)), "multi"),
huh.NewOption("Resolver & cache", "resolver"),
huh.NewOption("Shortcuts & command alias", "shortcuts"),
huh.NewOption("Custom commands — mtr, ping, scripts", "commands"),
huh.NewOption("History & activity logging", "operations"),
huh.NewOption("Completion", "completion"),
huh.NewOption("Save and exit", "save"),
).
Value(&action))).Run()
if err != nil {
return err
}
switch action {
case "defaults":
err = editSSHDefaults(cfg)
case "ssh":
cfg.SSH.SSHOptions, err = editSSHOptions("SSH options (all hosts)", cfg.SSH.SSHOptions)
case "rules":
var rules []config.SSHRule
if rules, err = configureRules(cfg.SSH.Rules, cfg.NetBoxes); err == nil {
cfg.SSH.Rules = rules
}
case "hosts":
var hosts []config.StaticHost
if hosts, err = configureHosts(cfg.Hosts); err == nil {
cfg.Hosts = hosts
}
case "multi":
err = editMulti(cfg)
case "resolver":
err = editResolverCache(cfg)
case "shortcuts":
err = editShortcuts(cfg)
case "commands":
err = editCommands(cfg)
case "operations":
err = editOperations(cfg)
case "completion":
err = editCompletion(cfg)
case "save":
return nil
}
if err != nil {
return err
}
}
}
func editSSHDefaults(cfg *config.Config) error {
defaultUser := cfg.SSH.DefaultUser
defaultPort := ""
if cfg.SSH.DefaultPort > 0 {
defaultPort = strconv.Itoa(cfg.SSH.DefaultPort)
}
err := huh.NewForm(huh.NewGroup(
huh.NewInput().
Title("Default SSH user").
Description("Leave empty to use your system user ($USER).").
Value(&defaultUser),
huh.NewInput().
Title("Default SSH port").
Description("Leave empty to use the standard port (22).").
Placeholder("22").
Value(&defaultPort).
Validate(func(s string) error {
if strings.TrimSpace(s) == "" {
return nil
}
n, err := strconv.Atoi(strings.TrimSpace(s))
if err != nil || n < 1 || n > 65535 {
return errors.New("must be a port number between 1 and 65535")
}
return nil
}),
).Title("SSH defaults")).Run()
if err != nil {
return err
}
cfg.SSH.DefaultUser = strings.TrimSpace(defaultUser)
cfg.SSH.DefaultPort, _ = strconv.Atoi(strings.TrimSpace(defaultPort))
return nil
}
func editResolverCache(cfg *config.Config) error {
strategiesRaw := strings.Join(cfg.Resolver.Strategies, ", ")
subnets := strings.Join(cfg.Resolver.ManagementSubnets, ", ")
interfaceName := cfg.Resolver.InterfaceName
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").
Description("Comma-separated, in priority order. First match wins.\nAvailable: primary_ip, management_subnet, interface_name, hostname").
Placeholder("primary_ip, management_subnet").
Value(&strategiesRaw).
Validate(validateStrategies),
huh.NewInput().
Title("Management subnets").
Description("Comma-separated CIDRs, e.g. 10.0.0.0/8, 192.168.0.0/16\nOnly used when management_subnet strategy is active.").
Value(&subnets),
huh.NewInput().
Title("Interface name").
Description("Only used when interface_name strategy is active.").
Placeholder("eth0").
Value(&interfaceName),
huh.NewInput().
Title("Hostname domain").
Description("Only used by the hostname strategy: appended to NetBox names without a dot,\ne.g. example.com turns web01 into web01.example.com.").
Value(&hostnameDomain),
huh.NewInput().
Title("Cache TTL (seconds)").
Value(&cacheTTL).
Validate(func(s string) error {
if _, err := strconv.Atoi(s); err != nil {
return errors.New("must be a number")
}
return nil
}),
huh.NewInput().
Title("Cache file").
Description("Where resolved hosts are stored. Leave empty for the default location.").
Value(&cachePath),
).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
}
cfg.Resolver.Strategies = parseStrategies(strategiesRaw)
cfg.Resolver.ManagementSubnets = splitList(subnets)
cfg.Resolver.InterfaceName = strings.TrimSpace(interfaceName)
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
rewrites := formatRewrites(cfg.Shortcuts.Rewrites)
commandAlias := cfg.Shell.Alias
showShortcuts := cfg.Shortcuts.Show
err := huh.NewForm(huh.NewGroup(
huh.NewInput().
Title("Domain suffixes").
Description("Comma-separated suffixes stripped for shortcuts, e.g. .example.com, .example.de\nAllows typing 'web01' instead of 'web01.example.com'.").
Placeholder(".example.com").
Value(&shortcutDomains),
huh.NewConfirm().
Title("Strip hyphens").
Description("When enabled, fsn1-web01.example.com can be accessed as fsn1web01.\nOnly works for hosts already in the cache.").
Value(&stripHyphens),
huh.NewText().
Title("Rewrite rules").
Description("One rule per line: REGEX => REPLACEMENT, applied after the domain suffix is removed.\n"+
"Example: ^([a-z]+)[0-9]+- => $1 turns fsn1-bx1.example.com into fsnbx1.\n"+
"Check rules with: netssh alias --test HOSTNAME").
Lines(3).
Value(&rewrites).
Validate(func(s string) error {
_, err := parseRewrites(s)
return err
}),
huh.NewConfirm().
Title("Show shortcuts").
Description("Show each host's shortcut alias in the TUI, netssh cache list and netssh hosts list,\n"+
"and offer shortcuts in Tab completion even when the full name matches.").
Value(&showShortcuts),
huh.NewInput().
Title("Command alias").
Description("Optional alias for netssh itself, e.g. j. Leave empty to disable.").
Placeholder("j").
Value(&commandAlias).
Validate(func(s string) error { return config.ValidateCommandAlias(strings.TrimSpace(s)) }),
).Title("Shortcuts")).Run()
if err != nil {
return err
}
cfg.Shortcuts.Domains = nil
for _, s := range splitList(shortcutDomains) {
if !strings.HasPrefix(s, ".") {
s = "." + s
}
cfg.Shortcuts.Domains = append(cfg.Shortcuts.Domains, s)
}
cfg.Shortcuts.StripHyphens = stripHyphens
cfg.Shortcuts.Rewrites, _ = parseRewrites(rewrites)
cfg.Shortcuts.Show = showShortcuts
cfg.Shell.Alias = strings.TrimSpace(commandAlias)
return nil
}
func editCompletion(cfg *config.Config) error {
maxResults := ""
if cfg.Completion.MaxResults > 0 {
maxResults = strconv.Itoa(cfg.Completion.MaxResults)
}
err := huh.NewForm(huh.NewGroup(
huh.NewInput().
Title("Maximum completion results").
Description("Limits the hostnames offered per Tab completion. Leave empty for unlimited.").
Value(&maxResults).
Validate(func(s string) error {
if strings.TrimSpace(s) == "" {
return nil
}
if n, err := strconv.Atoi(strings.TrimSpace(s)); err != nil || n < 0 {
return errors.New("must be a non-negative number")
}
return nil
}),
).Title("Completion")).Run()
if err != nil {
return err
}
cfg.Completion.MaxResults, _ = strconv.Atoi(strings.TrimSpace(maxResults))
return nil
}
// parseRewrites reads "REGEX => REPLACEMENT" lines; the replacement may be empty.
func parseRewrites(s string) ([]config.ShortcutRewrite, error) {
var out []config.ShortcutRewrite
for _, line := range parseLines(s) {
pattern, replace, ok := strings.Cut(line, "=>")
if !ok {
return nil, fmt.Errorf("%q: expected REGEX => REPLACEMENT", line)
}
out = append(out, config.ShortcutRewrite{Pattern: strings.TrimSpace(pattern), Replace: strings.TrimSpace(replace)})
}
if err := (config.ShortcutsConfig{Rewrites: out}).Validate(); err != nil {
return nil, err
}
return out, nil
}
func formatRewrites(rewrites []config.ShortcutRewrite) string {
lines := make([]string, 0, len(rewrites))
for _, r := range rewrites {
lines = append(lines, r.Pattern+" => "+r.Replace)
}
return strings.Join(lines, "\n")
}
// splitList returns the non-empty, trimmed entries of a comma-separated list.
func splitList(s string) []string {
var out []string
for _, part := range strings.Split(s, ",") {
if part = strings.TrimSpace(part); part != "" {
out = append(out, part)
}
}
return out
}
var knownStrategies = map[string]bool{
"primary_ip": true,
"management_subnet": true,
"interface_name": true,
"hostname": true,
}
func validateStrategies(s string) error {
@@ -214,29 +422,54 @@ func validateStrategies(s string) error {
}
for _, name := range parseStrategies(s) {
if !knownStrategies[name] {
return fmt.Errorf("unknown strategy %q — available: primary_ip, management_subnet, interface_name", name)
return fmt.Errorf("unknown strategy %q — available: primary_ip, management_subnet, interface_name, hostname", name)
}
}
return nil
}
func parseStrategies(s string) []string {
var out []string
for _, part := range strings.Split(s, ",") {
if name := strings.TrimSpace(part); name != "" {
out = append(out, name)
}
}
return out
}
func parseStrategies(s string) []string { return splitList(s) }
func save(cfg config.Config) error {
// Save validates cfg and writes it to the config file, replacing the old file.
func Save(cfg config.Config) error { return SaveTo(cfg, os.Stdout) }
// 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
}
if err := cfg.ValidateNetBoxes(); err != nil {
return err
}
if err := cfg.ValidateSSH(); err != nil {
return err
}
if err := cfg.Shortcuts.Validate(); err != nil {
return err
}
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
}
if err := cfg.ValidateCommands(); err != nil {
return err
}
if err := cfg.ValidateMulti(); err != nil {
return err
}
path := config.Path()
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return fmt.Errorf("creating config dir: %w", err)
@@ -247,12 +480,15 @@ func save(cfg config.Config) error {
b.WriteString("netboxes:\n")
for _, source := range cfg.NetBoxes {
fmt.Fprintf(&b, " - name: %q\n url: %q\n token: %q\n token_version: %d\n", source.Name, source.URL, source.Token, source.TokenVersion)
if source.DisablePrefix {
b.WriteString(" disable_prefix: true\n")
}
if !sshOptionsEmpty(source.SSH) {
b.WriteString(" ssh:\n")
writeSSHOptions(&b, " ", source.SSH)
}
}
} else {
} else if cfg.NetBox.URL != "" || len(cfg.Hosts) == 0 {
b.WriteString("netbox:\n")
fmt.Fprintf(&b, " url: %q\n token: %q\n token_version: %d\n", cfg.NetBox.URL, cfg.NetBox.Token, cfg.NetBox.TokenVersion)
if !sshOptionsEmpty(cfg.NetBox.SSH) {
@@ -266,6 +502,12 @@ func save(cfg config.Config) error {
for _, s := range cfg.Resolver.Strategies {
fmt.Fprintf(&b, " - %s\n", s)
}
if cfg.Resolver.Fallback {
b.WriteString(" fallback: true\n")
}
if cfg.Resolver.FallbackTimeout > 0 {
fmt.Fprintf(&b, " fallback_timeout: %d\n", cfg.Resolver.FallbackTimeout)
}
if len(cfg.Resolver.ManagementSubnets) > 0 {
b.WriteString(" management_subnets:\n")
for _, s := range cfg.Resolver.ManagementSubnets {
@@ -275,6 +517,9 @@ func save(cfg config.Config) error {
if cfg.Resolver.InterfaceName != "" {
fmt.Fprintf(&b, " interface_name: %q\n", cfg.Resolver.InterfaceName)
}
if cfg.Resolver.HostnameDomain != "" {
fmt.Fprintf(&b, " hostname_domain: %q\n", cfg.Resolver.HostnameDomain)
}
b.WriteString("\ncache:\n")
fmt.Fprintf(&b, " ttl: %d\n", cfg.Cache.TTL)
@@ -289,12 +534,19 @@ func save(cfg config.Config) error {
if cfg.SSH.DefaultPort > 0 {
fmt.Fprintf(&b, " default_port: %d\n", cfg.SSH.DefaultPort)
}
if cfg.SSH.WarnStatus != nil && !sameStrings(cfg.SSH.WarnStatus, config.DefaultWarnStatus) {
quoted := make([]string, 0, len(cfg.SSH.WarnStatus))
for _, status := range cfg.SSH.WarnStatus {
quoted = append(quoted, strconv.Quote(status))
}
fmt.Fprintf(&b, " warn_status: [%s]\n", strings.Join(quoted, ", "))
}
writeSSHOptions(&b, " ", cfg.SSH.SSHOptions)
if len(cfg.SSH.Rules) > 0 {
b.WriteString(" rules:\n")
for _, rule := range cfg.SSH.Rules {
b.WriteString(" - match:\n")
for _, field := range [][2]string{{"tag", rule.Match.Tag}, {"instance", rule.Match.Instance}, {"kind", rule.Match.Kind}, {"name", rule.Match.Name}} {
for _, field := range matchFields(rule.Match) {
if field[1] != "" {
fmt.Fprintf(&b, " %s: %q\n", field[0], field[1])
}
@@ -303,11 +555,96 @@ func save(cfg config.Config) error {
}
}
if len(cfg.Hosts) > 0 {
b.WriteString("\nhosts:\n")
for _, host := range cfg.Hosts {
fmt.Fprintf(&b, " - name: %q\n address: %q\n", host.Name, host.Address)
if host.User != "" {
fmt.Fprintf(&b, " user: %q\n", host.User)
}
if host.Port > 0 {
fmt.Fprintf(&b, " port: %d\n", host.Port)
}
if len(host.Tags) > 0 {
b.WriteString(" tags:\n")
for _, tag := range host.Tags {
fmt.Fprintf(&b, " - %q\n", tag)
}
}
if !sshOptionsEmpty(host.SSH) {
b.WriteString(" ssh:\n")
writeSSHOptions(&b, " ", host.SSH)
}
}
}
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))
for name := range cfg.Groups {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
quoted := make([]string, 0, len(cfg.Groups[name]))
for _, selector := range cfg.Groups[name] {
quoted = append(quoted, strconv.Quote(selector))
}
fmt.Fprintf(&b, " %s: [%s]\n", name, strings.Join(quoted, ", "))
}
}
if cfg.Multi != (config.MultiConfig{}) {
b.WriteString("\nmulti:\n")
if cfg.Multi.Multiplexer != "" {
fmt.Fprintf(&b, " multiplexer: %s\n", cfg.Multi.Multiplexer)
}
if cfg.Multi.PanesPerWindow > 0 {
fmt.Fprintf(&b, " panes_per_window: %d\n", cfg.Multi.PanesPerWindow)
}
for _, key := range [][2]string{{"sync_key", cfg.Multi.SyncKey}, {"solo_key", cfg.Multi.SoloKey}} {
if key[1] != "" {
fmt.Fprintf(&b, " %s: %q\n", key[0], key[1])
}
}
}
if cfg.Completion.MaxResults > 0 {
fmt.Fprintf(&b, "\ncompletion:\n max_results: %d\n", cfg.Completion.MaxResults)
}
if len(cfg.Shortcuts.Domains) > 0 || cfg.Shortcuts.StripHyphens {
if cfg.Shortcuts.Enabled() || cfg.Shortcuts.Show {
b.WriteString("\nshortcuts:\n")
if len(cfg.Shortcuts.Domains) > 0 {
b.WriteString(" domains:\n")
@@ -318,27 +655,69 @@ func save(cfg config.Config) error {
if cfg.Shortcuts.StripHyphens {
b.WriteString(" strip_hyphens: true\n")
}
if len(cfg.Shortcuts.Rewrites) > 0 {
b.WriteString(" rewrites:\n")
for _, r := range cfg.Shortcuts.Rewrites {
fmt.Fprintf(&b, " - pattern: %q\n replace: %q\n", r.Pattern, r.Replace)
}
}
if cfg.Shortcuts.Show {
b.WriteString(" show: true\n")
}
}
if len(cfg.Commands) > 0 {
b.WriteString("\ncommands:\n")
var names []string
for name := range cfg.Commands {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
command := cfg.Commands[name]
fmt.Fprintf(&b, " %s:\n alias_prefix: %q\n args:\n", name, command.AliasPrefix)
for _, arg := range command.Args {
fmt.Fprintf(&b, " - %q\n", arg)
}
fmt.Fprintf(&b, " confirm: %t\n timeout: %q\n post_run: %q\n", command.Confirm, command.Timeout, command.PostRun)
if command.Match != (config.SSHMatch{}) {
b.WriteString(" match:\n")
for _, pair := range matchFields(command.Match) {
if pair[1] != "" {
fmt.Fprintf(&b, " %s: %q\n", pair[0], pair[1])
}
}
}
}
}
fmt.Fprintf(&b, "\ntui:\n history_limit: %d\n", cfg.TUI.HistoryLimit)
if cfg.TUI.Columns != nil && !sameStrings(cfg.TUI.Columns, config.DefaultTUIColumns) {
fmt.Fprintf(&b, " columns: [%s]\n", strings.Join(cfg.TUI.Columns, ", "))
}
if cfg.TUI.ReachabilityTimeout > 0 {
fmt.Fprintf(&b, " reachability_timeout: %d\n", cfg.TUI.ReachabilityTimeout)
}
fmt.Fprintf(&b, "activity:\n enabled: %t\n retention_days: %d\n max_entries: %d\n", cfg.Activity.Enabled, cfg.Activity.RetentionDays, cfg.Activity.MaxEntries)
if cfg.Shell.Alias != "" {
fmt.Fprintf(&b, "\nshell:\n alias: %q\n", cfg.Shell.Alias)
}
if err := storage.WriteFile(path, []byte(b.String()), 0o600); err != nil {
if err := storage.WriteFile(path, []byte(strings.TrimLeft(b.String(), "\n")), 0o600); err != nil {
return fmt.Errorf("writing config: %w", err)
}
fmt.Printf("\nConfig saved → %s\n", path)
fmt.Fprintf(w, "\nConfig saved → %s\n", path)
return nil
}
func sshOptionsEmpty(o config.SSHOptions) bool {
return o.ProxyJump == "" && o.HostKeyChecking == "" && o.Target == "" && o.AddressFamily == "" && len(o.ExtraArgs) == 0 && len(o.Options) == 0
return o.ProxyJump == "" && o.HostKeyChecking == "" && o.Target == "" && o.AddressFamily == "" && len(o.ExtraArgs) == 0 && len(o.Options) == 0 && len(o.Forwards) == 0 && o.PreConnect == "" && o.PostDisconnect == ""
}
// writeSSHOptions keeps settings the wizard does not ask for when it rewrites the config.
func writeSSHOptions(b *strings.Builder, indent string, o config.SSHOptions) {
for _, field := range [][2]string{{"proxy_jump", o.ProxyJump}, {"host_key_checking", o.HostKeyChecking}, {"target", o.Target}, {"address_family", o.AddressFamily}} {
for _, field := range [][2]string{{"proxy_jump", o.ProxyJump}, {"host_key_checking", o.HostKeyChecking}, {"target", o.Target}, {"address_family", o.AddressFamily}, {"pre_connect", o.PreConnect}, {"post_disconnect", o.PostDisconnect}} {
if field[1] != "" {
fmt.Fprintf(b, "%s%s: %q\n", indent, field[0], field[1])
}
@@ -360,4 +739,38 @@ func writeSSHOptions(b *strings.Builder, indent string, o config.SSHOptions) {
fmt.Fprintf(b, "%s %s: %q\n", indent, key, o.Options[key])
}
}
if len(o.Forwards) > 0 {
names := make([]string, 0, len(o.Forwards))
for name := range o.Forwards {
names = append(names, name)
}
sort.Strings(names)
fmt.Fprintf(b, "%sforwards:\n", indent)
for _, name := range names {
f := o.Forwards[name]
for _, field := range [][2]string{{"local", f.Local}, {"remote", f.Remote}, {"dynamic", f.Dynamic}} {
if field[1] != "" {
fmt.Fprintf(b, "%s %s:\n%s %s: %q\n", indent, name, indent, field[0], field[1])
}
}
}
}
}
// matchFields lists the selectors of a rule or command match in config order.
func matchFields(m config.SSHMatch) [][2]string {
return [][2]string{{"tag", m.Tag}, {"instance", m.Instance}, {"kind", m.Kind}, {"name", m.Name},
{"site", m.Site}, {"role", m.Role}, {"platform", m.Platform}, {"tenant", m.Tenant}, {"status", m.Status}}
}
func sameStrings(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if !strings.EqualFold(a[i], b[i]) {
return false
}
}
return true
}
+344 -2
View File
@@ -295,6 +295,12 @@ func TestParseStrategies_PreservesOrder(t *testing.T) {
}
}
func TestValidateStrategiesHostname(t *testing.T) {
if err := validateStrategies("primary_ip, hostname"); err != nil {
t.Fatal(err)
}
}
func TestValidateStrategies_Valid(t *testing.T) {
cases := []string{
"primary_ip",
@@ -392,7 +398,7 @@ func TestSaveMultipleNetBoxesRoundTrip(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{
{Name: "office", URL: "https://office.example/netbox", Token: "nbt_secret: office", TokenVersion: 2},
{Name: "office", URL: "https://office.example/netbox", Token: "nbt_secret: office", TokenVersion: 2, DisablePrefix: true},
{Name: "lab", URL: "https://lab.example", Token: "legacy#token", TokenVersion: 1},
},
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}},
@@ -432,9 +438,10 @@ func TestSaveKeepsSSHOptions(t *testing.T) {
AddressFamily: "inet",
ExtraArgs: []string{"-A"},
Options: map[string]string{"serveraliveinterval": "60"},
PreConnect: `vpn-check "$NETSSH_HOST" && echo 'ok'`,
}
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://prod.example", Token: "t", TokenVersion: 1, SSH: config.SSHOptions{HostKeyChecking: "off"}}},
NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://prod.example", Token: "t", TokenVersion: 1, SSH: config.SSHOptions{HostKeyChecking: "off", PreConnect: "none"}}},
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}},
Cache: config.CacheConfig{TTL: 3600},
SSH: config.SSHConfig{
@@ -455,3 +462,338 @@ func TestSaveKeepsSSHOptions(t *testing.T) {
t.Fatalf("ssh settings lost:\n%+v\n%+v", loaded.SSH, loaded.NetBoxes[0].SSH)
}
}
// Re-running the configurator must keep settings that have no form field of
// their own or were not touched in the menu.
func TestPrepareKeepsUnmanagedSettings(t *testing.T) {
cfg := config.Config{
NetBox: config.NetBoxConfig{URL: "https://legacy.example", Token: "t"},
SSH: config.SSHConfig{
DefaultUser: "root",
SSHOptions: config.SSHOptions{ProxyJump: "jh.example.com", Options: map[string]string{"forwardagent": "yes"}},
Rules: []config.SSHRule{{Match: config.SSHMatch{Tag: "dmz"}, SSHOptions: config.SSHOptions{ProxyJump: "none"}}},
},
Completion: config.CompletionConfig{MaxResults: 50},
Cache: config.CacheConfig{Path: "/var/cache/netssh/hosts.json"},
}
sources := []config.NetBoxConfig{{Name: "default", URL: "https://legacy.example", Token: "t"}}
got := prepare(cfg, sources)
if !reflect.DeepEqual(got.SSH, cfg.SSH) || got.Completion != cfg.Completion || got.Cache.Path != cfg.Cache.Path {
t.Fatalf("settings lost: %+v", got)
}
if got.NetBox.URL != "" || !reflect.DeepEqual(got.NetBoxes, sources) {
t.Fatalf("legacy instance not migrated: %+v / %+v", got.NetBox, got.NetBoxes)
}
if !reflect.DeepEqual(got.Resolver.Strategies, []string{"primary_ip"}) || got.Cache.TTL != 3600 {
t.Fatalf("defaults missing: %+v %+v", got.Resolver, got.Cache)
}
}
func TestSaveRejectsInvalidSSHOptions(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("HOME", t.TempDir())
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://prod.example", Token: "t"}},
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}},
SSH: config.SSHConfig{Rules: []config.SSHRule{{SSHOptions: config.SSHOptions{ProxyJump: "none"}}}},
}
if err := save(cfg); err == nil {
t.Fatal("rule without match was saved")
}
if _, err := os.Stat(config.Path()); !os.IsNotExist(err) {
t.Fatalf("config file written despite error: %v", err)
}
}
func TestParseRewrites(t *testing.T) {
text := `^([a-z]+)[0-9]+- => $1
\.lab$ =>
`
got, err := parseRewrites(text)
if err != nil {
t.Fatal(err)
}
want := []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}, {Pattern: `\.lab$`, Replace: ""}}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %+v", got)
}
if again, _ := parseRewrites(formatRewrites(got)); !reflect.DeepEqual(again, want) {
t.Fatalf("roundtrip: %+v", again)
}
for _, bad := range []string{"no arrow", "[a- => x", " => x"} {
if _, err := parseRewrites(bad); err == nil {
t.Errorf("%q accepted", bad)
}
}
}
func TestSaveShortcutRewritesRoundtrip(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("HOME", t.TempDir())
rewrites := []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}, {Pattern: `\.lab\.example\.com$`, Replace: `"q"`}}
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://prod.example", Token: "t"}},
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}},
Shortcuts: config.ShortcutsConfig{Rewrites: rewrites},
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
loaded, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(loaded.Shortcuts.Rewrites, rewrites) {
t.Fatalf("got %+v", loaded.Shortcuts.Rewrites)
}
}
func TestSaveForwardsRoundtrip(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("HOME", t.TempDir())
global := map[string]config.Forward{"web": {Local: "8080:localhost:80"}, "socks": {Dynamic: "1080"}}
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://prod.example", Token: "t", SSH: config.SSHOptions{Forwards: map[string]config.Forward{"db": {Local: "5432:localhost:5432"}}}}},
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}},
SSH: config.SSHConfig{
SSHOptions: config.SSHOptions{Forwards: global},
Rules: []config.SSHRule{{Match: config.SSHMatch{Tag: "dmz"}, SSHOptions: config.SSHOptions{Forwards: map[string]config.Forward{"back": {Remote: "9000:localhost:9000"}}}}},
},
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
loaded, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(loaded.SSH.Forwards, global) ||
!reflect.DeepEqual(loaded.NetBoxes[0].SSH.Forwards, cfg.NetBoxes[0].SSH.Forwards) ||
!reflect.DeepEqual(loaded.SSH.Rules[0].Forwards, cfg.SSH.Rules[0].Forwards) {
t.Fatalf("forwards lost: %+v / %+v / %+v", loaded.SSH.Forwards, loaded.NetBoxes[0].SSH.Forwards, loaded.SSH.Rules)
}
}
func TestSaveStaticHostsRoundtrip(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("HOME", t.TempDir())
hosts := []config.StaticHost{
{Name: "router", Address: "192.168.1.1", User: "admin", Port: 2222, Tags: []string{"home"}, SSH: config.SSHOptions{ProxyJump: "none"}},
{Name: "nas", Address: "nas.example.org"},
}
cfg := config.Config{
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip", "hostname"}, HostnameDomain: "example.com"},
Hosts: hosts,
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
data, _ := os.ReadFile(config.Path())
if strings.Contains(string(data), "netbox:") {
t.Fatalf("static-only config got an empty netbox section:\n%s", data)
}
loaded, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(loaded.Hosts, hosts) || loaded.Resolver.HostnameDomain != "example.com" || loaded.HasNetBox() {
t.Fatalf("got %+v / %+v", loaded.Hosts, loaded.Resolver)
}
}
func TestValidateHostIn(t *testing.T) {
hosts := []config.StaticHost{{Name: "router", Address: "10.0.0.1"}, {Name: "nas", Address: "10.0.0.2"}}
if err := validateHostIn(config.StaticHost{Name: "Router", Address: "10.0.0.9"}, hosts, -1); err == nil {
t.Fatal("duplicate name accepted")
}
if err := validateHostIn(config.StaticHost{Name: "router", Address: "10.0.0.9"}, hosts, 0); err != nil {
t.Fatalf("editing a host in place rejected: %v", err)
}
if err := validateHostIn(config.StaticHost{Name: "new"}, hosts, -1); err != nil {
t.Fatalf("empty address while typing rejected: %v", err)
}
if err := validateHostIn(config.StaticHost{Name: "new", Address: "a b"}, hosts, -1); err == nil {
t.Fatal("invalid address accepted")
}
}
func TestParseGroupsAndSaveMulti(t *testing.T) {
groups, err := parseGroups("K8s: master1, tag:k8s-worker\npve: cluster:pve-fsn1 @k8s\n")
want := map[string][]string{"k8s": {"master1", "tag:k8s-worker"}, "pve": {"cluster:pve-fsn1", "@k8s"}}
if err != nil || !reflect.DeepEqual(groups, want) {
t.Fatalf("got %v %v", groups, err)
}
if again, _ := parseGroups(formatGroups(groups)); !reflect.DeepEqual(again, want) {
t.Fatalf("roundtrip: %v", again)
}
for _, bad := range []string{"no colon", "tag:x", "bad name: a", "empty:"} {
if _, err := parseGroups(bad); err == nil {
t.Errorf("%q accepted", bad)
}
}
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("HOME", t.TempDir())
cfg := config.Config{
Hosts: []config.StaticHost{{Name: "a", Address: "10.0.0.1"}},
Groups: groups,
Multi: config.MultiConfig{Multiplexer: "zellij", PanesPerWindow: 4},
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
loaded, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(loaded.Groups, want) || loaded.Multi != cfg.Multi {
t.Fatalf("got %v %+v", loaded.Groups, loaded.Multi)
}
}
func TestSaveKeepsShortcutsShow(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
t.Setenv("HOME", t.TempDir())
for _, sc := range []config.ShortcutsConfig{
{Domains: []string{".example.com"}, Show: true},
{Show: true}, // no shortcut rules yet: the switch alone must survive
} {
cfg := config.Config{
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}},
Cache: config.CacheConfig{TTL: 3600},
Shortcuts: sc,
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
loaded, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !loaded.Shortcuts.Show || !reflect.DeepEqual(loaded.Shortcuts.Domains, sc.Domains) {
t.Fatalf("shortcuts lost: %+v", loaded.Shortcuts)
}
}
}
func TestSaveCommandsRoundTrip(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
cfg := config.Config{
NetBox: config.NetBoxConfig{URL: "https://netbox.example", Token: "test"},
Commands: map[string]config.HostCommand{
"mtr": {AliasPrefix: "m", Args: []string{"mtr", "--report", "{address}"}},
"ping": {AliasPrefix: "p", Args: []string{"ping", "-c", "3", "{address}"}},
},
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
got, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(got.Commands, cfg.Commands) {
t.Fatalf("commands lost: %+v", got.Commands)
}
}
func TestOperationsRoundTrip(t *testing.T) {
t.Setenv("XDG_CONFIG_HOME", t.TempDir())
cfg := config.Config{
NetBox: config.NetBoxConfig{URL: "https://netbox.example", Token: "token"},
TUI: config.TUIConfig{HistoryLimit: 25},
Activity: config.ActivityConfig{Enabled: true, RetentionDays: 7, MaxEntries: 50},
SSH: config.SSHConfig{SSHOptions: config.SSHOptions{PostDisconnect: "echo done"}, Rules: []config.SSHRule{{Match: config.SSHMatch{Tag: "lab"}, SSHOptions: config.SSHOptions{PostDisconnect: "none"}}}},
Commands: map[string]config.HostCommand{"mtr": {Args: []string{"mtr", "{address}"}, AliasPrefix: "m", Timeout: "10s", Confirm: true, PostRun: "echo done", Match: config.SSHMatch{Tag: "router", Instance: "prod"}}},
}
if err := save(cfg); err != nil {
t.Fatal(err)
}
got, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(got.TUI, cfg.TUI) || got.Activity != cfg.Activity || !reflect.DeepEqual(got.Commands, cfg.Commands) || !reflect.DeepEqual(got.SSH, cfg.SSH) {
t.Fatalf("round trip lost operations: %+v", got)
}
}
func TestSaveRoundtripNetBoxInsightSettings(t *testing.T) {
dir := t.TempDir()
t.Setenv("XDG_CONFIG_HOME", dir)
cfg := config.Config{
NetBox: config.NetBoxConfig{URL: "https://nb.example", Token: "keyring"},
Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}, Fallback: true, FallbackTimeout: 400},
TUI: config.TUIConfig{HistoryLimit: 10, Columns: []string{"ip", "platform", "reachability"}, ReachabilityTimeout: 900},
SSH: config.SSHConfig{WarnStatus: []string{"planned"}, Rules: []config.SSHRule{{
Match: config.SSHMatch{Platform: "junos", Site: "fsn1", Role: "core", Tenant: "acme", Status: "active"},
SSHOptions: config.SSHOptions{ProxyJump: "jump"},
}}},
Commands: map[string]config.HostCommand{"cli": {Args: []string{"cli", "{address}"}, Match: config.SSHMatch{Platform: "eos"}}},
}
if err := Save(cfg); err != nil {
t.Fatal(err)
}
loaded, err := config.Load()
if err != nil {
t.Fatal(err)
}
if !loaded.Resolver.Fallback || loaded.Resolver.FallbackTimeout != 400 {
t.Fatalf("resolver lost: %+v", loaded.Resolver)
}
if !reflect.DeepEqual(loaded.TUI.Columns, []string{"ip", "platform", "reachability"}) || !loaded.TUI.ReachabilityEnabled() || loaded.TUI.ReachabilityTimeout != 900 {
t.Fatalf("tui lost: %+v", loaded.TUI)
}
if !loaded.SSH.WarnsStatus("planned") || loaded.SSH.WarnsStatus("offline") {
t.Fatalf("warn_status lost: %v", loaded.SSH.WarnStatus)
}
if got := loaded.SSH.Rules[0].Match; got != cfg.SSH.Rules[0].Match {
t.Fatalf("rule match lost: %+v", got)
}
if loaded.Commands["cli"].Match.Platform != "eos" {
t.Fatalf("command match lost: %+v", loaded.Commands["cli"].Match)
}
if !config.IsKeyringToken(loaded.NetBox.Token) || loaded.NetBox.TokenVersion != 0 {
t.Fatalf("keyring token changed: %+v", loaded.NetBox)
}
// Defaults stay implicit, so later default changes reach existing configs.
cfg = config.Config{NetBox: config.NetBoxConfig{URL: "https://nb.example"}, Resolver: config.ResolverConfig{Strategies: []string{"primary_ip"}}}
if err := Save(cfg); err != nil {
t.Fatal(err)
}
data, _ := os.ReadFile(filepath.Join(dir, "netssh.yaml"))
for _, key := range []string{"warn_status", "columns", "reachability", "fallback"} {
if strings.Contains(string(data), key) {
t.Errorf("default %s written:\n%s", key, data)
}
}
}
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)
}
}
+31 -4
View File
@@ -1,13 +1,30 @@
package shortcuts
import (
"regexp"
"strings"
"sync"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
// Normalize strips configured domain suffixes and optionally hyphens from a hostname.
// The result is lowercased for case-insensitive comparison.
// compiled caches rewrite patterns: Normalize runs for every cache entry on each lookup.
var compiled sync.Map // pattern → *regexp.Regexp
func rewritePattern(pattern string) *regexp.Regexp {
if re, ok := compiled.Load(pattern); ok {
return re.(*regexp.Regexp)
}
re, err := regexp.Compile(pattern)
if err != nil {
return nil // rejected by config.Load already
}
compiled.Store(pattern, re)
return re
}
// Normalize strips configured domain suffixes, applies rewrite rules in order, and
// optionally strips hyphens. The result is lowercased for case-insensitive comparison.
func Normalize(name string, cfg config.ShortcutsConfig) string {
s := strings.ToLower(name)
for _, domain := range cfg.Domains {
@@ -20,6 +37,11 @@ func Normalize(name string, cfg config.ShortcutsConfig) string {
break
}
}
for _, rewrite := range cfg.Rewrites {
if re := rewritePattern(rewrite.Pattern); re != nil {
s = re.ReplaceAllString(s, rewrite.Replace)
}
}
if cfg.StripHyphens {
s = strings.ReplaceAll(s, "-", "")
}
@@ -34,9 +56,14 @@ func MakeNormalizer(cfg config.ShortcutsConfig) func(string) string {
}
// AliasName returns a shell-safe alias name for the given host.
// It normalizes the name (strips configured domains and optionally hyphens) then
// It normalizes the name (strips configured domains, applies rewrites, optionally strips hyphens) then
// replaces any remaining dots with underscores so the result is a valid identifier.
func AliasName(name string, cfg config.ShortcutsConfig) string {
s := Normalize(name, cfg)
// Shorten only the hostname: anchored rewrite rules must not see "instance/".
prefix := ""
if source, host, ok := strings.Cut(name, "/"); ok {
prefix, name = strings.ToLower(source)+"_", host
}
s := prefix + Normalize(name, cfg)
return strings.NewReplacer(".", "_", "/", "_").Replace(s)
}
+47
View File
@@ -78,3 +78,50 @@ func TestAliasName_NoConfig(t *testing.T) {
t.Errorf("AliasName = %q, want %q", got, want)
}
}
func TestNormalizeRewrites(t *testing.T) {
cfg := config.ShortcutsConfig{
Domains: []string{".hoster.de"},
Rewrites: []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}},
}
for input, want := range map[string]string{
"fsn1-bx1.hoster.de": "fsnbx1",
"FSN1-BX1.hoster.de": "fsnbx1",
"fsn1-bx1": "fsnbx1",
"fsnbx1": "fsnbx1", // the shortcut itself is left alone
"web01.hoster.de": "web01",
} {
if got := shortcuts.Normalize(input, cfg); got != want {
t.Errorf("Normalize(%q) = %q, want %q", input, got, want)
}
}
if got := shortcuts.AliasName("fsn1-bx1.hoster.de", cfg); got != "fsnbx1" {
t.Errorf("AliasName = %q", got)
}
}
func TestNormalizeRewritesOrder(t *testing.T) {
// Rules run in order after domain stripping, before hyphen stripping.
cfg := config.ShortcutsConfig{
Domains: []string{".hoster.de"},
StripHyphens: true,
Rewrites: []config.ShortcutRewrite{
{Pattern: `\.hoster\.de$`, Replace: "-never"},
{Pattern: `^fsn`, Replace: "f"},
{Pattern: `^f1`, Replace: "falkenstein"},
},
}
if got := shortcuts.Normalize("fsn1-bx-1.hoster.de", cfg); got != "falkensteinbx1" {
t.Fatalf("got %q", got)
}
}
func TestAliasNameRewritesInstanceQualifiedHosts(t *testing.T) {
cfg := config.ShortcutsConfig{
Domains: []string{".hoster.test"},
Rewrites: []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}},
}
if got := shortcuts.AliasName("fsn/fsn1-pve1.hoster.test", cfg); got != "fsn_fsnpve1" {
t.Fatalf("got %q", got)
}
}
+56 -33
View File
@@ -12,15 +12,19 @@ var flagsWithArg = map[byte]bool{
// ParsedArgs holds the result of parsing SSH arguments.
type ParsedArgs struct {
Host string // hostname without the user@ prefix
Host string // hostname without the user@ prefix or :path
User string // empty if not specified
Path string // sftp only: the remote path after host:
DestIdx int // index in Args where [user@]host sits
Args []string
}
// Parse scans SSH arguments and extracts the destination ([user@]host).
// Returns nil if no destination is found.
func Parse(args []string) *ParsedArgs {
func Parse(args []string) *ParsedArgs { return SSH.Parse(args) }
// Parse extracts the destination: [user@]host, or [user@]host[:path] for sftp.
func (c Client) Parse(args []string) *ParsedArgs {
i := 0
for i < len(args) {
arg := args[i]
@@ -33,64 +37,83 @@ func Parse(args []string) *ParsedArgs {
if strings.HasPrefix(arg, "-") && len(arg) > 1 {
// OpenSSH accepts clusters such as -vp 2222 and -vladmin.
for j := 1; j < len(arg); j++ {
if flagsWithArg[arg[j]] {
if j == len(arg)-1 {
i++
}
break
}
if c.takesSeparateValue(arg) {
i++
}
i++
continue
}
// first non-flag argument is the destination
host, user := splitUserHost(arg)
return &ParsedArgs{
Host: host,
User: user,
DestIdx: i,
Args: args,
}
return c.parsed(args, i)
}
// handle arguments after "--"
if i < len(args) {
host, user := splitUserHost(args[i])
return &ParsedArgs{
Host: host,
User: user,
DestIdx: i,
Args: args,
}
return c.parsed(args, i)
}
return nil
}
func (c Client) parsed(args []string, i int) *ParsedArgs {
dest, path := args[i], ""
if c.paths {
if d, p, remote := c.splitRemote(dest); remote {
dest, path = d, p
}
}
host, user := splitUserHost(dest)
return &ParsedArgs{Host: host, User: user, Path: path, DestIdx: i, Args: args}
}
// ReplaceHost returns a copy of args with the destination replaced by newHost,
// preserving any user@ prefix.
func ReplaceHost(args []string, destIdx int, newHost string) []string {
return SSH.replaceHost(args, []int{destIdx}, newHost)
}
// replaceHost keeps user@ and, for sftp and scp, :path. Those clients read
// host:path, so an IPv6 address must be bracketed.
func (c Client) replaceHost(args []string, dests []int, newHost string) []string {
result := make([]string, len(args))
copy(result, args)
original := args[destIdx]
if at := strings.Index(original, "@"); at != -1 {
result[destIdx] = original[:at+1] + newHost
} else {
result[destIdx] = newHost
if c.paths && strings.Contains(newHost, ":") {
newHost = "[" + newHost + "]"
}
for _, destIdx := range dests {
original := args[destIdx]
prefix, suffix := "", ""
if at := strings.Index(original, "@"); at != -1 {
prefix, original = original[:at+1], original[at+1:]
}
if c.paths {
if _, path, remote := c.splitRemote(original); remote {
suffix = ":" + path
}
}
result[destIdx] = prefix + newHost + suffix
}
return result
}
// HasPortFlag reports whether a port was explicitly supplied.
func HasPortFlag(args []string) bool { return hasOption(args, 'p', "Port") }
func HasPortFlag(args []string) bool { return SSH.HasPortFlag(args) }
// HasUserFlag reports whether a login user was explicitly supplied.
func HasUserFlag(args []string) bool { return hasOption(args, 'l', "User") }
func HasUserFlag(args []string) bool { return SSH.HasUserFlag(args) }
// HasPortFlag reports whether a port was explicitly supplied.
func (c Client) HasPortFlag(args []string) bool { return c.hasOption(args, c.port, "Port") }
// HasUserFlag reports whether a login user was explicitly supplied.
func (c Client) HasUserFlag(args []string) bool { return c.hasOption(args, c.user, "User") }
func hasOption(args []string, wanted byte, keyword string) bool {
return SSH.hasOption(args, wanted, keyword)
}
func (c Client) hasOption(args []string, wanted byte, keyword string) bool {
for i := 0; i < len(args); i++ {
arg := args[i]
if arg == "--" || len(arg) < 2 || arg[0] != '-' {
@@ -98,7 +121,7 @@ func hasOption(args []string, wanted byte, keyword string) bool {
}
for j := 1; j < len(arg); j++ {
flag := arg[j]
if !flagsWithArg[flag] {
if !c.withArg[flag] {
continue
}
value := arg[j+1:]
@@ -109,7 +132,7 @@ func hasOption(args []string, wanted byte, keyword string) bool {
}
value = args[i]
}
if flag == wanted {
if wanted != 0 && flag == wanted {
return true
}
if flag == 'o' {
+162
View File
@@ -0,0 +1,162 @@
package ssh
import (
"fmt"
"strings"
)
// Client describes one OpenSSH program netssh can run. The programs share
// ssh's connection options but differ in flags and destination syntax.
type Client struct {
Name string // binary name: ssh, sftp, or scp
withArg map[byte]bool // short flags that consume a value
port byte // flag for the port: -p (ssh) or -P (sftp, scp)
user byte // flag for the login user; 0 when only user@ or -o User work
paths bool // destinations are host[:path]
// instances are the configured NetBox instance names; "inst/host:path"
// is remote only for these, so local paths like "dir/file:x" stay local.
instances map[string]bool
}
// WithInstances returns c aware of the NetBox instance prefixes in host:path.
func (c Client) WithInstances(names []string) Client {
c.instances = make(map[string]bool, len(names))
for _, name := range names {
c.instances[strings.ToLower(name)] = true
}
return c
}
var (
// SSH is the default client; its flag table is flagsWithArg.
SSH = Client{Name: "ssh", withArg: flagsWithArg, port: 'p', user: 'l'}
// SFTP follows sftp(1): -l is a bandwidth limit, -P the port.
SFTP = Client{Name: "sftp", withArg: flagSet("BbcDFiJloPRSsX"), port: 'P', paths: true}
// SCP follows scp(1); unlike sftp, -B and -R take no value.
SCP = Client{Name: "scp", withArg: flagSet("cDFiJloPSX"), port: 'P', paths: true}
)
func flagSet(flags string) map[byte]bool {
set := make(map[byte]bool, len(flags))
for i := 0; i < len(flags); i++ {
set[flags[i]] = true
}
return set
}
// PortArgs returns the arguments that set port for this client.
func (c Client) PortArgs(port string) []string { return []string{"-" + string(c.port), port} }
// UserArgs returns the arguments that set the login user for this client.
func (c Client) UserArgs(user string) []string {
if c.user == 0 {
return []string{"-o", "User=" + user}
}
return []string{"-" + string(c.user), user}
}
// Operand is a remote scp argument such as user@host:/path.
type Operand struct {
Idx int
User string
Host string
Path string
}
// Operands returns the remote operands of scp arguments. All remote operands
// must name the same host, because one set of options applies per call.
func (c Client) Operands(args []string) ([]Operand, error) {
start := c.optionsEnd(args)
var out []Operand
for i := start; i < len(args); i++ {
arg := args[i]
if strings.HasPrefix(arg, "scp://") || strings.HasPrefix(arg, "sftp://") {
return nil, fmt.Errorf("%q: use host:path instead of a URI", arg)
}
dest, path, remote := c.splitRemote(arg)
if !remote {
continue
}
host, user := splitUserHost(dest)
if host == "" {
continue
}
if len(out) > 0 && !strings.EqualFold(out[0].Host, host) {
return nil, fmt.Errorf("scp between two remote hosts (%s, %s) is not supported; copy in two steps", out[0].Host, host)
}
out = append(out, Operand{Idx: i, User: user, Host: host, Path: path})
}
return out, nil
}
// optionsEnd returns the index of the first operand; scp, like ssh, stops
// option parsing at the first non-option or after "--".
func (c Client) optionsEnd(args []string) int {
end := c.insertionPoint(args)
if end < len(args) && args[end] == "--" {
end++
}
return end
}
// insertionPoint is where added options still count as options: before the
// first operand or before "--".
func (c Client) insertionPoint(args []string) int {
for i := 0; i < len(args); i++ {
arg := args[i]
if arg == "--" {
return i
}
if !strings.HasPrefix(arg, "-") || len(arg) < 2 {
return i
}
if c.takesSeparateValue(arg) {
i++
}
}
return len(args)
}
// splitRemote is splitHostPath with netssh's [user@]instance/host:path form.
func (c Client) splitRemote(arg string) (dest, path string, remote bool) {
if head, rest, ok := strings.Cut(arg, "/"); ok {
instance := head[strings.LastIndex(head, "@")+1:]
if c.instances[strings.ToLower(instance)] {
if d, p, r := splitHostPath(rest); r {
return head + "/" + d, p, true
}
}
}
return splitHostPath(arg)
}
// splitHostPath mirrors scp's colon(): an argument is remote when a ':' comes
// before any '/'. A leading "[" starts a bracketed IPv6 address.
func splitHostPath(arg string) (dest, path string, remote bool) {
if strings.HasPrefix(arg, "/") || strings.HasPrefix(arg, ".") {
return "", "", false
}
inBracket := false
for i := 0; i < len(arg); i++ {
switch arg[i] {
case '[':
inBracket = true
case ']':
inBracket = false
case '/':
if !inBracket {
return "", "", false
}
case ':':
if !inBracket {
return arg[:i], arg[i+1:], true
}
}
}
return "", "", false
}
// HasForwardFlag reports whether -L, -R, or -D (or the -o equivalents) was given.
func (c Client) HasForwardFlag(args []string) bool {
return c.hasOption(args, 'L', "LocalForward") || c.hasOption(args, 'R', "RemoteForward") || c.hasOption(args, 'D', "DynamicForward")
}
+180
View File
@@ -0,0 +1,180 @@
package ssh
import (
"reflect"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
)
func TestSFTPParse(t *testing.T) {
// -l is a bandwidth limit and -s takes a value for sftp, unlike ssh.
parsed := SFTP.Parse([]string{"-l", "100", "-s", "sub", "-P", "2222", "ops@web01:/var/log"})
if parsed == nil || parsed.Host != "web01" || parsed.User != "ops" || parsed.Path != "/var/log" || parsed.DestIdx != 6 {
t.Fatalf("got %+v", parsed)
}
if p := SFTP.Parse([]string{"prod/web01"}); p == nil || p.Host != "prod/web01" || p.Path != "" {
t.Fatalf("instance-qualified host: %+v", p)
}
if !SFTP.HasPortFlag([]string{"-P", "2222", "web"}) || SFTP.HasPortFlag([]string{"-p", "web"}) {
t.Fatal("sftp port flag is -P")
}
if SFTP.HasUserFlag([]string{"-l", "100", "web"}) || !SFTP.HasUserFlag([]string{"-o", "User=ops", "web"}) {
t.Fatal("sftp has no -l user flag")
}
}
func TestSCPOperands(t *testing.T) {
ops, err := SCP.Operands([]string{"-X", "nrequests=8", "-r", "./local:dir", "/abs/file", "ops@web01:/tmp/", "web01:b"})
if err != nil {
t.Fatal(err)
}
want := []Operand{{Idx: 5, User: "ops", Host: "web01", Path: "/tmp/"}, {Idx: 6, Host: "web01", Path: "b"}}
if !reflect.DeepEqual(ops, want) {
t.Fatalf("got %+v", ops)
}
if ops, _ := SCP.Operands([]string{"a.txt", "b.txt"}); len(ops) != 0 {
t.Fatalf("local copy has remote operands: %+v", ops)
}
if _, err := SCP.Operands([]string{"web01:a", "db01:b"}); err == nil {
t.Fatal("two remote hosts accepted")
}
if _, err := SCP.Operands([]string{"scp://web01/a", "."}); err == nil {
t.Fatal("URI accepted")
}
}
func TestSFTPApply(t *testing.T) {
args := []string{"-P", "2222", "ops@web01:/var/log"}
opts := config.SSHOptions{ProxyJump: "jh", ExtraArgs: []string{"-A"}, Forwards: map[string]config.Forward{"web": {Local: "1:a:2"}}}
got := SFTP.Apply(args, []int{2}, Host{Name: "web01", IP: "192.0.2.10"}, opts, WrapperFlags{ForwardArgs: []string{"-L", "1:a:2"}}).Args
want := []string{"-P", "2222", "-J", "jh", "ops@192.0.2.10:/var/log"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %v, want %v (extra_args and forwards are ssh only)", got, want)
}
}
func TestSCPApplyReplacesEveryOperandAndBracketsIPv6(t *testing.T) {
args := []string{"a.txt", "web01:/tmp/", "ops@web01:b"}
got := SCP.Apply(args, []int{1, 2}, Host{Name: "web01", IP: "2001:db8::1"}, config.SSHOptions{HostKeyChecking: "accept-new"}, WrapperFlags{}).Args
want := []string{"-o", "StrictHostKeyChecking=accept-new", "a.txt", "[2001:db8::1]:/tmp/", "ops@[2001:db8::1]:b"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %v", got)
}
// sftp needs brackets even without a path; ssh never does.
if got := SFTP.Apply([]string{"web01"}, []int{0}, Host{Name: "web01", IP: "2001:db8::1"}, config.SSHOptions{}, WrapperFlags{}).Args; got[0] != "[2001:db8::1]" {
t.Fatalf("sftp: %v", got)
}
if got := apply([]string{"web01"}, config.SSHOptions{}, WrapperFlags{}); got.Args[0] != "192.0.2.10" {
t.Fatalf("ssh: %v", got.Args)
}
}
func TestSFTPTargetName(t *testing.T) {
got := SFTP.Apply([]string{"web01:/srv"}, []int{0}, Host{Name: "web01.example.com", IP: "192.0.2.10"}, config.SSHOptions{Target: "name"}, WrapperFlags{}).Args
want := []string{"-o", "HostName=192.0.2.10", "-o", "HostKeyAlias=web01.example.com", "web01.example.com:/srv"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got %v", got)
}
}
func TestClientUserAndPortArgs(t *testing.T) {
if got := SSH.UserArgs("ops"); !reflect.DeepEqual(got, []string{"-l", "ops"}) {
t.Fatal(got)
}
if got := SCP.UserArgs("ops"); !reflect.DeepEqual(got, []string{"-o", "User=ops"}) {
t.Fatal(got)
}
if got := SFTP.PortArgs("2222"); !reflect.DeepEqual(got, []string{"-P", "2222"}) {
t.Fatal(got)
}
}
func TestClientExtractWrapperFlags(t *testing.T) {
// For scp, -X takes a value; for ssh it does not.
flags, rest, err := SCP.ExtractWrapperFlags([]string{"-X", "--dry-run", "--dry-run", "a", "web:b"})
if err != nil || !flags.DryRun || !reflect.DeepEqual(rest, []string{"-X", "--dry-run", "a", "web:b"}) {
t.Fatalf("got %+v %v %v", flags, rest, err)
}
flags, rest, err = ExtractWrapperFlags([]string{"--forward", "web", "--forward=8080:localhost:80", "-v", "web01"})
if err != nil || !reflect.DeepEqual(flags.Forwards, []string{"web", "8080:localhost:80"}) || !reflect.DeepEqual(rest, []string{"-v", "web01"}) {
t.Fatalf("got %+v %v %v", flags, rest, err)
}
for _, args := range [][]string{{"--forward"}, {"--forward", "-L", "web"}} {
if _, _, err := ExtractWrapperFlags(args); err == nil {
t.Errorf("%v accepted", args)
}
}
}
func TestForwardArgs(t *testing.T) {
available := map[string]config.Forward{"web": {Local: "8080:localhost:80"}, "socks": {Dynamic: "1080"}, "back": {Remote: "9000:localhost:9000"}}
got, err := ForwardArgs([]string{"WEB", "socks", "back", "5432:db:5432", "127.0.0.1:3000:localhost:3000"}, available)
want := []string{"-L", "8080:localhost:80", "-D", "1080", "-R", "9000:localhost:9000", "-L", "5432:db:5432", "-L", "127.0.0.1:3000:localhost:3000"}
if err != nil || !reflect.DeepEqual(got, want) {
t.Fatalf("got %v %v", got, err)
}
if _, err := ForwardArgs([]string{"db"}, available); err == nil || !strings.Contains(err.Error(), "back, socks, web") {
t.Fatalf("unknown name: %v", err)
}
if _, err := ForwardArgs([]string{"db"}, nil); err == nil || !strings.Contains(err.Error(), "no forwards are configured") {
t.Fatalf("no forwards: %v", err)
}
}
func TestApplyForwardsAndTunnel(t *testing.T) {
flags := WrapperFlags{ForwardArgs: []string{"-L", "8080:localhost:80"}}
if got := apply([]string{"web"}, config.SSHOptions{}, flags).Args; !reflect.DeepEqual(got, []string{"-L", "8080:localhost:80", "192.0.2.10"}) {
t.Fatalf("forward: %v", got)
}
flags.Tunnel = true
result := apply([]string{"web"}, config.SSHOptions{}, flags)
want := []string{"-L", "8080:localhost:80", "-o", "ExitOnForwardFailure=yes", "-N", "192.0.2.10"}
if !reflect.DeepEqual(result.Args, want) || !strings.Contains(result.Notice, "forwarding -L 8080:localhost:80 via web.example.com") {
t.Fatalf("tunnel: %v %q", result.Args, result.Notice)
}
// The user's own ExitOnForwardFailure wins.
if got := apply([]string{"-o", "ExitOnForwardFailure=no", "web"}, config.SSHOptions{}, flags).Args; strings.Contains(strings.Join(got, " "), "=yes") {
t.Fatalf("overrode user option: %v", got)
}
}
func TestHasForwardFlag(t *testing.T) {
for args, want := range map[string]bool{"-L 1:a:2 web": true, "-vD1080 web": true, "-o RemoteForward=1_a_2 web": true, "-l ops web": false, "web -L 1:a:2": false} {
if got := SSH.HasForwardFlag(strings.Fields(args)); got != want {
t.Errorf("%q: got %v", args, got)
}
}
}
func TestApplyInsertsOptionsBeforeDoubleDash(t *testing.T) {
got := Apply([]string{"-v", "--", "web"}, 2, Host{Name: "web", IP: "192.0.2.10"}, config.SSHOptions{ProxyJump: "jh"}, WrapperFlags{}).Args
if want := []string{"-v", "-J", "jh", "--", "192.0.2.10"}; !reflect.DeepEqual(got, want) {
t.Fatalf("got %v, want %v", got, want)
}
}
// Instance-qualified hosts contain "/" before the ":" of host:path; only
// configured instances make such an argument remote.
func TestInstanceQualifiedHostPath(t *testing.T) {
scp := SCP.WithInstances([]string{"prod"})
ops, err := scp.Operands([]string{"a.txt", "ops@prod/web01:/tmp/", "dir/file:x"})
if err != nil {
t.Fatal(err)
}
if want := []Operand{{Idx: 1, User: "ops", Host: "prod/web01", Path: "/tmp/"}}; !reflect.DeepEqual(ops, want) {
t.Fatalf("got %+v", ops)
}
got := scp.Apply([]string{"a.txt", "ops@prod/web01:/tmp/"}, []int{1}, Host{Name: "web01", IP: "192.0.2.1"}, config.SSHOptions{}, WrapperFlags{}).Args
if want := []string{"a.txt", "ops@192.0.2.1:/tmp/"}; !reflect.DeepEqual(got, want) {
t.Fatalf("apply: %v", got)
}
sftp := SFTP.WithInstances([]string{"prod"})
if p := sftp.Parse([]string{"prod/web01:/var/log"}); p == nil || p.Host != "prod/web01" || p.Path != "/var/log" {
t.Fatalf("sftp: %+v", p)
}
if ops, _ := SCP.Operands([]string{"prod/web01:/tmp/", "."}); len(ops) != 0 {
t.Fatalf("unknown instance must stay local: %+v", ops)
}
}
+8 -5
View File
@@ -9,11 +9,14 @@ import (
// Exec replaces the current process with the native ssh client via syscall.Exec.
// All existing SSH configs, keys, and agent forwarding remain intact.
func Exec(args []string) error {
sshPath, err := exec.LookPath("ssh")
func Exec(args []string) error { return SSH.Exec(args) }
// Exec replaces the current process with the client's binary.
func (c Client) Exec(args []string) error {
path, err := exec.LookPath(c.Name)
if err != nil {
return fmt.Errorf("ssh not found in PATH: %w", err)
return fmt.Errorf("%s not found in PATH: %w", c.Name, err)
}
argv := append([]string{"ssh"}, args...)
return syscall.Exec(sshPath, argv, os.Environ())
argv := append([]string{c.Name}, args...)
return syscall.Exec(path, argv, os.Environ())
}
+116 -16
View File
@@ -2,6 +2,7 @@ package ssh
import (
"fmt"
"net/netip"
"regexp"
"sort"
"strings"
@@ -12,14 +13,26 @@ import (
// WrapperFlags are netssh's own long options. OpenSSH has no long options,
// so these never collide with flags meant for ssh.
type WrapperFlags struct {
DryRun bool
Jump string // --jump HOST overrides the configured jump host
NoJump bool // --no-jump disables any jump host, including ~/.ssh/config
DryRun bool
Jump string // --jump HOST overrides the configured jump host
NoJump bool // --no-jump disables any jump host, including ~/.ssh/config
Forwards []string // --forward NAME|SPEC, repeatable (ssh only)
// ForwardArgs are Forwards resolved by ForwardArgs; Apply inserts them.
ForwardArgs []string
// Tunnel runs ssh without a remote command (-N), for netssh tunnel.
Tunnel bool
// Force connects without asking about a NetBox status in ssh.warn_status.
Force bool
}
// ExtractWrapperFlags removes netssh's long options that appear before the
// destination. Anything after the destination belongs to the remote command.
func ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
return SSH.ExtractWrapperFlags(args)
}
// ExtractWrapperFlags removes netssh's long options before the destination.
func (c Client) ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
var flags WrapperFlags
out := make([]string, 0, len(args))
for i := 0; i < len(args); i++ {
@@ -29,6 +42,8 @@ func ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
flags.DryRun = true
case arg == "--no-jump":
flags.NoJump = true
case arg == "--force":
flags.Force = true
case arg == "--jump":
if i+1 >= len(args) {
return flags, nil, fmt.Errorf("--jump requires a host")
@@ -37,6 +52,14 @@ func ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
flags.Jump = args[i]
case strings.HasPrefix(arg, "--jump="):
flags.Jump = strings.TrimPrefix(arg, "--jump=")
case arg == "--forward":
if i+1 >= len(args) {
return flags, nil, fmt.Errorf("--forward requires a name or spec")
}
i++
flags.Forwards = append(flags.Forwards, args[i])
case strings.HasPrefix(arg, "--forward="):
flags.Forwards = append(flags.Forwards, strings.TrimPrefix(arg, "--forward="))
case arg == "--" || !strings.HasPrefix(arg, "-") || len(arg) < 2:
// Destination or end of options: keep the rest unchanged.
return flags, append(out, args[i:]...), validateJump(flags)
@@ -45,7 +68,7 @@ func ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
default:
out = append(out, arg)
// Keep the value of an ssh option such as -l USER together with it.
if takesSeparateValue(arg) && i+1 < len(args) {
if c.takesSeparateValue(arg) && i+1 < len(args) {
i++
out = append(out, args[i])
}
@@ -64,14 +87,48 @@ func validateJump(flags WrapperFlags) error {
if strings.HasPrefix(flags.Jump, "-") {
return fmt.Errorf("--jump: invalid host %q", flags.Jump)
}
for _, forward := range flags.Forwards {
if forward == "" || strings.HasPrefix(forward, "-") || strings.ContainsAny(forward, " \t\n") {
return fmt.Errorf("--forward: invalid value %q", forward)
}
}
return nil
}
var adHocForward = regexp.MustCompile(`^([^\s:]+:)?[0-9]+(:[^\s]+:[0-9]+)?$`)
// ForwardArgs resolves forward names against the configured forwards. A value
// that is no configured name but looks like a port or [bind:]port:host:port
// is used as a local forward (-L).
func ForwardArgs(names []string, available map[string]config.Forward) ([]string, error) {
var out []string
for _, name := range names {
if forward, ok := available[strings.ToLower(name)]; ok {
out = append(out, forward.Flag()...)
continue
}
if strings.Contains(name, ":") && adHocForward.MatchString(name) {
out = append(out, "-L", name)
continue
}
known := make([]string, 0, len(available))
for key := range available {
known = append(known, key)
}
sort.Strings(known)
if len(known) == 0 {
return nil, fmt.Errorf("unknown forward %q; no forwards are configured for this host (ssh.forwards), or pass a spec such as 8080:localhost:80", name)
}
return nil, fmt.Errorf("unknown forward %q; available: %s", name, strings.Join(known, ", "))
}
return out, nil
}
// takesSeparateValue reports whether a short option cluster ends with a flag
// whose value is the next argument (e.g. "-l" or "-vp").
func takesSeparateValue(arg string) bool {
func (c Client) takesSeparateValue(arg string) bool {
for j := 1; j < len(arg); j++ {
if flagsWithArg[arg[j]] {
if c.withArg[arg[j]] {
return j == len(arg)-1
}
}
@@ -90,15 +147,35 @@ type Result struct {
Notice string
}
var destinationName = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)
// ValidAddress reports whether addr is an IP address or a hostname. Addresses
// come from NetBox and the cache file; one such as "-oProxyCommand=…" would be
// read by ssh as an option and run a command.
func ValidAddress(addr string) bool {
if _, err := netip.ParseAddr(addr); err == nil {
return !strings.ContainsAny(addr, " \t\r\n")
}
return destinationName.MatchString(addr)
}
var plainHostname = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?$`)
// Apply replaces the destination at destIdx and inserts the configured -o
// options directly before it. Explicit options given by the user come first,
// and ssh uses the first -o value it obtains, so the user's choice wins.
func Apply(args []string, destIdx int, host Host, opts config.SSHOptions, flags WrapperFlags) Result {
return SSH.Apply(args, []int{destIdx}, host, opts, flags)
}
// Apply replaces the host in every destination (several only for scp) and
// inserts the configured options before the first one. extra_args and
// forwards are ssh flags and apply to ssh only.
func (c Client) Apply(args []string, dests []int, host Host, opts config.SSHOptions, flags WrapperFlags) Result {
destIdx := dests[0]
var inserted []string
add := func(keyword, value string) {
if !hasOption(args[:destIdx], 0, keyword) {
if !c.hasOption(args[:destIdx], 0, keyword) {
inserted = append(inserted, "-o", keyword+"="+value)
}
}
@@ -114,7 +191,7 @@ func Apply(args []string, destIdx int, host Host, opts config.SSHOptions, flags
}
}
userJump := hasOption(args[:destIdx], 'J', "ProxyJump") || hasOption(args[:destIdx], 0, "ProxyCommand")
userJump := c.hasOption(args[:destIdx], 'J', "ProxyJump") || c.hasOption(args[:destIdx], 0, "ProxyCommand")
switch {
case userJump:
case flags.NoJump:
@@ -140,7 +217,7 @@ func Apply(args []string, destIdx int, host Host, opts config.SSHOptions, flags
}
}
if opts.AddressFamily != "" && !hasBoolFlag(args[:destIdx], '4') && !hasBoolFlag(args[:destIdx], '6') {
if opts.AddressFamily != "" && !c.hasBoolFlag(args[:destIdx], '4') && !c.hasBoolFlag(args[:destIdx], '6') {
add("AddressFamily", opts.AddressFamily)
}
@@ -153,19 +230,42 @@ func Apply(args []string, destIdx int, host Host, opts config.SSHOptions, flags
add(key, opts.Options[key])
}
var extra []string
if c.Name == SSH.Name {
extra = opts.ExtraArgs
inserted = append(inserted, flags.ForwardArgs...)
if flags.Tunnel {
add("ExitOnForwardFailure", "yes")
inserted = append(inserted, "-N")
forwards := strings.Join(flags.ForwardArgs, " ")
if forwards == "" {
forwards = "the given ports"
}
tunnel := fmt.Sprintf("forwarding %s via %s, press Ctrl+C to stop", forwards, host.Name)
if notice == "" {
notice = tunnel
} else {
notice += "\nnetssh: " + tunnel
}
}
}
// Extra arguments go first: short flags such as -4 or -A take the last
// value given, so the user's own flags later on the line still win.
replaced := ReplaceHost(args, destIdx, dest)
out := make([]string, 0, len(opts.ExtraArgs)+len(replaced)+len(inserted))
out = append(out, opts.ExtraArgs...)
out = append(out, replaced[:destIdx]...)
// Options go before the first operand: scp stops reading options there,
// and after "--" they would be taken as the destination.
at := c.insertionPoint(args)
replaced := c.replaceHost(args, dests, dest)
out := make([]string, 0, len(extra)+len(replaced)+len(inserted))
out = append(out, extra...)
out = append(out, replaced[:at]...)
out = append(out, inserted...)
out = append(out, replaced[destIdx:]...)
out = append(out, replaced[at:]...)
return Result{Args: out, Notice: notice}
}
// hasBoolFlag reports whether a flag without a value, such as -4, was given.
func hasBoolFlag(args []string, wanted byte) bool {
func (c Client) hasBoolFlag(args []string, wanted byte) bool {
for i := 0; i < len(args); i++ {
arg := args[i]
if arg == "--" || len(arg) < 2 || arg[0] != '-' {
@@ -175,7 +275,7 @@ func hasBoolFlag(args []string, wanted byte) bool {
if arg[j] == wanted {
return true
}
if flagsWithArg[arg[j]] {
if c.withArg[arg[j]] {
if j == len(arg)-1 {
i++
}
+15 -1
View File
@@ -20,7 +20,7 @@ func TestExtractWrapperFlags(t *testing.T) {
{[]string{"--no-jump", "--", "web"}, WrapperFlags{NoJump: true}, []string{"--", "web"}},
} {
flags, rest, err := ExtractWrapperFlags(tc.args)
if err != nil || flags != tc.flags || !reflect.DeepEqual(rest, tc.rest) {
if err != nil || !reflect.DeepEqual(flags, tc.flags) || !reflect.DeepEqual(rest, tc.rest) {
t.Errorf("%v: got %+v %v %v", tc.args, flags, rest, err)
}
}
@@ -128,3 +128,17 @@ func TestQuote(t *testing.T) {
t.Fatalf("got %s", got)
}
}
func TestValidAddress(t *testing.T) {
for _, addr := range []string{"10.0.0.1", "fd00:30::60", "fe80::1%eth0", "web01", "web01.example.com", "db_1.lan"} {
if !ValidAddress(addr) {
t.Errorf("ValidAddress(%q) = false, want true", addr)
}
}
// ssh would read the first as an option and run the command.
for _, addr := range []string{"-oProxyCommand=touch /tmp/pwned", "-J", "", "a b", "host;id", "user@host", "host/path", "fe80::1%eth0 x", "$(id)"} {
if ValidAddress(addr) {
t.Errorf("ValidAddress(%q) = true, want false", addr)
}
}
}
Loaded 100 of 139 files, more files were not shown because too many files have changed in this diff. Show more