Device component - IETF L2VPN driver: (bfa801f7) · Commits · TFS / controller

src/device/service/drivers/ietf_l2vpn/IetfL2VpnDriver.py

+2 −10

Original line number	Original line	Diff line number	Diff line
	@@ -25,14 +25,6 @@ from .WimconnectorIETFL2VPN import WimconnectorIETFL2VPN

	LOGGER = logging.getLogger(__name__)		LOGGER = logging.getLogger(__name__)

	def process_connectivity_services(method : str, services : Any) -> Any:
	LOGGER.warning('[{:s}][process_connectivity_services] services={:s}'.format(str(method), str(services)))
	return services

	def process_connectivity_service(method : str, service : Any) -> Any:
	LOGGER.warning('[{:s}][process_connectivity_service] service={:s}'.format(str(method), str(service)))
	return service

	def service_exists(wim : WimconnectorIETFL2VPN, service_uuid : str) -> bool:		def service_exists(wim : WimconnectorIETFL2VPN, service_uuid : str) -> bool:
	try:		try:
	wim.get_connectivity_service_status(service_uuid)		wim.get_connectivity_service_status(service_uuid)
	@@ -103,11 +95,11 @@ class IetfL2VpnDriver(_Driver):
	elif resource_key == RESOURCE_SERVICES:		elif resource_key == RESOURCE_SERVICES:
	# return all services through		# return all services through
	reply = self.wim.get_all_active_connectivity_services()		reply = self.wim.get_all_active_connectivity_services()
	results.extend(process_connectivity_services('GetConfig', reply.json()))		results.extend(reply.json())
	else:		else:
	# assume single-service retrieval		# assume single-service retrieval
	reply = self.wim.get_connectivity_service(resource_key)		reply = self.wim.get_connectivity_service(resource_key)
	results.append(process_connectivity_service('GetConfig', reply.json()))		results.append(reply.json())
	except Exception as e: # pylint: disable=broad-except		except Exception as e: # pylint: disable=broad-except
	LOGGER.exception('Unhandled error processing resource_key({:s})'.format(str(resource_key)))		LOGGER.exception('Unhandled error processing resource_key({:s})'.format(str(resource_key)))
	results.append((resource_key, e))		results.append((resource_key, e))

src/device/service/drivers/ietf_l2vpn/Tools.py

+0 −136

