xos/synchronizer/steps/sync_olt_device.py - olt-service - Gitiles

 # 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 time import sleep

 import requests
 from multistructlog import create_logger
 from requests.auth import HTTPBasicAuth
 from synchronizers.new_base.syncstep import SyncStep, DeferredException
 from synchronizers.new_base.modelaccessor import OLTDevice, model_accessor
 from xosconfig import Config

 import os, sys
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 from helpers import Helpers

 log = create_logger(Config().get('logging'))

 class SyncOLTDevice(SyncStep):
     provides = [OLTDevice]
     observes = OLTDevice

     max_attempt = 120  # we give 10 minutes to the OLT to activate

     @staticmethod
     def get_ids_from_logical_device(o):
         voltha = Helpers.get_voltha_info(o.volt_service)

         request = requests.get("%s:%d/api/v1/logical_devices" % (voltha['url'], voltha['port']))

         if request.status_code != 200:
             raise Exception("Failed to retrieve logical devices from VOLTHA: %s" % request.text)

         response = request.json()

         for ld in response["items"]:
             if ld["root_device_id"] == o.device_id:
                 o.of_id = ld["id"]
                 o.dp_id = "of:%s" % (Helpers.datapath_id_to_hex(ld["datapath_id"])) # Convert to hex
                 return o

         raise Exception("Can't find a logical_device for OLT device id: %s" % o.device_id)

     def pre_provision_olt_device(self, model):
         log.info("Pre-provisioning OLT device in VOLTHA", object=str(model), **model.tologdict())

         voltha = Helpers.get_voltha_info(model.volt_service)

         data = {
             "type": model.device_type
         }

         if hasattr(model, "host") and hasattr(model, "port"):
             data["host_and_port"] = "%s:%s" % (model.host, model.port)
         elif hasattr(model, "mac_address"):
             data["mac_address"] = model.mac_address

         log.info("Pushing OLT to Voltha", data=data)

         request = requests.post("%s:%d/api/v1/devices" % (voltha['url'], voltha['port']), json=data)

         if request.status_code != 200:
             raise Exception("Failed to add OLT device: %s" % request.text)

         log.info("Add device response", text=request.text)

         res = request.json()

         log.info("Add device json res", res=res)

         if not res['id']:
             raise Exception(
                 'VOLTHA Device Id is empty. This probably means that the OLT device is already provisioned in VOLTHA')
         else:
             model.device_id = res['id'];

         return model

     def activate_olt(self, model):

         attempted = 0

         voltha = Helpers.get_voltha_info(model.volt_service)

         # Enable device
         request = requests.post("%s:%d/api/v1/devices/%s/enable" % (voltha['url'], voltha['port'], model.device_id))

         if request.status_code != 200:
             raise Exception("Failed to enable OLT device: %s" % request.text)

         model.backend_status = "Waiting for device to be activated"
         model.save(always_update_timestamp=False) # we don't want to kickoff a new loop

         # Read state
         request = requests.get("%s:%d/api/v1/devices/%s" % (voltha['url'], voltha['port'], model.device_id)).json()
         while request['oper_status'] == "ACTIVATING" and attempted < self.max_attempt:
             log.info("Waiting for OLT device %s (%s) to activate" % (model.name, model.device_id))
             sleep(5)
             request = requests.get("%s:%d/api/v1/devices/%s" % (voltha['url'], voltha['port'], model.device_id)).json()
             attempted = attempted + 1


         model.admin_state = request['admin_state']
         model.oper_status = request['oper_status']

         if model.oper_status != "ACTIVE":
             raise Exception("It was not possible to activate OLTDevice with id %s" % model.id)

         # Find the of_id of the device
         model = self.get_ids_from_logical_device(model)
         model.save()

         return model

     def configure_onos(self, model):

         log.info("Adding OLT device in onos-voltha", object=str(model), **model.tologdict())

         onos_voltha = Helpers.get_onos_voltha_info(model.volt_service)
         onos_voltha_basic_auth = HTTPBasicAuth(onos_voltha['user'], onos_voltha['pass'])

         try:
             # NOTE For now, we assume that each OLT has only one pon port
             vlan = model.pon_ports.all()[0].s_tag
         except Exception as e:
             raise DeferredException("Waiting for pon_ports to come up")


         # Add device info to onos-voltha
         data = {
           "devices": {
             model.dp_id: {
               "basic": {
                 "driver": model.driver
               },
               "accessDevice": {
                 "uplink": model.uplink,
                 "vlan": vlan
               }
             }
           }
         }

         url = "%s:%d/onos/v1/network/configuration/" % (onos_voltha['url'], onos_voltha['port'])
         request = requests.post(url, json=data, auth=onos_voltha_basic_auth)

         if request.status_code != 200:
             log.error(request.text)
             raise Exception("Failed to add OLT device %s into ONOS" % model.name)
         else:
             try:
                 print request.json()
             except Exception:
                 print request.text
         return model

     def sync_record(self, model):
         log.info("Synching device", object=str(model), **model.tologdict())

         # If the device has feedback_state is already present in voltha
         if not model.device_id and not model.admin_state and not model.oper_status and not model.of_id:
             log.info("Pushing OLT device to VOLTHA", object=str(model), **model.tologdict())
             model = self.pre_provision_olt_device(model)
             self.activate_olt(model)
         elif model.oper_status != "ACTIVE":
             raise Exception("It was not possible to activate OLTDevice with id %s" % model.id)
         else:
             log.info("OLT device already exists in VOLTHA", object=str(model), **model.tologdict())

         # TODO configure onos only if we have: Switch datapath id, Switch port, Uplink
         if model.switch_datapath_id and model.switch_port and model.uplink:
             log.info("Pushing OLT device to ONOS-VOLTHA", object=str(model), **model.tologdict())
             self.configure_onos(model)
         else:
             raise DeferredException("Not pushing OLTDevice (%s) to ONOS-VOLTHA as parameters are missing" %  model.id)

     def delete_record(self, model):
         log.info("Deleting OLT device", object=str(model), **model.tologdict())

         voltha = Helpers.get_voltha_info(model.volt_service)
         onos_voltha = Helpers.get_onos_voltha_info(model.volt_service)
         onos_voltha_basic_auth = HTTPBasicAuth(onos_voltha['user'], onos_voltha['pass'])

         if not model.device_id:
             log.error("OLTDevice %s has no device_id" % model.name)
         else:
             # Disable the OLT device
             request = requests.post("%s:%d/api/v1/devices/%s/disable" % (voltha['url'], voltha['port'], model.device_id))

             if request.status_code != 200:
                 log.error("Failed to disable OLT device in VOLTHA: %s - %s" % (model.name, model.device_id), rest_response=request.text, rest_status_code=request.status_code)
                 raise Exception("Failed to disable OLT device in VOLTHA")

             # Delete the OLT device
             request = requests.delete("%s:%d/api/v1/devices/%s/delete" % (voltha['url'], voltha['port'], model.device_id))

             if request.status_code != 200:
                 log.error("Failed to delete OLT device from VOLTHA: %s - %s" % (model.name, model.device_id), rest_response=request.text, rest_status_code=request.status_code)
                 raise Exception("Failed to delete OLT device from VOLTHA")

             # Remove the device from ONOS
             request = requests.delete("%s:%d/onos/v1/network/configuration/devices/%s" % (
                 onos_voltha['url'], onos_voltha['port'], model.of_id), auth=onos_voltha_basic_auth)

             if request.status_code != 204:
                 log.error("Failed to remove OLT device from ONOS: %s - %s" % (model.name, model.of_id), rest_response=request.text, rest_status_code=request.status_code)
                 raise Exception("Failed to remove OLT device from ONOS")
	# 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 time import sleep

	import requests
	from multistructlog import create_logger
	from requests.auth import HTTPBasicAuth
	from synchronizers.new_base.syncstep import SyncStep, DeferredException
	from synchronizers.new_base.modelaccessor import OLTDevice, model_accessor
	from xosconfig import Config

	import os, sys
	sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

	from helpers import Helpers

	log = create_logger(Config().get('logging'))

	class SyncOLTDevice(SyncStep):
	provides = [OLTDevice]
	observes = OLTDevice

	max_attempt = 120 # we give 10 minutes to the OLT to activate

	@staticmethod
	def get_ids_from_logical_device(o):
	voltha = Helpers.get_voltha_info(o.volt_service)

	request = requests.get("%s:%d/api/v1/logical_devices" % (voltha['url'], voltha['port']))

	if request.status_code != 200:
	raise Exception("Failed to retrieve logical devices from VOLTHA: %s" % request.text)

	response = request.json()

	for ld in response["items"]:
	if ld["root_device_id"] == o.device_id:
	o.of_id = ld["id"]
	o.dp_id = "of:%s" % (Helpers.datapath_id_to_hex(ld["datapath_id"])) # Convert to hex
	return o

	raise Exception("Can't find a logical_device for OLT device id: %s" % o.device_id)

	def pre_provision_olt_device(self, model):
	log.info("Pre-provisioning OLT device in VOLTHA", object=str(model), **model.tologdict())

	voltha = Helpers.get_voltha_info(model.volt_service)

	data = {
	"type": model.device_type
	}

	if hasattr(model, "host") and hasattr(model, "port"):
	data["host_and_port"] = "%s:%s" % (model.host, model.port)
	elif hasattr(model, "mac_address"):
	data["mac_address"] = model.mac_address

	log.info("Pushing OLT to Voltha", data=data)

	request = requests.post("%s:%d/api/v1/devices" % (voltha['url'], voltha['port']), json=data)

	if request.status_code != 200:
	raise Exception("Failed to add OLT device: %s" % request.text)

	log.info("Add device response", text=request.text)

	res = request.json()

	log.info("Add device json res", res=res)

	if not res['id']:
	raise Exception(
	'VOLTHA Device Id is empty. This probably means that the OLT device is already provisioned in VOLTHA')
	else:
	model.device_id = res['id'];

	return model

	def activate_olt(self, model):

	attempted = 0

	voltha = Helpers.get_voltha_info(model.volt_service)

	# Enable device
	request = requests.post("%s:%d/api/v1/devices/%s/enable" % (voltha['url'], voltha['port'], model.device_id))

	if request.status_code != 200:
	raise Exception("Failed to enable OLT device: %s" % request.text)

	model.backend_status = "Waiting for device to be activated"
	model.save(always_update_timestamp=False) # we don't want to kickoff a new loop

	# Read state
	request = requests.get("%s:%d/api/v1/devices/%s" % (voltha['url'], voltha['port'], model.device_id)).json()
	while request['oper_status'] == "ACTIVATING" and attempted < self.max_attempt:
	log.info("Waiting for OLT device %s (%s) to activate" % (model.name, model.device_id))
	sleep(5)
	request = requests.get("%s:%d/api/v1/devices/%s" % (voltha['url'], voltha['port'], model.device_id)).json()
	attempted = attempted + 1


	model.admin_state = request['admin_state']
	model.oper_status = request['oper_status']

	if model.oper_status != "ACTIVE":
	raise Exception("It was not possible to activate OLTDevice with id %s" % model.id)

	# Find the of_id of the device
	model = self.get_ids_from_logical_device(model)
	model.save()

	return model

	def configure_onos(self, model):

	log.info("Adding OLT device in onos-voltha", object=str(model), **model.tologdict())

	onos_voltha = Helpers.get_onos_voltha_info(model.volt_service)
	onos_voltha_basic_auth = HTTPBasicAuth(onos_voltha['user'], onos_voltha['pass'])

	try:
	# NOTE For now, we assume that each OLT has only one pon port
	vlan = model.pon_ports.all()[0].s_tag
	except Exception as e:
	raise DeferredException("Waiting for pon_ports to come up")


	# Add device info to onos-voltha
	data = {
	"devices": {
	model.dp_id: {
	"basic": {
	"driver": model.driver
	},
	"accessDevice": {
	"uplink": model.uplink,
	"vlan": vlan
	}
	}
	}
	}

	url = "%s:%d/onos/v1/network/configuration/" % (onos_voltha['url'], onos_voltha['port'])
	request = requests.post(url, json=data, auth=onos_voltha_basic_auth)

	if request.status_code != 200:
	log.error(request.text)
	raise Exception("Failed to add OLT device %s into ONOS" % model.name)
	else:
	try:
	print request.json()
	except Exception:
	print request.text
	return model

	def sync_record(self, model):
	log.info("Synching device", object=str(model), **model.tologdict())

	# If the device has feedback_state is already present in voltha
	if not model.device_id and not model.admin_state and not model.oper_status and not model.of_id:
	log.info("Pushing OLT device to VOLTHA", object=str(model), **model.tologdict())
	model = self.pre_provision_olt_device(model)
	self.activate_olt(model)
	elif model.oper_status != "ACTIVE":
	raise Exception("It was not possible to activate OLTDevice with id %s" % model.id)
	else:
	log.info("OLT device already exists in VOLTHA", object=str(model), **model.tologdict())

	# TODO configure onos only if we have: Switch datapath id, Switch port, Uplink
	if model.switch_datapath_id and model.switch_port and model.uplink:
	log.info("Pushing OLT device to ONOS-VOLTHA", object=str(model), **model.tologdict())
	self.configure_onos(model)
	else:
	raise DeferredException("Not pushing OLTDevice (%s) to ONOS-VOLTHA as parameters are missing" % model.id)

	def delete_record(self, model):
	log.info("Deleting OLT device", object=str(model), **model.tologdict())

	voltha = Helpers.get_voltha_info(model.volt_service)
	onos_voltha = Helpers.get_onos_voltha_info(model.volt_service)
	onos_voltha_basic_auth = HTTPBasicAuth(onos_voltha['user'], onos_voltha['pass'])

	if not model.device_id:
	log.error("OLTDevice %s has no device_id" % model.name)
	else:
	# Disable the OLT device
	request = requests.post("%s:%d/api/v1/devices/%s/disable" % (voltha['url'], voltha['port'], model.device_id))

	if request.status_code != 200:
	log.error("Failed to disable OLT device in VOLTHA: %s - %s" % (model.name, model.device_id), rest_response=request.text, rest_status_code=request.status_code)
	raise Exception("Failed to disable OLT device in VOLTHA")

	# Delete the OLT device
	request = requests.delete("%s:%d/api/v1/devices/%s/delete" % (voltha['url'], voltha['port'], model.device_id))

	if request.status_code != 200:
	log.error("Failed to delete OLT device from VOLTHA: %s - %s" % (model.name, model.device_id), rest_response=request.text, rest_status_code=request.status_code)
	raise Exception("Failed to delete OLT device from VOLTHA")

	# Remove the device from ONOS
	request = requests.delete("%s:%d/onos/v1/network/configuration/devices/%s" % (
	onos_voltha['url'], onos_voltha['port'], model.of_id), auth=onos_voltha_basic_auth)

	if request.status_code != 204:
	log.error("Failed to remove OLT device from ONOS: %s - %s" % (model.name, model.of_id), rest_response=request.text, rest_status_code=request.status_code)
	raise Exception("Failed to remove OLT device from ONOS")