Test / test (pull_request) Successful in 4m27s
- ssh.pre_connect: local shell command run before every connection, layered like proxy_jump (global, instance/static host, rules; "none" disables). Host details are passed as NETSSH_* env vars, a non-zero exit aborts the connection, --dry-run only prints it. - shortcuts.show: show shortcut aliases in the TUI host list, an ALIAS column in `cache list` / `hosts list` (also via --aliases) and in Tab completion. - Both editable in `netssh configure`; README and CHANGELOG updated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017GpWAuVpPncumMViLLc8N4
164 lines
5.2 KiB
Go
164 lines
5.2 KiB
Go
package main
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
|
|
"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})
|
|
}
|
|
return netbox.NewMultiClient(sources)
|
|
}
|
|
if cfg.NetBox.URL == "" {
|
|
return nil
|
|
}
|
|
return netbox.NewClient(cfg.NetBox.URL, cfg.NetBox.Token, cfg.NetBox.TokenVersion)
|
|
}
|
|
|
|
// 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 == "" {
|
|
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 {
|
|
return func(target string) string {
|
|
source, name := netbox.SplitTarget(target)
|
|
name = shortcuts.Normalize(name, cfg)
|
|
if qualified && source != "" {
|
|
return source + "/" + name
|
|
}
|
|
return name
|
|
}
|
|
}
|
|
|
|
// hostCompletions returns the cached hosts matching toComplete in a form that
|
|
// starts with the typed text, because bash and fish only accept such
|
|
// candidates. Without an instance prefix, a hostname that is unique across
|
|
// 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").
|
|
// 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)
|
|
for _, e := range entries {
|
|
_, name := netbox.SplitTarget(e.Name)
|
|
instances[strings.ToLower(name)]++
|
|
}
|
|
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 {
|
|
names = append(names, name)
|
|
} else {
|
|
names = append(names, e.Name)
|
|
}
|
|
case strings.HasPrefix(target, prefix):
|
|
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)
|
|
}
|
|
}
|
|
return out
|
|
}
|