netbox-cesnet-services-plugin 3.0.1__py3-none-any.whl

netbox_cesnet_services_plugin/__init__.py

@@ -0,0 +1,27 @@
+"""Top-level package for NetBox cesnet_services Plugin."""
+
+__author__ = """Jan Krupa"""
+__email__ = "jan.krupa@cesnet.cz"
+__version__ = "3.0.1"
+
+
+from netbox.plugins import PluginConfig
+
+
+class CesnetServicesConfig(PluginConfig):
+    name = "netbox_cesnet_services_plugin"
+    verbose_name = "NetBox cesnet_services Plugin"
+    description = "NetBox plugin for CESNET services."
+    version = __version__
+    base_url = "netbox-cesnet-services-plugin"
+    author = __author__
+    author_email = __email__
+    min_version = "4.5.4"
+    max_version = "4.6.99"
+    default_settings = {
+        "bgp_last_seen_warning_days": 2,
+        "bgp_last_seen_danger_days": 5,
+    }
+
+
+config = CesnetServicesConfig

netbox_cesnet_services_plugin/api/serializers.py

@@ -0,0 +1,226 @@
+from dcim.api.serializers import DeviceSerializer, InterfaceSerializer
+from ipam.api.serializers import ASNSerializer, IPAddressSerializer, PrefixSerializer, VRFSerializer
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+from tenancy.api.serializers import TenantSerializer
+
+from netbox_cesnet_services_plugin.models import (
+    BGPConnection,
+    LLDPNeighbor,
+    LLDPNeighborLeaf,
+    ServiceCoreTrunk,
+    ServiceCoreLink,
+    ServiceIP,
+)
+
+
+class LLDPNeighborLeafSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cesnet_services_plugin-api:lldpneighborleaf-detail"
+    )
+    device_nb = DeviceSerializer(nested=True)
+    interface_nb = InterfaceSerializer(nested=True)
+
+    class Meta:
+        model = LLDPNeighborLeaf
+        fields = (
+            "id",
+            "url",
+            "device_nb",
+            "interface_nb",
+            "device_ext",
+            "interface_ext",
+            "status",
+            "comments",
+            "tags",
+            "imported_data",
+            "custom_fields",
+            "created",
+            "last_updated",
+        )
+        brief_fields = (
+            "id",
+            "device_nb",
+            "interface_nb",
+            "device_ext",
+            "interface_ext",
+            "status",
+        )
+
+
+class LLDPNeighborSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cesnet_services_plugin-api:lldpneighbor-detail"
+    )
+    device_a = DeviceSerializer(nested=True)
+    interface_a = InterfaceSerializer(nested=True)
+    device_b = DeviceSerializer(nested=True)
+    interface_b = InterfaceSerializer(nested=True)
+
+    class Meta:
+        model = LLDPNeighbor
+        fields = (
+            "id",
+            "url",
+            "device_a",
+            "interface_a",
+            "device_b",
+            "interface_b",
+            "status",
+            "status_detail",
+            "last_seen",
+            "comments",
+            "tags",
+            "imported_data",
+            "custom_fields",
+            "created",
+            "last_updated",
+        )
+        brief_fields = (
+            "id",
+            "device_a",
+            "interface_a",
+            "device_b",
+            "interface_b",
+            "status",
+            "status_detail",
+        )
+
+
+class ServiceCoreTrunkSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cesnet_services_plugin-api:servicecoretrunk-detail"
+    )
+    tenant = TenantSerializer(nested=True, allow_null=True, required=False)
+    node_a = DeviceSerializer(nested=True, allow_null=True, required=False)
+    node_b = DeviceSerializer(nested=True, allow_null=True, required=False)
+    if_a = InterfaceSerializer(nested=True, allow_null=True, required=False)
+    if_b = InterfaceSerializer(nested=True, allow_null=True, required=False)
+
+    class Meta:
+        model = ServiceCoreTrunk
+        fields = (
+            "id", "display", "url",
+            "name", "status", "active", "tenant",
+            "service_start", "service_end", "rt", "monitored",
+            "node_a", "node_b", "if_a", "if_b",
+            "linked_segments",
+            "tags", "comments", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = (
+            "id", "url", "display", "name", "status", "tenant",
+            "node_a", "node_b",
+        )
+
+
+class ServiceCoreLinkSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cesnet_services_plugin-api:servicecorelink-detail"
+    )
+    tenant = TenantSerializer(nested=True, allow_null=True, required=False)
+    node_a = DeviceSerializer(nested=True, allow_null=True, required=False)
+    node_b = DeviceSerializer(nested=True, allow_null=True, required=False)
+    phy_if_a = InterfaceSerializer(nested=True, allow_null=True, required=False)
+    phy_if_b = InterfaceSerializer(nested=True, allow_null=True, required=False)
+    ipv4_addr_a = IPAddressSerializer(nested=True, allow_null=True, required=False)
+    ipv4_addr_b = IPAddressSerializer(nested=True, allow_null=True, required=False)
+    ipv6_addr_a = IPAddressSerializer(nested=True, allow_null=True, required=False)
+    ipv6_addr_b = IPAddressSerializer(nested=True, allow_null=True, required=False)
+
+    class Meta:
+        model = ServiceCoreLink
+        fields = (
+            "id", "display", "url",
+            "name", "status", "active", "tenant",
+            "service_start", "service_end", "rt", "monitored",
+            "node_a", "node_b", "phy_if_a", "phy_if_b",
+            "linked_segments", "saps", "core_trunks",
+            "lldp_enable", "flowspec_enable",
+            "encapsulation_mode", "encapsulation_qinq_s_vlan_id", "encapsulation_qinq_c_vlan_id",
+            "routing_isis_enabled", "routing_isis_instance", "routing_isis_bfd",
+            "routing_ospf_enable", "routing_ospf_area",
+            "ipv4_addr_a", "ipv4_addr_b", "ipv6_addr_a", "ipv6_addr_b",
+            "tags", "comments", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = (
+            "id", "url", "display", "name", "status", "tenant",
+            "node_a", "node_b", "encapsulation_mode",
+        )
+
+
+class ServiceIPSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cesnet_services_plugin-api:serviceip-detail"
+    )
+    tenant = TenantSerializer(nested=True, allow_null=True, required=False)
+    sap = InterfaceSerializer(nested=True, allow_null=True, required=False)
+    ipv4_addr = IPAddressSerializer(nested=True, allow_null=True, required=False)
+    ipv6_addr = IPAddressSerializer(nested=True, allow_null=True, required=False)
+    routing_static_next_hop = IPAddressSerializer(nested=True, allow_null=True, required=False)
+    routing_bgp_peer_as = ASNSerializer(nested=True, allow_null=True, required=False)
+    routing_bgp_peer_ip = IPAddressSerializer(nested=True, allow_null=True, required=False)
+
+    class Meta:
+        model = ServiceIP
+        fields = (
+            "id", "display", "url",
+            "name", "status", "active", "tenant",
+            "service_start", "service_end", "rt", "monitored",
+            "sap",
+            "encapsulation_mode", "encapsulation_qinq_s_vlan_id", "encapsulation_qinq_c_vlan_id",
+            "ipv4_addr", "ipv6_addr",
+            "routing_type", "routing_prefixes",
+            "routing_static_next_hop",
+            "routing_bgp_peer_as", "routing_bgp_peer_ip", "routing_bgp_policy",
+            "tags", "comments", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = (
+            "id", "url", "display", "name", "status", "tenant",
+            "sap", "routing_type",
+        )
+
+
+class BGPConnectionSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cesnet_services_plugin-api:bgpconnection-detail"
+    )
+    device = DeviceSerializer(nested=True)
+    next_hop = IPAddressSerializer(nested=True, allow_null=True)
+    bgp_prefix = PrefixSerializer(nested=True, allow_null=True)
+    vrf = VRFSerializer(nested=True, allow_null=True)
+
+    class Meta:
+        model = BGPConnection
+        fields = (
+            "id",
+            "display",
+            "url",
+            "device",
+            "raw_next_hop",
+            "next_hop",
+            "raw_bgp_prefix",
+            "bgp_prefix",
+            "raw_vrf",
+            "vrf",
+            "role",
+            "last_seen",
+            "tags",
+            "import_data",
+            "custom_fields",
+            "created",
+            "last_updated",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "display",
+            "device",
+            "raw_next_hop",
+            "next_hop",
+            "raw_bgp_prefix",
+            "bgp_prefix",
+            "raw_vrf",
+            "vrf",
+            "role",
+            "tags",
+        )

