| |
| # 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. |
| |
| |
| import random |
| import json |
| |
| from xos.logger import Logger, logging |
| from services.metronetwork.models import * |
| from core.models import Site |
| from synchronizers.metronetwork.providers.metronetworkprovider import MetroNetworkProvider |
| |
| logger = Logger(level=logging.INFO) |
| |
| |
| class MetroNetworkTestProvider(MetroNetworkProvider): |
| def __init__(self, networkdevice, **args): |
| MetroNetworkProvider.__init__(self, networkdevice, **args) |
| |
| # Method for retrieving all network ports from the backend system |
| def get_network_ports(self): |
| # |
| # Our Test Network Consists of one NetworkDevice (which correspond to ONOS instance): |
| # |
| # 8 Ports |
| # 1 Eline (2 ports) |
| # 1 Etree (3 ports) |
| # 1 Elan (3 ports) |
| # |
| # 2 Sites - Representing Two R-CORD Pods |
| # 2 Ports, One-per-site |
| # 1 Bandwidth Profile |
| # 2 Service Spokes |
| # 1 VnodGlobalService |
| |
| objs = [] |
| |
| # For The Test Provider we don't handle re-sync for anything but the Metro Test Network |
| if self.networkdevice.id != 'TestMetroNet': |
| return objs |
| |
| # Set the parent device id to just be the Test NetworkDevice |
| device1 = NetworkDevice() |
| device1.id = self.networkdevice.id |
| |
| port1 = NetworkEdgePort() |
| port1.element = device1 |
| port1.pid = device1.id + "." + "of:000000001/1" |
| port1.bwpCfgCbs = 1000000 |
| port1.bwpCfgEbs = 1000000 |
| port1.bwpCfgEir = 1000000 |
| port1.bwpCfgCir = 1000000 |
| port1.location = "San Francisco" |
| port1.name = "Central Office 1" |
| port1.latlng = "[-122.419416, 37.774929]" |
| objs.append(port1) |
| |
| port2 = NetworkEdgePort() |
| port2.element = device1 |
| port2.pid = device1.id + "." + "of:000000001/2" |
| port2.bwpCfgCbs = 1000000 |
| port2.bwpCfgEbs = 1000000 |
| port2.bwpCfgEir = 1000000 |
| port2.bwpCfgCir = 1000000 |
| port2.location = "San Jose" |
| port2.name = "Central Office 2" |
| port2.latlng = "[-121.886329, 37.338208]" |
| objs.append(port2) |
| |
| port3 = NetworkEdgePort() |
| port3.element = device1 |
| port3.pid = device1.id + "." + "of:000000001/3" |
| port3.bwpCfgCbs = 1000000 |
| port3.bwpCfgEbs = 1000000 |
| port3.bwpCfgEir = 1000000 |
| port3.bwpCfgCir = 1000000 |
| port3.location = "Palo Alto" |
| port3.name = "Central Office 3" |
| port3.latlng = "[-122.143019, 37.441883]" |
| objs.append(port3) |
| |
| port4 = NetworkEdgePort() |
| port4.element = device1 |
| port4.pid = device1.id + "." + "of:000000001/4" |
| port4.bwpCfgCbs = 1000000 |
| port4.bwpCfgEbs = 1000000 |
| port4.bwpCfgEir = 1000000 |
| port4.bwpCfgCir = 1000000 |
| port4.location = "Oakland" |
| port4.name = "Central Office 4" |
| port4.latlng = "[-122.271114, 37.804364]" |
| objs.append(port4) |
| |
| port5 = NetworkEdgePort() |
| port5.element = device1 |
| port5.pid = device1.id + "." + "of:000000001/5" |
| port5.bwpCfgCbs = 1000000 |
| port5.bwpCfgEbs = 1000000 |
| port5.bwpCfgEir = 1000000 |
| port5.bwpCfgCir = 1000000 |
| port5.location = "San Rafael" |
| port5.name = "Central Office 5" |
| port5.latlng = "[-122.531087, 37.973535]" |
| objs.append(port5) |
| |
| port6 = NetworkEdgePort() |
| port6.element = device1 |
| port6.pid = device1.id + "." + "of:000000001/6" |
| port6.bwpCfgCbs = 1000000 |
| port6.bwpCfgEbs = 1000000 |
| port6.bwpCfgEir = 1000000 |
| port6.bwpCfgCir = 1000000 |
| port6.location = "San Mateo" |
| port6.name = "Central Office 6" |
| port6.latlng = "[-122.325525, 37.562992]" |
| objs.append(port6) |
| |
| port7 = NetworkEdgePort() |
| port7.element = device1 |
| port7.pid = device1.id + "." + "of:000000001/7" |
| port7.bwpCfgCbs = 1000000 |
| port7.bwpCfgEbs = 1000000 |
| port7.bwpCfgEir = 1000000 |
| port7.bwpCfgCir = 1000000 |
| port7.location = "Hayward" |
| port7.name = "Central Office 7" |
| port7.latlng = "[-122.080796, 37.668821]" |
| objs.append(port7) |
| |
| port8 = NetworkEdgePort() |
| port8.element = device1 |
| port8.pid = device1.id + "." + "of:000000001/8" |
| port8.bwpCfgCbs = 1000000 |
| port8.bwpCfgEbs = 1000000 |
| port8.bwpCfgEir = 1000000 |
| port8.bwpCfgCir = 1000000 |
| port8.location = "Fremont" |
| port8.name = "Central Office 8" |
| port8.latlng = "[-121.988572, 37.548270]" |
| objs.append(port8) |
| |
| return objs |
| |
| def get_network_ports_for_deletion(self): |
| |
| objs = [] |
| |
| # For The Test Provider we don't handle re-sync for anything but the Metro Test Network |
| if self.networkdevice.id != 'TestMetroNet': |
| return objs |
| |
| allports = MetroNetworkProvider.get_network_ports_for_deletion(self) |
| |
| for port in allports: |
| objs.append(port) |
| |
| return objs |
| |
| def get_network_links(self): |
| |
| objs = [] |
| |
| # Connectivity object - Point to Point |
| cordpod1device = NetworkDevice() |
| cordpod1device.id = self.networkdevice.id |
| |
| # Edge to Edge Point Connectivity Objects |
| edgetoedgeconnectivity = NetworkEdgeToEdgePointConnection() |
| edgetoedgeconnectivity.uni1_createbuffer = cordpod1device.id + "." + "of:000000001/1" |
| edgetoedgeconnectivity.uni2_createbuffer = cordpod1device.id + "." + "of:000000001/2" |
| edgetoedgeconnectivity.type = 'direct' |
| edgetoedgeconnectivity.operstate = 'active' |
| edgetoedgeconnectivity.adminstate = 'enabled' |
| edgetoedgeconnectivity.sid = 'EdgeToEdgePointConnectivity_1' |
| objs.append(edgetoedgeconnectivity) |
| |
| |
| # Multipoint to Multipoint Connectivity Objects |
| multipoint2multipointconnectivity=NetworkMultipointToMultipointConnection() |
| multipoint2multipointconnectivity.operstate = 'active' |
| multipoint2multipointconnectivity.adminstate = 'enabled' |
| multipoint2multipointconnectivity.type = 'ethernet' |
| multipoint2multipointconnectivity.sid = 'MultipointToMultipointConnectivity_1' |
| |
| # |
| # Create JSON array for post-save behaviour |
| # |
| eps = [] |
| eps.append(cordpod1device.id + "." + "of:000000001/3") |
| eps.append(cordpod1device.id + "." + "of:000000001/4") |
| eps.append(cordpod1device.id + "." + "of:000000001/5") |
| |
| myjsonstr = {'eps': eps, 'foo':0, 'bar':0} |
| multipoint2multipointconnectivity.eps_createbuffer = json.dumps(myjsonstr) |
| objs.append(multipoint2multipointconnectivity) |
| |
| # Edge to Multipoint Connectivity Objects |
| edge2multipointconnectivity = NetworkEdgeToMultipointConnection() |
| edge2multipointconnectivity.operstate = 'active' |
| edge2multipointconnectivity.adminstate = 'enabled' |
| edge2multipointconnectivity.type = 'ethernet' |
| edge2multipointconnectivity.sid = 'EdgeToMultipointConnectivity_1' |
| edge2multipointconnectivity.root_createbuffer = cordpod1device.id + "." + "of:000000001/7" |
| # |
| # Create JSON array for post-save behaviour |
| # |
| eps = [] |
| eps.append(cordpod1device.id + "." + "of:000000001/6") |
| eps.append(cordpod1device.id + "." + "of:000000001/8") |
| |
| myjsonstr = {'eps': eps, 'foo': 0, 'bar': 0} |
| edge2multipointconnectivity.eps_createbuffer = json.dumps(myjsonstr) |
| objs.append(edge2multipointconnectivity) |
| |
| # Create Objects for VnodGlobal Sort of Testing |
| |
| # Bandwidth Profile |
| |
| bwprofile = BandwidthProfile() |
| bwprofile.bwpcfgcbs = 0 |
| bwprofile.bwpcfgcir = 0 |
| bwprofile.bwpcfgebs = 0 |
| bwprofile.bwpcfgeir = 0 |
| bwprofile.name = 'TestBWP' |
| objs.append(bwprofile) |
| |
| # Two Sites |
| site1 = Site() |
| site1.name = 'CORDPod1' |
| site1.login_base = 'CordPod1' |
| site1.site_url = 'http://1.2.3.4:8080/VnodLocalApi' |
| objs.append(site1) |
| |
| site2 = Site() |
| site2.name = 'CORDPod2' |
| site2.login_base = 'CordPod2' |
| site2.site_url = 'http://10.11.12.13:8080/VnodLocalApi' |
| objs.append(site2) |
| |
| # Two Ports - one per Site |
| |
| remoteport1 = RemotePort() |
| remoteport1.name = "CORDPOD1:Port1" |
| remoteport1.sitename = 'CordPod1' |
| remoteport1.edgeportname = cordpod1device.id + "." + "of:000000001/1" |
| objs.append(remoteport1) |
| |
| remoteport2 = RemotePort() |
| remoteport2.name = "CORDPOD2:Port1" |
| remoteport2.sitename = 'CordPod2' |
| remoteport2.edgeportname = cordpod1device.id + "." + "of:000000001/2" |
| objs.append(remoteport2) |
| |
| # One Spoke/Site |
| spoke1 = ServiceSpoke() |
| spoke1.name = 'TestSpoke1' |
| spoke1.remoteportname = "CORDPOD1:Port1" |
| spoke1.remotevnodid = 'CORDPod1:VnodLocal:1' |
| spoke1.operstate = 'inactive' |
| spoke1.adminstate = 'enabled' |
| spoke1.sitename = 'CordPod1' |
| objs.append(spoke1) |
| |
| spoke2 = ServiceSpoke() |
| spoke2.name = 'TestSpoke2' |
| spoke2.remoteportname = "CORDPOD2:Port1" |
| spoke2.remotevnodid = 'CORDPod2:VnodLocal:1' |
| spoke2.operstate = 'active' |
| spoke2.adminstate = 'enabled' |
| spoke2.sitename = 'CordPod2' |
| objs.append(spoke2) |
| |
| # One VnodGlobal Service |
| vnodglobal = VnodGlobalService() |
| vnodglobal.name = 'VnodGlobalPtToPtTest1' |
| vnodglobal.type = 'eline' |
| vnodglobal.vlanid = '100' |
| vnodglobal.operstate = 'active' |
| vnodglobal.adminstate = 'enabled' |
| vnodglobal.servicehandle = 'testhandle1' |
| vnodglobal.pointtopointsid = 'onos_eline_id' |
| vnodglobal.bwpname = 'TestBWP' |
| |
| # Create JSON array for post-save behaviour |
| # |
| spokes = ['TestSpoke1', 'TestSpoke2'] |
| myjsonstr = {'spokes': spokes} |
| vnodglobal.spokes_createbuffer = json.dumps(myjsonstr) |
| objs.append(vnodglobal) |
| |
| return objs |
| |
| def get_network_links_for_deletion(self): |
| |
| # For now we'll rely on cascade deletes in the port area - so from the test provider nothing to do |
| objs = [] |
| return objs |
| |
| def create_point_to_point_connectivity(self, obj): |
| |
| # Ok - here is what we'll do to simulate the 'real world' - get a random number between 1 and 10 |
| # 1-7 is considered 'successful' 8 is considered a transient error - 9 is a configuration problem |
| # 10 is a - resource exhausted problem - there you go!! |
| scenario = random.randint(1, 10) |
| |
| if (scenario >= 1 and scenario <= 7): |
| obj.adminstate = 'enabled' |
| obj.operstate = 'active' |
| return True |
| elif (scenario == 8): |
| obj.adminstate = 'enabled' |
| obj.operstate = 'inactive' |
| obj.backend_status = '8 - Transient Server Error' |
| return False |
| elif (scenario == 9): |
| obj.adminstate = 'invalid' |
| obj.operstate = 'inactive' |
| obj.backend_status = '9 - Configuration Error' |
| return False |
| else: |
| obj.adminstate = 'enabled' |
| obj.operstate = 'inactive' |
| obj.backend_status = '10 - Resource Exhaustion' |
| return False |
| |
| def delete_point_to_point_connectivity(self, obj): |
| |
| # Ok - here is what we'll do to simulate the 'real world' - get a random number between 1 and 10 |
| # 1-8 is considered 'successful' 8 is considered a transient error - 9 is a configuration problem |
| scenario = random.randint(1, 10) |
| |
| if (scenario >= 1 and scenario <= 8): |
| obj.adminstate = 'disabled' |
| obj.operstate = 'inactive' |
| return True |
| elif (scenario == 9): |
| obj.adminstate = 'disabled' |
| obj.backend_status = '8 - Transient Server Error' |
| return False |
| else: |
| obj.adminstate = 'invalid' |
| obj.backend_status = '9 - Configuration Error' |
| return False |