adapters/adtran_olt/adtran_olt.py - voltha-adtran-adapter - Gitiles

 #
 # Copyright 2019-present ADTRAN, Inc.
 #
 # 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.
 #
 """
 ADTRAN OLT Adapter.
 """
 import structlog
 from twisted.internet import reactor, defer

 from pyvoltha.adapters.iadapter import OltAdapter
 from pyvoltha.protos import third_party
 from pyvoltha.protos.common_pb2 import AdminState
 from pyvoltha.protos.health_pb2 import HealthStatus
 from adtran_olt_handler import AdtranOltHandler


 _ = third_party
 log = structlog.get_logger()


 class AdtranOltAdapter(OltAdapter):
     name = 'adtran_olt'

     def __init__(self, core_proxy, adapter_proxy, config):
         super(AdtranOltAdapter, self).__init__(core_proxy=core_proxy,
                                                adapter_proxy=adapter_proxy,
                                                config=config,
                                                device_handler_class=AdtranOltHandler,
                                                name=AdtranOltAdapter.name,
                                                vendor='ADTRAN, Inc.',
                                                version='2.0.0',
                                                device_type=AdtranOltAdapter.name,
                                                accepts_bulk_flow_update=True,
                                                accepts_add_remove_flow_updates=True)

         log.debug('adtran_olt.__init__')

     def health(self):
         """
         Return a 3-state health status using the voltha.HealthStatus message.

         :return: Deferred or direct return with voltha.HealthStatus message
         """
         # TODO: Currently this is always healthy for every adapter.
         #       If we decide not to modify this, delete this method and use base class method
         return HealthStatus(state=HealthStatus.HEALTHY)

     def abandon_device(self, device):
         """
         Make sure the adapter no longer looks after device. This is called
         if device ownership is taken over by another Voltha instance.

         :param device: A Voltha.Device object
         :return: (Deferred) Shall be fired to acknowledge abandonment.
         """
         log.info('abandon-device', device=device)
         raise NotImplementedError()

     def adopt_device(self, device):
         """
         Make sure the adapter looks after given device. Called when a device
         is provisioned top-down and needs to be activated by the adapter.

         :param device: A voltha.Device object, with possible device-type
                        specific extensions. Such extensions shall be described as part of
                        the device type specification returned by device_types().

         :return: (Deferred) Shall be fired to acknowledge device ownership.
         """
         log.info('adopt-device', device=device)
         kwargs = {
             'adapter': self,
             'device-id': device.id
         }
         try:
             self.devices_handlers[device.id] = self.device_handler_class(**kwargs)
             d = defer.Deferred()
             reactor.callLater(0, self.devices_handlers[device.id].activate, d, False)
             return d

         except Exception as _e:
             raise

     def reconcile_device(self, device):
         """
         Make sure the adapter looks after given device. Called when this
         device has changed ownership from another Voltha instance to
         this one (typically, this occurs when the previous voltha
         instance went down).

         :param device: A voltha.Device object, with possible device-type
                        specific extensions. Such extensions shall be described as part of
                        the device type specification returned by device_types().

         :return: (Deferred) Shall be fired to acknowledge device ownership.
         """
         try:
             kwargs = {
                 'adapter': self,
                 'device-id': device.id
             }
             self.devices_handlers[device.id] = self.device_handler_class(**kwargs)
             # Work only required for devices that are in ENABLED state
             if device.admin_state == AdminState.ENABLED:
                 d = defer.Deferred()
                 reactor.callLater(0, self.devices_handlers[device.id].activate, d, True)

             else:
                 # Invoke the children reconciliation which would setup the
                 # basic children data structures
                 self.core_proxy.reconcile_child_devices(device.id)
             return device

         except Exception, e:
             log.exception('Exception', e=e)

     def self_test_device(self, device):
         """
         This is called to Self a device based on a NBI call.
         :param device: A Voltha.Device object.
         :return: Will return result of self test
         """
         log.info('self-test-device', device=device.id)
         # TODO: Support self test?
         from pyvoltha.protos.voltha_pb2 import SelfTestResponse
         return SelfTestResponse(result=SelfTestResponse.NOT_SUPPORTED)

     def delete_device(self, device):
         """
         This is called to delete a device from the PON based on a NBI call.
         If the device is an OLT then the whole PON will be deleted.

         :param device: A Voltha.Device object.
         :return: (Deferred) Shall be fired to acknowledge the deletion.
         """
         log.info('delete-device', device=device)
         handler = self.devices_handlers.get(device.id)
         if handler is not None:
             reactor.callLater(0, handler.delete)
             del self.device_handlers[device.id]
             del self.logical_device_id_to_root_device_id[device.parent_id]

         return device

     def download_image(self, device, request):
         """
         This is called to request downloading a specified image into the standby partition
         of a device based on a NBI call.

         :param device: A Voltha.Device object.
         :param request: A Voltha.ImageDownload object.
         :return: (Deferred) Shall be fired to acknowledge the download.
         """
         log.info('image_download', device=device, request=request)
         handler = self.devices_handlers.get(device.id)
         if handler is not None:
             return handler.start_download(device, request, defer.Deferred())

     def get_image_download_status(self, device, request):
         """
         This is called to inquire about a requested image download status based
         on a NBI call. The adapter is expected to update the DownloadImage DB object
         with the query result

         :param device: A Voltha.Device object.
         :param request: A Voltha.ImageDownload object.
         :return: (Deferred) Shall be fired to acknowledge
         """
         log.info('get_image_download', device=device, request=request)
         handler = self.devices_handlers.get(device.id)
         if handler is not None:
             return handler.download_status(device, request, defer.Deferred())

     def cancel_image_download(self, device, request):
         """
         This is called to cancel a requested image download
         based on a NBI call.  The admin state of the device will not
         change after the download.
         :param device: A Voltha.Device object.
         :param request: A Voltha.ImageDownload object.
         :return: (Deferred) Shall be fired to acknowledge
         """
         log.info('cancel_image_download', device=device)
         handler = self.devices_handlers.get(device.id)
         if handler is not None:
             return handler.cancel_download(device, request, defer.Deferred())

     def activate_image_update(self, device, request):
         """
         This is called to activate a downloaded image from
         a standby partition into active partition.
         Depending on the device implementation, this call
         may or may not cause device reboot.
         If no reboot, then a reboot is required to make the
         activated image running on device
         This call is expected to be non-blocking.
         :param device: A Voltha.Device object.
         :param request: A Voltha.ImageDownload object.
         :return: (Deferred) OperationResponse object.
         """
         log.info('activate_image_update', device=device, request=request)
         handler = self.devices_handlers.get(device.id)
         if handler is not None:
             return handler.activate_image(device, request, defer.Deferred())

     def revert_image_update(self, device, request):
         """
         This is called to deactivate the specified image at
         active partition, and revert to previous image at
         standby partition.
         Depending on the device implementation, this call
         may or may not cause device reboot.
         If no reboot, then a reboot is required to make the
         previous image running on device
         This call is expected to be non-blocking.
         :param device: A Voltha.Device object.
         :param request: A Voltha.ImageDownload object.
         :return: (Deferred) OperationResponse object.
         """
         log.info('revert_image_update', device=device, request=request)
         handler = self.devices_handlers.get(device.id)
         if handler is not None:
             return handler.revert_image(device, request, defer.Deferred())
	#
	# Copyright 2019-present ADTRAN, Inc.
	#
	# 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.
	#
	"""
	ADTRAN OLT Adapter.
	"""
	import structlog
	from twisted.internet import reactor, defer

	from pyvoltha.adapters.iadapter import OltAdapter
	from pyvoltha.protos import third_party
	from pyvoltha.protos.common_pb2 import AdminState
	from pyvoltha.protos.health_pb2 import HealthStatus
	from adtran_olt_handler import AdtranOltHandler


	_ = third_party
	log = structlog.get_logger()


	class AdtranOltAdapter(OltAdapter):
	name = 'adtran_olt'

	def __init__(self, core_proxy, adapter_proxy, config):
	super(AdtranOltAdapter, self).__init__(core_proxy=core_proxy,
	adapter_proxy=adapter_proxy,
	config=config,
	device_handler_class=AdtranOltHandler,
	name=AdtranOltAdapter.name,
	vendor='ADTRAN, Inc.',
	version='2.0.0',
	device_type=AdtranOltAdapter.name,
	accepts_bulk_flow_update=True,
	accepts_add_remove_flow_updates=True)

	log.debug('adtran_olt.__init__')

	def health(self):
	"""
	Return a 3-state health status using the voltha.HealthStatus message.

	:return: Deferred or direct return with voltha.HealthStatus message
	"""
	# TODO: Currently this is always healthy for every adapter.
	# If we decide not to modify this, delete this method and use base class method
	return HealthStatus(state=HealthStatus.HEALTHY)

	def abandon_device(self, device):
	"""
	Make sure the adapter no longer looks after device. This is called
	if device ownership is taken over by another Voltha instance.

	:param device: A Voltha.Device object
	:return: (Deferred) Shall be fired to acknowledge abandonment.
	"""
	log.info('abandon-device', device=device)
	raise NotImplementedError()

	def adopt_device(self, device):
	"""
	Make sure the adapter looks after given device. Called when a device
	is provisioned top-down and needs to be activated by the adapter.

	:param device: A voltha.Device object, with possible device-type
	specific extensions. Such extensions shall be described as part of
	the device type specification returned by device_types().

	:return: (Deferred) Shall be fired to acknowledge device ownership.
	"""
	log.info('adopt-device', device=device)
	kwargs = {
	'adapter': self,
	'device-id': device.id
	}
	try:
	self.devices_handlers[device.id] = self.device_handler_class(**kwargs)
	d = defer.Deferred()
	reactor.callLater(0, self.devices_handlers[device.id].activate, d, False)
	return d

	except Exception as _e:
	raise

	def reconcile_device(self, device):
	"""
	Make sure the adapter looks after given device. Called when this
	device has changed ownership from another Voltha instance to
	this one (typically, this occurs when the previous voltha
	instance went down).

	:param device: A voltha.Device object, with possible device-type
	specific extensions. Such extensions shall be described as part of
	the device type specification returned by device_types().

	:return: (Deferred) Shall be fired to acknowledge device ownership.
	"""
	try:
	kwargs = {
	'adapter': self,
	'device-id': device.id
	}
	self.devices_handlers[device.id] = self.device_handler_class(**kwargs)
	# Work only required for devices that are in ENABLED state
	if device.admin_state == AdminState.ENABLED:
	d = defer.Deferred()
	reactor.callLater(0, self.devices_handlers[device.id].activate, d, True)

	else:
	# Invoke the children reconciliation which would setup the
	# basic children data structures
	self.core_proxy.reconcile_child_devices(device.id)
	return device

	except Exception, e:
	log.exception('Exception', e=e)

	def self_test_device(self, device):
	"""
	This is called to Self a device based on a NBI call.
	:param device: A Voltha.Device object.
	:return: Will return result of self test
	"""
	log.info('self-test-device', device=device.id)
	# TODO: Support self test?
	from pyvoltha.protos.voltha_pb2 import SelfTestResponse
	return SelfTestResponse(result=SelfTestResponse.NOT_SUPPORTED)

	def delete_device(self, device):
	"""
	This is called to delete a device from the PON based on a NBI call.
	If the device is an OLT then the whole PON will be deleted.

	:param device: A Voltha.Device object.
	:return: (Deferred) Shall be fired to acknowledge the deletion.
	"""
	log.info('delete-device', device=device)
	handler = self.devices_handlers.get(device.id)
	if handler is not None:
	reactor.callLater(0, handler.delete)
	del self.device_handlers[device.id]
	del self.logical_device_id_to_root_device_id[device.parent_id]

	return device

	def download_image(self, device, request):
	"""
	This is called to request downloading a specified image into the standby partition
	of a device based on a NBI call.

	:param device: A Voltha.Device object.
	:param request: A Voltha.ImageDownload object.
	:return: (Deferred) Shall be fired to acknowledge the download.
	"""
	log.info('image_download', device=device, request=request)
	handler = self.devices_handlers.get(device.id)
	if handler is not None:
	return handler.start_download(device, request, defer.Deferred())

	def get_image_download_status(self, device, request):
	"""
	This is called to inquire about a requested image download status based
	on a NBI call. The adapter is expected to update the DownloadImage DB object
	with the query result

	:param device: A Voltha.Device object.
	:param request: A Voltha.ImageDownload object.
	:return: (Deferred) Shall be fired to acknowledge
	"""
	log.info('get_image_download', device=device, request=request)
	handler = self.devices_handlers.get(device.id)
	if handler is not None:
	return handler.download_status(device, request, defer.Deferred())

	def cancel_image_download(self, device, request):
	"""
	This is called to cancel a requested image download
	based on a NBI call. The admin state of the device will not
	change after the download.
	:param device: A Voltha.Device object.
	:param request: A Voltha.ImageDownload object.
	:return: (Deferred) Shall be fired to acknowledge
	"""
	log.info('cancel_image_download', device=device)
	handler = self.devices_handlers.get(device.id)
	if handler is not None:
	return handler.cancel_download(device, request, defer.Deferred())

	def activate_image_update(self, device, request):
	"""
	This is called to activate a downloaded image from
	a standby partition into active partition.
	Depending on the device implementation, this call
	may or may not cause device reboot.
	If no reboot, then a reboot is required to make the
	activated image running on device
	This call is expected to be non-blocking.
	:param device: A Voltha.Device object.
	:param request: A Voltha.ImageDownload object.
	:return: (Deferred) OperationResponse object.
	"""
	log.info('activate_image_update', device=device, request=request)
	handler = self.devices_handlers.get(device.id)
	if handler is not None:
	return handler.activate_image(device, request, defer.Deferred())

	def revert_image_update(self, device, request):
	"""
	This is called to deactivate the specified image at
	active partition, and revert to previous image at
	standby partition.
	Depending on the device implementation, this call
	may or may not cause device reboot.
	If no reboot, then a reboot is required to make the
	previous image running on device
	This call is expected to be non-blocking.
	:param device: A Voltha.Device object.
	:param request: A Voltha.ImageDownload object.
	:return: (Deferred) OperationResponse object.
	"""
	log.info('revert_image_update', device=device, request=request)
	handler = self.devices_handlers.get(device.id)
	if handler is not None:
	return handler.revert_image(device, request, defer.Deferred())