netbox_cesnet_services_plugin/api/urls.py

@@ -0,0 +1,14 @@
+from netbox.api.routers import NetBoxRouter
+
+from . import views
+
+app_name = "netbox_cesnet_services_plugin"
+router = NetBoxRouter()
+router.register("bgp-connections", views.BGPConnectionViewSet)
+router.register("lldp-neighbors", views.LLDPNeighborViewSet)
+router.register("lldp-neighbor-leafs", views.LLDPNeighborLeafViewSet)
+router.register("service-core-trunks", views.ServiceCoreTrunkViewSet)
+router.register("service-core-links", views.ServiceCoreLinkViewSet)
+router.register("service-ip", views.ServiceIPViewSet)
+
+urlpatterns = router.urls

netbox_cesnet_services_plugin/api/views.py

@@ -0,0 +1,64 @@
+from netbox.api.metadata import ContentTypeMetadata
+from netbox.api.viewsets import NetBoxModelViewSet
+
+from netbox_cesnet_services_plugin import filtersets, models
+from .serializers import (
+    BGPConnectionSerializer,
+    LLDPNeighborSerializer,
+    LLDPNeighborLeafSerializer,
+    ServiceCoreTrunkSerializer,
+    ServiceCoreLinkSerializer,
+    ServiceIPSerializer,
+)
+
+
+class BGPConnectionViewSet(NetBoxModelViewSet):
+    metadata_class = ContentTypeMetadata
+    queryset = models.BGPConnection.objects.all()
+    serializer_class = BGPConnectionSerializer
+    filterset_class = filtersets.BGPConnectionFilterSet
+
+
+class LLDPNeighborViewSet(NetBoxModelViewSet):
+    metadata_class = ContentTypeMetadata
+    queryset = models.LLDPNeighbor.objects.all()
+    serializer_class = LLDPNeighborSerializer
+    filterset_class = filtersets.LLDPNeighborFilterSet
+
+
+class LLDPNeighborLeafViewSet(NetBoxModelViewSet):
+    metadata_class = ContentTypeMetadata
+    queryset = models.LLDPNeighborLeaf.objects.all()
+    serializer_class = LLDPNeighborLeafSerializer
+    filterset_class = filtersets.LLDPNeighborLeafFilterSet
+
+
+class ServiceCoreTrunkViewSet(NetBoxModelViewSet):
+    metadata_class = ContentTypeMetadata
+    queryset = models.ServiceCoreTrunk.objects.select_related(
+        "tenant", "node_a", "node_b", "if_a", "if_b"
+    )
+    serializer_class = ServiceCoreTrunkSerializer
+    filterset_class = filtersets.ServiceCoreTrunkFilterSet
+
+
+class ServiceCoreLinkViewSet(NetBoxModelViewSet):
+    metadata_class = ContentTypeMetadata
+    queryset = models.ServiceCoreLink.objects.select_related(
+        "tenant", "node_a", "node_b", "phy_if_a", "phy_if_b",
+        "ipv4_addr_a", "ipv4_addr_b", "ipv6_addr_a", "ipv6_addr_b",
+    ).prefetch_related("saps", "core_trunks", "linked_segments")
+    serializer_class = ServiceCoreLinkSerializer
+    filterset_class = filtersets.ServiceCoreLinkFilterSet
+
+
+
+class ServiceIPViewSet(NetBoxModelViewSet):
+    metadata_class = ContentTypeMetadata
+    queryset = models.ServiceIP.objects.select_related(
+        "tenant", "sap",
+        "ipv4_addr", "ipv6_addr",
+        "routing_static_next_hop", "routing_bgp_peer_as", "routing_bgp_peer_ip",
+    ).prefetch_related("routing_prefixes")
+    serializer_class = ServiceIPSerializer
+    filterset_class = filtersets.ServiceIPFilterSet

