343 lines
13 KiB
Python
343 lines
13 KiB
Python
import decimal
|
|
import svgwrite
|
|
from svgwrite.container import Hyperlink
|
|
from svgwrite.image import Image
|
|
from svgwrite.gradients import LinearGradient
|
|
from svgwrite.shapes import Rect
|
|
from svgwrite.text import Text
|
|
|
|
from django.conf import settings
|
|
from django.core.exceptions import FieldError
|
|
from django.db.models import Q
|
|
from django.template.defaultfilters import floatformat
|
|
from django.urls import reverse
|
|
from django.utils.http import urlencode
|
|
|
|
from netbox.config import get_config
|
|
from utilities.data import array_to_ranges
|
|
from utilities.html import foreground_color
|
|
from dcim.constants import RACK_ELEVATION_BORDER_WIDTH
|
|
|
|
|
|
__all__ = (
|
|
'RackElevationSVG',
|
|
)
|
|
|
|
GRADIENT_RESERVED = '#b0b0ff'
|
|
GRADIENT_OCCUPIED = '#d7d7d7'
|
|
GRADIENT_BLOCKED = '#ffc0c0'
|
|
STROKE_RESERVED = '#4d4dff'
|
|
|
|
|
|
def get_device_name(device):
|
|
if device.virtual_chassis:
|
|
name = f'{device.virtual_chassis.name}:{device.vc_position}'
|
|
elif device.name:
|
|
name = device.name
|
|
else:
|
|
name = str(device.device_type)
|
|
if device.devicebay_count:
|
|
name += ' ({}/{})'.format(device.get_children().count(), device.devicebay_count)
|
|
|
|
return name
|
|
|
|
|
|
def get_device_description(device):
|
|
"""
|
|
Return a description for a device to be rendered in the rack elevation in the following format
|
|
|
|
Name: <name>
|
|
Role: <role>
|
|
Device Type: <manufacturer> <model> (<u_height>)
|
|
Asset tag: <asset_tag> (if defined)
|
|
Serial: <serial> (if defined)
|
|
Description: <description> (if defined)
|
|
"""
|
|
description = f'Name: {device.name}'
|
|
description += f'\nRole: {device.role}'
|
|
u_height = f'{floatformat(device.device_type.u_height)}U'
|
|
description += f'\nDevice Type: {device.device_type.manufacturer.name} {device.device_type.model} ({u_height})'
|
|
if device.asset_tag:
|
|
description += f'\nAsset tag: {device.asset_tag}'
|
|
if device.serial:
|
|
description += f'\nSerial: {device.serial}'
|
|
if device.description:
|
|
description += f'\nDescription: {device.description}'
|
|
|
|
return description
|
|
|
|
|
|
class RackElevationSVG:
|
|
"""
|
|
Use this class to render a rack elevation as an SVG image.
|
|
|
|
:param rack: A NetBox Rack instance
|
|
:param unit_width: Rendered unit width, in pixels
|
|
:param unit_height: Rendered unit height, in pixels
|
|
:param legend_width: Legend width, in pixels (where the unit labels appear)
|
|
:param margin_width: Margin width, in pixels (where reservations appear)
|
|
:param user: User instance. If specified, only devices viewable by this user will be fully displayed.
|
|
:param include_images: If true, the SVG document will embed front/rear device face images, where available
|
|
:param base_url: Base URL for links within the SVG document. If none, links will be relative.
|
|
:param highlight_params: Iterable of two-tuples which identifies attributes of devices to highlight
|
|
"""
|
|
def __init__(self, rack, unit_height=None, unit_width=None, legend_width=None, margin_width=None, user=None,
|
|
include_images=True, base_url=None, highlight_params=None):
|
|
self.rack = rack
|
|
self.include_images = include_images
|
|
self.base_url = base_url.rstrip('/') if base_url is not None else ''
|
|
|
|
# Set drawing dimensions
|
|
config = get_config()
|
|
self.unit_width = unit_width or config.RACK_ELEVATION_DEFAULT_UNIT_WIDTH
|
|
self.unit_height = unit_height or config.RACK_ELEVATION_DEFAULT_UNIT_HEIGHT
|
|
self.legend_width = legend_width or config.RACK_ELEVATION_DEFAULT_LEGEND_WIDTH
|
|
self.margin_width = margin_width or config.RACK_ELEVATION_DEFAULT_MARGIN_WIDTH
|
|
|
|
# Determine the subset of devices within this rack that are viewable by the user, if any
|
|
permitted_devices = self.rack.devices
|
|
if user is not None:
|
|
permitted_devices = permitted_devices.restrict(user, 'view')
|
|
self.permitted_device_ids = permitted_devices.values_list('pk', flat=True)
|
|
|
|
# Determine device(s) to highlight within the elevation (if any)
|
|
self.highlight_devices = []
|
|
if highlight_params:
|
|
q = Q()
|
|
for k, v in highlight_params:
|
|
q |= Q(**{k: v})
|
|
try:
|
|
self.highlight_devices = permitted_devices.filter(q)
|
|
except FieldError:
|
|
pass
|
|
|
|
@staticmethod
|
|
def _add_gradient(drawing, id_, color):
|
|
gradient = LinearGradient(
|
|
start=(0, 0),
|
|
end=(0, 25),
|
|
spreadMethod='repeat',
|
|
id_=id_,
|
|
gradientTransform='rotate(45, 0, 0)',
|
|
gradientUnits='userSpaceOnUse'
|
|
)
|
|
gradient.add_stop_color(offset='0%', color='#f7f7f7')
|
|
gradient.add_stop_color(offset='50%', color='#f7f7f7')
|
|
gradient.add_stop_color(offset='50%', color=color)
|
|
gradient.add_stop_color(offset='100%', color=color)
|
|
|
|
drawing.defs.add(gradient)
|
|
|
|
def _setup_drawing(self):
|
|
width = self.unit_width + self.legend_width + self.margin_width + RACK_ELEVATION_BORDER_WIDTH * 2
|
|
height = self.unit_height * self.rack.u_height + RACK_ELEVATION_BORDER_WIDTH * 2
|
|
drawing = svgwrite.Drawing(size=(width, height))
|
|
|
|
# Add the stylesheet
|
|
with open(f'{settings.STATIC_ROOT}/rack_elevation.css') as css_file:
|
|
drawing.defs.add(drawing.style(css_file.read()))
|
|
|
|
# Add gradients
|
|
RackElevationSVG._add_gradient(drawing, 'reserved', GRADIENT_RESERVED)
|
|
RackElevationSVG._add_gradient(drawing, 'occupied', GRADIENT_OCCUPIED)
|
|
RackElevationSVG._add_gradient(drawing, 'blocked', GRADIENT_BLOCKED)
|
|
|
|
return drawing
|
|
|
|
def _get_device_coords(self, position, height):
|
|
"""
|
|
Return the X, Y coordinates of the top left corner for a device in the specified rack unit.
|
|
"""
|
|
x = self.legend_width + RACK_ELEVATION_BORDER_WIDTH
|
|
y = RACK_ELEVATION_BORDER_WIDTH
|
|
if self.rack.desc_units:
|
|
y += int((position - self.rack.starting_unit) * self.unit_height)
|
|
else:
|
|
y += int((self.rack.u_height - position + self.rack.starting_unit) * self.unit_height) - int(height * self.unit_height)
|
|
|
|
return x, y
|
|
|
|
def _draw_device(self, device, coords, size, color=None, image=None):
|
|
name = get_device_name(device)
|
|
description = get_device_description(device)
|
|
text_color = f'#{foreground_color(color)}' if color else '#000000'
|
|
text_coords = (
|
|
coords[0] + size[0] / 2,
|
|
coords[1] + size[1] / 2
|
|
)
|
|
|
|
# Determine whether highlighting is in use, and if so, whether to shade this device
|
|
is_shaded = self.highlight_devices and device not in self.highlight_devices
|
|
css_extra = ' shaded' if is_shaded else ''
|
|
|
|
# Create hyperlink element
|
|
link = Hyperlink(href=f'{self.base_url}{device.get_absolute_url()}', target="_parent")
|
|
link.set_desc(description)
|
|
|
|
# Add rect element to hyperlink
|
|
if color:
|
|
link.add(Rect(coords, size, style=f'fill: #{color}', class_=f'slot{css_extra}'))
|
|
else:
|
|
link.add(Rect(coords, size, class_=f'slot blocked{css_extra}'))
|
|
link.add(Text(name, insert=text_coords, fill=text_color, class_=f'label{css_extra}'))
|
|
|
|
# Embed device type image if provided
|
|
if self.include_images and image:
|
|
url = f'{self.base_url}{image.url}' if image.url.startswith('/') else image.url
|
|
image = Image(
|
|
href=url,
|
|
insert=coords,
|
|
size=size,
|
|
class_=f'device-image{css_extra}'
|
|
)
|
|
image.fit(scale='slice')
|
|
link.add(image)
|
|
link.add(
|
|
Text(name, insert=text_coords, stroke='black', stroke_width='0.2em', stroke_linejoin='round',
|
|
class_=f'device-image-label{css_extra}')
|
|
)
|
|
link.add(
|
|
Text(name, insert=text_coords, fill='white', class_=f'device-image-label{css_extra}')
|
|
)
|
|
|
|
self.drawing.add(link)
|
|
|
|
def draw_device_front(self, device, coords, size):
|
|
"""
|
|
Draw the front (mounted) face of a device.
|
|
"""
|
|
color = device.role.color
|
|
image = device.device_type.front_image
|
|
self._draw_device(device, coords, size, color=color, image=image)
|
|
|
|
def draw_device_rear(self, device, coords, size):
|
|
"""
|
|
Draw the rear (opposite) face of a device.
|
|
"""
|
|
image = device.device_type.rear_image
|
|
self._draw_device(device, coords, size, image=image)
|
|
|
|
def draw_border(self):
|
|
"""
|
|
Draw a border around the collection of rack units.
|
|
"""
|
|
border_width = RACK_ELEVATION_BORDER_WIDTH
|
|
border_offset = RACK_ELEVATION_BORDER_WIDTH / 2
|
|
frame = Rect(
|
|
insert=(self.legend_width + border_offset, border_offset),
|
|
size=(self.unit_width + border_width, self.rack.u_height * self.unit_height + border_width),
|
|
class_='rack'
|
|
)
|
|
self.drawing.add(frame)
|
|
|
|
def draw_legend(self):
|
|
"""
|
|
Draw the rack unit labels along the lefthand side of the elevation.
|
|
"""
|
|
for ru in range(0, self.rack.u_height):
|
|
start_y = ru * self.unit_height + RACK_ELEVATION_BORDER_WIDTH
|
|
position_coordinates = (self.legend_width / 2, start_y + self.unit_height / 2 + RACK_ELEVATION_BORDER_WIDTH)
|
|
unit = ru + 1 if self.rack.desc_units else self.rack.u_height - ru
|
|
unit = unit + self.rack.starting_unit - 1
|
|
self.drawing.add(
|
|
Text(str(unit), position_coordinates, class_='unit')
|
|
)
|
|
|
|
def draw_margin(self):
|
|
"""
|
|
Draw any rack reservations in the right-hand margin alongside the rack elevation.
|
|
"""
|
|
for reservation in self.rack.reservations.all():
|
|
for segment in array_to_ranges(reservation.units):
|
|
u_height = 1 if len(segment) == 1 else segment[1] + 1 - segment[0]
|
|
coords = self._get_device_coords(segment[0], u_height)
|
|
coords = (coords[0] + self.unit_width + RACK_ELEVATION_BORDER_WIDTH * 2, coords[1])
|
|
size = (
|
|
self.margin_width - 3,
|
|
u_height * self.unit_height
|
|
)
|
|
link = Hyperlink(href=f'{self.base_url}{reservation.get_absolute_url()}', target='_parent')
|
|
link.set_desc(f'Reservation #{reservation.pk}: {reservation.description}')
|
|
link.add(
|
|
Rect(coords, size, class_='reservation', stroke=STROKE_RESERVED, stroke_width=2)
|
|
)
|
|
self.drawing.add(link)
|
|
|
|
def draw_background(self, face):
|
|
"""
|
|
Draw the rack unit placeholders which form the "background" of the rack elevation.
|
|
"""
|
|
x_offset = RACK_ELEVATION_BORDER_WIDTH + self.legend_width
|
|
url_string = '{}?{}&position={{}}'.format(
|
|
reverse('dcim:device_add'),
|
|
urlencode({
|
|
'site': self.rack.site.pk,
|
|
'location': self.rack.location.pk if self.rack.location else '',
|
|
'rack': self.rack.pk,
|
|
'face': face,
|
|
})
|
|
)
|
|
|
|
for ru in range(0, self.rack.u_height):
|
|
unit = ru + 1 if self.rack.desc_units else self.rack.u_height - ru
|
|
unit = unit + self.rack.starting_unit - 1
|
|
y_offset = RACK_ELEVATION_BORDER_WIDTH + ru * self.unit_height
|
|
text_coords = (
|
|
x_offset + self.unit_width / 2,
|
|
y_offset + self.unit_height / 2
|
|
)
|
|
|
|
link = Hyperlink(href=url_string.format(unit), target='_parent')
|
|
link.add(Rect((x_offset, y_offset), (self.unit_width, self.unit_height), class_='slot'))
|
|
link.add(Text('add device', insert=text_coords, class_='add-device'))
|
|
|
|
self.drawing.add(link)
|
|
|
|
def draw_face(self, face, opposite=False):
|
|
"""
|
|
Draw any occupied rack units for the specified rack face.
|
|
"""
|
|
for unit in self.rack.get_rack_units(face=face, expand_devices=False):
|
|
|
|
# Loop through all units in the elevation
|
|
device = unit['device']
|
|
height = unit.get('height', decimal.Decimal(1.0))
|
|
|
|
device_coords = self._get_device_coords(unit['id'], height)
|
|
device_size = (
|
|
self.unit_width,
|
|
int(self.unit_height * height)
|
|
)
|
|
|
|
# Draw the device
|
|
if device and device.pk in self.permitted_device_ids:
|
|
if device.face == face and not opposite:
|
|
self.draw_device_front(device, device_coords, device_size)
|
|
else:
|
|
self.draw_device_rear(device, device_coords, device_size)
|
|
|
|
elif device:
|
|
# Devices which the user does not have permission to view are rendered only as unavailable space
|
|
self.drawing.add(Rect(device_coords, device_size, class_='blocked'))
|
|
|
|
def render(self, face):
|
|
"""
|
|
Return an SVG document representing a rack elevation.
|
|
"""
|
|
|
|
# Initialize the drawing
|
|
self.drawing = self._setup_drawing()
|
|
|
|
# Draw the empty rack, legend, and margin
|
|
self.draw_legend()
|
|
self.draw_background(face)
|
|
self.draw_margin()
|
|
|
|
# Draw the rack face
|
|
self.draw_face(face)
|
|
|
|
# Draw the rack border last
|
|
self.draw_border()
|
|
|
|
return self.drawing
|