def on_save(self):
for label in self.labels:
Label.ensure_label(
label.label,
description="Auto-created for PM scope",
is_protected=True,
expose_metric=True,
)
def _refresh_labels(self):
"""
Recalculate labels on model
:return:
"""
from django.db import connection
for scope in self.iter_scopes():
labels = [f"noc::rxfilter::{self.name}::{scope}::="] + (self.labels
or [])
model, field = scope.split("_")
if model == "managedobject":
# Cleanup current labels
logger.info("[%s] Cleanup ManagedObject effective labels: %s",
self.name, labels)
Label.reset_model_labels("sa.ManagedObject", labels)
# Apply new rule
logger.info("[%s] Apply new regex '%s' labels", self.name,
self.regexp)
sql = f"""
UPDATE sa_managedobject
SET effective_labels=ARRAY (
SELECT DISTINCT e FROM unnest(effective_labels || %s::varchar[]) AS a(e)
)
WHERE {field} ~ %s
"""
cursor = connection.cursor()
cursor.execute(sql, [labels, self.regexp])
elif model == "interface":
# Cleanup current labels
logger.info("[%s] Cleanup Interface effective labels: %s",
self.name, labels)
Label.reset_model_labels("inv.Interface", labels)
# Apply new rule
coll = get_db()["noc.interfaces"]
coll.bulk_write([
UpdateMany[{
field: {
"$re": self.regexp
}
}, {
"$addToSet": {
"effective_labels": {
"$each": labels
}
}
}, ]
])
def handler(self):
# Get configured probes
self.logger.info("Checking SLA Probes")
new_probes = {}
for p in self.object.scripts.get_sla_probes():
new_probes[p.get("group", ""), p["name"]] = p
# Check existing probes
for p in SLAProbe.objects.filter(managed_object=self.object.id):
group = p.group or ""
new_data = new_probes.get((group, p.name))
if not new_data:
# Remove stale probe
self.logger.info("[%s|%s] Removing probe", group, p.name)
p.fire_event("missed")
continue
self.update_if_changed(
p,
{
"description":
new_data.get("description"),
"type":
new_data["type"],
"target":
new_data["target"],
"hw_timestamp":
new_data.get("hw_timestamp", False),
"labels": [
ll for ll in new_data.get("tags", [])
if Label.get_effective_setting(ll, "enable_slaprobe")
],
},
)
p.fire_event("seen")
if not new_data["status"]:
p.fire_event("down")
else:
p.fire_event("up")
p.touch()
del new_probes[group, p.name]
# Add remaining probes
for group, name in new_probes:
self.logger.info("[%s|%s] Creating probe", group, name)
new_data = new_probes.get((group, name))
probe = SLAProbe(
managed_object=self.object,
name=name,
profile=SLAProfile.get_default_profile(),
group=group,
description=new_data.get("description"),
type=new_data["type"],
target=new_data["target"],
hw_timestamp=new_data.get("hw_timestamp", False),
labels=new_data.get("tags", []),
)
probe.save()
if not new_data["status"]:
probe.fire_event("down")
def on_save(self):
"""
Sync field changes to model
For scope change:
* Remove label from model
For Regex change:
* Update labels set for regex
For labels change:
* Sync label for change
:return:
"""
if not hasattr(self, "_changed_fields"):
return
interface_labels, managed_object_labels = [], []
# Sync scope
for f in self._changed_fields:
if not f.startswith("enable"):
continue
logger.info("[%s] Field scope %s changed. Reset effective labels",
self.name, f)
_, scope = f.split("_", 1)
if scope.startswith("managedobject"):
managed_object_labels += [
f"noc::rxfilter::{self.name}::{scope}::="
]
elif scope.startswith("interface"):
interface_labels += [f"noc::rxfilter::{self.name}::{scope}::="]
if interface_labels:
Label.reset_model_labels("inv.Interface", interface_labels)
if managed_object_labels:
Label.reset_model_labels("sa.ManagedObject", managed_object_labels)
# Refresh regex
if "regexp" in self._changed_fields:
logger.info("[%s] Regex field change. Refresh labels", self.name)
self._reset_caches()
self._refresh_labels()
elif "labels" in self._changed_fields:
self._refresh_labels()
def can_set_label(cls, label):
return Label.get_effective_setting(label,
setting="enable_allocationgroup")
def can_set_label(cls, label):
return Label.get_effective_setting(label, "enable_objectmodel")
def can_set_label(cls, label):
return Label.get_effective_setting(label, "enable_vc")
def test_iter_scopes(label: str, expected: List[str]):
instance = Label(name=label)
scopes = list(instance.iter_scopes())
assert scopes == expected
def can_set_label(cls, label):
return Label.get_effective_setting(
label, setting="enable_managedobjectprofile")
def can_set_label(cls, label):
return Label.get_effective_setting(label,
setting="enable_subscriberprofile")
def can_set_label(cls, label):
return Label.get_effective_setting(label, setting="enable_dnszonerecord")
def can_set_label(cls, label):
return Label.get_effective_setting(label,
setting="enable_resourcegroup")
def can_set_label(cls, label):
return Label.get_effective_setting(label, setting="enable_prefixprofile")
def can_set_label(cls, label):
return Label.get_effective_setting(label, setting="enable_administrativedomain")
def can_set_label(cls, label):
return Label.get_effective_setting(label,
setting="enable_ipaddressrange")
def test_merge_labels(iter_labels: Tuple[List[str]], expected: List[str]):
assert Label.merge_labels(iter_labels) == expected
def can_set_label(cls, label):
return Label.get_effective_setting(label, setting="enable_commandsnippet")
def test_is_wildcard(label: str, expected: bool):
instance = Label(name=label)
assert instance.is_wildcard is expected
def can_set_label(cls, label):
return Label.get_effective_setting(label, setting="enable_sensor")
def can_set_label(cls, label):
return Label.get_effective_setting(label, "enable_serviceprofile")