netbox_cesnet_services_plugin/choices.py

@@ -0,0 +1,57 @@
+from utilities.choices import ChoiceSet
+from django.utils.translation import gettext_lazy as _
+
+
+class EncapsulationModeChoices(ChoiceSet):
+    MODE_NONE = "none"
+    MODE_DOT1Q = "dot1q"
+    MODE_QINQ = "qinq"
+
+    CHOICES = [
+        (MODE_NONE, _("None / Untagged"), "gray"),
+        (MODE_DOT1Q, _("dot1q"), "blue"),
+        (MODE_QINQ, _("QinQ"), "purple"),
+    ]
+
+
+class RoutingTypeChoices(ChoiceSet):
+    TYPE_NONE = "none"
+    TYPE_STATIC = "static"
+    TYPE_BGP = "bgp"
+
+    CHOICES = [
+        (TYPE_NONE, _("None"), "gray"),
+        (TYPE_STATIC, _("Static"), "blue"),
+        (TYPE_BGP, _("BGP"), "green"),
+    ]
+
+
+class LLDPNeigborStatusChoices(ChoiceSet):
+    STATUS_ACTIVE = "active"
+    STATUS_INACTIVE = "inactive"
+
+    CHOICES = (
+        (STATUS_ACTIVE, _("Active"), "green"),
+        (STATUS_INACTIVE, _("Inactive"), "gray"),
+    )
+
+
+class LLDPNeigborStatusDetailChoices(ChoiceSet):
+    """
+    Fully connected - both sides found in LLDP data
+    Lost Sync - previous state was fully connected, but one side is not in LLDP data -> after N days switch to unconfirmed or inactive
+    Unconfirmed - one side is not in LLDP data, but the other side is. Both sides are in the Netbox.
+    None - no detail needed, primary status is inactive. No side is in LLDP data.
+    """
+
+    STATUS_ACTIVE = "fully_connected"
+    STATUS_UNCONFIRMED = "unconfirmed"
+    STATUS_ONEWAY = "lost_sync"
+    STATUS_NONE = "none"
+
+    CHOICES = (
+        (STATUS_ACTIVE, _("Fully Connected"), "green"),
+        (STATUS_UNCONFIRMED, _("Unconfirmed"), "yellow"),
+        (STATUS_ONEWAY, _("Lost Sync"), "orange"),
+        (STATUS_NONE, _("None"), "gray"),
+    )

