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.
@@ -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
@@ -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")}