class IPAddressInterfaceSerializer(WritableNestedSerializer):
"""
Nested representation of an Interface which may belong to a Device *or* a VirtualMachine.
"""
url = serializers.SerializerMethodField(
) # We're imitating a HyperlinkedIdentityField here
device = NestedDeviceSerializer(read_only=True)
virtual_machine = NestedVirtualMachineSerializer(read_only=True)
class Meta:
model = Interface
fields = [
'id',
'url',
'device',
'virtual_machine',
'name',
]
def get_url(self, obj):
"""
Return a link to the Interface via either the DCIM API if the parent is a Device, or via the virtualization API
if the parent is a VirtualMachine.
"""
url_name = 'dcim-api:interface-detail' if obj.device else 'virtualization-api:interface-detail'
return reverse(url_name,
kwargs={'pk': obj.pk},
request=self.context['request'])
class ServiceSerializer(CustomFieldModelSerializer):
device = NestedDeviceSerializer(required=False, allow_null=True)
virtual_machine = NestedVirtualMachineSerializer(required=False,
allow_null=True)
protocol = ChoiceField(choices=ServiceProtocolChoices)
ipaddresses = SerializedPKRelatedField(
queryset=IPAddress.objects.all(),
serializer=NestedIPAddressSerializer,
required=False,
many=True)
class Meta:
model = Service
fields = [
'id',
'device',
'virtual_machine',
'name',
'port',
'protocol',
'ipaddresses',
'description',
'custom_fields',
'created',
'last_updated',
]
class SecretSerializer(TaggitSerializer, CustomFieldModelSerializer):
device = NestedDeviceSerializer()
role = NestedSecretRoleSerializer()
plaintext = serializers.CharField()
tags = TagListSerializerField(required=False)
class Meta:
model = Secret
fields = [
'id',
'device',
'role',
'name',
'plaintext',
'hash',
'tags',
'custom_fields',
'created',
'last_updated',
]
validators = []
def validate(self, data):
# Encrypt plaintext data using the master key provided from the view context
if data.get('plaintext'):
s = Secret(plaintext=data['plaintext'])
s.encrypt(self.context['master_key'])
data['ciphertext'] = s.ciphertext
data['hash'] = s.hash
super().validate(data)
return data
class ServiceSerializer(PrimaryModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='ipam-api:service-detail')
device = NestedDeviceSerializer(required=False, allow_null=True)
virtual_machine = NestedVirtualMachineSerializer(required=False,
allow_null=True)
protocol = ChoiceField(choices=ServiceProtocolChoices, required=False)
ipaddresses = SerializedPKRelatedField(
queryset=IPAddress.objects.all(),
serializer=NestedIPAddressSerializer,
required=False,
many=True)
class Meta:
model = Service
fields = [
'id',
'url',
'display',
'device',
'virtual_machine',
'name',
'ports',
'protocol',
'ipaddresses',
'description',
'tags',
'custom_fields',
'created',
'last_updated',
]
class BGPSessionSerializer(TaggedObjectSerializer, CustomFieldModelSerializer):
status = ChoiceField(choices=SessionStatusChoices, required=False)
site = NestedSiteSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
device = NestedDeviceSerializer(required=False, allow_null=True)
local_address = NestedIPAddressSerializer(required=True, allow_null=False)
remote_address = NestedIPAddressSerializer(required=True, allow_null=False)
local_as = ASNSerializer(required=True, allow_null=False)
remote_as = ASNSerializer(required=True, allow_null=False)
class Meta:
model = BGPSession
fields = '__all__'
class BGPSessionSerializer(TaggedObjectSerializer, CustomFieldModelSerializer):
status = ChoiceField(choices=SessionStatusChoices, required=False)
site = NestedSiteSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
device = NestedDeviceSerializer(required=False, allow_null=True)
local_address = NestedIPAddressSerializer(required=True, allow_null=False)
remote_address = NestedIPAddressSerializer(required=True, allow_null=False)
local_as = NestedASNSerializer(required=True, allow_null=False)
remote_as = NestedASNSerializer(required=True, allow_null=False)
peer_group = NestedBGPPeerGroupSerializer(required=False, allow_null=True)
import_policies = SerializedPKRelatedField(
queryset=RoutingPolicy.objects.all(),
serializer=NestedRoutingPolicySerializer,
required=False,
allow_null=True,
many=True
)
export_policies = SerializedPKRelatedField(
queryset=RoutingPolicy.objects.all(),
serializer=NestedRoutingPolicySerializer,
required=False,
allow_null=True,
many=True
)
class Meta:
model = BGPSession
fields = '__all__'
def to_representation(self, instance):
ret = super().to_representation(instance)
if instance is not None:
if instance.peer_group:
for pol in instance.peer_group.import_policies.difference(instance.import_policies.all()):
ret['import_policies'].append(
NestedRoutingPolicySerializer(pol, context={'request': self.context['request']}).data
)
for pol in instance.peer_group.export_policies.difference(instance.export_policies.all()):
ret['export_policies'].append(
NestedRoutingPolicySerializer(pol, context={'request': self.context['request']}).data
)
return ret
class SecretSerializer(TaggitSerializer, CustomFieldModelSerializer):
device = NestedDeviceSerializer()
role = NestedSecretRoleSerializer()
plaintext = serializers.CharField()
tags = TagListSerializerField(required=False)
class Meta:
model = Secret
fields = [
'id',
'device',
'role',
'name',
'plaintext',
'hash',
'tags',
'custom_fields',
'created',
'last_updated',
]
validators = []
def validate(self, data):
# Encrypt plaintext data using the master key provided from the view context
if data.get('plaintext'):
s = Secret(plaintext=data['plaintext'])
s.encrypt(self.context['master_key'])
data['ciphertext'] = s.ciphertext
data['hash'] = s.hash
# Validate uniqueness of name if one has been provided.
if data.get('name'):
validator = UniqueTogetherValidator(queryset=Secret.objects.all(),
fields=('device', 'role',
'name'))
validator.set_context(self)
validator(data)
# Enforce model validation
super().validate(data)
return data
class BgpPeeringSerializer(serializers.ModelSerializer):
"""Serializer for the BgpPeering model."""
site = NestedSiteSerializer(
many=False,
read_only=False,
required=False,
help_text="BgpPeering Site",
)
device = NestedDeviceSerializer(
many=False,
read_only=False,
required=True,
help_text="BgpPeering Device",
)
local_ip = NestedIPAddressSerializer(
many=False,
read_only=False,
required=True,
help_text="Local peering IP",
)
class Meta:
model = BgpPeering
fields = [
"id",
"site",
"device",
"local_ip",
"local_as",
"remote_ip",
"remote_as",
"peer_name",
"description",
]
class SecretSerializer(TaggedObjectSerializer, CustomFieldModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='secrets-api:secret-detail')
device = NestedDeviceSerializer()
role = NestedSecretRoleSerializer()
plaintext = serializers.CharField()
class Meta:
model = Secret
fields = [
'id',
'url',
'device',
'role',
'name',
'plaintext',
'hash',
'tags',
'custom_fields',
'created',
'last_updated',
]
validators = []
def validate(self, data):
# Encrypt plaintext data using the master key provided from the view context
if data.get('plaintext'):
s = Secret(plaintext=data['plaintext'])
s.encrypt(self.context['master_key'])
data['ciphertext'] = s.ciphertext
data['hash'] = s.hash
super().validate(data)
return data
class DeviceExampleSerializer(serializers.ModelSerializer):
device = NestedDeviceSerializer()
class Meta:
model = DeviceExample
fields = ['id', 'device', 'name', 'value']
class BGPSessionSerializer(NetBoxModelSerializer):
status = ChoiceField(choices=SessionStatusChoices, required=False)
site = NestedSiteSerializer(required=False, allow_null=True)
tenant = NestedTenantSerializer(required=False, allow_null=True)
device = NestedDeviceSerializer(required=False, allow_null=True)
local_address = NestedIPAddressSerializer(required=True, allow_null=False)
remote_address = NestedIPAddressSerializer(required=True, allow_null=False)
local_as = NestedASNSerializer(required=True, allow_null=False)
remote_as = NestedASNSerializer(required=True, allow_null=False)
peer_group = NestedBGPPeerGroupSerializer(required=False, allow_null=True)
import_policies = SerializedPKRelatedField(
queryset=RoutingPolicy.objects.all(),
serializer=NestedRoutingPolicySerializer,
required=False,
allow_null=True,
many=True)
export_policies = SerializedPKRelatedField(
queryset=RoutingPolicy.objects.all(),
serializer=NestedRoutingPolicySerializer,
required=False,
allow_null=True,
many=True)
class Meta:
model = BGPSession
fields = '__all__'
validators = []
def validate(self, attrs):
qs = BGPSession.objects.filter(
device=attrs.get('device'),
local_as=attrs.get('local_as'),
local_address=attrs.get('local_address'),
remote_as=attrs.get('remote_as'),
remote_address=attrs.get('remote_address'),
)
if qs.exists():
raise ValidationError({
'error':
'BGP Session with this Device, Local address, Local AS, Remote address and Remote AS already exists.'
})
return attrs
def to_representation(self, instance):
ret = super().to_representation(instance)
if instance is not None:
if instance.peer_group:
for pol in instance.peer_group.import_policies.difference(
instance.import_policies.all()):
ret['import_policies'].append(
NestedRoutingPolicySerializer(
pol, context={
'request': self.context['request']
}).data)
for pol in instance.peer_group.export_policies.difference(
instance.export_policies.all()):
ret['export_policies'].append(
NestedRoutingPolicySerializer(
pol, context={
'request': self.context['request']
}).data)
return ret
