netbox-blade-chassis 0.1.2__py3-none-any.whl

netbox_blade_chassis/__init__.py

@@ -0,0 +1,24 @@
+from netbox.plugins import PluginConfig
+
+from .version import __version__
+
+
+class NetboxBladeChassisConfig(PluginConfig):
+    name = 'netbox_blade_chassis'
+    verbose_name = 'NetBox Blade Chassis'
+    description = 'Visualize blade server bays inside chassis devices in rack elevations.'
+    version = __version__
+    base_url = 'blade-chassis'
+    min_version = '4.6.0'
+    max_version = '4.7.99'
+
+    default_settings = {
+        'enable_inline_elevation': True,
+    }
+
+    def ready(self):
+        super().ready()
+        from . import views  # noqa: F401 — registers plugin views via decorators
+
+
+config = NetboxBladeChassisConfig

netbox_blade_chassis/api/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+
+from netbox_blade_chassis.api import views
+
+app_name = 'netbox_blade_chassis-api'
+
+urlpatterns = [
+    path('racks/<int:pk>/elevation/', views.RackElevationAPIView.as_view(), name='rack-elevation'),
+]

netbox_blade_chassis/api/views.py

@@ -0,0 +1,60 @@
+from django.http import HttpResponse
+from django.shortcuts import get_object_or_404
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from dcim.api.serializers_.racks import RackElevationDetailFilterSerializer
+from dcim.api.serializers_.rackunits import RackUnitSerializer
+from dcim.models import Rack
+
+from netbox_blade_chassis.svg.racks import BladeChassisRackElevationSVG
+
+
+class RackElevationAPIView(APIView):
+    queryset = Rack.objects.all()
+
+    def get(self, request, pk):
+        rack = get_object_or_404(Rack.objects.restrict(request.user, 'view'), pk=pk)
+        serializer = RackElevationDetailFilterSerializer(data=request.GET)
+        if not serializer.is_valid():
+            return Response(serializer.errors, 400)
+
+        data = serializer.validated_data
+
+        if data['render'] == 'svg':
+            highlight_params = []
+            for param in request.GET.getlist('highlight'):
+                try:
+                    highlight_params.append(param.split(':', 1))
+                except ValueError:
+                    pass
+
+            drawing = BladeChassisRackElevationSVG(
+                rack,
+                user=request.user,
+                unit_width=data['unit_width'],
+                unit_height=data['unit_height'],
+                legend_width=data['legend_width'],
+                margin_width=data['margin_width'],
+                include_images=data['include_images'],
+                base_url=request.build_absolute_uri('/'),
+                highlight_params=highlight_params,
+            )
+            return HttpResponse(drawing.render(data['face']).tostring(), content_type='image/svg+xml')
+
+        elevation = rack.get_rack_units(
+            face=data['face'],
+            user=request.user,
+            exclude=data['exclude'],
+            expand_devices=data['expand_devices'],
+        )
+
+        if q := data['q']:
+            q = q.lower()
+            elevation = [
+                unit for unit in elevation
+                if q in str(unit['id']) or q in str(unit['name']).lower()
+            ]
+
+        rack_units = RackUnitSerializer(elevation, many=True, context={'request': request})
+        return Response(rack_units.data)

netbox_blade_chassis/forms.py

