| |
| # Copyright 2017-present Open Networking Foundation |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| |
| from django.http import HttpResponseBadRequest |
| from rest_framework.response import Response |
| from rest_framework.views import APIView |
| from rest_framework import serializers, filters, status |
| from api.xosapi_helpers import PlusModelSerializer, XOSViewSet, ReadOnlyField |
| from services.metronetwork.models import * |
| from random import randint |
| import json |
| from django.core.exceptions import ObjectDoesNotExist |
| from django.core import serializers as jsonserializer |
| |
| class MetroNetworkSystemSerializer(PlusModelSerializer): |
| id = ReadOnlyField() |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| |
| class Meta: |
| model = MetroNetworkSystem |
| fields = ('humanReadableName', |
| 'id', |
| 'restUrl', |
| 'administrativeState', |
| 'operationalState') |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class MetroNetworkSystemViewSet(XOSViewSet): |
| base_name = "metronetworksystem" |
| method_name = "metronetworksystem" |
| method_kind = "viewset" |
| queryset = MetroNetworkSystem.objects.all() |
| serializer_class = MetroNetworkSystemSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(MetroNetworkSystemViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| |
| class NetworkEdgePortSerializer(PlusModelSerializer): |
| id = ReadOnlyField() |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| |
| class Meta: |
| model = NetworkEdgePort |
| fields = ('humanReadableName', |
| 'pid', |
| 'id', |
| 'element', |
| 'bwpCfgCbs', |
| 'bwpCfgEbs', |
| 'bwpCfgCir', |
| 'bwpCfgEir', |
| 'name', |
| 'location', |
| 'latlng') |
| |
| |
| def getHumanReadableName(self, obj): |
| return obj.id |
| |
| class NetworkEdgePortViewSet(XOSViewSet): |
| base_name = "UNI" |
| method_name = "UNI" |
| method_kind = "viewset" |
| queryset = NetworkEdgePort.objects.all() |
| serializer_class = NetworkEdgePortSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(NetworkEdgePortViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| class NetworkEdgeToEdgePointConnectionSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| uni1 = NetworkEdgePortSerializer(required=True, read_only=False) |
| uni2 = NetworkEdgePortSerializer(required=True, read_only=False) |
| |
| class Meta: |
| model = NetworkEdgeToEdgePointConnection |
| |
| fields = ('humanReadableName', |
| 'sid', |
| 'id', |
| 'type', |
| 'uni1', |
| 'uni2', |
| 'operstate', |
| 'adminstate' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.id |
| |
| class NetworkEdgeToEdgePointConnectionViewSet(XOSViewSet): |
| base_name = "ELINE" |
| method_name = "ELINE" |
| method_kind = "viewset" |
| queryset = NetworkEdgeToEdgePointConnection.get_service_objects().all() |
| serializer_class = NetworkEdgeToEdgePointConnectionSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(NetworkEdgeToEdgePointConnectionViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| def destroy(self, request, pk=None): |
| ELineConnectionToDelete = NetworkEdgeToEdgePointConnection.objects.get(pk=pk) |
| |
| if (ELineConnectionToDelete): |
| ELineConnectionToDelete.adminstate = 'deactivationrequested' |
| ELineConnectionToDelete.save() |
| else: |
| return Response(status=status.HTTP_400_BAD_REQUEST) |
| |
| return Response(status=status.HTTP_200_OK) |
| |
| |
| def create(self, validated_data): |
| |
| ELineConnection = NetworkEdgeToEdgePointConnection() |
| ELineConnection.sid = validated_data.data.get('sid') |
| ELineConnection.adminstate = validated_data.data.get('adminstate') |
| ELineConnection.operstate = validated_data.data.get('operstate') |
| ELineConnection.sid = validated_data.data.get('sid') |
| ELineConnection.type = 'Point_To_Point' |
| |
| uni1 = validated_data.data.get('uni1') |
| uni2 = validated_data.data.get('uni2') |
| |
| uni1 = NetworkEdgePort.objects.get(pk=uni1['id']) |
| uni2 = NetworkEdgePort.objects.get(pk=uni2['id']) |
| |
| ELineConnection.uni1 = uni1 |
| ELineConnection.uni2 = uni2 |
| ELineConnection.save() |
| |
| response_data = {} |
| response_data['sid'] = ELineConnection.sid |
| response_data['adminstate'] = ELineConnection.adminstate |
| response_data['operstate'] = ELineConnection.operstate |
| response_data['type'] = ELineConnection.type |
| |
| response_data['uni1'] = {} |
| response_data['uni1']['id'] = uni1.id |
| response_data['uni1']['pid'] = uni1.pid |
| response_data['uni1']['bwpCfgCbs'] = uni1.bwpCfgCbs |
| response_data['uni1']['bwpCfgEbs'] = uni1.bwpCfgEbs |
| response_data['uni1']['bwpCfgCir'] = uni1.bwpCfgCir |
| response_data['uni1']['bwpCfgEir'] = uni1.bwpCfgEir |
| response_data['uni1']['name'] = uni1.name |
| response_data['uni1']['location'] = uni1.location |
| response_data['uni1']['latlng'] = uni1.latlng |
| |
| response_data['uni2'] = {} |
| response_data['uni2']['id'] = uni2.id |
| response_data['uni2']['pid'] = uni2.pid |
| response_data['uni2']['bwpCfgCbs'] = uni2.bwpCfgCbs |
| response_data['uni2']['bwpCfgEbs'] = uni2.bwpCfgEbs |
| response_data['uni2']['bwpCfgCir'] = uni2.bwpCfgCir |
| response_data['uni2']['bwpCfgEir'] = uni2.bwpCfgEir |
| response_data['uni2']['name'] = uni1.name |
| response_data['uni2']['location'] = uni1.location |
| response_data['uni2']['latlng'] = uni1.latlng |
| |
| return Response(response_data) |
| |
| class NetworkEdgeToMultipointConnectionSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| root = NetworkEdgePortSerializer(required=True, read_only=False) |
| eps = NetworkEdgePortSerializer(required=True, read_only=False, many=True) |
| |
| class Meta: |
| model = NetworkEdgeToMultipointConnection |
| |
| fields = ('humanReadableName', |
| 'sid', |
| 'id', |
| 'type', |
| 'root', |
| 'eps', |
| 'operstate', |
| 'adminstate' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.id |
| |
| class NetworkEdgeToMultipointConnectionViewSet(XOSViewSet): |
| base_name = "ETREE" |
| method_name = "ETREE" |
| method_kind = "viewset" |
| queryset = NetworkEdgeToMultipointConnection.get_service_objects().all() |
| serializer_class = NetworkEdgeToMultipointConnectionSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(NetworkEdgeToMultipointConnectionViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| def destroy(self, request, pk=None): |
| ETreeConnectionToDelete = NetworkEdgeToMultipointConnection.objects.get(pk=pk) |
| |
| if (ETreeConnectionToDelete): |
| ETreeConnectionToDelete.adminstate = 'deactivationrequested' |
| ETreeConnectionToDelete.save() |
| else: |
| return Response(status=status.HTTP_400_BAD_REQUEST) |
| |
| return Response(status=status.HTTP_200_OK) |
| |
| def create(self, validated_data): |
| |
| ETreeConnection = NetworkEdgeToMultipointConnection() |
| ETreeConnection.sid = validated_data.data.get('sid') |
| ETreeConnection.adminstate = validated_data.data.get('adminstate') |
| ETreeConnection.operstate = validated_data.data.get('operstate') |
| ETreeConnection.sid = validated_data.data.get('sid') |
| ETreeConnection.type = 'Root_Multipoint' |
| |
| root_id = validated_data.data.get('root') |
| eps_list = validated_data.data.get('eps') |
| |
| root = NetworkEdgePort.objects.get(pk=root_id) |
| ETreeConnection.root = root |
| ETreeConnection.save() |
| |
| for ep in eps_list: |
| port = NetworkEdgePort.objects.get(pk=ep['id']) |
| ETreeConnection.eps.add(port) |
| |
| response_data = {} |
| response_data['sid'] = ETreeConnection.sid |
| response_data['adminstate'] = ETreeConnection.adminstate |
| response_data['operstate'] = ETreeConnection.operstate |
| response_data['type'] = ETreeConnection.type |
| |
| response_data['root'] = {} |
| response_data['root']['id'] = root.id |
| response_data['root']['pid'] = root.pid |
| response_data['root']['bwpCfgCbs'] = root.bwpCfgCbs |
| response_data['root']['bwpCfgEbs'] = root.bwpCfgEbs |
| response_data['root']['bwpCfgCir'] = root.bwpCfgCir |
| response_data['root']['bwpCfgEir'] = root.bwpCfgEir |
| response_data['root']['name'] = root.name |
| response_data['root']['location'] = root.location |
| response_data['root']['latlng'] = root.latlng |
| |
| eps_data = [] |
| for ep in ETreeConnection.eps.all(): |
| port = {} |
| port['id'] = ep.id |
| port['pid'] = ep.pid |
| port['bwpCfgCbs'] = ep.bwpCfgCbs |
| port['bwpCfgEbs'] = ep.bwpCfgEbs |
| port['bwpCfgCir'] = ep.bwpCfgCir |
| port['bwpCfgEir'] = ep.bwpCfgEir |
| port['name'] = ep.name |
| port['location'] = ep.location |
| port['latlng'] = ep.latlng |
| eps_data.append(port) |
| |
| response_data['eps'] = eps_data |
| |
| return Response(response_data) |
| |
| class NetworkMultipointToMultipointConnectionSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| eps = NetworkEdgePortSerializer(required=True, read_only=False, many=True) |
| |
| class Meta: |
| model = NetworkMultipointToMultipointConnection |
| |
| fields = ('humanReadableName', |
| 'sid', |
| 'id', |
| 'type', |
| 'eps', |
| 'operstate', |
| 'adminstate' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.id |
| |
| class NetworkMultipointToMultipointConnectionViewSet(XOSViewSet): |
| base_name = "ELAN" |
| method_name = "ELAN" |
| method_kind = "viewset" |
| queryset = NetworkMultipointToMultipointConnection.get_service_objects().all() |
| serializer_class = NetworkMultipointToMultipointConnectionSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(NetworkMultipointToMultipointConnectionViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| def destroy(self, request, pk=None): |
| ETreeConnectionToDelete = NetworkMultipointToMultipointConnection.objects.get(pk=pk) |
| |
| if (ETreeConnectionToDelete): |
| ETreeConnectionToDelete.adminstate = 'deactivationrequested' |
| ETreeConnectionToDelete.save() |
| else: |
| return Response(status=status.HTTP_400_BAD_REQUEST) |
| |
| return Response(status=status.HTTP_200_OK) |
| |
| def create(self, validated_data): |
| |
| ELanConnection = NetworkMultipointToMultipointConnection() |
| ELanConnection.sid = validated_data.data.get('sid') |
| ELanConnection.adminstate = validated_data.data.get('adminstate') |
| ELanConnection.operstate = validated_data.data.get('operstate') |
| ELanConnection.sid = validated_data.data.get('sid') |
| ELanConnection.type = 'Multipoint_To_Multipoint' |
| |
| eps_list = validated_data.data.get('eps') |
| ELanConnection.save() |
| |
| for ep in eps_list: |
| port = NetworkEdgePort.objects.get(pk=ep['id']) |
| ELanConnection.eps.add(port) |
| |
| response_data = {} |
| response_data['sid'] = ELanConnection.sid |
| response_data['adminstate'] = ELanConnection.adminstate |
| response_data['operstate'] = ELanConnection.operstate |
| response_data['type'] = ELanConnection.type |
| |
| eps_data = [] |
| for ep in ELanConnection.eps.all(): |
| port = {} |
| port['id'] = ep.id |
| port['pid'] = ep.pid |
| port['bwpCfgCbs'] = ep.bwpCfgCbs |
| port['bwpCfgEbs'] = ep.bwpCfgEbs |
| port['bwpCfgCir'] = ep.bwpCfgCir |
| port['bwpCfgEir'] = ep.bwpCfgEir |
| port['name'] = ep.name |
| port['location'] = ep.location |
| port['latlng'] = ep.latlng |
| eps_data.append(port) |
| |
| response_data['eps'] = eps_data |
| |
| return Response(response_data) |
| |
| ############################ |
| |
| class BandwidthProfileSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| |
| class Meta: |
| model = BandwidthProfile |
| |
| |
| fields = ('humanReadableName', |
| 'id', |
| 'bwpcfgcbs', |
| 'bwpcfgebs', |
| 'bwpcfgcir', |
| 'bwpcfgeir', |
| 'name' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class BandwidthProfileViewSet(XOSViewSet): |
| base_name = "BANDWIDTH_PROFILE" |
| method_name = "BANDWIDTH_PROFILE" |
| method_kind = "viewset" |
| queryset = BandwidthProfile.objects.all() |
| serializer_class = BandwidthProfileSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(BandwidthProfileViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| def create(self, validated_data): |
| |
| bandwidthProfile = BandwidthProfile() |
| bandwidthProfile.name = validated_data.data.get('name') |
| bandwidthProfile.bwpcfgcbs = validated_data.data.get('bwpcfgcbs') |
| bandwidthProfile.bwpcfgebs = validated_data.data.get('bwpcfgebs') |
| bandwidthProfile.bwpcfgcir = validated_data.data.get('bwpcfgcir') |
| bandwidthProfile.bwpcfgeir = validated_data.data.get('bwpcfgeir') |
| |
| bandwidthProfile.save() |
| |
| response_data = {} |
| response_data['name'] = bandwidthProfile.name |
| response_data['bwpcfgcbs'] = bandwidthProfile.bwpcfgcbs |
| response_data['bwpcfgebs'] = bandwidthProfile.bwpcfgebs |
| response_data['bwpcfgcir'] = bandwidthProfile.bwpcfgeir |
| response_data['bwpcfgcir'] = bandwidthProfile.bwpcfgcir |
| response_data['id'] = bandwidthProfile.id |
| |
| return Response(response_data) |
| |
| class UserNetworkInterfaceSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| |
| class Meta: |
| model = UserNetworkInterface |
| |
| fields = ('humanReadableName', |
| 'id', |
| 'bwpcfgcbs', |
| 'bwpcfgebs', |
| 'bwpcfgcir', |
| 'bwpcfgeir', |
| 'name' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class UserNetworkInterfaceViewSet(XOSViewSet): |
| base_name = "USER_NETWORK_INTERFACE" |
| method_name = "USER_NETWORK_INTERFACE" |
| method_kind = "viewset" |
| queryset = UserNetworkInterface.objects.all() |
| serializer_class = UserNetworkInterfaceSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(UserNetworkInterfaceViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| def create(self, validated_data): |
| |
| userNetworkInterface = UserNetworkInterface() |
| |
| userNetworkInterface.name = validated_data.data.get('name') |
| userNetworkInterface.capacity = validated_data.data.get('capacity') |
| userNetworkInterface.bw_used = validated_data.data.get('bw_used') |
| userNetworkInterface.vlanIds = validated_data.data.get('vlanIds') |
| userNetworkInterface.location = validated_data.data.get('location') |
| userNetworkInterface.latlng = validated_data.data.get('latlng') |
| |
| copyin_props = ['enabled', 'capacity', 'bw_used', 'vlanIds', 'location', 'latlng', 'name'] |
| |
| userNetworkInterface.save() |
| |
| response_data = {} |
| response_data['name'] = userNetworkInterface.name |
| response_data['capacity'] = userNetworkInterface.capacity |
| response_data['bw_used'] = userNetworkInterface.bw_used |
| response_data['vlanIds'] = userNetworkInterface.vlanIds |
| response_data['location'] = userNetworkInterface.location |
| response_data['latlng'] = userNetworkInterface.latlng |
| response_data['id'] = userNetworkInterface.id |
| |
| return Response(response_data) |
| |
| class VnodSiteSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| |
| class Meta: |
| model = Site |
| |
| fields = ('humanReadableName', |
| 'site_url', |
| 'enabled', |
| 'longitude', |
| 'latitude', |
| 'name' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class RemotePortSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| edgeport = NetworkEdgePortSerializer(read_only=True) |
| remoteportsite = VnodSiteSerializer(read_only=True) |
| |
| class Meta: |
| model = RemotePort |
| |
| fields = ('humanReadableName', |
| 'name', |
| 'edgeport', |
| 'id', |
| 'remoteportsite' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class ServiceSpokeSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| vnodlocalsite = VnodSiteSerializer(read_only=True) |
| vnodlocalport = RemotePortSerializer(read_only=True) |
| |
| class Meta: |
| model = ServiceSpoke |
| |
| fields = ('humanReadableName', |
| 'id', |
| 'name', |
| 'remotesubscriber', |
| 'remotevnodid', |
| 'autoattached', |
| 'operstate', |
| 'vnodlocalsite', |
| 'vnodlocalport' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class VnodGlobalServiceSerializer(PlusModelSerializer): |
| humanReadableName = serializers.SerializerMethodField("getHumanReadableName") |
| metronetworkroottomultipoint = NetworkEdgeToMultipointConnectionSerializer(read_only=True) |
| metronetworkmultipoint = NetworkMultipointToMultipointConnectionSerializer(read_only=True) |
| metronetworkpointtopoint = NetworkEdgeToEdgePointConnectionSerializer(read_only=True) |
| spokes = ServiceSpokeSerializer(read_only=True, many=True) |
| bandwidthProfile = BandwidthProfileSerializer(read_only=True) |
| |
| class Meta: |
| model = VnodGlobalService |
| |
| fields = ('humanReadableName', |
| 'servicehandle', |
| 'vlanid', |
| 'id', |
| 'type', |
| 'operstate', |
| 'adminstate', |
| 'metronetworkroottomultipoint', |
| 'metronetworkmultipoint', |
| 'metronetworkpointtopoint', |
| 'spokes', |
| 'bandwidthProfile', |
| 'name' |
| ) |
| |
| def getHumanReadableName(self, obj): |
| return obj.name |
| |
| class VnodGlobalServiceViewSet(XOSViewSet): |
| base_name = "VNOD_GLOBAL_SERVICE" |
| method_name = "VNOD_GLOBAL_SERVICE" |
| method_kind = "viewset" |
| queryset = VnodGlobalService.get_service_objects().all() |
| serializer_class = VnodGlobalServiceSerializer |
| |
| @classmethod |
| def get_urlpatterns(self, api_path="^"): |
| patterns = super(VnodGlobalServiceViewSet, self).get_urlpatterns(api_path=api_path) |
| |
| return patterns |
| |
| def list(self, request): |
| |
| object_list = self.filter_queryset(self.get_queryset()) |
| |
| serializer = self.get_serializer(object_list, many=True) |
| |
| return Response(serializer.data) |
| |
| def destroy(self, request, pk=None): |
| VnodGlobalServiceToDelete = VnodGlobalService.objects.get(pk=pk) |
| |
| if (VnodGlobalServiceToDelete): |
| VnodGlobalServiceToDelete.adminstate = 'deactivationrequested' |
| VnodGlobalServiceToDelete.save() |
| else: |
| return Response(status=status.HTTP_400_BAD_REQUEST) |
| |
| return Response(status=status.HTTP_200_OK) |
| |
| def create(self, validated_data): |
| |
| vnodGlobalService = VnodGlobalService() |
| |
| vnodGlobalService.name = validated_data.data.get('name') |
| |
| if VnodGlobalService.objects.filter( |
| name=vnodGlobalService.name).exists(): |
| return HttpResponseBadRequest('Error: VnodGlobalService name \'' + vnodGlobalService.name |
| + '\' already exists.') |
| |
| vnodGlobalService.servicehandle = validated_data.data.get('servicehandle') |
| vnodGlobalService.adminstate = 'enabled' |
| vnodGlobalService.operstate = 'inactive' |
| vnodGlobalService.type = validated_data.data.get('type') |
| |
| vnodGlobalService.vlanid = self.getUniqueVlandId() |
| |
| bandwidth_profile = validated_data.data.get('bandwidthProfile') |
| bandwidthprofile = BandwidthProfile.objects.get(pk=bandwidth_profile['id']) |
| if (bandwidth_profile): |
| vnodGlobalService.bandwidthProfile = bandwidthprofile |
| |
| vnodGlobalService.save() |
| |
| spokes_list = validated_data.data.get('spokes') |
| if (spokes_list is None): |
| vnodGlobalService.delete() |
| return HttpResponseBadRequest('Error: No spokes found in request.') |
| |
| for spoke in spokes_list: |
| vnodlocalsite = Site.objects.get(pk=spoke['vnodlocalsite']['id']) |
| servicespoke = ServiceSpoke() |
| servicespoke.vnodlocalsite = vnodlocalsite |
| servicespoke.vnodlocalport = self.getRandomRemotePort(vnodlocalsite) |
| servicespoke.name = spoke['name'] |
| if (spoke.get('autoattached')): |
| servicespoke.autoattached = spoke['autoattached'] |
| servicespoke.operstate = 'inactive' |
| servicespoke.adminstate = 'disabled' |
| servicespoke.save() |
| vnodGlobalService.spokes.add(servicespoke) |
| |
| serializer = self.get_serializer(vnodGlobalService) |
| return Response(serializer.data) |
| |
| def getUniqueVlandId(self): |
| unique = False |
| while not unique: |
| vlanid = randint(1, 4095) |
| vnodglobalservice = VnodGlobalService.get_service_objects().filter(vlanid=vlanid) |
| if (not vnodglobalservice): |
| unique = True |
| return vlanid |
| |
| def getRandomRemotePort(self, site): |
| remotePort = RemotePort.objects.get(remoteportsite__name=site.name) |
| if (remotePort): |
| return remotePort |
| return None |
| |
| @classmethod |
| def calculateVnodGlobalOperState(self, servicehandle): |
| vnodglobalservice = VnodGlobalService.get_service_objects().filter(servicehandle=servicehandle) |
| if (not vnodglobalservice): |
| HttpResponseBadRequest('Error: Could not find VnodGlobalObject with servicehandle=' + servicehandle) |
| |
| vnodglobalservice = vnodglobalservice[0] |
| all_spokes_active_and_enabled = True |
| |
| for spoke in vnodglobalservice.spokes.all(): |
| if (spoke.operstate != 'active' or spoke.adminstate != 'enabled'): |
| all_spokes_active_and_enabled = False |
| break; |
| |
| if (all_spokes_active_and_enabled): |
| vnodglobalservice.operstate = 'active' |
| else: |
| vnodglobalservice.operstate = 'inactive' |
| |
| vnodglobalservice.save() |
| return all_spokes_active_and_enabled |
| |
| @classmethod |
| def createService(self, servicehandle): |
| vnodglobalservice = VnodGlobalService.get_service_objects().filter(servicehandle=servicehandle) |
| if (not vnodglobalservice): |
| HttpResponseBadRequest('Error: Could not find VnodGlobalObject with servicehandle=' + servicehandle) |
| |
| vnodglobalservice = vnodglobalservice[0] |
| if (vnodglobalservice.type == 'eline'): |
| |
| spokes = vnodglobalservice.spokes.all() |
| uni1 = spokes[0].vnodlocalport.edgeport |
| uni2 = spokes[1].vnodlocalport.edgeport |
| name = 'ELine-' + str(vnodglobalservice.id) |
| type = 'Point_To_Point' |
| operstate = 'active' |
| adminstate = 'activationrequested' |
| |
| eline = NetworkEdgeToEdgePointConnection() |
| eline.name = name |
| eline.type = type |
| eline.operstate = operstate |
| eline.adminstate = adminstate |
| eline.vlanid = vnodglobalservice.vlanid |
| eline.sid = name |
| eline.uni1 = NetworkEdgePort.objects.get(pid=uni1.pid) |
| eline.uni2 = NetworkEdgePort.objects.get(pid=uni2.pid) |
| |
| eline.save() |
| vnodglobalservice.metronetworkpointtopoint = eline |
| vnodglobalservice.save() |
| |
| elif (vnodglobalservice.type == 'elan'): |
| |
| spokes = vnodglobalservice.spokes.all() |
| |
| name = 'ELAN-' + str(vnodglobalservice.id) |
| type = 'Multipoint_To_Multipoint' |
| operstate = 'active' |
| adminstate = 'activationrequested' |
| |
| elan = NetworkMultipointToMultipointConnection() |
| elan.name = name |
| elan.type = type |
| elan.operstate = 'inactive' |
| elan.adminstate = 'disabled' |
| elan.vlanid = vnodglobalservice.vlanid |
| elan.save() |
| |
| for spoke in spokes: |
| uni = NetworkEdgePort.objects.get(pid=spoke.vnodlocalport.edgeport.pid) |
| elan.eps.add(uni) |
| |
| elan.operstate = operstate |
| elan.adminstate = adminstate |
| elan.save() |
| |
| vnodglobalservice.metronetworkmultipoint = elan |
| vnodglobalservice.save() |
| |
| # TODO: elif (vnodglobalservice.type == 'etree'): |
| |
| class VnodGlobalServiceAutoAttachmentView(APIView): |
| method_kind = "list" |
| method_name = "vnodglobal_api_autoattach" |
| |
| def get(self, request, format=None): |
| params = request.query_params |
| sitename = params.get('sitename') |
| |
| if ( sitename is None): |
| HttpResponseBadRequest("Error: Request requires] 'sitename' as a query param.") |
| |
| vnodglobalservices = VnodGlobalService.get_service_objects().filter(spokes__autoattached=True, |
| spokes__operstate='inactive', |
| spokes__vnodlocalsite__name=sitename) |
| |
| if (not vnodglobalservices): |
| HttpResponseBadRequest({"handles" : []}) |
| |
| handles = [] |
| for vnodglobalservice in vnodglobalservices: |
| if (vnodglobalservice.adminstate != 'disabled'): |
| handles.append(vnodglobalservice.servicehandle) |
| |
| response_data = {'servicehandles' : handles} |
| return Response(response_data) |
| |
| class VnodGlobalServiceConfigurationView(APIView): |
| method_kind = "list" |
| method_name = "vnodglobal_api_configuration" |
| |
| def get(self, request, format=None): |
| params = request.query_params |
| servicehandle = params.get('servicehandle') |
| sitename = params.get('sitename') |
| |
| if (servicehandle is None or sitename is None): |
| HttpResponseBadRequest("Error: Request requires 'servicehandle' and 'sitename' as query params.") |
| |
| vnodglobalservice = VnodGlobalService.get_service_objects().filter(servicehandle=servicehandle) |
| if (not vnodglobalservice): |
| HttpResponseBadRequest('Error: Could not find VnodGlobalObject with servicehandle=' + servicehandle) |
| |
| vnodglobalservice = vnodglobalservice[0] |
| response_data = {} |
| response_data['vlanid'] = vnodglobalservice.vlanid |
| |
| for spoke in vnodglobalservice.spokes.all(): |
| if (spoke.vnodlocalsite.name == sitename and spoke.adminstate != 'configured'): |
| response_data['port'] = {} |
| response_data['port']['name'] = spoke.vnodlocalport.name |
| break; |
| |
| return Response(response_data) |
| |
| class VnodGlobalServiceActivationView(APIView): |
| method_kind = "list" |
| method_name = "vnodglobal_api_activation" |
| |
| def post(self, request, format=None): |
| body_json = request.body |
| body = json.loads(body_json) |
| |
| servicehandle=body['servicehandle'] |
| sitename=body['sitename'] |
| activate = body['activate'] |
| vnodlocalid = body['vnodlocalid'] |
| portid = body.get('portid') |
| |
| if (activate == 'true' or activate == 'True'): |
| isActivate = True |
| else: |
| isActivate = False |
| |
| vnodglobalservice = VnodGlobalService.get_service_objects().filter(servicehandle=servicehandle) |
| if (not vnodglobalservice): |
| HttpResponseBadRequest('Error: Could not find VnodGlobalObject with servicehandle=' + servicehandle) |
| |
| vnodglobalservice = vnodglobalservice[0] |
| |
| for spoke in vnodglobalservice.spokes.all(): |
| if (spoke.vnodlocalsite.name == sitename and spoke.vnodlocalport.name == portid): |
| spoke_id = spoke.id |
| servicespoke = ServiceSpoke.objects.get(id=spoke_id) |
| servicespoke.remotevnodid = vnodlocalid |
| servicespoke.save() |
| break; |
| |
| return Response() |
| |
| class VnodGlobalServiceAdminOperationalStateView(APIView): |
| method_kind = "list" |
| method_name = "vnodglobal_api_status" |
| |
| def post(self, request, format=None): |
| body_json = request.body |
| body = json.loads(body_json) |
| |
| servicehandle = body['servicehandle'] |
| sitename = body['sitename'] |
| operstate = body.get('operstate') |
| adminstate = body.get('adminstate') |
| portid = body.get('portid') |
| |
| vnodglobalservice = VnodGlobalService.get_service_objects().filter(servicehandle=servicehandle) |
| if (not vnodglobalservice): |
| HttpResponseBadRequest('Error: Could not find VnodGlobalObject with servicehandle=' + servicehandle) |
| |
| vnodglobalservice = vnodglobalservice[0] |
| |
| for spoke in vnodglobalservice.spokes.all(): |
| if (spoke.vnodlocalsite.name == sitename and spoke.vnodlocalport.name == portid): |
| spoke_id = spoke.id |
| servicespoke = ServiceSpoke.objects.get(id=spoke_id) |
| if (operstate): |
| servicespoke.operstate = operstate |
| if (adminstate): |
| servicespoke.adminstate = adminstate |
| servicespoke.save() |
| break; |
| |
| isGlobalActive = VnodGlobalServiceViewSet.calculateVnodGlobalOperState(servicehandle=servicehandle) |
| |
| if (vnodglobalservice.metronetworkmultipoint is None and vnodglobalservice.metronetworkpointtopoint is None and |
| vnodglobalservice.metronetworkroottomultipoint is None and isGlobalActive): |
| VnodGlobalServiceViewSet.createService(servicehandle=servicehandle) |
| |
| return Response() |