Nokia: Putting in support for metro network services within XOS for E-CORD
Change-Id: Idbc7e09ca53b0d9705d24bf1730fd9b05347a241
diff --git a/xos/synchronizer/providers/__init__.py b/xos/synchronizer/providers/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/xos/synchronizer/providers/__init__.py
@@ -0,0 +1 @@
+
diff --git a/xos/synchronizer/providers/metronetworkprovider.py b/xos/synchronizer/providers/metronetworkprovider.py
new file mode 100644
index 0000000..db651c3
--- /dev/null
+++ b/xos/synchronizer/providers/metronetworkprovider.py
@@ -0,0 +1,95 @@
+from xos.logger import Logger, logging
+from core.models.netw import *
+
+logger = Logger(level=logging.INFO)
+
+
+class MetroNetworkProvider(object):
+ networkdevice = None
+
+ def __init__(self, networkdevice, **args):
+ self.networkdevice = networkdevice
+ pass
+
+ # Methods to support for Synchronization - effectively list all interfaces
+ #
+ # Method for retrieving all network ports from the backend system
+ # Intended for use when doing a re-sync
+ def get_network_ports(self):
+ # Default method needs to be overriden
+ logger.debug("get_network_ports default called - should be overriden")
+
+ # Method for getting a list of network ports to delete
+ # The default imnplementation just gets a list from the local DB
+ # Intended for use when doing a re-sync
+ def get_network_ports_for_deletion(self):
+ # Default method needs to be overriden
+ logger.debug("get_network_ports for deletion called - default is all ports in the db related to this id")
+ objs = []
+ # ports = NetworkPort.objects.filter(networkdevice=self.networkdevice.id)
+ ports = NetworkPort.objects.all()
+ for port in ports:
+ objs.append(port)
+
+ return objs
+
+ # Method for retrieving all network links from the backend system
+ # Includes Connectivity Objects
+ # Intended for use when doing a re-sync
+ def get_network_links(self):
+ # Default method needs to be overriden
+ logger.debug("get_network_links default called - should be overriden")
+ objs = []
+ return objs
+
+ # Method for getting a list of network links to delete
+ # Includes Connectivity Objects
+ # Intended for use when doing a re-sync
+ def get_network_links_for_deletion(self):
+ # Default method needs to be overriden
+ logger.debug("get_network_links for deletion called - should be overidden")
+ objs = []
+ return objs
+
+ # Methods to support Event Management - movement of changes from the Domain to XOS
+ #
+ # Method for Create and Update - Create and Update are together given the base design
+ def get_updated_or_created_objects(self):
+ # Default method needs to be overriden
+ logger.debug("get_updated_or_created_objects default called - should be overriden")
+ objs = []
+ return objs
+
+ # Method for Delete - Create and Update are together given the base design
+ def get_deleted_objects(self):
+ # Default method needs to be overriden
+ logger.debug("get_deleted_objects default called - should be overriden")
+ objs = []
+ return objs
+
+ # Methods to support Movement of changes from XOS into the Domain
+ #
+ # Method for creating point to point connectivity object
+ #
+ # obj - Connection object - with all configuration variables set
+ # returns - Boolean - indicating whether or not the request succeeded - in either case the Admin/Oper
+ # states are assigned - if False the backend_status field
+ # should be assigned with the appropriate error code - in the case of True the
+ # backend_status will be assigned by the system and should be unassigned
+
+ def create_point_to_point_connectivity(self, obj):
+ # Default method needs to be overriden
+ logger.debug("create_point_to_point_connectivity called - should be overriden")
+ return False
+
+ # Method for deleting point to point connectivity object
+ #
+ # obj - Connection object
+ # returns - Boolean - indicating whether or not the request succeeded - in either case the Admin/Oper
+ # states are assigned - if False the backend_status field
+ # should be assigned with the appropriate error code - in the case of True the
+ # backend_status will be assigned by the system and should be unassigned
+ def delete_point_to_point_connectivity(self, obj):
+ # Default method needs to be overriden
+ logger.debug("delete_point_to_point_connectivity called - should be overriden")
+ return False
diff --git a/xos/synchronizer/providers/metronetworkrestprovider.py b/xos/synchronizer/providers/metronetworkrestprovider.py
new file mode 100644
index 0000000..fa9ef71
--- /dev/null
+++ b/xos/synchronizer/providers/metronetworkrestprovider.py
@@ -0,0 +1,232 @@
+from xos.logger import Logger, logging
+from core.models.netw import *
+from synchronizers.metronetwork.providers.metronetworkprovider import MetroNetworkProvider
+
+import requests, json
+from requests.auth import HTTPBasicAuth
+
+logger = Logger(level=logging.INFO)
+
+
+class MetroNetworkRestProvider(MetroNetworkProvider):
+ def __init__(self, networkdevice, **args):
+ MetroNetworkProvider.__init__(self, networkdevice, **args)
+
+ def get_network_ports(self):
+
+ objs = []
+
+ restCtrlUrl = self.networkdevice.restCtrlUrl
+ username = self.networkdevice.username
+ password = self.networkdevice.password
+
+ resp = requests.get("{}/mef-sca-api/SCA_ETH_FPP_UNI_N".format(restCtrlUrl),
+ auth=HTTPBasicAuth(username, password))
+
+ if resp.status_code == 200:
+ for uni in resp.json():
+ hostname = uni['transportPort']['Hostname']
+ port = uni['transportPort']['Port']
+
+ # Default values
+ bwpCfgCbs = 0
+ bwpCfgEbs = 0
+ bwpCfgCir = 0
+ bwpCfgEir = 0
+
+ if 'interfaceCfgIngressBwp' in uni:
+ bwpCfgCbs = uni['interfaceCfgIngressBwp']['bwpCfgCbs']
+ bwpCfgEbs = uni['interfaceCfgIngressBwp']['bwpCfgEbs']
+ bwpCfgCir = uni['interfaceCfgIngressBwp']['bwpCfgCir']
+ bwpCfgEir = uni['interfaceCfgIngressBwp']['bwpCfgEir']
+
+ uniPort = NetworkEdgePort()
+ uniPort.element = self.networkdevice
+ uniPort.pid = "{}.{}/{}".format(self.networkdevice.id, hostname, port)
+ uniPort.bwpCfgCbs = bwpCfgCbs
+ uniPort.bwpCfgEbs = bwpCfgEbs
+ uniPort.bwpCfgCir = bwpCfgCir
+ uniPort.bwpCfgEir = bwpCfgEir
+
+ objs.append(uniPort)
+
+ return objs
+
+ else:
+ raise Exception("OnosApiError: get_network_ports()")
+
+ def get_network_links(self):
+
+ objs = []
+
+ restCtrlUrl = self.networkdevice.restCtrlUrl
+ username = self.networkdevice.username
+ password = self.networkdevice.password
+
+ resp = requests.get("{}/mef-sca-api/SCA_ETH_FDFr_EC/findByState?state=Active".format(restCtrlUrl),
+ auth=HTTPBasicAuth(username, password))
+
+ if resp.status_code == 200:
+ for evc in resp.json():
+ id = evc['id']
+ evcServiceType = evc['evcServiceType']
+
+ if (evcServiceType == "Point_To_Point"):
+ uni1 = evc['SCA_ETH_Flow_Points'][0]
+ hostname = uni1['scaEthFppUniN']['transportPort']['Hostname']
+ port = uni1['scaEthFppUniN']['transportPort']['Port']
+
+ if 'interfaceCfgIngressBwp' in uni1['scaEthFppUniN']:
+ bwpCfgCbs = uni1['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgCbs']
+ bwpCfgEbs = uni1['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgEbs']
+ bwpCfgCir = uni1['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgCir']
+ bwpCfgEir = uni1['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgEir']
+
+ edgePort1 = NetworkEdgePort()
+ edgePort1.element = self.networkdevice
+ edgePort1.pid = "{}.{}/{}".format(self.networkdevice.id, hostname, port)
+ edgePort1.bwpCfgCbs = bwpCfgCbs
+ edgePort1.bwpCfgEbs = bwpCfgEbs
+ edgePort1.bwpCfgCir = bwpCfgCir
+ edgePort1.bwpCfgEir = bwpCfgEir
+
+ uni2 = evc['SCA_ETH_Flow_Points'][1]
+ hostname = uni2['scaEthFppUniN']['transportPort']['Hostname']
+ port = uni2['scaEthFppUniN']['transportPort']['Port']
+
+ if 'interfaceCfgIngressBwp' in uni1['scaEthFppUniN']:
+ bwpCfgCbs = uni2['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgCbs']
+ bwpCfgEbs = uni2['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgEbs']
+ bwpCfgCir = uni2['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgCir']
+ bwpCfgEir = uni2['scaEthFppUniN']['interfaceCfgIngressBwp']['bwpCfgEir']
+
+ edgePort2 = NetworkEdgePort()
+ edgePort2.element = self.networkdevice
+ edgePort2.pid = "{}.{}/{}".format(self.networkdevice.id, hostname, port)
+ edgePort2.bwpCfgCbs = bwpCfgCbs
+ edgePort2.bwpCfgEbs = bwpCfgEbs
+ edgePort2.bwpCfgCir = bwpCfgCir
+ edgePort2.bwpCfgEir = bwpCfgEir
+
+ edgeToEdgeConnectivity = NetworkEdgeToEdgePointConnection()
+ edgeToEdgeConnectivity.sid = id
+ edgeToEdgeConnectivity.type = evcServiceType
+ edgeToEdgeConnectivity.uni1 = edgePort1
+ edgeToEdgeConnectivity.uni2 = edgePort2
+ edgeToEdgeConnectivity.operstate = "active"
+ edgeToEdgeConnectivity.adminstate = "enabled"
+
+ objs.append(edgeToEdgeConnectivity)
+
+ return objs
+
+ else:
+ raise Exception("OnosApiError: get_network_links()")
+
+ def create_point_to_point_connectivity(self, obj):
+
+ restCtrlUrl = self.networkdevice.restCtrlUrl
+ username = self.networkdevice.username
+ password = self.networkdevice.password
+
+ evcServiceType = obj.type
+ # evcServiceType = "Point_To_Point"
+
+ uni1 = obj.uni1
+ uni1Id = uni1.pid
+ uni1IdToken = (uni1Id.split('.', 1))[1].split('/', 1)
+ uni1Hostname = uni1IdToken[0]
+ uni1Port = uni1IdToken[1]
+ uni1BwpCfgCbs = uni1.bwpCfgCbs
+ uni1BwpCfgEbs = uni1.bwpCfgEbs
+ uni1BwpCfgCir = uni1.bwpCfgCir
+ uni1BwpCfgEir = uni1.bwpCfgEir
+
+ uni2 = obj.uni2
+ uni2Id = uni2.pid
+ uni2IdToken = (uni2Id.split('.', 1))[1].split('/', 1)
+ uni2Hostname = uni2IdToken[0]
+ uni2Port = uni2IdToken[1]
+ uni2BwpCfgCbs = uni2.bwpCfgCbs
+ uni2BwpCfgEbs = uni2.bwpCfgEbs
+ uni2BwpCfgCir = uni2.bwpCfgCir
+ uni2BwpCfgEir = uni2.bwpCfgEir
+
+ data = {
+ "evcServiceType": evcServiceType,
+ "SCA_ETH_Flow_Points": [
+ {
+ "scaEthFppUniN": {"transportPort": {"Hostname": uni1Hostname, "Port": uni1Port},
+ "interfaceCfgIngressBwp": {"bwpCfgCbs": uni1BwpCfgCbs,
+ "bwpCfgEbs": uni1BwpCfgEbs,
+ "bwpCfgCir": uni1BwpCfgCir,
+ "bwpCfgEir": uni1BwpCfgEir}}},
+ {
+ "scaEthFppUniN": {"transportPort": {"Hostname": uni2Hostname, "Port": uni2Port},
+ "interfaceCfgIngressBwp": {"bwpCfgCbs": uni2BwpCfgCbs,
+ "bwpCfgEbs": uni2BwpCfgEbs,
+ "bwpCfgCir": uni2BwpCfgCir,
+ "bwpCfgEir": uni2BwpCfgEir}}}]
+ }
+
+ headers = {'Content-Type': 'application/json'}
+
+ resp = requests.post('{}/mef-sca-api/SCA_ETH_FDFr_EC'.format(restCtrlUrl),
+ data=json.dumps(data), headers=headers, auth=HTTPBasicAuth(username, password))
+
+ if resp.status_code == 201:
+ result = resp.json()
+ message = result['message']
+
+ msg_token = message.split()
+ for i, token in enumerate(msg_token):
+ if token == 'id':
+ service_id = msg_token[i + 1]
+ obj.sid = service_id
+ obj.adminstate = "enabled"
+ obj.operstate = "active"
+
+ return True
+
+ elif resp.status_code == 204:
+ obj.adminstate = "invalid" # what's the meaning?
+ obj.operstate = "inactive"
+ obj.backend_status = '204 - No network resource'
+ return False
+
+ elif resp.status_code == 500:
+ obj.adminstate = "enabled"
+ obj.operstate = "inactive"
+ obj.backend_status = '500 - Internal Server Error'
+ return False
+
+ else:
+ raise Exception("OnosApiError: create_point_to_point_connectivity()")
+
+ def delete_point_to_point_connectivity(self, obj):
+
+ restCtrlUrl = self.networkdevice.restCtrlUrl
+ username = self.networkdevice.username
+ password = self.networkdevice.password
+ evcId = obj.sid
+
+ resp = requests.delete("{}/mef-sca-api/SCA_ETH_FDFr_EC/{}".format(restCtrlUrl, evcId),
+ auth=HTTPBasicAuth(username, password))
+
+ if resp.status_code == 200:
+ obj.adminstate = 'disabled'
+ obj.operstate = 'inactive'
+ return True
+
+ elif resp.status_code == 204:
+ obj.adminstate = "invalid" # what's the meaning?
+ obj.backend_status = '204 - No such network resource: {}'.format(evcId)
+ return False
+
+ elif resp.status_code == 500:
+ obj.adminstate = "disabled"
+ obj.backend_status = '500 - Internal Server Error'
+ return False
+
+ else:
+ raise Exception("OnosApiError: delete_point_to_point_connectivity()")
diff --git a/xos/synchronizer/providers/metronetworktestprovider.py b/xos/synchronizer/providers/metronetworktestprovider.py
new file mode 100644
index 0000000..b88427d
--- /dev/null
+++ b/xos/synchronizer/providers/metronetworktestprovider.py
@@ -0,0 +1,284 @@
+import random
+
+from xos.logger import Logger, logging
+from core.models.netw import *
+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 6 ports - two on each of three internal switches
+
+ 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
+
+ # Ok - in the test class we cheat and create the adjunct NetworkDevices Devices
+ device1 = NetworkDevice()
+ device1.id = 'TestCORD1Net'
+ device1.administrativeState = 'enabled'
+ device1.restCtrlUrl = 'testCordPod1.onlab.net:8000'
+ device1.username = 'karaf'
+ device1.password = 'karaf'
+ objs.append(device1)
+
+ device2 = NetworkDevice()
+ device2.id = 'TestCORD2Net'
+ device2.administrativeState = 'enabled'
+ device2.restCtrlUrl = 'testCordPod2.onlabl.net:8000'
+ device2.username = 'karaf'
+ device2.password = 'karaf'
+ objs.append(device2)
+
+ # Ok - here we go creating ports - its 4 ports for each CORD Pod and 2 for MetroNetwork
+
+ # Metro Network Switch
+ port1 = NetworkPort()
+ port1.element = self.networkdevice
+ port1.pid = self.networkdevice.id + "." + "of:000000001/1"
+ objs.append(port1)
+
+ port2 = NetworkPort()
+ port2.element = self.networkdevice
+ port2.pid = self.networkdevice.id + "." + "of:000000001/2"
+ objs.append(port2)
+
+ # CORD POD1
+ cordpod1device = NetworkDevice()
+ cordpod1device.id = 'TestCORD1Net'
+
+ port3 = NetworkEdgePort()
+ port3.element = cordpod1device
+ port3.pid = cordpod1device.id + "." + "of:000000001/1"
+ port3.bwpCfgCbs = 1000000
+ port3.bwpCfgEbs = 1000000
+ port3.bwpCfgEir = 1000000
+ port3.bwpCfgCir = 1000000
+ port3.bwpCfgCir = 1000000
+ objs.append(port3)
+
+ port4 = NetworkPort()
+ port4.element = cordpod1device
+ port4.pid = cordpod1device.id + "." + "of:000000001/2"
+ objs.append(port4)
+
+ # Internal Switch 3
+ port5 = NetworkEdgePort()
+ port5.element = cordpod1device
+ port5.pid = cordpod1device.id + "." + "of:000000001/3"
+ port5.bwpCfgCbs = 1000000
+ port5.bwpCfgEbs = 1000000
+ port5.bwpCfgEir = 1000000
+ port5.bwpCfgCir = 1000000
+ port5.bwpCfgCir = 1000000
+ objs.append(port5)
+
+ port6 = NetworkPort()
+ port6.element = cordpod1device
+ port6.capacity = 1000000000
+ port6.usedCapacity = 1000000000
+ port6.pid = cordpod1device.id + "." + "of:000000001/4"
+ objs.append(port6)
+
+ # CORD POD2
+ cordpod2device = NetworkDevice()
+ cordpod2device.id = 'TestCORD2Net'
+
+ port7 = NetworkEdgePort()
+ port7.element = cordpod2device
+ port7.pid = cordpod2device.id + "." + "of:000000001/1"
+ port7.bwpCfgCbs = 1000000
+ port7.bwpCfgEbs = 1000000
+ port7.bwpCfgEir = 1000000
+ port7.bwpCfgCir = 1000000
+ port7.bwpCfgCir = 1000000
+ objs.append(port7)
+
+ port8 = NetworkPort()
+ port8.element = cordpod2device
+ port8.pid = cordpod2device.id + "." + "of:000000001/2"
+ objs.append(port8)
+
+ # Internal Switch 3
+ port9 = NetworkEdgePort()
+ port9.element = cordpod2device
+ port9.pid = cordpod2device.id + "." + "of:000000001/3"
+ port9.bwpCfgCbs = 1000000
+ port9.bwpCfgEbs = 1000000
+ port9.bwpCfgEir = 1000000
+ port9.bwpCfgCir = 1000000
+ port9.bwpCfgCir = 1000000
+ objs.append(port9)
+
+ port10 = NetworkPort()
+ port10.element = cordpod2device
+ port10.pid = cordpod2device.id + "." + "of:000000001/4"
+ objs.append(port10)
+
+ 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)
+
+ # Ok - in the test class we cheat and take down the adjunct Fake NetworkDevices Devices
+ device1 = NetworkDevice()
+ device1.id = 'TestCORD1Net'
+ objs.append(device1)
+
+ device2 = NetworkDevice()
+ device2.id = 'TestCORD2Net'
+ objs.append(device2)
+
+ return objs
+
+ def get_network_links(self):
+
+ objs = []
+
+ # Metro Link Connectivity object - Point to Point
+ metronetconnectivity = NetworkPointToPointConnection()
+ port1 = NetworkPort()
+ port1.pid = self.networkdevice.id + "." + "of:000000001/1"
+ port2 = NetworkPort()
+ port2.pid = self.networkdevice.id + "." + "of:000000001/2"
+ metronetconnectivity.src = port1
+ metronetconnectivity.dest = port2
+ metronetconnectivity.type = 'direct'
+ metronetconnectivity.operstate = 'active'
+ metronetconnectivity.adminstate = 'enabled'
+ metronetconnectivity.sid = 'MetroNetworkPointToPointConnectivity_1'
+ objs.append(metronetconnectivity)
+
+ # CORDPOD1 Connectivity object - Point to Point
+ cordpod1device = NetworkDevice()
+ cordpod1device.id = 'TestCORD1Net'
+
+ cordpod1connectivity = NetworkPointToPointConnection()
+ port6 = NetworkPort()
+ port6.pid = cordpod1device.id + "." + "of:000000001/4"
+ port4 = NetworkPort()
+ port4.pid = cordpod1device.id + "." + "of:000000001/2"
+ cordpod1connectivity.src = port6
+ cordpod1connectivity.dest = port4
+ cordpod1connectivity.type = 'direct'
+ cordpod1connectivity.operstate = 'active'
+ cordpod1connectivity.adminstate = 'enabled'
+ cordpod1connectivity.sid = 'CordPod1PointToPointConnectivity_1'
+ objs.append(cordpod1connectivity)
+
+ # CORDPOD2 Connectivity object - Point to Point
+ cordpod2device = NetworkDevice()
+ cordpod2device.id = 'TestCORD2Net'
+
+ cordpod2connectivity = NetworkPointToPointConnection()
+ port8 = NetworkPort()
+ port8.pid = cordpod2device.id + "." + "of:000000001/2"
+ port10 = NetworkPort()
+ port10.pid = cordpod2device.id + "." + "of:000000001/4"
+ cordpod2connectivity.src = port10
+ cordpod2connectivity.dest = port8
+ cordpod2connectivity.type = 'direct'
+ cordpod2connectivity.operstate = 'active'
+ cordpod2connectivity.adminstate = 'enabled'
+ cordpod2connectivity.sid = 'CordPod2PointToPointConnectivity_1'
+ objs.append(cordpod2connectivity)
+
+ # InterLink object between CORDPOD1 and MetroNet
+ interlink1 = NetworkInterLink()
+ interlink1.src = port1
+ interlink1.dest = port6
+ interlink1.state = 'active'
+ objs.append(interlink1)
+
+ # InterLink object between CORDPOD2 and MetroNet
+ interlink2 = NetworkInterLink()
+ interlink2.src = port2
+ interlink2.dest = port10
+ interlink2.state = 'active'
+ objs.append(interlink2)
+
+ # Edge to Edge Point Connectivity Objects
+ edgetoedgeconnectivity = NetworkEdgeToEdgePointConnection()
+ port3 = NetworkEdgePort()
+ port3.pid = cordpod1device.id + "." + "of:000000001/1"
+ port7 = NetworkEdgePort()
+ port7.pid = cordpod2device.id + "." + "of:000000001/1"
+ edgetoedgeconnectivity.uni1 = port3
+ edgetoedgeconnectivity.uni2 = port7
+ edgetoedgeconnectivity.type = 'direct'
+ edgetoedgeconnectivity.operstate = 'active'
+ edgetoedgeconnectivity.adminstate = 'enabled'
+ edgetoedgeconnectivity.sid = 'EdgePointToEdgePointConnectivity_1'
+ objs.append(edgetoedgeconnectivity)
+
+ 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
diff --git a/xos/synchronizer/providers/providerfactory.py b/xos/synchronizer/providers/providerfactory.py
new file mode 100644
index 0000000..9ef6cb8
--- /dev/null
+++ b/xos/synchronizer/providers/providerfactory.py
@@ -0,0 +1,21 @@
+import sys
+
+from synchronizers.metronetwork.providers.metronetworktestprovider import MetroNetworkTestProvider
+from synchronizers.metronetwork.providers.metronetworkrestprovider import MetroNetworkRestProvider
+
+
+class ProviderFactory(object):
+ @staticmethod
+ def getprovider(networkdevice):
+
+ undertest = False
+
+ # We either return Test or Rest
+ # By convention a NetworkDevice with name TestDomain will use test objects
+ if networkdevice.id == 'TestMetroNet' or networkdevice.id == 'TestCORD1Net' or networkdevice.id == 'TestCORD2Net':
+ undertest = True
+
+ if undertest:
+ return MetroNetworkTestProvider(networkdevice)
+ else:
+ return MetroNetworkRestProvider(networkdevice)