netbox_cesnet_services_plugin/filtersets/__init__.py

@@ -0,0 +1,17 @@
+from .bgpconnection import BGPConnectionFilterSet
+from .bgpconnection_aggregation import BGPConnectionAggregationFilterSet
+from .lldpneighbor import LLDPNeighborFilterSet
+from .lldpneighborleaf import LLDPNeighborLeafFilterSet
+from .service_core_trunk import ServiceCoreTrunkFilterSet
+from .service_core_link import ServiceCoreLinkFilterSet
+from .service_ip import ServiceIPFilterSet
+
+__all__ = [
+    "BGPConnectionFilterSet",
+    "BGPConnectionAggregationFilterSet",
+    "LLDPNeighborFilterSet",
+    "LLDPNeighborLeafFilterSet",
+    "ServiceCoreTrunkFilterSet",
+    "ServiceCoreLinkFilterSet",
+    "ServiceIPFilterSet",
+]

netbox_cesnet_services_plugin/filtersets/bgpconnection.py

@@ -0,0 +1,144 @@
+import django_filters
+from dcim.models import Device, Interface
+from django.db.models import Q
+from django.utils.translation import gettext as _
+from extras.filters import TagFilter
+from ipam.models import VRF, IPAddress, Prefix
+from netbox.filtersets import NetBoxModelFilterSet
+from tenancy.models import Tenant
+from utilities.forms.fields import DynamicMultipleChoiceField
+
+from netbox_cesnet_services_plugin.models import BGPConnection, BGPConnectionChoices
+
+
+class BGPConnectionFilterSet(NetBoxModelFilterSet):
+    q = django_filters.CharFilter(method="search", label="Search")
+    device = django_filters.ModelMultipleChoiceFilter(queryset=Device.objects.all())
+    device_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="device__id",
+        queryset=Device.objects.all(),
+        to_field_name="id",
+        label="Device (ID)",
+    )
+    next_hop = django_filters.ModelMultipleChoiceFilter(
+        queryset=IPAddress.objects.all()
+    )
+    next_hop_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="next_hop__id",
+        queryset=IPAddress.objects.all(),
+        to_field_name="id",
+        label="Next Hop (ID)",
+    )
+
+    next_hop_interface_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="next_hop__interface__id",
+        queryset=Interface.objects.all(),
+        to_field_name="id",
+        label="Next Hop Interface (ID)",
+    )
+    bgp_prefix = django_filters.ModelMultipleChoiceFilter(queryset=Prefix.objects.all())
+    bgp_prefix_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="bgp_prefix__id",
+        queryset=Prefix.objects.all(),
+        to_field_name="id",
+        label="BGP Prefix (ID)",
+    )
+    bgp_prefix_tenant_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="bgp_prefix__tenant__id",
+        queryset=Tenant.objects.all(),
+        to_field_name="id",
+        label="BGP Prefix Tenant (ID)",
+    )
+    vrf = django_filters.ModelMultipleChoiceFilter(queryset=VRF.objects.all())
+    vrf_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="vrf__id",
+        queryset=VRF.objects.all(),
+        to_field_name="id",
+        label="VRF (ID)",
+    )
+    vrf_none = django_filters.BooleanFilter(method="_vrf_none", label="Empty VRF")
+
+    # TODO: as CHAR filter or as IPAddress filter?
+    raw_next_hop = django_filters.CharFilter(
+        # method='filter_address',
+        label=_("Address"),
+    )
+    raw_bgp_prefix = django_filters.CharFilter(
+        # method='filter_prefix',
+        label=_("Prefix"),
+    )
+    raw_vrf = django_filters.CharFilter(
+        label=_("VRF"),
+    )
+
+    role = DynamicMultipleChoiceField(choices=BGPConnectionChoices, required=False)
+
+    last_seen = django_filters.DateTimeFilter()
+    last_seen__gte = django_filters.DateTimeFilter(
+        field_name="last_seen", lookup_expr="gte"
+    )
+    last_seen__lte = django_filters.DateTimeFilter(
+        field_name="last_seen", lookup_expr="lte"
+    )
+    last_seen__isnull = django_filters.BooleanFilter(
+        field_name="last_seen", lookup_expr="isnull"
+    )
+
+    tag = TagFilter()
+
+    class Meta:
+        model = BGPConnection
+        fields = [
+            "raw_next_hop",
+            "next_hop",
+            "bgp_prefix",
+            "raw_vrf",
+            "vrf",
+            "role",
+            "last_seen",
+            "tag",
+        ]
+
+    def search(self, queryset, name, value):
+        filters = (
+            Q(device__name=value)
+            | Q(raw_next_hop__icontains=value)
+            | Q(raw_bgp_prefix__icontains=value)
+            | Q(bgp_prefix__tenant__name__icontains=value)
+            | Q(raw_vrf__icontains=value)
+            | Q(vrf__name__icontains=value)
+            | Q(role__icontains=value)
+        )
+
+        return queryset.filter(filters)
+
+    def _vrf_none(self, queryset, name, value):
+        if value:
+            return queryset.filter(vrf=None)
+        else:
+            return queryset.filter(vrf__isnull=False)
+
+    # TODO: Filter `raw`` Address and Prefix with netaddr or treat it like a string?
+    """
+    def filter_address(self, queryset, name, value):
+        # Let's first parse the addresses passed
+        # as argument. If they are all invalid,
+        # we return an empty queryset
+        # TODO: Use Netaddr or ipaddress module
+        value = self.parse_inet_addresses(value)
+        if len(value) == 0:
+            return queryset.none()
+        try:
+            return queryset.filter(address__net_in=value)
+        except ValidationError:
+            return queryset.none()
+
+    def filter_prefix(self, queryset, name, value):
+        query_values = []
+        for v in value:
+            try:
+                query_values.append(netaddr.IPNetwork(v))
+            except (AddrFormatError, ValueError):
+                pass
+        return queryset.filter(prefix__in=query_values)
+    """