@@ -0,0 +1,111 @@
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+from dcim.forms.model_forms import DeviceBayTemplateForm as BaseDeviceBayTemplateForm
+from dcim.forms.object_create import ComponentCreateForm
+from utilities.forms.fields import ExpandableNameField
+from utilities.forms.rendering import FieldSet
+
+from netbox_blade_chassis.models import DeviceBayTemplateLayout
+
+
+def _parse_position(value):
+    if value in (None, ''):
+        return None
+    return int(value)
+
+
+def _layout_requested(position_x, position_y):
+    return position_x is not None and position_y is not None
+
+
+class DeviceBayTemplateLayoutBulkForm(forms.ModelForm):
+    position_x = forms.IntegerField(
+        required=False,
+        min_value=0,
+        widget=forms.NumberInput(attrs={'class': 'form-control form-control-sm', 'min': 0}),
+    )
+    position_y = forms.IntegerField(
+        required=False,
+        min_value=0,
+        widget=forms.NumberInput(attrs={'class': 'form-control form-control-sm', 'min': 0}),
+    )
+
+    class Meta:
+        model = DeviceBayTemplateLayout
+        fields = ('position_x', 'position_y')
+
+
+class DeviceBayTemplateForm(BaseDeviceBayTemplateForm):
+    class Meta(BaseDeviceBayTemplateForm.Meta):
+        fields = BaseDeviceBayTemplateForm.Meta.fields
+
+    position_x = forms.IntegerField(
+        label=_('Position X'),
+        min_value=0,
+        required=False,
+        help_text=_(
+            'Horizontal slot index within the row (0-based). Both Position X and Y are required for elevation display.'
+        ),
+    )
+    position_y = forms.IntegerField(
+        label=_('Position Y'),
+        min_value=0,
+        required=False,
+        help_text=_(
+            'Row index within the blade grid (0-based). Both Position X and Y are required for elevation display.'
+        ),
+    )
+
+    fieldsets = (
+        FieldSet('device_type', 'name', 'label', 'enabled', 'description', name=_('Template')),
+        FieldSet('position_x', 'position_y', name=_('Blade Layout')),
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance.pk:
+            layout = DeviceBayTemplateLayout.objects.filter(device_bay_template=self.instance).first()
+            if layout:
+                self.fields['position_x'].initial = layout.position_x
+                self.fields['position_y'].initial = layout.position_y
+
+    def save(self, commit=True):
+        instance = super().save(commit)
+        position_x = _parse_position(self.cleaned_data.get('position_x'))
+        position_y = _parse_position(self.cleaned_data.get('position_y'))
+
+        if not _layout_requested(position_x, position_y):
+            DeviceBayTemplateLayout.objects.filter(device_bay_template=instance).delete()
+            return instance
+
+        DeviceBayTemplateLayout.objects.update_or_create(
+            device_bay_template=instance,
+            defaults={
+                'position_x': position_x,
+                'position_y': position_y,
+            },
+        )
+        return instance
+
+
+class DeviceBayTemplateCreateForm(ComponentCreateForm, DeviceBayTemplateForm):
+    position_x = ExpandableNameField(
+        label=_('Position X'),
+        required=False,
+        help_text=_('Alphanumeric ranges are supported. (Must match the number of names being created.)'),
+    )
+    position_y = ExpandableNameField(
+        label=_('Position Y'),
+        required=False,
+        help_text=_('Alphanumeric ranges are supported. (Must match the number of names being created.)'),
+    )
+    replication_fields = ('name', 'label', 'position_x', 'position_y')
+
+    fieldsets = (
+        FieldSet('device_type', 'name', 'label', 'enabled', 'description', name=_('Template')),
+        FieldSet('position_x', 'position_y', name=_('Blade Layout')),
+    )
+
+    class Meta(DeviceBayTemplateForm.Meta):
+        exclude = ('name', 'label', 'position_x', 'position_y')

netbox_blade_chassis/layout.py

@@ -0,0 +1,79 @@
+from collections import defaultdict
+from typing import NamedTuple
+
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+from dcim.models import Device, DeviceType
+
+from netbox_blade_chassis.models import DeviceBayTemplateLayout
+
+
+class LayoutEntry(NamedTuple):
+    position_x: int
+    position_y: int
+
+
+def get_layout_map(device_type: DeviceType) -> dict[str, LayoutEntry]:
+    layouts = DeviceBayTemplateLayout.objects.filter(
+        device_bay_template__device_type=device_type,
+    ).select_related('device_bay_template')
+
+    return {
+        layout.device_bay_template.name: LayoutEntry(
+            layout.position_x,
+            layout.position_y,
+        )
+        for layout in layouts
+    }
+
+
+def device_has_blade_layout(device_type: DeviceType) -> bool:
+    return DeviceBayTemplateLayout.objects.filter(
+        device_bay_template__device_type=device_type,
+    ).exists()
+
+
+def group_layout_by_row(
+    layout_map: dict[str, LayoutEntry],
+) -> dict[int, list[tuple[int, str]]]:
+    rows: dict[int, list[tuple[int, str]]] = defaultdict(list)
+    for name, entry in layout_map.items():
+        rows[entry.position_y].append((entry.position_x, name))
+    for row in rows.values():
+        row.sort(key=lambda item: item[0])
+    return dict(rows)
+
+
+def get_symmetric_column_count(layout_map: dict[int, list[tuple[int, str]]]) -> int:
+    if not layout_map:
+        return 0
+    return max(max(position_x for position_x, _ in cells) + 1 for cells in layout_map.values())
+
+
+def mirror_column_index(position_x: int, column_count: int) -> int:
+    return column_count - 1 - position_x
+
+
+def validate_grid_symmetry(layout_map: dict[str, LayoutEntry]) -> None:
+    rows: dict[int, set[int]] = defaultdict(set)
+    for entry in layout_map.values():
+        rows[entry.position_y].add(entry.position_x)
+
+    if not rows:
+        return
+
+    row_column_counts = [max(columns) + 1 for columns in rows.values()]
+    if len(set(row_column_counts)) > 1:
+        raise ValidationError(_('All blade rows must have the same number of columns.'))
+
+
+def get_chassis_title(device: Device) -> str:
+    return device.name or device.device_type.model
+
+
+def get_blade_label(device: Device) -> str:
+    name = device.name or str(device.device_type)
+    if '#' in name:
+        return name.split('#', 1)[0]
+    return name

netbox_blade_chassis/migrations/0001_initial.py

@@ -0,0 +1,28 @@
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('dcim', '0237_module_remove_local_context_data'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='DeviceBayTemplateLayout',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('position_x', models.PositiveIntegerField(default=0, help_text='Horizontal slot index within the row (0-based, left to right).', verbose_name='position X')),
+                ('position_y', models.PositiveIntegerField(default=0, help_text='Row index within the chassis (0-based, top to bottom).', verbose_name='position Y')),
+                ('device_bay_template', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='blade_layout', to='dcim.devicebaytemplate')),
+            ],
+            options={
+                'verbose_name': 'device bay template layout',
+                'verbose_name_plural': 'device bay template layouts',
+                'ordering': ('position_y', 'position_x'),
+            },
+        ),
+    ]

