v1
This commit is contained in:
commit
8d4915543e
132 files changed
+20628
No files matched your search
@@ -0,0 +1,496 @@
|
||||
package netbox
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
sources map[string]*Client
|
||||
baseURL string
|
||||
token string
|
||||
tokenVersion int
|
||||
httpClient *http.Client
|
||||
}
|
||||
|
||||
// NewClient creates a NetBox API client. Pass tokenVersion=0 to auto-detect
|
||||
// from the token string (1 for legacy, 2 for nbt_-prefixed tokens).
|
||||
func NewClient(baseURL, token string, tokenVersion int) *Client {
|
||||
if tokenVersion == 0 {
|
||||
tokenVersion = TokenVersion(token)
|
||||
}
|
||||
return &Client{
|
||||
baseURL: strings.TrimRight(baseURL, "/"),
|
||||
token: token,
|
||||
tokenVersion: tokenVersion,
|
||||
httpClient: &http.Client{Timeout: 15 * time.Second},
|
||||
}
|
||||
}
|
||||
|
||||
// Search queries up to 50 devices and VMs in parallel and merges the results.
|
||||
// Use SearchOptions to restrict by kind or tag.
|
||||
func (c *Client) Search(ctx context.Context, query string, opts SearchOptions) ([]HostEntry, error) {
|
||||
if c.sources != nil {
|
||||
return c.searchSources(ctx, query, opts, false)
|
||||
}
|
||||
if opts.Kind != "" && opts.Kind != "device" && opts.Kind != "vm" {
|
||||
return nil, fmt.Errorf("invalid host kind %q", opts.Kind)
|
||||
}
|
||||
var (
|
||||
mu sync.Mutex
|
||||
results []HostEntry
|
||||
errs []error
|
||||
wg sync.WaitGroup
|
||||
started int
|
||||
)
|
||||
|
||||
if opts.Kind != "vm" {
|
||||
started++
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
devices, err := c.searchDevices(ctx, query, opts.Tag)
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if err != nil {
|
||||
errs = append(errs, fmt.Errorf("devices: %w", err))
|
||||
return
|
||||
}
|
||||
results = append(results, devices...)
|
||||
}()
|
||||
}
|
||||
|
||||
if opts.Kind != "device" {
|
||||
started++
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
vms, err := c.searchVMs(ctx, query, opts.Tag)
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if err != nil {
|
||||
errs = append(errs, fmt.Errorf("vms: %w", err))
|
||||
return
|
||||
}
|
||||
results = append(results, vms...)
|
||||
}()
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
|
||||
if len(errs) == started {
|
||||
if started == 1 {
|
||||
return nil, errs[0]
|
||||
}
|
||||
return nil, fmt.Errorf("netbox search failed: %v; %v", errs[0], errs[1])
|
||||
}
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// SearchAll paginates through all matching devices and VMs, fetching every page.
|
||||
// Intended for cache refresh; use Search for interactive queries.
|
||||
func (c *Client) SearchAll(ctx context.Context, query string, opts SearchOptions) ([]HostEntry, error) {
|
||||
if c.sources != nil {
|
||||
return c.searchSources(ctx, query, opts, true)
|
||||
}
|
||||
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
|
||||
errs []error
|
||||
wg sync.WaitGroup
|
||||
)
|
||||
|
||||
if opts.Kind != "vm" {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
devices, err := c.fetchAllDevices(ctx, query, filters)
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if err != nil {
|
||||
errs = append(errs, fmt.Errorf("devices: %w", err))
|
||||
return
|
||||
}
|
||||
results = append(results, devices...)
|
||||
}()
|
||||
}
|
||||
|
||||
if opts.Kind != "device" {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
vms, err := c.fetchAllVMs(ctx, query, filters)
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if err != nil {
|
||||
errs = append(errs, fmt.Errorf("vms: %w", err))
|
||||
return
|
||||
}
|
||||
results = append(results, vms...)
|
||||
}()
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
|
||||
if len(errs) > 0 {
|
||||
return nil, errors.Join(errs...)
|
||||
}
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// GetIPs returns all IP addresses assigned to a host, used by resolver strategies
|
||||
// that need more than just the primary IP.
|
||||
func (c *Client) GetIPs(ctx context.Context, entry HostEntry) ([]string, error) {
|
||||
if c.sources != nil {
|
||||
source, host, err := c.sourceForHost(entry)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return source.GetIPs(ctx, host)
|
||||
}
|
||||
switch entry.Kind {
|
||||
case "device":
|
||||
return c.fetchAllIPs(ctx, fmt.Sprintf("device_id=%d", entry.ID))
|
||||
case "vm":
|
||||
return c.fetchAllIPs(ctx, fmt.Sprintf("virtual_machine_id=%d", entry.ID))
|
||||
}
|
||||
return nil, fmt.Errorf("unknown host kind: %q", entry.Kind)
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// GetIPsWithFilter calls /api/ipam/ip-addresses/ with arbitrary filter query parameters.
|
||||
func (c *Client) GetIPsWithFilter(ctx context.Context, filterParams string) ([]string, error) {
|
||||
if c.sources != nil {
|
||||
return nil, fmt.Errorf("IP filters require a host instance; use GetIPsWithFilterForHost")
|
||||
}
|
||||
return c.fetchAllIPs(ctx, filterParams)
|
||||
}
|
||||
|
||||
func (c *Client) searchDevices(ctx context.Context, query, tag string) ([]HostEntry, error) {
|
||||
apiURL := fmt.Sprintf("%s/api/dcim/devices/?name__ic=%s&limit=50", c.baseURL, url.QueryEscape(query))
|
||||
if tag != "" {
|
||||
apiURL += "&tag=" + url.QueryEscape(tag)
|
||||
}
|
||||
var resp netboxListResponse[netboxDevice]
|
||||
if err := c.get(ctx, apiURL, &resp); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
entries := make([]HostEntry, 0, len(resp.Results))
|
||||
for _, d := range resp.Results {
|
||||
entries = append(entries, deviceToEntry(d))
|
||||
}
|
||||
return entries, nil
|
||||
}
|
||||
|
||||
func (c *Client) searchVMs(ctx context.Context, query, tag string) ([]HostEntry, error) {
|
||||
apiURL := fmt.Sprintf("%s/api/virtualization/virtual-machines/?name__ic=%s&limit=50", c.baseURL, url.QueryEscape(query))
|
||||
if tag != "" {
|
||||
apiURL += "&tag=" + url.QueryEscape(tag)
|
||||
}
|
||||
var resp netboxListResponse[netboxVM]
|
||||
if err := c.get(ctx, apiURL, &resp); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
entries := make([]HostEntry, 0, len(resp.Results))
|
||||
for _, v := range resp.Results {
|
||||
entries = append(entries, vmToEntry(v))
|
||||
}
|
||||
return entries, nil
|
||||
}
|
||||
|
||||
// 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) + filters
|
||||
var resp netboxListResponse[netboxDevice]
|
||||
if err := c.get(ctx, apiURL, &resp); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, d := range resp.Results {
|
||||
all = append(all, deviceToEntry(d))
|
||||
}
|
||||
if len(resp.Results) == 0 || len(all) >= resp.Count {
|
||||
break
|
||||
}
|
||||
}
|
||||
return all, nil
|
||||
}
|
||||
|
||||
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) + filters
|
||||
var resp netboxListResponse[netboxVM]
|
||||
if err := c.get(ctx, apiURL, &resp); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, v := range resp.Results {
|
||||
all = append(all, vmToEntry(v))
|
||||
}
|
||||
if len(resp.Results) == 0 || len(all) >= resp.Count {
|
||||
break
|
||||
}
|
||||
}
|
||||
return all, nil
|
||||
}
|
||||
|
||||
// TokenVersion returns 2 for NetBox v2 tokens (nbt_ prefix) or 1 for legacy tokens.
|
||||
func TokenVersion(token string) int {
|
||||
if strings.HasPrefix(token, "nbt_") {
|
||||
return 2
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
func (c *Client) get(ctx context.Context, apiURL string, out any) error {
|
||||
_, err := c.request(ctx, http.MethodGet, apiURL, nil, "", out)
|
||||
return err
|
||||
}
|
||||
|
||||
func (c *Client) request(ctx context.Context, method, apiURL string, body io.Reader, etag string, out any) (string, error) {
|
||||
req, err := http.NewRequestWithContext(ctx, method, apiURL, body)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("creating request: %w", err)
|
||||
}
|
||||
scheme := "Token "
|
||||
if c.tokenVersion == 2 {
|
||||
scheme = "Bearer "
|
||||
}
|
||||
req.Header.Set("Authorization", scheme+c.token)
|
||||
if body != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
if etag != "" {
|
||||
req.Header.Set("If-Match", etag)
|
||||
}
|
||||
req.Header.Set("Accept", "application/json")
|
||||
|
||||
resp, err := c.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("request to %s: %w", apiURL, err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode == http.StatusForbidden {
|
||||
hint := "check token permissions in NetBox"
|
||||
if c.tokenVersion == 1 {
|
||||
hint += " — legacy v1 token detected, consider upgrading to a v2 token (starts with nbt_)"
|
||||
}
|
||||
return "", fmt.Errorf("%s: %s", apiURL, hint)
|
||||
}
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return "", &StatusError{Code: resp.StatusCode, URL: apiURL}
|
||||
}
|
||||
|
||||
if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
|
||||
return "", fmt.Errorf("decoding response: %w", err)
|
||||
}
|
||||
return resp.Header.Get("ETag"), nil
|
||||
}
|
||||
|
||||
func deviceToEntry(d netboxDevice) HostEntry {
|
||||
e := HostEntry{ID: d.ID, Name: d.Name, Kind: "device"}
|
||||
if d.PrimaryIP4 != nil {
|
||||
e.PrimaryIP4 = stripPrefix(d.PrimaryIP4.Address)
|
||||
}
|
||||
if d.PrimaryIP6 != nil {
|
||||
e.PrimaryIP6 = stripPrefix(d.PrimaryIP6.Address)
|
||||
}
|
||||
for _, t := range d.Tags {
|
||||
e.Tags = append(e.Tags, t.Name)
|
||||
}
|
||||
if d.Cluster != nil {
|
||||
e.Cluster = d.Cluster.Name
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
func vmToEntry(v netboxVM) HostEntry {
|
||||
e := HostEntry{ID: v.ID, Name: v.Name, Kind: "vm"}
|
||||
if v.PrimaryIP4 != nil {
|
||||
e.PrimaryIP4 = stripPrefix(v.PrimaryIP4.Address)
|
||||
}
|
||||
if v.PrimaryIP6 != nil {
|
||||
e.PrimaryIP6 = stripPrefix(v.PrimaryIP6.Address)
|
||||
}
|
||||
for _, t := range v.Tags {
|
||||
e.Tags = append(e.Tags, t.Name)
|
||||
}
|
||||
if v.Cluster != nil {
|
||||
e.Cluster = v.Cluster.Name
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
// stripPrefix removes the CIDR prefix length from a NetBox IP (e.g. "10.0.1.5/24" → "10.0.1.5").
|
||||
func stripPrefix(cidr string) string {
|
||||
if idx := strings.Index(cidr, "/"); idx != -1 {
|
||||
return cidr[:idx]
|
||||
}
|
||||
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")
|
||||
|
||||
// FindHost refuses ambiguous names so writes cannot target an arbitrary server.
|
||||
func (c *Client) FindHost(ctx context.Context, name, kind string) (HostEntry, error) {
|
||||
if kind != "" && kind != "device" && kind != "vm" {
|
||||
return HostEntry{}, fmt.Errorf("invalid kind %q", kind)
|
||||
}
|
||||
entries, err := c.SearchAll(ctx, name, SearchOptions{Kind: kind})
|
||||
_, hostname := SplitTarget(name)
|
||||
if err != nil {
|
||||
return HostEntry{}, err
|
||||
}
|
||||
var matches []HostEntry
|
||||
for _, e := range entries {
|
||||
if strings.EqualFold(e.Name, hostname) {
|
||||
matches = append(matches, e)
|
||||
}
|
||||
}
|
||||
if len(matches) == 0 {
|
||||
return HostEntry{}, fmt.Errorf("%w: %q", ErrHostNotFound, name)
|
||||
}
|
||||
if len(matches) != 1 {
|
||||
if c.sources != nil {
|
||||
return HostEntry{}, fmt.Errorf("host %q: found %d exact matches; use instance/hostname and --kind to select a unique host", name, len(matches))
|
||||
}
|
||||
return HostEntry{}, fmt.Errorf("host %q: found %d exact matches; use --kind or a unique hostname", name, len(matches))
|
||||
}
|
||||
return matches[0], nil
|
||||
}
|
||||
|
||||
func (c *Client) hostURL(host HostEntry) (string, error) {
|
||||
var path string
|
||||
switch host.Kind {
|
||||
case "device":
|
||||
path = "dcim/devices"
|
||||
case "vm":
|
||||
path = "virtualization/virtual-machines"
|
||||
default:
|
||||
return "", fmt.Errorf("invalid host kind %q", host.Kind)
|
||||
}
|
||||
if host.ID <= 0 {
|
||||
return "", fmt.Errorf("invalid host ID")
|
||||
}
|
||||
return fmt.Sprintf("%s/api/%s/%d/", c.baseURL, path, host.ID), nil
|
||||
}
|
||||
|
||||
func (c *Client) GetComments(ctx context.Context, host HostEntry) (string, string, error) {
|
||||
if c.sources != nil {
|
||||
source, host, err := c.sourceForHost(host)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
return source.GetComments(ctx, host)
|
||||
}
|
||||
u, err := c.hostURL(host)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
var out struct {
|
||||
Comments string `json:"comments"`
|
||||
}
|
||||
etag, err := c.request(ctx, http.MethodGet, u, nil, "", &out)
|
||||
return out.Comments, etag, err
|
||||
}
|
||||
|
||||
func (c *Client) SetComments(ctx context.Context, host HostEntry, comments, etag string) error {
|
||||
if c.sources != nil {
|
||||
source, host, err := c.sourceForHost(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return source.SetComments(ctx, host, comments, etag)
|
||||
}
|
||||
u, err := c.hostURL(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
data, err := json.Marshal(map[string]string{"comments": comments})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var out json.RawMessage
|
||||
_, err = c.request(ctx, http.MethodPatch, u, bytes.NewReader(data), etag, &out)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,546 @@
|
||||
package netbox
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// newTestServer returns an httptest.Server that serves fixed responses per path.
|
||||
func newTestServer(t *testing.T, handlers map[string]any) *httptest.Server {
|
||||
t.Helper()
|
||||
mux := http.NewServeMux()
|
||||
for path, body := range handlers {
|
||||
b, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
t.Fatalf("marshalling handler for %s: %v", path, err)
|
||||
}
|
||||
captured := b
|
||||
mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Write(captured)
|
||||
})
|
||||
}
|
||||
return httptest.NewServer(mux)
|
||||
}
|
||||
|
||||
func deviceListResponse(devices ...netboxDevice) netboxListResponse[netboxDevice] {
|
||||
return netboxListResponse[netboxDevice]{Count: len(devices), Results: devices}
|
||||
}
|
||||
|
||||
func vmListResponse(vms ...netboxVM) netboxListResponse[netboxVM] {
|
||||
return netboxListResponse[netboxVM]{Count: len(vms), Results: vms}
|
||||
}
|
||||
|
||||
func ipListResponse(addrs ...string) netboxIPListResponse {
|
||||
resp := netboxIPListResponse{Count: len(addrs)}
|
||||
for _, a := range addrs {
|
||||
resp.Results = append(resp.Results, struct {
|
||||
Address string `json:"address"`
|
||||
Interface *struct {
|
||||
Name string `json:"name"`
|
||||
} `json:"assigned_object"`
|
||||
}{Address: a})
|
||||
}
|
||||
return resp
|
||||
}
|
||||
|
||||
func TestSearch_ReturnsBothDevicesAndVMs(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(
|
||||
netboxDevice{ID: 1, Name: "router-01", PrimaryIP4: &netboxIP{Address: "10.0.0.1/24"}},
|
||||
),
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(
|
||||
netboxVM{ID: 2, Name: "vm-01", PrimaryIP4: &netboxIP{Address: "10.0.0.2/24"}},
|
||||
),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, err := c.Search(context.Background(), "", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("Search: %v", err)
|
||||
}
|
||||
if len(results) != 2 {
|
||||
t.Errorf("got %d results, want 2", len(results))
|
||||
}
|
||||
|
||||
names := map[string]bool{}
|
||||
for _, r := range results {
|
||||
names[r.Name] = true
|
||||
}
|
||||
if !names["router-01"] || !names["vm-01"] {
|
||||
t.Errorf("missing expected hosts in results: %v", names)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_MapsKindCorrectly(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(
|
||||
netboxDevice{ID: 1, Name: "sw-01"},
|
||||
),
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(
|
||||
netboxVM{ID: 2, Name: "vm-01"},
|
||||
),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, _ := c.Search(context.Background(), "", SearchOptions{})
|
||||
|
||||
for _, r := range results {
|
||||
switch r.Name {
|
||||
case "sw-01":
|
||||
if r.Kind != "device" {
|
||||
t.Errorf("sw-01 kind: got %q, want %q", r.Kind, "device")
|
||||
}
|
||||
case "vm-01":
|
||||
if r.Kind != "vm" {
|
||||
t.Errorf("vm-01 kind: got %q, want %q", r.Kind, "vm")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_StripsPrefixFromPrimaryIP(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(
|
||||
netboxDevice{ID: 1, Name: "host", PrimaryIP4: &netboxIP{Address: "192.168.1.10/24"}},
|
||||
),
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, _ := c.Search(context.Background(), "host", SearchOptions{})
|
||||
if len(results) == 0 {
|
||||
t.Fatal("expected at least one result")
|
||||
}
|
||||
if results[0].PrimaryIP4 != "192.168.1.10" {
|
||||
t.Errorf("PrimaryIP4: got %q, want %q", results[0].PrimaryIP4, "192.168.1.10")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_TagsAreMapped(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(
|
||||
netboxDevice{
|
||||
ID: 1,
|
||||
Name: "host",
|
||||
Tags: []struct {
|
||||
Name string `json:"name"`
|
||||
}{{Name: "prod"}, {Name: "mgmt"}},
|
||||
},
|
||||
),
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, _ := c.Search(context.Background(), "", SearchOptions{})
|
||||
if len(results[0].Tags) != 2 {
|
||||
t.Errorf("tags: got %v, want [prod mgmt]", results[0].Tags)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_PartialFailure_ReturnsAvailableResults(t *testing.T) {
|
||||
// Only devices endpoint works; VMs returns 500.
|
||||
mux := http.NewServeMux()
|
||||
body, _ := json.Marshal(deviceListResponse(netboxDevice{ID: 1, Name: "sw-01"}))
|
||||
mux.HandleFunc("/api/dcim/devices/", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Write(body)
|
||||
})
|
||||
mux.HandleFunc("/api/virtualization/virtual-machines/", func(w http.ResponseWriter, r *http.Request) {
|
||||
http.Error(w, "internal error", http.StatusInternalServerError)
|
||||
})
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, err := c.Search(context.Background(), "", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("partial failure should not return error, got: %v", err)
|
||||
}
|
||||
if len(results) != 1 || results[0].Name != "sw-01" {
|
||||
t.Errorf("expected device results, got %v", results)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_BothFail_ReturnsError(t *testing.T) {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
||||
http.Error(w, "error", http.StatusInternalServerError)
|
||||
})
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
_, err := c.Search(context.Background(), "", SearchOptions{})
|
||||
if err == nil {
|
||||
t.Error("both endpoints failing should return an error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetIPs_Device(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/ipam/ip-addresses/": ipListResponse("10.0.0.1/24", "10.0.0.2/24"),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
ips, err := c.GetIPs(context.Background(), HostEntry{ID: 1, Kind: "device"})
|
||||
if err != nil {
|
||||
t.Fatalf("GetIPs: %v", err)
|
||||
}
|
||||
if len(ips) != 2 {
|
||||
t.Errorf("got %d IPs, want 2", len(ips))
|
||||
}
|
||||
if ips[0] != "10.0.0.1" || ips[1] != "10.0.0.2" {
|
||||
t.Errorf("IPs: got %v, want [10.0.0.1 10.0.0.2]", ips)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetIPs_VM(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/ipam/ip-addresses/": ipListResponse("172.16.0.5/16"),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
ips, err := c.GetIPs(context.Background(), HostEntry{ID: 2, Kind: "vm"})
|
||||
if err != nil {
|
||||
t.Fatalf("GetIPs: %v", err)
|
||||
}
|
||||
if len(ips) != 1 || ips[0] != "172.16.0.5" {
|
||||
t.Errorf("IPs: got %v, want [172.16.0.5]", ips)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetIPs_UnknownKind(t *testing.T) {
|
||||
c := NewClient("http://localhost", "token", 0)
|
||||
_, err := c.GetIPs(context.Background(), HostEntry{ID: 1, Kind: "unknown"})
|
||||
if err == nil {
|
||||
t.Error("unknown kind should return an error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetIPsWithFilter(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/ipam/ip-addresses/": ipListResponse("10.10.10.1/24"),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
ips, err := c.GetIPsWithFilter(context.Background(), "device_id=1&interface=mgmt0")
|
||||
if err != nil {
|
||||
t.Fatalf("GetIPsWithFilter: %v", err)
|
||||
}
|
||||
if len(ips) != 1 || ips[0] != "10.10.10.1" {
|
||||
t.Errorf("IPs: got %v, want [10.10.10.1]", ips)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTokenVersion(t *testing.T) {
|
||||
tests := []struct {
|
||||
token string
|
||||
want int
|
||||
}{
|
||||
{"nbt_abc123", 2},
|
||||
{"nbt_", 2},
|
||||
{"abc123def456", 1},
|
||||
{"", 1},
|
||||
{"Token abc", 1},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
if got := TokenVersion(tt.token); got != tt.want {
|
||||
t.Errorf("TokenVersion(%q) = %d, want %d", tt.token, got, tt.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewClient_AutoDetectsVersion(t *testing.T) {
|
||||
c := NewClient("http://localhost", "nbt_secret", 0)
|
||||
if c.tokenVersion != 2 {
|
||||
t.Errorf("tokenVersion: got %d, want 2", c.tokenVersion)
|
||||
}
|
||||
|
||||
c2 := NewClient("http://localhost", "legacytoken", 0)
|
||||
if c2.tokenVersion != 1 {
|
||||
t.Errorf("tokenVersion: got %d, want 1", c2.tokenVersion)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewClient_RespectsExplicitVersion(t *testing.T) {
|
||||
// Explicit version overrides auto-detection.
|
||||
c := NewClient("http://localhost", "legacytoken", 2)
|
||||
if c.tokenVersion != 2 {
|
||||
t.Errorf("tokenVersion: got %d, want 2", c.tokenVersion)
|
||||
}
|
||||
}
|
||||
|
||||
func Test403_V1Token_HintsUpgrade(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
http.Error(w, "forbidden", http.StatusForbidden)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "legacytoken", 1)
|
||||
_, err := c.Search(context.Background(), "host", SearchOptions{})
|
||||
if err == nil {
|
||||
t.Fatal("expected error on 403")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "v1 token") {
|
||||
t.Errorf("expected v1 hint in error, got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func Test403_V2Token_NoV1Hint(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
http.Error(w, "forbidden", http.StatusForbidden)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "nbt_secret", 2)
|
||||
_, err := c.Search(context.Background(), "host", SearchOptions{})
|
||||
if err == nil {
|
||||
t.Fatal("expected error on 403")
|
||||
}
|
||||
if strings.Contains(err.Error(), "v1 token") {
|
||||
t.Errorf("v1 hint should not appear for v2 token, got: %v", err)
|
||||
}
|
||||
if !strings.Contains(err.Error(), "check token permissions") {
|
||||
t.Errorf("expected permissions hint in error, got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGet_SendsAuthorizationHeader(t *testing.T) {
|
||||
for _, token := range []string{"nbt_mytoken", "legacytoken"} {
|
||||
t.Run(token, func(t *testing.T) {
|
||||
want := "Token " + token
|
||||
if strings.HasPrefix(token, "nbt_") {
|
||||
want = "Bearer " + token
|
||||
}
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if got := r.Header.Get("Authorization"); got != want {
|
||||
t.Errorf("Authorization: got %q, want %q", got, want)
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
b, _ := json.Marshal(deviceListResponse())
|
||||
w.Write(b)
|
||||
}))
|
||||
defer srv.Close()
|
||||
c := NewClient(srv.URL, token, 0)
|
||||
if _, err := c.Search(context.Background(), "", SearchOptions{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearchAll_PaginatesResults(t *testing.T) {
|
||||
// Simulate a NetBox endpoint with 3 total devices split across 2 pages.
|
||||
// count=3 throughout; first page has 2 results, second has 1.
|
||||
callCount := 0
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/api/dcim/devices/", func(w http.ResponseWriter, r *http.Request) {
|
||||
callCount++
|
||||
offset := r.URL.Query().Get("offset")
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
var resp netboxListResponse[netboxDevice]
|
||||
switch offset {
|
||||
case "", "0":
|
||||
resp = netboxListResponse[netboxDevice]{
|
||||
Count: 3,
|
||||
Results: []netboxDevice{{ID: 1, Name: "d-01"}, {ID: 2, Name: "d-02"}},
|
||||
}
|
||||
default:
|
||||
resp = netboxListResponse[netboxDevice]{
|
||||
Count: 3,
|
||||
Results: []netboxDevice{{ID: 3, Name: "d-03"}},
|
||||
}
|
||||
}
|
||||
b, _ := json.Marshal(resp)
|
||||
w.Write(b)
|
||||
})
|
||||
mux.HandleFunc("/api/virtualization/virtual-machines/", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
b, _ := json.Marshal(vmListResponse())
|
||||
w.Write(b)
|
||||
})
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, err := c.SearchAll(context.Background(), "", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatalf("SearchAll: %v", err)
|
||||
}
|
||||
if len(results) != 3 {
|
||||
t.Errorf("SearchAll: got %d results, want 3", len(results))
|
||||
}
|
||||
if callCount < 2 {
|
||||
t.Errorf("expected at least 2 device API calls for pagination, got %d", callCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_KindFilterDeviceOnly(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(
|
||||
netboxDevice{ID: 1, Name: "sw-01"},
|
||||
),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, err := c.Search(context.Background(), "", SearchOptions{Kind: "device"})
|
||||
if err != nil {
|
||||
t.Fatalf("Search: %v", err)
|
||||
}
|
||||
if len(results) != 1 || results[0].Name != "sw-01" {
|
||||
t.Errorf("expected 1 device result, got %v", results)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSearch_KindFilterVMOnly(t *testing.T) {
|
||||
srv := newTestServer(t, map[string]any{
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(
|
||||
netboxVM{ID: 1, Name: "vm-01"},
|
||||
),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
results, err := c.Search(context.Background(), "", SearchOptions{Kind: "vm"})
|
||||
if err != nil {
|
||||
t.Fatalf("Search: %v", err)
|
||||
}
|
||||
if len(results) != 1 || results[0].Name != "vm-01" {
|
||||
t.Errorf("expected 1 vm result, got %v", results)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStripPrefix(t *testing.T) {
|
||||
tests := []struct {
|
||||
in string
|
||||
want string
|
||||
}{
|
||||
{"10.0.0.1/24", "10.0.0.1"},
|
||||
{"::1/128", "::1"},
|
||||
{"192.168.1.1", "192.168.1.1"}, // no prefix — unchanged
|
||||
{"", ""},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
if got := stripPrefix(tt.in); got != tt.want {
|
||||
t.Errorf("stripPrefix(%q) = %q, want %q", tt.in, got, tt.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommentsPreserveFieldAndSendConflictHeader(t *testing.T) {
|
||||
for _, kind := range []string{"device", "vm"} {
|
||||
t.Run(kind, func(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Header.Get("Authorization") != "Bearer nbt_test" {
|
||||
t.Error("wrong authentication")
|
||||
}
|
||||
if r.Method == http.MethodPatch {
|
||||
if r.Header.Get("If-Match") != `W/"123"` {
|
||||
t.Error("missing conflict protection")
|
||||
}
|
||||
var payload map[string]string
|
||||
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if len(payload) != 1 || payload["comments"] != "new\nnotes" {
|
||||
t.Errorf("unexpected patch: %v", payload)
|
||||
}
|
||||
}
|
||||
w.Header().Set("ETag", `W/"123"`)
|
||||
w.Write([]byte(`{"comments":"existing notes"}`))
|
||||
}))
|
||||
defer srv.Close()
|
||||
c := NewClient(srv.URL, "nbt_test", 0)
|
||||
host := HostEntry{ID: 1, Kind: kind}
|
||||
text, etag, err := c.GetComments(context.Background(), host)
|
||||
if err != nil || text != "existing notes" {
|
||||
t.Fatalf("read: %q, %v", text, err)
|
||||
}
|
||||
if err := c.SetComments(context.Background(), host, "new\nnotes", etag); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFullRefreshRejectsPartialFailure(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if strings.Contains(r.URL.Path, "virtualization") {
|
||||
w.WriteHeader(http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
w.Write([]byte(`{"count":0,"results":[]}`))
|
||||
}))
|
||||
defer srv.Close()
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
if _, err := c.SearchAll(context.Background(), "", SearchOptions{}); err == nil {
|
||||
t.Fatal("partial refresh reported as successful")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommentConflictIsReported(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusPreconditionFailed) }))
|
||||
defer srv.Close()
|
||||
c := NewClient(srv.URL, "token", 0)
|
||||
if err := c.SetComments(context.Background(), HostEntry{ID: 1, Kind: "device"}, "draft", "old"); err == nil {
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package netbox
|
||||
|
||||
import "strings"
|
||||
|
||||
// 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 {
|
||||
Source string // named NetBox instance; empty for the legacy single-instance config
|
||||
ID int
|
||||
Name string
|
||||
Kind string // "device" | "vm"
|
||||
PrimaryIP4 string // e.g. "10.0.1.5" (prefix length stripped)
|
||||
PrimaryIP6 string
|
||||
Tags []string
|
||||
Cluster string // virtualization cluster name, if assigned
|
||||
}
|
||||
|
||||
// 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.
|
||||
type netboxIP struct {
|
||||
Address string `json:"address"` // CIDR notation, e.g. "10.0.1.5/24"
|
||||
}
|
||||
|
||||
// netboxDevice matches the relevant fields of the NetBox /dcim/devices/ response.
|
||||
type netboxDevice struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Tags []struct {
|
||||
Name string `json:"name"`
|
||||
} `json:"tags"`
|
||||
PrimaryIP4 *netboxIP `json:"primary_ip4"`
|
||||
PrimaryIP6 *netboxIP `json:"primary_ip6"`
|
||||
Cluster *netboxCluster `json:"cluster"`
|
||||
}
|
||||
|
||||
// netboxVM matches the relevant fields of the NetBox /virtualization/virtual-machines/ response.
|
||||
type netboxVM struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Tags []struct {
|
||||
Name string `json:"name"`
|
||||
} `json:"tags"`
|
||||
PrimaryIP4 *netboxIP `json:"primary_ip4"`
|
||||
PrimaryIP6 *netboxIP `json:"primary_ip6"`
|
||||
Cluster *netboxCluster `json:"cluster"`
|
||||
}
|
||||
|
||||
type netboxListResponse[T any] struct {
|
||||
Count int `json:"count"`
|
||||
Results []T `json:"results"`
|
||||
}
|
||||
|
||||
type netboxIPListResponse struct {
|
||||
Count int `json:"count"`
|
||||
Results []struct {
|
||||
Address string `json:"address"`
|
||||
Interface *struct {
|
||||
Name string `json:"name"`
|
||||
} `json:"assigned_object"`
|
||||
} `json:"results"`
|
||||
}
|
||||
|
||||
// Target returns an unambiguous selector for cache, completion, and SSH.
|
||||
func (h HostEntry) Target() string {
|
||||
if h.Source == "" {
|
||||
return h.Name
|
||||
}
|
||||
return h.Source + "/" + h.Name
|
||||
}
|
||||
|
||||
// SplitTarget separates an optional instance prefix from a hostname.
|
||||
func SplitTarget(target string) (source, name string) {
|
||||
if source, name, ok := strings.Cut(target, "/"); ok {
|
||||
return strings.ToLower(source), name
|
||||
}
|
||||
return "", target
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
package netbox
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Source binds a name to its own API client and credentials.
|
||||
type Source struct {
|
||||
Name string
|
||||
URL string
|
||||
Token string
|
||||
TokenVersion int
|
||||
}
|
||||
|
||||
func NewMultiClient(sources []Source) *Client {
|
||||
c := &Client{sources: make(map[string]*Client)}
|
||||
for _, source := range sources {
|
||||
c.sources[strings.ToLower(source.Name)] = NewClient(source.URL, source.Token, source.TokenVersion)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
func (c *Client) searchSources(ctx context.Context, query string, opts SearchOptions, all bool) ([]HostEntry, error) {
|
||||
requested, query := SplitTarget(query)
|
||||
if requested != "" {
|
||||
if _, ok := c.sources[requested]; !ok {
|
||||
return nil, fmt.Errorf("unknown NetBox instance %q", requested)
|
||||
}
|
||||
}
|
||||
var mu sync.Mutex
|
||||
var wg sync.WaitGroup
|
||||
var entries []HostEntry
|
||||
var errs []error
|
||||
started := 0
|
||||
for name, client := range c.sources {
|
||||
if requested != "" && name != requested {
|
||||
continue
|
||||
}
|
||||
started++
|
||||
wg.Add(1)
|
||||
go func(name string, client *Client) {
|
||||
defer wg.Done()
|
||||
var found []HostEntry
|
||||
var err error
|
||||
if all {
|
||||
found, err = client.SearchAll(ctx, query, opts)
|
||||
} else {
|
||||
found, err = client.Search(ctx, query, opts)
|
||||
}
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if err != nil {
|
||||
errs = append(errs, fmt.Errorf("NetBox %s: %w", name, err))
|
||||
return
|
||||
}
|
||||
for i := range found {
|
||||
found[i].Source = name
|
||||
}
|
||||
entries = append(entries, found...)
|
||||
}(name, client)
|
||||
}
|
||||
wg.Wait()
|
||||
// Full lookups must see every source to rule out ambiguous hostnames.
|
||||
if len(errs) > 0 && (all || len(errs) == started) {
|
||||
return nil, errors.Join(errs...)
|
||||
}
|
||||
sort.Slice(entries, func(i, j int) bool { return entries[i].Target() < entries[j].Target() })
|
||||
return entries, errors.Join(errs...)
|
||||
}
|
||||
|
||||
func (c *Client) sourceForHost(host HostEntry) (*Client, HostEntry, error) {
|
||||
prefix, name := SplitTarget(host.Name)
|
||||
if prefix != "" {
|
||||
if host.Source != "" && !strings.EqualFold(prefix, host.Source) {
|
||||
return nil, host, fmt.Errorf("conflicting NetBox instance for %q", host.Name)
|
||||
}
|
||||
host.Source, host.Name = prefix, name
|
||||
}
|
||||
if c.sources == nil {
|
||||
return c, host, nil
|
||||
}
|
||||
source, ok := c.sources[strings.ToLower(host.Source)]
|
||||
if !ok {
|
||||
return nil, host, fmt.Errorf("specify a configured NetBox instance as instance/hostname (got %q)", host.Target())
|
||||
}
|
||||
host.Source = strings.ToLower(host.Source)
|
||||
return source, host, nil
|
||||
}
|
||||
|
||||
// HostScope identifies a local note by its original NetBox URL and canonical
|
||||
// hostname, so renaming an instance does not move or mix its notes.
|
||||
func (c *Client) HostScope(host HostEntry) (HostEntry, string, error) {
|
||||
source, host, err := c.sourceForHost(host)
|
||||
if err != nil {
|
||||
return host, "", err
|
||||
}
|
||||
return host, source.baseURL, nil
|
||||
}
|
||||
|
||||
func (c *Client) GetIPsWithFilterForHost(ctx context.Context, host HostEntry, filters string) ([]string, error) {
|
||||
source, _, err := c.sourceForHost(host)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return source.GetIPsWithFilter(ctx, filters)
|
||||
}
|
||||
|
||||
func (c *Client) MultipleSources() bool { return c.sources != nil }
|
||||
@@ -0,0 +1,192 @@
|
||||
package netbox
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func sourceTestServer(t *testing.T, token, ip, comment string) *httptest.Server {
|
||||
t.Helper()
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if got := r.Header.Get("Authorization"); got != "Token "+token {
|
||||
t.Errorf("credentials crossed sources: %q, want %q", got, token)
|
||||
http.Error(w, "bad token", 401)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
switch r.URL.Path {
|
||||
case "/api/dcim/devices/":
|
||||
json.NewEncoder(w).Encode(deviceListResponse(netboxDevice{ID: 1, Name: "web", PrimaryIP4: &netboxIP{Address: ip + "/24"}}))
|
||||
case "/api/virtualization/virtual-machines/":
|
||||
json.NewEncoder(w).Encode(vmListResponse())
|
||||
case "/api/ipam/ip-addresses/":
|
||||
if r.URL.Query().Get("device_id") != "1" {
|
||||
t.Errorf("wrong host ID: %s", r.URL.RawQuery)
|
||||
}
|
||||
json.NewEncoder(w).Encode(ipListResponse(ip + "/24"))
|
||||
case "/api/dcim/devices/1/":
|
||||
if r.Method == http.MethodPatch {
|
||||
var data map[string]string
|
||||
if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if data["comments"] != comment+" updated" {
|
||||
t.Errorf("comment write crossed sources: %v", data)
|
||||
}
|
||||
}
|
||||
json.NewEncoder(w).Encode(map[string]string{"comments": comment})
|
||||
default:
|
||||
http.NotFound(w, r)
|
||||
}
|
||||
}))
|
||||
t.Cleanup(srv.Close)
|
||||
return srv
|
||||
}
|
||||
|
||||
func TestMultiSourceSearchAndRouting(t *testing.T) {
|
||||
office := sourceTestServer(t, "office-token", "10.0.0.1", "office note")
|
||||
lab := sourceTestServer(t, "lab-token", "10.0.0.2", "lab note")
|
||||
c := NewMultiClient([]Source{{Name: "office", URL: office.URL, Token: "office-token"}, {Name: "lab", URL: lab.URL, Token: "lab-token"}})
|
||||
ctx := context.Background()
|
||||
entries, err := c.Search(ctx, "web", SearchOptions{})
|
||||
if err != nil || len(entries) != 2 {
|
||||
t.Fatalf("combined search: %+v, %v", entries, err)
|
||||
}
|
||||
if entries[0].Target() != "lab/web" || entries[1].Target() != "office/web" {
|
||||
t.Fatalf("source lost: %+v", entries)
|
||||
}
|
||||
if _, err := c.FindHost(ctx, "web", ""); err == nil {
|
||||
t.Fatal("ambiguous unqualified hostname accepted")
|
||||
}
|
||||
for _, tc := range []struct{ name, ip, note string }{{"office", "10.0.0.1", "office note"}, {"lab", "10.0.0.2", "lab note"}} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
host, err := c.FindHost(ctx, tc.name+"/web", "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if host.Source != tc.name || host.Name != "web" || host.ID != 1 {
|
||||
t.Fatalf("wrong host identity: %+v", host)
|
||||
}
|
||||
ips, err := c.GetIPs(ctx, host)
|
||||
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=mgmt0")
|
||||
if err != nil || len(ips) != 1 || ips[0] != tc.ip {
|
||||
t.Fatalf("wrong interface source: %v, %v", ips, err)
|
||||
}
|
||||
text, _, err := c.GetComments(ctx, host)
|
||||
if err != nil || text != tc.note {
|
||||
t.Fatalf("wrong comment source: %q, %v", text, err)
|
||||
}
|
||||
// TUI cache items carry a qualified name rather than a separate source.
|
||||
qualified := HostEntry{Name: tc.name + "/web", ID: 1, Kind: "device"}
|
||||
if err := c.SetComments(ctx, qualified, tc.note+" updated", ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
if _, err := c.Search(ctx, "missing/web", SearchOptions{}); err == nil {
|
||||
t.Fatal("unknown source accepted")
|
||||
}
|
||||
if _, _, err := c.HostScope(HostEntry{Name: "web", Kind: "device"}); err == nil {
|
||||
t.Fatal("unqualified note namespace accepted")
|
||||
}
|
||||
if _, err := c.GetIPsWithFilter(ctx, "device_id=1"); err == nil {
|
||||
t.Fatal("IP filter without instance accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultiSourceSearchRunsConcurrently(t *testing.T) {
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(2)
|
||||
makeServer := func() *httptest.Server {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
wg.Done()
|
||||
both := make(chan struct{})
|
||||
go func() { wg.Wait(); close(both) }()
|
||||
select {
|
||||
case <-both:
|
||||
fmt.Fprint(w, `{"count":0,"results":[]}`)
|
||||
case <-r.Context().Done():
|
||||
}
|
||||
}))
|
||||
t.Cleanup(srv.Close)
|
||||
return srv
|
||||
}
|
||||
a, b := makeServer(), makeServer()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
defer cancel()
|
||||
c := NewMultiClient([]Source{{Name: "a", URL: a.URL}, {Name: "b", URL: b.URL}})
|
||||
if _, err := c.Search(ctx, "web", SearchOptions{Kind: "device"}); err != nil {
|
||||
t.Fatalf("sources did not run concurrently: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultiSourcePartialFailure(t *testing.T) {
|
||||
good := sourceTestServer(t, "good-token", "10.0.0.1", "note")
|
||||
failed := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Error(w, "unavailable", 503) }))
|
||||
defer failed.Close()
|
||||
c := NewMultiClient([]Source{{Name: "good", URL: good.URL, Token: "good-token"}, {Name: "offline", URL: failed.URL}})
|
||||
ctx := context.Background()
|
||||
entries, err := c.Search(ctx, "web", SearchOptions{})
|
||||
if len(entries) != 1 || err == nil || !strings.Contains(err.Error(), "offline") {
|
||||
t.Fatalf("partial search lost results or warning: %+v, %v", entries, err)
|
||||
}
|
||||
if _, err := c.SearchAll(ctx, "web", SearchOptions{}); err == nil {
|
||||
t.Fatal("incomplete full search succeeded")
|
||||
}
|
||||
if _, err := c.FindHost(ctx, "web", ""); err == nil {
|
||||
t.Fatal("incomplete search claimed unique host")
|
||||
}
|
||||
if host, err := c.FindHost(ctx, "good/web", ""); err != nil || host.Source != "good" {
|
||||
t.Fatalf("qualified lookup blocked by unrelated outage: %+v, %v", host, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultiSourceKeepsIndependentDeviceAndVMInventories(t *testing.T) {
|
||||
office := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(netboxDevice{ID: 1, Name: "office-router", PrimaryIP4: &netboxIP{Address: "10.1.0.1/24"}}),
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(netboxVM{ID: 2, Name: "office-vm", PrimaryIP4: &netboxIP{Address: "10.1.0.2/24"}}),
|
||||
})
|
||||
defer office.Close()
|
||||
lab := newTestServer(t, map[string]any{
|
||||
"/api/dcim/devices/": deviceListResponse(netboxDevice{ID: 1, Name: "lab-switch", PrimaryIP4: &netboxIP{Address: "10.2.0.1/24"}}),
|
||||
"/api/virtualization/virtual-machines/": vmListResponse(netboxVM{ID: 2, Name: "lab-vm", PrimaryIP4: &netboxIP{Address: "10.2.0.2/24"}}),
|
||||
})
|
||||
defer lab.Close()
|
||||
client := NewMultiClient([]Source{{Name: "office", URL: office.URL}, {Name: "lab", URL: lab.URL}})
|
||||
entries, err := client.SearchAll(context.Background(), "", SearchOptions{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := map[string]string{"office/office-router": "device", "office/office-vm": "vm", "lab/lab-switch": "device", "lab/lab-vm": "vm"}
|
||||
if len(entries) != len(want) {
|
||||
t.Fatalf("independent inventories missing: %+v", entries)
|
||||
}
|
||||
for _, entry := range entries {
|
||||
if want[entry.Target()] != entry.Kind {
|
||||
t.Fatalf("inventory crossed source or kind: %+v", entry)
|
||||
}
|
||||
}
|
||||
vms, err := client.Search(context.Background(), "", SearchOptions{Kind: "vm"})
|
||||
if err != nil || len(vms) != 2 {
|
||||
t.Fatalf("VM filter across instances: %+v, %v", vms, err)
|
||||
}
|
||||
for _, host := range vms {
|
||||
if host.Kind != "vm" {
|
||||
t.Fatalf("device leaked into VM filter: %+v", host)
|
||||
}
|
||||
}
|
||||
host, err := client.FindHost(context.Background(), "lab/lab-vm", "vm")
|
||||
if err != nil || host.Source != "lab" || host.ID != 2 || host.PrimaryIP4 != "10.2.0.2" {
|
||||
t.Fatalf("wrong VM selected: %+v, %v", host, err)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user