diff --git a/CHANGELOG.md b/CHANGELOG.md index be10bfc..ffc24ed 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,7 +19,8 @@ publish a tag that has no section here. Where LLDP sees nothing, cables recorded in NetBox (through patch panels) or entered by hand (`POST`/`DELETE /api/v1/cables`); the BMC's port to the out-of-band switch that way, OOB switches marked; NetBox cables that disagree with LLDP are shown. -- NetBox's web UI through Rollcall at its `BASE_PATH` (admins only), and links to NetBox from the +- NetBox's web UI through Rollcall at its `BASE_PATH` on a listener of its own (`ipam.ui_listen`, + default `:8444`: another origin than Rollcall's UI), admins only, and links to NetBox from the web UI (sidebar, sites, rooms, racks, switches, machine devices); `ipam.ui_url` for direct links. With `ipam.ui_login_secret_file` the admin certificate signs in to NetBox too (NetBox's remote user header, guarded by a shared secret the web server in front of NetBox checks). @@ -52,8 +53,16 @@ publish a tag that has no section here. ### Changed - `rollcall ca rotate -yes` (replace the root, racks join again) is gone; the three steps replace it. +- The web UI's files are served with `Cache-Control: no-cache` and an ETag per build: browsers + revalidate and pick up a new build right after a deploy. +- Upgrading: database tables and columns are added at start. For NetBox cables the NetBox user + needs `view` on `dcim.cable` and `dcim.interface`; for the UI through Rollcall, NetBox's + `BASE_PATH` and `CSRF_TRUSTED_ORIGINS` (README, NetBox's UI through Rollcall). ### Fixed +- The release workflow could not publish the commissioning image (permission denied on + `SHA256SUMS`); an existing checksum file is now verified instead of rewritten. +- Stored PXE boot entries kept the old `rollcall.ca` after a root rotation; the rack re-pins them. - A rack typed in from a machine's location and the same rack from NetBox in another case showed twice; the layout sync folds it into NetBox's spelling (place, comment and machines follow). - NetBox paging under a `BASE_PATH` doubled the path on the next page. diff --git a/README.md b/README.md index 0398c5f..5f67969 100644 --- a/README.md +++ b/README.md @@ -882,14 +882,18 @@ The NetBox user needs `view/add/change/delete` on `dcim.device`, When NetBox runs under a path (its `BASE_PATH`, e.g. `BASE_PATH = 'netbox/'`) and `ipam.url` carries it (`"url": "https://netbox.example/netbox/"`), Rollcall -serves NetBox's web UI at that same path, `https:///netbox/`, for +serves NetBox's web UI at that same path on a listener of its own, +`https://:8444/netbox/` (`ipam.ui_listen`, default `:8444`), for admins only (the admin certificate, as for the API). NetBox keeps its own login. This opens NetBox wherever Rollcall opens, also when the browser cannot reach -NetBox itself. Two settings on the NetBox side: +NetBox itself. The separate port is on purpose: another origin than Rollcall's +UI, so a script in a NetBox page (a custom link, an export template) can +neither read the Rollcall UI's stored admin token nor call Rollcall's API as +the admin. Two settings on the NetBox side: ```python BASE_PATH = 'netbox/' -CSRF_TRUSTED_ORIGINS = ['https://rollcall.example'] # where browsers post from +CSRF_TRUSTED_ORIGINS = ['https://rollcall.example:8444'] # where browsers post from ``` **Signing in with the admin certificate.** With `"ui_login_secret_file"` in the @@ -918,7 +922,8 @@ request_header @notrollcall -X-Rollcall-User request_header -X-Rollcall-Proxy-Secret ``` -Rollcall drops both headers when a browser sends them. An admin with a token +Rollcall drops both headers when a browser sends them, in any spelling a WSGI +server would read as the same (`X-Rollcall_User`). An admin with a token instead of a certificate signs in to NetBox by hand. `lab/netbox/install.sh` sets all of this up for the lab NetBox. diff --git a/cmd/rollcall/cabling.go b/cmd/rollcall/cabling.go index 98106f8..fd64cd2 100644 --- a/cmd/rollcall/cabling.go +++ b/cmd/rollcall/cabling.go @@ -3,8 +3,8 @@ package main // Cabling: what each machine's ports are plugged into, and where the // switches at the other end stand. A port's switch port comes from, first, // the LLDP its commissioning saw (lldpcli's neighbours per interface): what -// is really there; then a cable recorded in NetBox on the machine's device -// (dcim interfaces with link peers); then one entered here. The BMC's port +// is really there; then one entered here; then a cable recorded in NetBox on +// the machine's device (dcim interfaces, through patch panels). The BMC's port // is not seen by the host's LLDP: its cable (to the out-of-band switch) is // NetBox's or entered here. When NetBox records another switch port than // LLDP sees, the port says so (netbox_says). @@ -220,8 +220,9 @@ func (s *Store) ReplaceNetBoxCables(ctx context.Context, cs []Cable) error { return err } for _, c := range cs { - if _, err := tx.Exec(ctx, `INSERT INTO cables(machine_id, port, switch, switch_port, source) VALUES ($1,$2,$3,$4,'netbox') ON CONFLICT DO NOTHING`, - c.Machine, c.Port, c.Switch, c.SwitchPort); err != nil { + // a device whose rollcall_machine names no machine here (deleted, typed in) is skipped + if _, err := tx.Exec(ctx, `INSERT INTO cables(machine_id, port, switch, switch_port, source) SELECT $1,$2,$3,$4,'netbox' + WHERE EXISTS (SELECT 1 FROM machines WHERE id=$1) ON CONFLICT DO NOTHING`, c.Machine, c.Port, c.Switch, c.SwitchPort); err != nil { return err } } @@ -312,7 +313,7 @@ func (a *App) handleCabling(w http.ResponseWriter, r *http.Request) { } // mergeCables adds the recorded cables to the ports LLDP filled: a port -// without a neighbour takes NetBox's cable, else one entered here; the BMC's +// without a neighbour takes the one entered here, else NetBox's; the BMC's // port is added when a cable is recorded for it. A NetBox cable that // disagrees with LLDP is kept as netbox_says. func mergeCables(ports []Port, cs []Cable) []Port { @@ -447,13 +448,20 @@ func (a *App) syncSwitches(ctx context.Context, nb *netBox) error { if len(names) == 0 { return nil } - q := url.Values{} + var list []string for n := range names { - q.Add("name", n) + list = append(list, n) } - devs, err := nb.all(ctx, "dcim/devices/", q) - if err != nil { - return err + sort.Strings(list) + var devs []obj + for len(list) > 0 { // 50 names per request: a large site would outgrow a URL + batch := list[:min(50, len(list))] + list = list[len(batch):] + got, err := nb.all(ctx, "dcim/devices/", url.Values{"name": batch}) + if err != nil { + return err + } + devs = append(devs, got...) } for _, x := range switchPlaces(devs) { if err := a.store.PutSwitch(ctx, x); err != nil { diff --git a/cmd/rollcall/carot.go b/cmd/rollcall/carot.go index efaff7f..6c7d199 100644 --- a/cmd/rollcall/carot.go +++ b/cmd/rollcall/carot.go @@ -315,22 +315,31 @@ func (a *App) trustState() *rackTrustState { } // caRefreshFiles keep a deployed machine's roots current: the bundle comes -// over HTTPS from the rack, checked against the roots the machine trusts now, -// so a rotation reaches it during prepare (before the new root signs) and the -// old root leaves it after retire. +// over HTTPS from the rack, checked against the Rollcall roots the machine +// trusts now (pinned: a certificate from a public CA for the rack's name is +// not enough), so a rotation reaches it during prepare (before the new root +// signs) and the old root leaves it after retire. Only CA certificates are +// taken from the bundle. func caRefreshFiles(tlsBase string) []seedFile { script := `#!/bin/sh # rollcall: keep the installation's roots current (written at deploy time) set -eu URL=` + shQuote(tlsBase+"/ca-bundle.pem") + ` T=$(mktemp -d); trap 'rm -rf "$T"' EXIT -rc=0; curl -fsS --max-time 30 -o "$T/bundle" "$URL" || rc=$? +cat /usr/local/share/ca-certificates/rollcall-ca*.crt /etc/pki/ca-trust/source/anchors/rollcall-ca*.crt > "$T/pin" 2>/dev/null || true +[ -s "$T/pin" ] || { echo "rollcall: no Rollcall root installed here to check $URL with" >&2; exit 1; } +rc=0; curl -fsS --max-time 30 --cacert "$T/pin" -o "$T/bundle" "$URL" || rc=$? if [ $rc -eq 60 ]; then # the server's certificate is from a root not trusted here echo "rollcall: $URL is not trusted here: the root rotation went past prepare before this machine refreshed; install the bundle by hand" >&2; exit 1 fi [ $rc -eq 0 ] || exit 0 # unreachable: the timer tries again awk -v d="$T" '/-----BEGIN CERTIFICATE-----/{n++} n{print > (d "/c" n)} /-----END CERTIFICATE-----/{close(d "/c" n)}' "$T/bundle" [ -f "$T/c1" ] || exit 0 +if command -v openssl >/dev/null 2>&1; then + for c in "$T"/c[0-9]*; do + openssl x509 -in "$c" -noout -text 2>/dev/null | grep -q 'CA:TRUE' || { echo "rollcall: $URL sent a certificate that is not a CA; nothing changed" >&2; exit 1; } + done +fi changed= for dir in /usr/local/share/ca-certificates /etc/pki/ca-trust/source/anchors; do [ -d "$dir" ] || continue diff --git a/cmd/rollcall/carot_test.go b/cmd/rollcall/carot_test.go index b1883d4..b82f5e5 100644 --- a/cmd/rollcall/carot_test.go +++ b/cmd/rollcall/carot_test.go @@ -167,6 +167,10 @@ func TestCARefreshScript(t *testing.T) { if len(fs) != 3 || !strings.Contains(fs[0].Content, "URL='https://10.213.78.1/ca-bundle.pem'") { t.Fatalf("%+v", fs[0]) } + // the rack is checked against the Rollcall roots installed, not the system's; only CAs are taken + if !strings.Contains(fs[0].Content, `--cacert "$T/pin"`) || !strings.Contains(fs[0].Content, "CA:TRUE") { + t.Fatal("refresh is not pinned to the installed roots or takes any certificate") + } f := filepath.Join(t.TempDir(), "s") _ = os.WriteFile(f, []byte(fs[0].Content), 0o755) if out, err := exec.Command("sh", "-n", f).CombinedOutput(); err != nil { diff --git a/cmd/rollcall/hwsize.go b/cmd/rollcall/hwsize.go index 4548c8b..692425b 100644 --- a/cmd/rollcall/hwsize.go +++ b/cmd/rollcall/hwsize.go @@ -79,10 +79,12 @@ func machineSize(m *Machine, override map[string]int) rackSize { if ct := strings.ToLower(str(sys["chassis-type"])); strings.Contains(ct, "multi-system") || strings.Contains(ct, "blade") { node = true } - if model != "" { - for k, u := range override { // exact model, or "vendor model" - if strings.EqualFold(k, model) || strings.EqualFold(k, mfr+" "+model) { - return rackSize{U: u, Node: node, Source: "config"} + if model != "" { // "vendor model" before the bare model: both may be set, map order must not choose + for _, want := range []string{mfr + " " + model, model} { + for k, u := range override { + if strings.EqualFold(k, want) { + return rackSize{U: u, Node: node, Source: "config"} + } } } } diff --git a/cmd/rollcall/ipam.go b/cmd/rollcall/ipam.go index 00794fc..267bf25 100644 --- a/cmd/rollcall/ipam.go +++ b/cmd/rollcall/ipam.go @@ -24,6 +24,7 @@ import ( "fmt" "io" "log" + "net" "net/http" "net/netip" "net/url" @@ -41,6 +42,7 @@ type IPAMConfig struct { URL string `json:"url"` // https://netbox.example; with NetBox's BASE_PATH (…/netbox/) its UI is served here too (nbproxy.go) UIURL string `json:"ui_url"` // where "open in NetBox" links go when not through Rollcall UILoginFile string `json:"ui_login_secret_file"` // shared with NetBox's front: the admin certificate signs in to NetBox (nbproxy.go) + UIListen string `json:"ui_listen"` // the NetBox UI's own HTTPS listener (its own origin), default ":8444" TokenFile string `json:"token_file"` // API token (NetBox v2 "nbt_..." or v1) User string `json:"user"` // Infoblox WAPI user PasswordFile string `json:"password_file"` // Infoblox WAPI password @@ -417,7 +419,14 @@ func (a *App) handleIPAM(w http.ResponseWriter, r *http.Request) { a.ipamSt.mu.Lock() last := a.ipamSt.last a.ipamSt.mu.Unlock() - writeJSON(w, 200, obj{"provider": a.ipam.Name(), "url": a.cfg.IPAM.URL, "ui": a.netboxUILink(), "dns_zone": a.cfg.IPAM.DNSZone, + ui := obj{} + if a.cfg.IPAM.UIURL != "" { + ui["url"] = strings.TrimRight(a.cfg.IPAM.UIURL, "/") + } else if p := a.netboxUIPath(); p != "" && a.cfg.TLSListen != "" { + _, port, _ := net.SplitHostPort(a.cfg.IPAM.uiListen()) + ui["port"], ui["path"] = port, p // the browser puts its own host in front + } + writeJSON(w, 200, obj{"provider": a.ipam.Name(), "url": a.cfg.IPAM.URL, "ui": ui, "dns_zone": a.cfg.IPAM.DNSZone, "tag": a.cfg.IPAM.tag(), "machine_field": a.cfg.IPAM.field(), "last_sync": last}) } diff --git a/cmd/rollcall/nbdevices.go b/cmd/rollcall/nbdevices.go index 32bf26c..2065ff7 100644 --- a/cmd/rollcall/nbdevices.go +++ b/cmd/rollcall/nbdevices.go @@ -16,6 +16,7 @@ package main import ( "context" "fmt" + "log" "net/url" "regexp" "sort" @@ -487,8 +488,10 @@ func (n *netBox) ensureType(ctx context.Context, mfr int64, model string, sz rac if len(got) > 0 { t := got[0] if n.tagged(t) && sz.Source != "" && int(num(t["u_height"])) != uh { + // NetBox refuses a height its racked devices do not fit (0 while a device has + // a position, more units than are free): the type stays, the devices sync on if err := n.do(ctx, "PATCH", fmt.Sprintf("dcim/device-types/%d/", nbID(t)), obj{"u_height": uh}, nil); err != nil { - return 0, fmt.Errorf("height of %s: %w", model, err) + log.Printf("netbox: device type %s stays %vU (wanted %dU): %v", model, t["u_height"], uh, err) } } return nbID(t), nil diff --git a/cmd/rollcall/nbproxy.go b/cmd/rollcall/nbproxy.go index 254b7b5..02b2638 100644 --- a/cmd/rollcall/nbproxy.go +++ b/cmd/rollcall/nbproxy.go @@ -3,8 +3,10 @@ package main // The NetBox web UI through Rollcall, so it opens wherever Rollcall's does // (a lab NetBox on a network the browser cannot reach, say). With NetBox as // the IPAM and its url carrying a path (NetBox's BASE_PATH: -// "url": "https://netbox.example/netbox/"), that path on Rollcall is NetBox, -// for admins only (the admin certificate, as for the API). NetBox keeps its +// "url": "https://netbox.example/netbox/"), that path on Rollcall's own +// NetBox listener (ui_listen, default :8444: another origin than the +// Rollcall UI) is NetBox, for admins only (the admin certificate, as for +// the API). NetBox keeps its // own login and session. Its CSRF_TRUSTED_ORIGINS must list Rollcall's // address for its forms to work: the browser posts from there. // @@ -45,12 +47,24 @@ func (a *App) netboxUIPath() string { return p } -// netboxUILink: where the UI's "open in NetBox" links go -func (a *App) netboxUILink() string { - if a.cfg.IPAM.UIURL != "" { - return strings.TrimRight(a.cfg.IPAM.UIURL, "/") +func (c IPAMConfig) uiListen() string { return orDefault(c.UIListen, ":8444") } + +// netboxUIHandler serves NetBox's UI on its own listener (ui_listen): its +// own origin, so a script in a NetBox page can neither read the Rollcall +// UI's storage (the admin token) nor call Rollcall's API as the admin. Only +// the proxy is there; "/" leads to it. +func (a *App) netboxUIHandler() (http.Handler, error) { + px, err := a.netboxProxy() + if err != nil { + return nil, err } - return a.netboxUIPath() + p, mux := a.netboxUIPath(), http.NewServeMux() + h := a.adminAuth(px.ServeHTTP) + for _, m := range []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"} { + mux.HandleFunc(m+" "+p+"/", h) + } + mux.HandleFunc("GET /{$}", func(w http.ResponseWriter, r *http.Request) { http.Redirect(w, r, p+"/", http.StatusFound) }) + return logging(http.NewCrossOriginProtection().Handler(mux)), nil } func (a *App) netboxProxy() (http.Handler, error) { @@ -73,8 +87,11 @@ func (a *App) netboxProxy() (http.Handler, error) { pr.Out.URL.Scheme, pr.Out.URL.Host = target.Scheme, target.Host pr.Out.Host = target.Host pr.Out.Header.Del("Authorization") // Rollcall's credentials are not NetBox's - pr.Out.Header.Del("X-Rollcall-User") - pr.Out.Header.Del("X-Rollcall-Proxy-Secret") + for k := range pr.Out.Header { // also X-Rollcall_User: the WSGI server makes HTTP_X_ROLLCALL_USER of both + if n := strings.ToLower(strings.ReplaceAll(k, "_", "-")); n == "x-rollcall-user" || n == "x-rollcall-proxy-secret" { + delete(pr.Out.Header, k) + } + } if name := a.peerAdmin(pr.In); name != "" && secret != "" { pr.Out.Header.Set("X-Rollcall-User", name) pr.Out.Header.Set("X-Rollcall-Proxy-Secret", secret) diff --git a/cmd/rollcall/nbproxy_test.go b/cmd/rollcall/nbproxy_test.go index f2049cc..6f2de5a 100644 --- a/cmd/rollcall/nbproxy_test.go +++ b/cmd/rollcall/nbproxy_test.go @@ -6,6 +6,7 @@ import ( "net/http" "net/http/httptest" "os" + "strings" "testing" ) @@ -42,6 +43,7 @@ func TestNetBoxProxy(t *testing.T) { req.Header.Set("Authorization", "Bearer rollcall-admin") req.Header.Set("X-Rollcall-User", "admin") // a browser claiming a NetBox user req.Header.Set("X-Rollcall-Proxy-Secret", "guessed") // and the secret + req.Header["X-Rollcall_user"] = []string{"admin"} // spelled so the WSGI server still reads it as HTTP_X_ROLLCALL_USER rec := httptest.NewRecorder() h.ServeHTTP(rec, req) if rec.Code != http.StatusFound || rec.Header().Get("Location") != "/netbox/login/?next=/netbox/" { @@ -50,7 +52,7 @@ func TestNetBoxProxy(t *testing.T) { if seen.Header.Get("Authorization") != "" { t.Fatal("Rollcall's credentials went to NetBox") } - if seen.Header.Get("X-Rollcall-User") != "" || seen.Header.Get("X-Rollcall-Proxy-Secret") != "" { + if seen.Header.Get("X-Rollcall-User") != "" || seen.Header.Get("X-Rollcall-Proxy-Secret") != "" || len(seen.Header["X-Rollcall_user"]) != 0 { t.Fatal("the browser's user header went to NetBox") } rec = httptest.NewRecorder() @@ -79,12 +81,20 @@ func TestNetBoxNextLinkBasePath(t *testing.T) { } } -// the proxy's routes sit beside the UI's "GET /" (a bare path pattern panicked at start) +// NetBox's UI is on its own listener, admins only; the Rollcall UI's routes do not carry it func TestNetBoxProxyRoutes(t *testing.T) { up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "nb "+r.Method+" "+r.URL.Path) })) defer up.Close() a := &App{cfg: &Config{IPAM: IPAMConfig{URL: up.URL + "/netbox/"}, AdminHTTP: "allow"}, ipam: &netBox{base: up.URL + "/netbox", client: up.Client()}} - h := a.routes() + h, err := a.netboxUIHandler() + if err != nil { + t.Fatal(err) + } + rec := httptest.NewRecorder() + a.routes().ServeHTTP(rec, httptest.NewRequest("GET", "/netbox/dcim/", nil)) + if rec.Code == http.StatusUnauthorized || strings.Contains(rec.Body.String(), "nb GET") { + t.Fatalf("the Rollcall UI's origin serves NetBox: %d", rec.Code) + } for _, m := range []string{"GET", "POST"} { rec := httptest.NewRecorder() h.ServeHTTP(rec, httptest.NewRequest(m, "/netbox/dcim/", nil)) diff --git a/cmd/rollcall/server.go b/cmd/rollcall/server.go index ec73d6b..11bac09 100644 --- a/cmd/rollcall/server.go +++ b/cmd/rollcall/server.go @@ -287,16 +287,6 @@ func (a *App) routes() http.Handler { mux.HandleFunc("DELETE /api/v1/racks", a.adminAuth(a.handleRacks)) mux.HandleFunc("POST /api/v1/racks/positions", a.adminAuth(a.handleRackPositions)) mux.HandleFunc("GET /api/v1/cabling", a.adminAuth(a.handleCabling)) - if p := a.netboxUIPath(); p != "" { // per method: a bare path would clash with "GET /" below - if px, err := a.netboxProxy(); err != nil { - log.Printf("netbox ui: %v; not served", err) - } else { - h := a.adminAuth(px.ServeHTTP) - for _, m := range []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"} { - mux.HandleFunc(m+" "+p+"/", h) - } - } - } mux.HandleFunc("POST /api/v1/switches", a.adminAuth(a.handleSwitches)) mux.HandleFunc("POST /api/v1/cables", a.adminAuth(a.handleCables)) mux.HandleFunc("DELETE /api/v1/cables", a.adminAuth(a.handleCables)) @@ -908,6 +898,19 @@ func serve(cfgPath string) error { log.Printf("HTTPS listener: %v", err) } }() + if app.netboxUIPath() != "" { // NetBox's UI on its own origin (nbproxy.go) + if nh, err := app.netboxUIHandler(); err != nil { + log.Printf("netbox ui: %v; not served", err) + } else { + nsrv := &http.Server{Addr: cfg.IPAM.uiListen(), Handler: nh, ReadHeaderTimeout: 10 * time.Second, ReadTimeout: 2 * time.Minute, IdleTimeout: 2 * time.Minute, TLSConfig: tsrv.TLSConfig.Clone()} + go func() { + log.Printf("netbox ui on %s%s", cfg.IPAM.uiListen(), app.netboxUIPath()) + if err := nsrv.ListenAndServeTLS("", ""); err != nil { + log.Printf("netbox ui listener: %v", err) + } + }() + } + } } srv := &http.Server{Addr: cfg.Listen, Handler: handler, ReadHeaderTimeout: 10 * time.Second, ReadTimeout: 2 * time.Minute, IdleTimeout: 2 * time.Minute} log.Printf("rollcall listening on %s (image=%s tftp=%s agent_token=%v)", cfg.Listen, cfg.ImageDir, cfg.TFTPRoot, cfg.AgentToken != "") diff --git a/cmd/rollcall/web/app.js b/cmd/rollcall/web/app.js index 8a28792..be3f5b5 100644 --- a/cmd/rollcall/web/app.js +++ b/cmd/rollcall/web/app.js @@ -2,9 +2,18 @@ // Rollcall web UI: a fleet view first (filters, selection, bulk actions), machine detail second. const $ = (s, el = document) => el.querySelector(s); const $$ = (s, el = document) => Array.from(el.querySelectorAll(s)); +// nbUI: where NetBox's UI is: ui_url, or Rollcall's NetBox listener on this +// host (another port: its own origin), "" without one +function nbUI() { + const ui = S.ipam && S.ipam.provider === 'netbox' && S.ipam.ui; if (!ui) return ''; + if (ui.url) return ui.url; + if (!ui.port) return ''; + const u = new URL(location.href); u.port = ui.port; u.pathname = ui.path; u.search = ''; u.hash = ''; + return u.href.replace(/\/$/, ''); +} // nbLink: "open in NetBox" for a NetBox page (path and query), when NetBox is the IPAM function nbLink(path, label = 'NetBox ↗') { - const ui = S.ipam && S.ipam.provider === 'netbox' && S.ipam.ui; + const ui = nbUI(); return ui ? `${esc(label)}` : ''; } const nbQ = o => '?' + new URLSearchParams(Object.entries(o).filter(([, v]) => v)).toString(); @@ -88,7 +97,7 @@ async function refresh(full) { [S.ips, S.ipam] = await Promise.all([api('GET', '/api/v1/ips'), api('GET', '/api/v1/ipam').catch(() => null)]); } $('#n-machines').textContent = machines.length; - const nb = $('#nav-netbox'), ui = S.ipam && S.ipam.provider === 'netbox' && S.ipam.ui; nb.style.display = ui ? '' : 'none'; if (ui) nb.href = ui + '/'; // .side a sets display: hidden would not hold + const nb = $('#nav-netbox'), ui = nbUI(); nb.style.display = ui ? '' : 'none'; if (ui) nb.href = ui + '/'; // .side a sets display: hidden would not hold const active = S.jobs.filter(j => j.state === 'pending' || j.state === 'running').length; $('#n-jobs').textContent = active ? `${active} active` : ''; $('#status').textContent = `updated ${new Date().toLocaleTimeString()}`; diff --git a/lab/netbox/install.sh b/lab/netbox/install.sh index f0b16d6..17eb7d0 100644 --- a/lab/netbox/install.sh +++ b/lab/netbox/install.sh @@ -24,7 +24,7 @@ set -euo pipefail NETBOX_VERSION=${NETBOX_VERSION:-4.7.4} MYIP=${MYIP:-10.213.77.6} SITE=${SITE:-lab} -ROLLCALL_ORIGINS=${ROLLCALL_ORIGINS:-"https://10.0.0.234 https://10.213.77.1"} +ROLLCALL_ORIGINS=${ROLLCALL_ORIGINS:-"https://10.0.0.234:8444 https://10.213.77.1:8444"} # the region's NetBox listener (ui_listen) ROLLCALL_IP=${ROLLCALL_IP:-10.213.77.1} PREFIXES=${PREFIXES:-"10.213.77.0/24 10.213.78.0/24 10.213.79.0/24 fd00:213:77::/64 fd00:213:78::/64"} export DEBIAN_FRONTEND=noninteractive