netbox_blade_chassis/models.py

@@ -0,0 +1,53 @@
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+
+class DeviceBayTemplateLayout(models.Model):
+    device_bay_template = models.OneToOneField(
+        to='dcim.DeviceBayTemplate',
+        on_delete=models.CASCADE,
+        related_name='blade_layout',
+    )
+    position_x = models.PositiveIntegerField(
+        verbose_name=_('position X'),
+        default=0,
+        help_text=_('Horizontal slot index within the row (0-based, left to right).'),
+    )
+    position_y = models.PositiveIntegerField(
+        verbose_name=_('position Y'),
+        default=0,
+        help_text=_('Row index within the chassis (0-based, top to bottom).'),
+    )
+
+    class Meta:
+        ordering = ('position_y', 'position_x')
+        verbose_name = _('device bay template layout')
+        verbose_name_plural = _('device bay template layouts')
+
+    def __str__(self):
+        return f'{self.device_bay_template}: ({self.position_x}, {self.position_y})'
+
+    @property
+    def device_type(self):
+        return self.device_bay_template.device_type
+
+    def clean(self):
+        super().clean()
+
+        if not hasattr(self, 'device_bay_template'):
+            return
+
+        device_type = self.device_bay_template.device_type
+        duplicates = DeviceBayTemplateLayout.objects.filter(
+            device_bay_template__device_type=device_type,
+            position_x=self.position_x,
+            position_y=self.position_y,
+        ).exclude(pk=self.pk)
+
+        if duplicates.exists():
+            raise ValidationError({
+                'position_x': _(
+                    'Another bay template on this device type already uses position ({x}, {y}).'
+                ).format(x=self.position_x, y=self.position_y),
+            })

