netbox-netscaler 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- netbox_netscaler/__init__.py +39 -0
- netbox_netscaler/api.py +17 -0
- netbox_netscaler/cache.py +52 -0
- netbox_netscaler/inventory.py +194 -0
- netbox_netscaler/matching.py +162 -0
- netbox_netscaler/navigation.py +25 -0
- netbox_netscaler/nitro.py +81 -0
- netbox_netscaler/resolve.py +53 -0
- netbox_netscaler/sync.py +227 -0
- netbox_netscaler/sync_netbox.py +138 -0
- netbox_netscaler/templates/netbox_netscaler/_pairs.html +21 -0
- netbox_netscaler/templates/netbox_netscaler/_state.html +1 -0
- netbox_netscaler/templates/netbox_netscaler/ip_tab.html +98 -0
- netbox_netscaler/templates/netbox_netscaler/netscaler_tab.html +65 -0
- netbox_netscaler/templates/netbox_netscaler/stale_vips.html +63 -0
- netbox_netscaler/templates/netbox_netscaler/sync_vips.html +116 -0
- netbox_netscaler/urls.py +11 -0
- netbox_netscaler/views.py +247 -0
- netbox_netscaler-0.1.0.dist-info/METADATA +154 -0
- netbox_netscaler-0.1.0.dist-info/RECORD +23 -0
- netbox_netscaler-0.1.0.dist-info/WHEEL +5 -0
- netbox_netscaler-0.1.0.dist-info/licenses/LICENSE +190 -0
- netbox_netscaler-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
"""
|
|
2
|
+
NetBox NetScaler Plugin
|
|
3
|
+
|
|
4
|
+
Read-only view of Citrix NetScaler lb VIPs, service group members and GSLB names
|
|
5
|
+
on VirtualMachine and Device detail pages, plus a Stale VIPs report.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from netbox.plugins import PluginConfig
|
|
9
|
+
|
|
10
|
+
__version__ = "0.1.0"
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class NetScalerConfig(PluginConfig):
|
|
14
|
+
"""Plugin configuration for NetBox NetScaler integration."""
|
|
15
|
+
|
|
16
|
+
name = "netbox_netscaler"
|
|
17
|
+
verbose_name = "NetScaler"
|
|
18
|
+
description = "Show NetScaler VIPs, service group members and GSLB names that depend on a VM or device"
|
|
19
|
+
version = __version__
|
|
20
|
+
author = "Jeremy Worden"
|
|
21
|
+
author_email = "jeremy.worden@gmail.com"
|
|
22
|
+
base_url = "netscaler"
|
|
23
|
+
min_version = "4.7.5"
|
|
24
|
+
max_version = "5.99"
|
|
25
|
+
required_settings = []
|
|
26
|
+
default_settings = {
|
|
27
|
+
"top_level_menu": False,
|
|
28
|
+
"tab_weight": 9005,
|
|
29
|
+
"username": "",
|
|
30
|
+
"password": "",
|
|
31
|
+
"pairs": [],
|
|
32
|
+
"cache_timeout": 900,
|
|
33
|
+
"timeout": 15,
|
|
34
|
+
"verify_ssl": False,
|
|
35
|
+
"vip_tenant": "",
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
config = NetScalerConfig
|
netbox_netscaler/api.py
ADDED
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
"""Reuse hook: what NetScaler config depends on a NetBox VM or Device."""
|
|
2
|
+
|
|
3
|
+
from functools import lru_cache
|
|
4
|
+
|
|
5
|
+
from .cache import get_inventories
|
|
6
|
+
from .matching import Membership, memberships_for_ips
|
|
7
|
+
from .resolve import ips_for_object, object_key, resolve_ip
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
def memberships_for(obj, inventories=None) -> list[Membership]:
|
|
11
|
+
"""Every lb vserver membership (with GSLB names) for one VirtualMachine or Device."""
|
|
12
|
+
ips = ips_for_object(obj)
|
|
13
|
+
if not ips:
|
|
14
|
+
return []
|
|
15
|
+
inventories = get_inventories() if inventories is None else inventories
|
|
16
|
+
resolve = lru_cache(maxsize=None)(resolve_ip) # per call, so NetBox status changes show up
|
|
17
|
+
return memberships_for_ips(ips, object_key(obj), inventories, resolve)
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
"""Per-pair inventory cache (option A: live fetch + Django cache)."""
|
|
2
|
+
|
|
3
|
+
from concurrent.futures import ThreadPoolExecutor
|
|
4
|
+
|
|
5
|
+
from django.conf import settings
|
|
6
|
+
from django.core.cache import cache
|
|
7
|
+
|
|
8
|
+
from .inventory import PairInventory, fetch_pair
|
|
9
|
+
|
|
10
|
+
PLUGIN = "netbox_netscaler"
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
def plugin_settings() -> dict:
|
|
14
|
+
from . import NetScalerConfig
|
|
15
|
+
|
|
16
|
+
merged = dict(NetScalerConfig.default_settings)
|
|
17
|
+
merged.update(settings.PLUGINS_CONFIG.get(PLUGIN, {}))
|
|
18
|
+
return merged
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def _key(pair: dict) -> str:
|
|
22
|
+
return f"{PLUGIN}:pair:{pair.get('name')}"
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def get_inventories(force: bool = False) -> list[PairInventory]:
|
|
26
|
+
"""Inventories for every configured pair, fetching (in parallel) any that are not cached."""
|
|
27
|
+
conf = plugin_settings()
|
|
28
|
+
pairs = conf.get("pairs") or []
|
|
29
|
+
cached = {} if force else cache.get_many([_key(p) for p in pairs])
|
|
30
|
+
missing = [p for p in pairs if _key(p) not in cached]
|
|
31
|
+
if missing:
|
|
32
|
+
with ThreadPoolExecutor(max_workers=len(missing)) as pool:
|
|
33
|
+
fetched = list(pool.map(lambda p: fetch_pair(p, conf), missing))
|
|
34
|
+
for pair, inv in zip(missing, fetched):
|
|
35
|
+
# Unavailable results are cached briefly so a dead pair doesn't stall every page.
|
|
36
|
+
timeout = conf["cache_timeout"] if inv.available else min(60, conf["cache_timeout"])
|
|
37
|
+
cache.set(_key(pair), inv, timeout)
|
|
38
|
+
cached[_key(pair)] = inv
|
|
39
|
+
return [cached[_key(p)] for p in pairs]
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def cached_inventories() -> list[PairInventory] | None:
|
|
43
|
+
"""Cache-only read: never contacts NetScaler. None if any pair is not cached."""
|
|
44
|
+
pairs = plugin_settings().get("pairs") or []
|
|
45
|
+
cached = cache.get_many([_key(p) for p in pairs])
|
|
46
|
+
if len(cached) != len(pairs):
|
|
47
|
+
return None
|
|
48
|
+
return [cached[_key(p)] for p in pairs]
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def clear() -> None:
|
|
52
|
+
cache.delete_many([_key(p) for p in plugin_settings().get("pairs") or []])
|
|
@@ -0,0 +1,194 @@
|
|
|
1
|
+
"""Normalize NITRO responses from one HA pair's Primary into plain dataclasses."""
|
|
2
|
+
|
|
3
|
+
import logging
|
|
4
|
+
from dataclasses import dataclass, field
|
|
5
|
+
from datetime import datetime, timezone
|
|
6
|
+
|
|
7
|
+
from .nitro import NitroClient, NitroError, find_primary
|
|
8
|
+
|
|
9
|
+
logger = logging.getLogger(__name__)
|
|
10
|
+
|
|
11
|
+
LBVSERVER = "config/lbvserver"
|
|
12
|
+
SG_MEMBER_BY_VSERVER = "config/lbvserver_servicegroupmember_binding?bulkbindings=yes"
|
|
13
|
+
SG_MEMBER = "config/servicegroup_servicegroupmember_binding?bulkbindings=yes"
|
|
14
|
+
SERVICE_BY_VSERVER = "config/lbvserver_service_binding?bulkbindings=yes"
|
|
15
|
+
GSLBVSERVER = "config/gslbvserver"
|
|
16
|
+
GSLB_DOMAIN = "config/gslbvserver_domain_binding?bulkbindings=yes"
|
|
17
|
+
GSLB_SERVICE = "config/gslbvserver_gslbservice_binding?bulkbindings=yes"
|
|
18
|
+
|
|
19
|
+
# Endpoints a box may refuse (e.g. no GSLB feature/licence) without losing the lb data.
|
|
20
|
+
OPTIONAL_ENDPOINTS = (GSLBVSERVER, GSLB_DOMAIN, GSLB_SERVICE)
|
|
21
|
+
|
|
22
|
+
ENDPOINTS = (LBVSERVER, SG_MEMBER_BY_VSERVER, SG_MEMBER, SERVICE_BY_VSERVER, GSLBVSERVER, GSLB_DOMAIN, GSLB_SERVICE)
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
@dataclass
|
|
26
|
+
class Member:
|
|
27
|
+
servicegroup: str
|
|
28
|
+
ip: str
|
|
29
|
+
port: int
|
|
30
|
+
state: str
|
|
31
|
+
servername: str
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
@dataclass
|
|
35
|
+
class Vserver:
|
|
36
|
+
pair: str
|
|
37
|
+
name: str
|
|
38
|
+
ip: str
|
|
39
|
+
port: int
|
|
40
|
+
protocol: str
|
|
41
|
+
state: str
|
|
42
|
+
members: list[Member] = field(default_factory=list)
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
@dataclass
|
|
46
|
+
class GslbName:
|
|
47
|
+
pair: str
|
|
48
|
+
vserver: str
|
|
49
|
+
domains: list[str]
|
|
50
|
+
state: str
|
|
51
|
+
service_targets: list[tuple[str, int]]
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
@dataclass
|
|
55
|
+
class PairInventory:
|
|
56
|
+
name: str
|
|
57
|
+
available: bool
|
|
58
|
+
node: str | None
|
|
59
|
+
error: str | None
|
|
60
|
+
fetched_at: datetime
|
|
61
|
+
vservers: list[Vserver] = field(default_factory=list)
|
|
62
|
+
gslb: list[GslbName] = field(default_factory=list)
|
|
63
|
+
warning: str | None = None
|
|
64
|
+
|
|
65
|
+
|
|
66
|
+
def _rows(resp: dict, key: str) -> list[dict]:
|
|
67
|
+
"""NITRO omits the list key entirely when there are no rows."""
|
|
68
|
+
return resp.get(key, []) or []
|
|
69
|
+
|
|
70
|
+
|
|
71
|
+
def _port(value) -> int:
|
|
72
|
+
try:
|
|
73
|
+
return int(value)
|
|
74
|
+
except (TypeError, ValueError):
|
|
75
|
+
return 0
|
|
76
|
+
|
|
77
|
+
|
|
78
|
+
def build_inventory(pair_name: str, node: str, raw: dict[str, dict]) -> PairInventory:
|
|
79
|
+
"""Build one pair's inventory from the raw responses keyed by ENDPOINTS path."""
|
|
80
|
+
servernames = {
|
|
81
|
+
(r.get("servicegroupname"), r.get("ip"), _port(r.get("port"))): r.get("servername", "")
|
|
82
|
+
for r in _rows(raw[SG_MEMBER], "servicegroup_servicegroupmember_binding")
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
vservers = {}
|
|
86
|
+
for r in _rows(raw[LBVSERVER], "lbvserver"):
|
|
87
|
+
vservers[r["name"]] = Vserver(
|
|
88
|
+
pair=pair_name,
|
|
89
|
+
name=r["name"],
|
|
90
|
+
ip=r.get("ipv46", ""),
|
|
91
|
+
port=_port(r.get("port")),
|
|
92
|
+
protocol=r.get("servicetype", ""),
|
|
93
|
+
state=r.get("curstate", ""),
|
|
94
|
+
)
|
|
95
|
+
|
|
96
|
+
for r in _rows(raw[SG_MEMBER_BY_VSERVER], "lbvserver_servicegroupmember_binding"):
|
|
97
|
+
vserver = vservers.get(r.get("name"))
|
|
98
|
+
if vserver is None:
|
|
99
|
+
continue
|
|
100
|
+
sg, ip, port = r.get("servicegroupname", ""), r.get("ipv46", ""), _port(r.get("port"))
|
|
101
|
+
vserver.members.append(
|
|
102
|
+
Member(
|
|
103
|
+
servicegroup=sg,
|
|
104
|
+
ip=ip,
|
|
105
|
+
port=port,
|
|
106
|
+
state=r.get("curstate", ""),
|
|
107
|
+
servername=servernames.get((sg, ip, port), ""),
|
|
108
|
+
)
|
|
109
|
+
)
|
|
110
|
+
|
|
111
|
+
for r in _rows(raw[SERVICE_BY_VSERVER], "lbvserver_service_binding"):
|
|
112
|
+
vserver = vservers.get(r.get("name"))
|
|
113
|
+
if vserver is None:
|
|
114
|
+
continue
|
|
115
|
+
vserver.members.append(
|
|
116
|
+
Member(
|
|
117
|
+
servicegroup="",
|
|
118
|
+
ip=r.get("ipv46", ""),
|
|
119
|
+
port=_port(r.get("port")),
|
|
120
|
+
state=r.get("curstate", ""),
|
|
121
|
+
servername=r.get("servicename", ""),
|
|
122
|
+
)
|
|
123
|
+
)
|
|
124
|
+
|
|
125
|
+
domains: dict[str, list[str]] = {}
|
|
126
|
+
for r in _rows(raw[GSLB_DOMAIN], "gslbvserver_domain_binding"):
|
|
127
|
+
domains.setdefault(r.get("name"), []).append(r.get("domainname", ""))
|
|
128
|
+
targets: dict[str, list[tuple[str, int]]] = {}
|
|
129
|
+
for r in _rows(raw[GSLB_SERVICE], "gslbvserver_gslbservice_binding"):
|
|
130
|
+
targets.setdefault(r.get("name"), []).append((r.get("ipaddress", ""), _port(r.get("port"))))
|
|
131
|
+
|
|
132
|
+
gslb = [
|
|
133
|
+
GslbName(
|
|
134
|
+
pair=pair_name,
|
|
135
|
+
vserver=r["name"],
|
|
136
|
+
domains=domains.get(r["name"], []),
|
|
137
|
+
state=r.get("curstate", ""),
|
|
138
|
+
service_targets=targets.get(r["name"], []),
|
|
139
|
+
)
|
|
140
|
+
for r in _rows(raw[GSLBVSERVER], "gslbvserver")
|
|
141
|
+
]
|
|
142
|
+
|
|
143
|
+
return PairInventory(
|
|
144
|
+
name=pair_name,
|
|
145
|
+
available=True,
|
|
146
|
+
node=node,
|
|
147
|
+
error=None,
|
|
148
|
+
fetched_at=datetime.now(timezone.utc),
|
|
149
|
+
vservers=list(vservers.values()),
|
|
150
|
+
gslb=gslb,
|
|
151
|
+
)
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
def fetch_pair(pair: dict, defaults: dict, client_factory=NitroClient) -> PairInventory:
|
|
155
|
+
"""Find the pair's Primary and pull its inventory. Never raises: failures become an unavailable inventory."""
|
|
156
|
+
name = pair.get("name", ", ".join(pair.get("nodes", [])))
|
|
157
|
+
|
|
158
|
+
def make(host):
|
|
159
|
+
return client_factory(
|
|
160
|
+
host,
|
|
161
|
+
pair.get("username") or defaults.get("username", ""),
|
|
162
|
+
pair.get("password") or defaults.get("password", ""),
|
|
163
|
+
defaults.get("timeout", 15),
|
|
164
|
+
defaults.get("verify_ssl", False),
|
|
165
|
+
)
|
|
166
|
+
|
|
167
|
+
def unavailable(message):
|
|
168
|
+
return PairInventory(
|
|
169
|
+
name=name, available=False, node=None, error=f"{name}: {message}", fetched_at=datetime.now(timezone.utc)
|
|
170
|
+
)
|
|
171
|
+
|
|
172
|
+
try:
|
|
173
|
+
primary, error = find_primary(pair.get("nodes", []), make)
|
|
174
|
+
if primary is None:
|
|
175
|
+
raise NitroError(error)
|
|
176
|
+
client = make(primary)
|
|
177
|
+
raw, skipped = {}, []
|
|
178
|
+
for path in ENDPOINTS:
|
|
179
|
+
try:
|
|
180
|
+
raw[path] = client.get(path)
|
|
181
|
+
except NitroError as exc:
|
|
182
|
+
if path not in OPTIONAL_ENDPOINTS:
|
|
183
|
+
raise
|
|
184
|
+
raw[path] = {}
|
|
185
|
+
skipped.append(f"{path.split('?')[0]} ({exc})")
|
|
186
|
+
inventory = build_inventory(name, primary, raw)
|
|
187
|
+
except NitroError as exc:
|
|
188
|
+
return unavailable(exc)
|
|
189
|
+
except Exception as exc: # malformed data must not turn the page into a 500
|
|
190
|
+
logger.exception("netbox_netscaler: unexpected error reading pair %s", name)
|
|
191
|
+
return unavailable(f"unexpected {exc.__class__.__name__}: {exc}")
|
|
192
|
+
if skipped:
|
|
193
|
+
inventory.warning = "GSLB data unavailable: " + "; ".join(skipped)
|
|
194
|
+
return inventory
|
|
@@ -0,0 +1,162 @@
|
|
|
1
|
+
"""Pure matching rules: which VIPs depend on a server, and which VIPs are stale.
|
|
2
|
+
|
|
3
|
+
NetBox lookups are injected as a Resolver so this module stays testable without Django.
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
import ipaddress
|
|
7
|
+
from dataclasses import dataclass, field
|
|
8
|
+
from typing import Callable
|
|
9
|
+
|
|
10
|
+
from .inventory import GslbName, Member, PairInventory, Vserver
|
|
11
|
+
|
|
12
|
+
RETIRED_STATUSES = {"decommissioning", "offline"}
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
@dataclass
|
|
16
|
+
class Match:
|
|
17
|
+
obj_key: str # "vm:<id>", "device:<id>", or "ip:<id>" for an unassigned IP
|
|
18
|
+
obj_name: str
|
|
19
|
+
obj_url: str
|
|
20
|
+
status: str
|
|
21
|
+
ip_dns_name: str
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
Resolver = Callable[[str], list[Match]]
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
@dataclass
|
|
28
|
+
class Membership:
|
|
29
|
+
vserver: Vserver
|
|
30
|
+
member: Member
|
|
31
|
+
matches: list[Match]
|
|
32
|
+
ambiguous: bool
|
|
33
|
+
name_mismatch: bool
|
|
34
|
+
last_live: bool
|
|
35
|
+
gslb: list[GslbName] = field(default_factory=list)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
@dataclass
|
|
39
|
+
class StaleRow:
|
|
40
|
+
vserver: Vserver
|
|
41
|
+
reason: str
|
|
42
|
+
members: list[tuple[Member, list[Match]]]
|
|
43
|
+
gslb: list[GslbName]
|
|
44
|
+
name_mismatch: bool
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def _short(name: str) -> str:
|
|
48
|
+
return (name or "").split(".")[0].lower()
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def is_name_mismatch(servername: str, matches: list[Match]) -> bool:
|
|
52
|
+
"""True when the NetScaler server name matches neither the NetBox object nor the IP's DNS name."""
|
|
53
|
+
if not servername or not matches:
|
|
54
|
+
return False
|
|
55
|
+
try:
|
|
56
|
+
ipaddress.ip_address(servername)
|
|
57
|
+
return False # server object named after its IP (member bound by address): nothing to compare
|
|
58
|
+
except ValueError:
|
|
59
|
+
pass
|
|
60
|
+
short = _short(servername)
|
|
61
|
+
return all(short != _short(m.obj_name) and short != _short(m.ip_dns_name) for m in matches)
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
def gslb_for(vserver: Vserver, inventories: list[PairInventory]) -> list[GslbName]:
|
|
65
|
+
"""GSLB vservers (on any pair) whose services point at this lb vserver's VIP:port.
|
|
66
|
+
|
|
67
|
+
GSLB config is synced to every site, so the same vserver/domains on several pairs is listed once.
|
|
68
|
+
"""
|
|
69
|
+
target = (vserver.ip, vserver.port)
|
|
70
|
+
seen, result = set(), []
|
|
71
|
+
for inv in inventories:
|
|
72
|
+
if not inv.available:
|
|
73
|
+
continue
|
|
74
|
+
for g in inv.gslb:
|
|
75
|
+
key = (g.vserver, tuple(g.domains))
|
|
76
|
+
if target in g.service_targets and key not in seen:
|
|
77
|
+
seen.add(key)
|
|
78
|
+
result.append(g)
|
|
79
|
+
return result
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def _is_last_live(vserver: Vserver, obj_key: str, resolve: Resolver) -> bool:
|
|
83
|
+
for member in vserver.members:
|
|
84
|
+
if member.state != "UP":
|
|
85
|
+
continue
|
|
86
|
+
if obj_key not in {m.obj_key for m in resolve(member.ip)}:
|
|
87
|
+
return False
|
|
88
|
+
return True
|
|
89
|
+
|
|
90
|
+
|
|
91
|
+
def memberships_for_ips(
|
|
92
|
+
ips: set[str], obj_key: str, inventories: list[PairInventory], resolve: Resolver
|
|
93
|
+
) -> list[Membership]:
|
|
94
|
+
"""Every service-group member, on every available pair, whose IP is one of the object's IPs."""
|
|
95
|
+
result = []
|
|
96
|
+
for inv in inventories:
|
|
97
|
+
if not inv.available:
|
|
98
|
+
continue
|
|
99
|
+
for vserver in inv.vservers:
|
|
100
|
+
mine = [member for member in vserver.members if member.ip in ips]
|
|
101
|
+
if not mine:
|
|
102
|
+
continue
|
|
103
|
+
last_live = _is_last_live(vserver, obj_key, resolve)
|
|
104
|
+
gslb = gslb_for(vserver, inventories)
|
|
105
|
+
for member in mine:
|
|
106
|
+
matches = resolve(member.ip)
|
|
107
|
+
result.append(
|
|
108
|
+
Membership(
|
|
109
|
+
vserver=vserver,
|
|
110
|
+
member=member,
|
|
111
|
+
matches=matches,
|
|
112
|
+
ambiguous=len(matches) > 1,
|
|
113
|
+
name_mismatch=is_name_mismatch(member.servername, matches),
|
|
114
|
+
last_live=last_live,
|
|
115
|
+
gslb=gslb,
|
|
116
|
+
)
|
|
117
|
+
)
|
|
118
|
+
return result
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
def _stale_reason(resolved: list[tuple[Member, list[Match]]]) -> str | None:
|
|
122
|
+
if not resolved:
|
|
123
|
+
return "no members"
|
|
124
|
+
|
|
125
|
+
def retired(matches):
|
|
126
|
+
return bool(matches) and all(m.status in RETIRED_STATUSES for m in matches)
|
|
127
|
+
|
|
128
|
+
if not all(member.state != "UP" or retired(matches) or not matches for member, matches in resolved):
|
|
129
|
+
return None
|
|
130
|
+
if all(member.state != "UP" for member, _ in resolved):
|
|
131
|
+
return "all members down"
|
|
132
|
+
if all(retired(matches) for _, matches in resolved):
|
|
133
|
+
return "members retired"
|
|
134
|
+
return "member not in NetBox"
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
def stale_vservers(inventories: list[PairInventory], resolve: Resolver) -> list[StaleRow]:
|
|
138
|
+
"""lb vservers where no member is a live server: DOWN, retired in NetBox, or unknown to NetBox."""
|
|
139
|
+
rows = []
|
|
140
|
+
for inv in inventories:
|
|
141
|
+
if not inv.available:
|
|
142
|
+
continue
|
|
143
|
+
for vserver in inv.vservers:
|
|
144
|
+
resolved = [(member, resolve(member.ip)) for member in vserver.members]
|
|
145
|
+
reason = _stale_reason(resolved)
|
|
146
|
+
if reason is None:
|
|
147
|
+
continue
|
|
148
|
+
rows.append(
|
|
149
|
+
StaleRow(
|
|
150
|
+
vserver=vserver,
|
|
151
|
+
reason=reason,
|
|
152
|
+
members=resolved,
|
|
153
|
+
gslb=gslb_for(vserver, inventories),
|
|
154
|
+
name_mismatch=any(is_name_mismatch(m.servername, matches) for m, matches in resolved),
|
|
155
|
+
)
|
|
156
|
+
)
|
|
157
|
+
return sorted(rows, key=lambda r: (r.vserver.pair, r.vserver.name))
|
|
158
|
+
|
|
159
|
+
|
|
160
|
+
def vservers_at(host: str, inventories: list[PairInventory]) -> list[Vserver]:
|
|
161
|
+
"""lb vservers (on any available pair) whose VIP is this address."""
|
|
162
|
+
return [v for inv in inventories if inv.available for v in inv.vservers if v.ip == host]
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
"""Navigation menu items for NetBox NetScaler Plugin."""
|
|
2
|
+
|
|
3
|
+
from django.conf import settings
|
|
4
|
+
from netbox.plugins import PluginMenu, PluginMenuItem
|
|
5
|
+
|
|
6
|
+
_items = (
|
|
7
|
+
PluginMenuItem(
|
|
8
|
+
link="plugins:netbox_netscaler:stale_vips",
|
|
9
|
+
link_text="Stale VIPs",
|
|
10
|
+
permissions=["ipam.view_ipaddress"],
|
|
11
|
+
),
|
|
12
|
+
PluginMenuItem(
|
|
13
|
+
link="plugins:netbox_netscaler:sync_vips",
|
|
14
|
+
link_text="Sync VIPs",
|
|
15
|
+
permissions=["ipam.view_ipaddress"],
|
|
16
|
+
),
|
|
17
|
+
)
|
|
18
|
+
|
|
19
|
+
_menu = PluginMenu(label="NetScaler", groups=(("Load Balancing", _items),), icon_class="mdi mdi-scale-balance")
|
|
20
|
+
|
|
21
|
+
# top_level_menu=False puts this plugin's items under the shared "Plugins" menu
|
|
22
|
+
if settings.PLUGINS_CONFIG.get("netbox_netscaler", {}).get("top_level_menu", False):
|
|
23
|
+
menu = _menu
|
|
24
|
+
else:
|
|
25
|
+
menu_items = _items
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
"""Read-only Citrix NetScaler NITRO client.
|
|
2
|
+
|
|
3
|
+
Only HTTP GET is used. This module must never change NetScaler configuration.
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
import logging
|
|
7
|
+
from typing import Callable
|
|
8
|
+
|
|
9
|
+
import requests
|
|
10
|
+
import urllib3
|
|
11
|
+
|
|
12
|
+
logger = logging.getLogger(__name__)
|
|
13
|
+
|
|
14
|
+
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
class NitroError(Exception):
|
|
18
|
+
"""A NITRO request failed: connection error, non-200 status, or non-zero errorcode."""
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
class NitroClient:
|
|
22
|
+
"""Minimal read-only NITRO client for one NetScaler node."""
|
|
23
|
+
|
|
24
|
+
def __init__(self, host: str, username: str, password: str, timeout: int = 15, verify_ssl: bool = False):
|
|
25
|
+
self.host = host
|
|
26
|
+
self.username = username
|
|
27
|
+
self.password = password
|
|
28
|
+
self.timeout = timeout
|
|
29
|
+
self.verify_ssl = verify_ssl
|
|
30
|
+
|
|
31
|
+
def get(self, path: str) -> dict:
|
|
32
|
+
"""GET https://{host}/nitro/v1/{path} and return the decoded JSON body."""
|
|
33
|
+
url = f"https://{self.host}/nitro/v1/{path}"
|
|
34
|
+
headers = {
|
|
35
|
+
"X-NITRO-USER": self.username,
|
|
36
|
+
"X-NITRO-PASS": self.password,
|
|
37
|
+
"Accept": "application/json",
|
|
38
|
+
}
|
|
39
|
+
try:
|
|
40
|
+
response = requests.get(url, headers=headers, timeout=self.timeout, verify=self.verify_ssl)
|
|
41
|
+
except requests.RequestException as exc:
|
|
42
|
+
raise NitroError(f"{self.host}: {exc.__class__.__name__}: {exc}") from exc
|
|
43
|
+
|
|
44
|
+
if response.status_code != 200:
|
|
45
|
+
raise NitroError(f"{self.host}: HTTP {response.status_code} for {path}: {response.text[:200]}")
|
|
46
|
+
try:
|
|
47
|
+
body = response.json()
|
|
48
|
+
except ValueError as exc:
|
|
49
|
+
raise NitroError(f"{self.host}: invalid JSON for {path}") from exc
|
|
50
|
+
if not isinstance(body, dict):
|
|
51
|
+
raise NitroError(f"{self.host}: unexpected JSON for {path}")
|
|
52
|
+
if body.get("errorcode", 0) != 0:
|
|
53
|
+
raise NitroError(f"{self.host}: errorcode {body.get('errorcode')} for {path}: {body.get('message')}")
|
|
54
|
+
return body
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def _local_state(hanode: dict) -> str | None:
|
|
58
|
+
"""State of the node that answered: NITRO lists the local node as id "0"."""
|
|
59
|
+
for node in hanode.get("hanode", []):
|
|
60
|
+
if str(node.get("id")) == "0":
|
|
61
|
+
return node.get("state")
|
|
62
|
+
return None
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
def find_primary(nodes: list[str], client_factory: Callable[[str], NitroClient]) -> tuple[str | None, str | None]:
|
|
66
|
+
"""Return (primary_host, error) for an HA pair, asking each node about itself.
|
|
67
|
+
|
|
68
|
+
A one-node "pair" is a standalone appliance: it is used if it answers, whatever its HA state.
|
|
69
|
+
"""
|
|
70
|
+
errors = []
|
|
71
|
+
for host in nodes:
|
|
72
|
+
try:
|
|
73
|
+
state = _local_state(client_factory(host).get("config/hanode"))
|
|
74
|
+
except NitroError as exc:
|
|
75
|
+
message = str(exc)
|
|
76
|
+
errors.append(message if host in message else f"{host}: {message}")
|
|
77
|
+
continue
|
|
78
|
+
if len(nodes) == 1 or state == "Primary":
|
|
79
|
+
return host, None
|
|
80
|
+
errors.append(f"{host}: is {state or 'unknown'}")
|
|
81
|
+
return None, "no Primary found: " + "; ".join(errors)
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
"""NetBox lookups: member IP -> VM/Device, and object -> its IPs."""
|
|
2
|
+
|
|
3
|
+
from ipam.models import IPAddress
|
|
4
|
+
|
|
5
|
+
from .matching import Match
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
def _host(address) -> str:
|
|
9
|
+
return str(address).split("/")[0]
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
def resolve_ip(ip: str) -> list[Match]:
|
|
13
|
+
"""Every NetBox IPAddress with this host part (any mask, any VRF), as Matches."""
|
|
14
|
+
matches = []
|
|
15
|
+
qs = IPAddress.objects.filter(address__net_host=ip).prefetch_related("assigned_object")
|
|
16
|
+
for address in qs:
|
|
17
|
+
assigned = address.assigned_object
|
|
18
|
+
parent = getattr(assigned, "virtual_machine", None) or getattr(assigned, "device", None)
|
|
19
|
+
if parent is None:
|
|
20
|
+
matches.append(
|
|
21
|
+
Match(
|
|
22
|
+
obj_key=f"ip:{address.pk}",
|
|
23
|
+
obj_name=str(address),
|
|
24
|
+
obj_url=address.get_absolute_url(),
|
|
25
|
+
status=address.status,
|
|
26
|
+
ip_dns_name=address.dns_name or "",
|
|
27
|
+
)
|
|
28
|
+
)
|
|
29
|
+
continue
|
|
30
|
+
kind = "vm" if hasattr(assigned, "virtual_machine") else "device"
|
|
31
|
+
matches.append(
|
|
32
|
+
Match(
|
|
33
|
+
obj_key=f"{kind}:{parent.pk}",
|
|
34
|
+
obj_name=parent.name or str(parent),
|
|
35
|
+
obj_url=parent.get_absolute_url(),
|
|
36
|
+
status=parent.status,
|
|
37
|
+
ip_dns_name=address.dns_name or "",
|
|
38
|
+
)
|
|
39
|
+
)
|
|
40
|
+
return matches
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
def object_key(obj) -> str:
|
|
44
|
+
return f"vm:{obj.pk}" if obj._meta.model_name == "virtualmachine" else f"device:{obj.pk}"
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def ips_for_object(obj) -> set[str]:
|
|
48
|
+
"""Host part of every IPAddress on any of the object's interfaces."""
|
|
49
|
+
if obj._meta.model_name == "virtualmachine":
|
|
50
|
+
qs = IPAddress.objects.filter(vminterface__virtual_machine=obj)
|
|
51
|
+
else:
|
|
52
|
+
qs = IPAddress.objects.filter(interface__device=obj)
|
|
53
|
+
return {_host(a.address) for a in qs.only("address")}
|