Original line number	Original line	Diff line number	Diff line
	@@ -12,143 +12,7 @@
	# See the License for the specific language governing permissions and		# See the License for the specific language governing permissions and
	# limitations under the License.		# limitations under the License.

	import json, logging, operator, requests
	from requests.auth import HTTPBasicAuth
	from typing import Dict, Optional		from typing import Dict, Optional
	from device.service.driver_api._Driver import RESOURCE_ENDPOINTS

	LOGGER = logging.getLogger(__name__)

	HTTP_OK_CODES = {
	200, # OK
	201, # Created
	202, # Accepted
	204, # No Content
	}

	def find_key(resource, key):
	return json.loads(resource[1])[key]


	def config_getter(
	root_url : str, resource_key : str, auth : Optional[HTTPBasicAuth] = None, timeout : Optional[int] = None
	):
	url = '{:s}/restconf/data/tapi-common:context'.format(root_url)
	result = []
	try:
	response = requests.get(url, timeout=timeout, verify=False, auth=auth)
	except requests.exceptions.Timeout:
	LOGGER.exception('Timeout connecting {:s}'.format(url))
	return result
	except Exception as e: # pylint: disable=broad-except
	LOGGER.exception('Exception retrieving {:s}'.format(resource_key))
	result.append((resource_key, e))
	return result

	try:
	context = json.loads(response.content)
	except Exception as e: # pylint: disable=broad-except
	LOGGER.warning('Unable to decode reply: {:s}'.format(str(response.content)))
	result.append((resource_key, e))
	return result

	if resource_key != RESOURCE_ENDPOINTS: return result

	if 'tapi-common:context' in context:
	context = context['tapi-common:context']
	elif 'context' in context:
	context = context['context']

	for sip in context['service-interface-point']:
	layer_protocol_name = sip.get('layer-protocol-name', '?')
	supportable_spectrum = sip.get('tapi-photonic-media:media-channel-service-interface-point-spec', {})
	supportable_spectrum = supportable_spectrum.get('mc-pool', {})
	supportable_spectrum = supportable_spectrum.get('supportable-spectrum', [])
	supportable_spectrum = supportable_spectrum[0] if len(supportable_spectrum) == 1 else {}
	grid_type = supportable_spectrum.get('frequency-constraint', {}).get('grid-type')
	granularity = supportable_spectrum.get('frequency-constraint', {}).get('adjustment-granularity')
	direction = sip.get('direction', '?')
	endpoint_type = [layer_protocol_name, grid_type, granularity, direction]
	str_endpoint_type = ':'.join(filter(lambda i: operator.is_not(i, None), endpoint_type))
	endpoint_url = '/endpoints/endpoint[{:s}]'.format(sip['uuid'])
	endpoint_data = {'uuid': sip['uuid'], 'type': str_endpoint_type}
	result.append((endpoint_url, endpoint_data))

	return result

	def create_connectivity_service(
	root_url, uuid, input_sip, output_sip, direction, capacity_value, capacity_unit, layer_protocol_name,
	layer_protocol_qualifier,
	auth : Optional[HTTPBasicAuth] = None, timeout : Optional[int] = None
	):

	url = '{:s}/restconf/data/tapi-common:context/tapi-connectivity:connectivity-context'.format(root_url)
	headers = {'content-type': 'application/json'}
	data = {
	'tapi-connectivity:connectivity-service': [
	{
	'uuid': uuid,
	'connectivity-constraint': {
	'requested-capacity': {
	'total-size': {
	'value': capacity_value,
	'unit': capacity_unit
	}
	},
	'connectivity-direction': direction
	},
	'end-point': [
	{
	'service-interface-point': {
	'service-interface-point-uuid': input_sip
	},
	'layer-protocol-name': layer_protocol_name,
	'layer-protocol-qualifier': layer_protocol_qualifier,
	'local-id': input_sip
	},
	{
	'service-interface-point': {
	'service-interface-point-uuid': output_sip
	},
	'layer-protocol-name': layer_protocol_name,
	'layer-protocol-qualifier': layer_protocol_qualifier,
	'local-id': output_sip
	}
	]
	}
	]
	}
	results = []
	try:
	LOGGER.info('Connectivity service {:s}: {:s}'.format(str(uuid), str(data)))
	response = requests.post(
	url=url, data=json.dumps(data), timeout=timeout, headers=headers, verify=False, auth=auth)
	LOGGER.info('TAPI response: {:s}'.format(str(response)))
	except Exception as e: # pylint: disable=broad-except
	LOGGER.exception('Exception creating ConnectivityService(uuid={:s}, data={:s})'.format(str(uuid), str(data)))
	results.append(e)
	else:
	if response.status_code not in HTTP_OK_CODES:
	msg = 'Could not create ConnectivityService(uuid={:s}, data={:s}). status_code={:s} reply={:s}'
	LOGGER.error(msg.format(str(uuid), str(data), str(response.status_code), str(response)))
	results.append(response.status_code in HTTP_OK_CODES)
	return results

	def delete_connectivity_service(root_url, uuid, auth : Optional[HTTPBasicAuth] = None, timeout : Optional[int] = None):
	url = '{:s}/restconf/data/tapi-common:context/tapi-connectivity:connectivity-context/connectivity-service={:s}'
	url = url.format(root_url, uuid)
	results = []
	try:
	response = requests.delete(url=url, timeout=timeout, verify=False, auth=auth)
	except Exception as e: # pylint: disable=broad-except
	LOGGER.exception('Exception deleting ConnectivityService(uuid={:s})'.format(str(uuid)))
	results.append(e)
	else:
	if response.status_code not in HTTP_OK_CODES:
	msg = 'Could not delete ConnectivityService(uuid={:s}). status_code={:s} reply={:s}'
	LOGGER.error(msg.format(str(uuid), str(response.status_code), str(response)))
	results.append(response.status_code in HTTP_OK_CODES)
	return results

	def compose_service_endpoint_id(site_id : str, endpoint_id : Dict):		def compose_service_endpoint_id(site_id : str, endpoint_id : Dict):
	device_uuid = endpoint_id['device_id']['device_uuid']['uuid']		device_uuid = endpoint_id['device_id']['device_uuid']['uuid']