netbox_blade_chassis/svg/racks.py

@@ -0,0 +1,269 @@
+from django.utils.translation import gettext as _
+from svgwrite.container import Hyperlink
+from svgwrite.masking import ClipPath
+from svgwrite.shapes import Line, Rect
+from svgwrite.text import Text, TSpan
+
+from dcim.models import Device
+from dcim.svg.racks import RackElevationSVG, truncate_text
+from utilities.html import foreground_color
+
+from netbox_blade_chassis.layout import (
+    device_has_blade_layout,
+    get_blade_label,
+    get_chassis_title,
+    get_layout_map,
+    get_symmetric_column_count,
+    group_layout_by_row,
+    mirror_column_index,
+)
+
+
+class BladeChassisRackElevationSVG(RackElevationSVG):
+    HEADER_HEIGHT = 18
+    HEADER_FONT_SIZE = 10
+    CELL_FONT_SIZE = 7
+    LINE_HEIGHT_RATIO = 1.25
+
+    BLADE_STYLES = """
+        svg .blade-chassis { stroke: none; }
+        svg .blade-grid-bg { fill: var(--nbx-rack-slot-bg); stroke: none; }
+        svg .blade-cell-empty { fill: color-mix(in srgb, var(--nbx-rack-slot-bg) 65%, var(--nbx-rack-bg)); stroke: none; }
+        svg .blade-cell-filled { stroke: none; opacity: 0.92; }
+        svg .blade-grid-line { stroke: var(--nbx-rack-slot-border); stroke-width: 1; }
+        svg .blade-header-label { font-size: 10px; font-weight: 600; }
+        svg .blade-cell-label { font-size: 7px; }
+        svg .blade-cell-empty-label { font-size: 8px; fill: var(--nbx-rack-unit-color); opacity: 0.45; }
+    """
+
+    def __init__(self, *args, user=None, **kwargs):
+        super().__init__(*args, user=user, **kwargs)
+        self._user = user
+
+    def _setup_drawing(self):
+        drawing = super()._setup_drawing()
+        drawing.defs.add(drawing.style(self.BLADE_STYLES))
+        return drawing
+
+    def _device_is_viewable(self, device):
+        if device.pk in self.permitted_device_ids:
+            return True
+        if self._user is None:
+            return True
+        return Device.objects.restrict(self._user, 'view').filter(pk=device.pk).exists()
+
+    def draw_device_front(self, device, coords, size):
+        if device_has_blade_layout(device.device_type):
+            self._draw_blade_chassis(device, coords, size)
+        else:
+            super().draw_device_front(device, coords, size)
+
+    def draw_device_rear(self, device, coords, size):
+        if device_has_blade_layout(device.device_type):
+            self._draw_blade_chassis(device, coords, size, mirrored=True)
+        else:
+            super().draw_device_rear(device, coords, size)
+
+    def _draw_blade_chassis(self, device, coords, size, mirrored=False):
+        x, y = coords
+        width, height = size
+        layout_map = get_layout_map(device.device_type)
+        if not layout_map:
+            super().draw_device_front(device, coords, size)
+            return
+
+        bays_by_name = {bay.name: bay for bay in device.devicebays.all()}
+        rows = group_layout_by_row(layout_map)
+        row_indices = sorted(rows.keys())
+        row_count = len(row_indices)
+        column_count = get_symmetric_column_count(rows)
+
+        header_height = min(self.HEADER_HEIGHT, max(height * 0.18, 12))
+        inner_y = y + header_height
+        inner_height = max(height - header_height, 1)
+        row_height = inner_height / row_count if row_count else inner_height
+        column_width = width / column_count if column_count else width
+
+        color = device.role.color if device.role else None
+        header_bg = f'#{color}' if color else 'var(--nbx-rack-slot-bg)'
+        text_color = f'#{foreground_color(color)}' if color else 'var(--nbx-rack-unit-color)'
+        is_shaded = self.highlight_devices and device not in self.highlight_devices
+        css_extra = ' shaded' if is_shaded else ''
+
+        clip_id = f'blade-clip-{device.pk}'
+        clip_path = ClipPath(id=clip_id)
+        clip_path.add(Rect((x, inner_y), (width, inner_height)))
+        self.drawing.defs.add(clip_path)
+
+        chassis_link = Hyperlink(href=f'{self.base_url}{device.get_absolute_url()}', target='_parent')
+        chassis_link.add(Rect(coords, size, style=f'fill: {header_bg}', class_=f'blade-chassis{css_extra}'))
+        chassis_link.add(
+            Text(
+                truncate_text(get_chassis_title(device), width, font_size=self.HEADER_FONT_SIZE),
+                insert=(x + width / 2, y + header_height / 2),
+                fill=text_color,
+                class_=f'blade-header-label{css_extra}',
+            )
+        )
+        self.drawing.add(chassis_link)
+
+        self.drawing.add(Rect((x, inner_y), (width, inner_height), class_=f'blade-grid-bg{css_extra}'))
+
+        for row_number, row_index in enumerate(row_indices):
+            cell_y = inner_y + row_number * row_height
+            cells_by_x = dict(rows[row_index])
+
+            for position_x in range(column_count):
+                bay_name = cells_by_x.get(position_x)
+                bay = bays_by_name.get(bay_name) if bay_name else None
+                display_x = mirror_column_index(position_x, column_count) if mirrored else position_x
+                cell_x = x + display_x * column_width
+                self._draw_blade_cell(
+                    bay=bay,
+                    coords=(cell_x, cell_y),
+                    size=(column_width, row_height),
+                    css_extra=css_extra,
+                    clip_id=clip_id,
+                )
+
+        self._draw_blade_grid_lines(
+            x=x,
+            y=inner_y,
+            width=width,
+            height=inner_height,
+            row_count=row_count,
+            column_count=column_count,
+            css_extra=css_extra,
+        )
+        self.drawing.add(Line(
+            start=(x, inner_y),
+            end=(x + width, inner_y),
+            class_=f'blade-grid-line{css_extra}',
+        ))
+
+    def _draw_blade_grid_lines(self, x, y, width, height, row_count, column_count, css_extra=''):
+        row_height = height / row_count if row_count else height
+        column_width = width / column_count if column_count else width
+
+        for column_index in range(1, column_count):
+            line_x = x + column_index * column_width
+            self.drawing.add(Line(
+                start=(line_x, y),
+                end=(line_x, y + height),
+                class_=f'blade-grid-line{css_extra}',
+            ))
+
+        for row_index in range(1, row_count):
+            line_y = y + row_index * row_height
+            self.drawing.add(Line(
+                start=(x, line_y),
+                end=(x + width, line_y),
+                class_=f'blade-grid-line{css_extra}',
+            ))
+
+    def _draw_blade_cell(self, bay, coords, size, css_extra='', clip_id=None):
+        cell_x, cell_y = coords
+        cell_width, cell_height = size
+        clip_attr = {'clip-path': f'url(#{clip_id})'} if clip_id else {}
+        text_padding = 2
+        text_width = max(cell_width - text_padding * 2, 1)
+        text_height = max(cell_height - text_padding * 2, 1)
+
+        installed = bay.installed_device if bay else None
+        if installed and self._device_is_viewable(installed):
+            label = get_blade_label(installed)
+            description = _('Blade: {name}').format(name=label)
+            blade_color = installed.role.color if installed.role else None
+            fill_style = f'fill: #{blade_color}' if blade_color else None
+            label_color = f'#{foreground_color(blade_color)}' if blade_color else 'var(--nbx-rack-unit-color)'
+
+            link = Hyperlink(href=f'{self.base_url}{installed.get_absolute_url()}', target='_parent')
+            link.set_desc(description)
+            link.add(Rect(coords, size, style=fill_style, class_=f'blade-cell-filled{css_extra}', **clip_attr))
+            link.add(self._build_cell_text(
+                label,
+                center_x=cell_x + cell_width / 2,
+                center_y=cell_y + cell_height / 2,
+                width=text_width,
+                height=text_height,
+                fill=label_color,
+                css_class=f'blade-cell-label{css_extra}',
+                clip_attr=clip_attr,
+            ))
+            self.drawing.add(link)
+        else:
+            self.drawing.add(Rect(coords, size, class_=f'blade-cell-empty{css_extra}', **clip_attr))
+            if cell_height >= 10 and cell_width >= 10:
+                self.drawing.add(Text(
+                    '—',
+                    insert=(cell_x + cell_width / 2, cell_y + cell_height / 2),
+                    class_=f'blade-cell-empty-label{css_extra}',
+                    **clip_attr,
+                ))
+
+    def _build_cell_text(self, text, center_x, center_y, width, height, fill, css_class, clip_attr=None):
+        lines = self._wrap_text(text, width, height, self.CELL_FONT_SIZE)
+        line_height = self.CELL_FONT_SIZE * self.LINE_HEIGHT_RATIO
+        block_height = line_height * len(lines)
+        start_y = center_y - block_height / 2 + line_height / 2
+
+        text_elem = Text('', fill=fill, class_=css_class, **(clip_attr or {}))
+        text_elem['text-anchor'] = 'middle'
+
+        for index, line in enumerate(lines):
+            if index == 0:
+                text_elem.add(TSpan(line, insert=(center_x, start_y)))
+            else:
+                text_elem.add(TSpan(line, x=[center_x], dy=[f'{self.LINE_HEIGHT_RATIO}em']))
+
+        return text_elem
+
+    def _wrap_text(self, text, max_width, max_height, font_size):
+        char_width = font_size * 0.55
+        max_chars = max(1, int(max_width / char_width))
+        max_lines = max(1, int(max_height / (font_size * self.LINE_HEIGHT_RATIO)))
+
+        chunks = []
+        for part in text.split('.'):
+            if chunks:
+                chunks.append('.')
+            if part:
+                chunks.append(part)
+
+        lines = []
+        current = ''
+        for chunk in chunks:
+            candidate = current + chunk
+            if len(candidate) <= max_chars:
+                current = candidate
+                continue
+
+            if current:
+                lines.append(current)
+                current = ''
+
+            while chunk and len(lines) < max_lines:
+                if len(chunk) <= max_chars:
+                    current = chunk
+                    chunk = ''
+                    break
+                lines.append(chunk[:max_chars])
+                chunk = chunk[max_chars:]
+
+        if current and len(lines) < max_lines:
+            lines.append(current)
+
+        if not lines:
+            lines = [truncate_text(text, max_width, font_size=font_size)]
+        elif len(lines) > max_lines:
+            lines = lines[:max_lines]
+
+        joined_length = sum(len(line) for line in lines)
+        if joined_length < len(text) and lines:
+            last = lines[-1]
+            if len(last) > 3:
+                lines[-1] = last[: max(1, max_chars - 1)] + '…'
+            else:
+                lines[-1] = '…'
+
+        return lines

netbox_blade_chassis/template_content.py

@@ -0,0 +1,14 @@
+from netbox.plugins import PluginTemplateExtension
+from netbox.plugins.utils import get_plugin_config
+
+
+class ElevationPatchExtension(PluginTemplateExtension):
+    def head(self):
+        if not get_plugin_config('netbox_blade_chassis', 'enable_inline_elevation', True):
+            return ''
+        return self.render('netbox_blade_chassis/inc/elevation_patch.html')
+
+
+template_extensions = [
+    ElevationPatchExtension,
+]