netbox_cesnet_services_plugin/filtersets/bgpconnection_aggregation.py

@@ -0,0 +1,68 @@
+import django_filters
+from dcim.models import Device, Interface
+from netbox.filtersets import NetBoxModelFilterSet
+from tenancy.models import Tenant
+
+from netbox_cesnet_services_plugin.models.bgpconnection import BGPConnection
+
+
+class BGPConnectionAggregationFilterSet(NetBoxModelFilterSet):
+    """FilterSet for BGP Connection Aggregation view"""
+
+    device = django_filters.ModelMultipleChoiceFilter(
+        queryset=Device.objects.all(), field_name="device", label="Device"
+    )
+
+    device_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=Device.objects.all(),
+        field_name="device__id",
+        to_field_name="id",
+        label="Device (ID)",
+    )
+
+    next_hop_interface = django_filters.ModelMultipleChoiceFilter(
+        queryset=Interface.objects.all(),
+        field_name="next_hop__interface",
+        label="Next Hop Interface",
+    )
+
+    next_hop_interface_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=Interface.objects.all(),
+        field_name="next_hop__interface__id",
+        to_field_name="id",
+        label="Next Hop Interface (ID)",
+    )
+
+    bgp_prefix_tenant = django_filters.ModelMultipleChoiceFilter(
+        queryset=Tenant.objects.all(),
+        field_name="bgp_prefix__tenant",
+        label="BGP Prefix Tenant",
+    )
+
+    bgp_prefix_tenant_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=Tenant.objects.all(),
+        field_name="bgp_prefix__tenant__id",
+        to_field_name="id",
+        label="BGP Prefix Tenant (ID)",
+    )
+
+    has_tenant = django_filters.BooleanFilter(method="_has_tenant", label="Has Tenant")
+
+    def _has_tenant(self, queryset, name, value):
+        """Filter by whether the BGP connection has a tenant or not"""
+        if value:
+            return queryset.exclude(bgp_prefix__tenant__isnull=True)
+        else:
+            return queryset.filter(bgp_prefix__tenant__isnull=True)
+
+    class Meta:
+        model = BGPConnection
+        fields = (
+            "device",
+            "device_id",
+            "next_hop_interface",
+            "next_hop_interface_id",
+            "bgp_prefix_tenant",
+            "bgp_prefix_tenant_id",
+            "has_tenant",
+        )