Device - IETF ACTN Driver: (bc3954ad) · Commits · TFS / controller

src/device/service/drivers/ietf_actn/IetfActnDriver.py

+29 −35

Original line number	Diff line number	Diff line
		@@ -16,45 +16,40 @@ import json, logging, requests, threading
		from typing import Any, Iterator, List, Optional, Tuple, Union
		from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method
		from common.type_checkers.Checkers import chk_string, chk_type
		from device.service.driver_api._Driver import _Driver
		from device.service.drivers.ietf_actn.Tools import create_resource, delete_resource, get_resource
		from . import ALL_RESOURCE_KEYS
		#from .Tools import create_connectivity_service, find_key, config_getter, delete_connectivity_service
		from device.service.driver_api._Driver import _Driver, RESOURCE_SERVICES
		from .handlers.EthtServiceHandler import EthtServiceHandler
		from .handlers.OsuTunnelHandler import OsuTunnelHandler
		from .handlers.RestApiClient import RestApiClient

		LOGGER = logging.getLogger(__name__)

		ALL_RESOURCE_KEYS = [
		RESOURCE_SERVICES,
		]

		DRIVER_NAME = 'ietf_actn'
		METRICS_POOL = MetricsPool('Device', 'Driver', labels={'driver': DRIVER_NAME})


		class IetfActnDriver(_Driver):
		def __init__(self, address: str, port: int, **settings) -> None:
		super().__init__(DRIVER_NAME, address, port, **settings)
		self.__lock = threading.Lock()
		self.__started = threading.Event()
		self.__terminate = threading.Event()

		username = self.settings.get('username')
		password = self.settings.get('password')
		self.__auth = HTTPBasicAuth(username, password) if username is not None and password is not None else None

		scheme = self.settings.get('scheme', 'http')
		base_url = self.settings.get('base_url', DEFAULT_BASE_URL)
		self.__base_url = '{:s}://{:s}:{:d}{:s}'.format(scheme, address, int(port), base_url)

		self.__timeout = int(self.settings.get('timeout', DEFAULT_TIMEOUT))
		self._rest_api_client = RestApiClient(address, port, settings=settings)
		self._handler_osu_tunnel = OsuTunnelHandler(self._rest_api_client)
		self._handler_etht_service = EthtServiceHandler(self._rest_api_client)

		def Connect(self) -> bool:
		url = self.__base_url + '/tapi-common:context'
		with self.__lock:
		if self.__started.is_set(): return True
		try:
		requests.get(url, timeout=self.__timeout, verify=False, auth=self.__auth)
		self._rest_api_client.get('Check Credentials', '', [])
		except requests.exceptions.Timeout:
		LOGGER.exception('Timeout connecting {:s}'.format(str(self.__base_url)))
		LOGGER.exception('Timeout exception checking connectivity')
		return False
		except Exception: # pylint: disable=broad-except
		LOGGER.exception('Exception connecting {:s}'.format(str(self.__base_url)))
		LOGGER.exception('Unhandled exception checking connectivity')
		return False
		else:
		self.__started.set()
		@@ -78,25 +73,24 @@ class IetfActnDriver(_Driver):
		if len(resource_keys) == 0: resource_keys = ALL_RESOURCE_KEYS
		for i, resource_key in enumerate(resource_keys):
		chk_string('resource_key[#{:d}]'.format(i), resource_key, allow_empty=False)
		results.extend(get_resource(
		self.__base_url, resource_key,
		timeout=self.__timeout, auth=self.__auth
		))
		etht_service = self._handler_etht_service.get(etht_service_name)
		osu_tunnel = self._handler_osu_tunnel.get(osu_tunnel_name)
		service_data = {}
		results.extend(('/service/service[...]', service_data))
		return results

		@metered_subclass_method(METRICS_POOL)
		def SetConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
		results = []
		if len(resources) == 0:
		return results
		if len(resources) == 0: return results
		with self.__lock:
		for resource_key, resource_value in resources:
		LOGGER.info('resource: key({:s}) => value({:s})'.format(str(resource_key), str(resource_value)))
		if isinstance(value, str): value = json.loads(value)
		results.extend(create_resource(
		self.__base_url, resource_key, resource_value,
		timeout=self.__timeout, auth=self.__auth
		))
		if isinstance(resource_value, str): resource_value = json.loads(resource_value)
		succeeded = self._handler_osu_tunnel.update(resource_value)
		if succeeded:
		succeeded = self._handler_etht_service.update(resource_value)
		results.extend(succeeded)
		return results

		@metered_subclass_method(METRICS_POOL)
		@@ -106,11 +100,11 @@ class IetfActnDriver(_Driver):
		with self.__lock:
		for resource_key, resource_value in resources:
		LOGGER.info('resource: key({:s}) => value({:s})'.format(str(resource_key), str(resource_value)))
		if isinstance(value, str): value = json.loads(value)
		results.extend(delete_resource(
		self.__base_url, resource_key, resource_value,
		timeout=self.__timeout, auth=self.__auth
		))
		if isinstance(resource_value, str): resource_value = json.loads(resource_value)
		succeeded = self._handler_etht_service.delete(etht_service_name)
		if succeeded:
		succeeded = self._handler_osu_tunnel.delete(osu_tunnel_name)
		results.extend(succeeded)
		return results

		@metered_subclass_method(METRICS_POOL)

src/device/service/drivers/ietf_actn/init.py

+0 −7

Original line number	Diff line number	Diff line
		@@ -11,10 +11,3 @@
		# 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 device.service.driver_api._Driver import RESOURCE_ENDPOINTS, RESOURCE_SERVICES

		ALL_RESOURCE_KEYS = [
		RESOURCE_ENDPOINTS,
		RESOURCE_SERVICES,
		]

src/device/service/drivers/ietf_actn/data.txt

0 → 100644

+14 −0

Original line number	Diff line number	Diff line

		osu_tunnel_1:
		delay = 20
		te_odu_number = 40
		src_ttp_channel_name = 'och:1-odu2:1-oduflex:1-osuflex:2'
		dst_ttp_channel_name = 'och:1-odu2:1-oduflex:3-osuflex:1'

		etht_service_1:
		etht_svc_type = 'op-mp2mp-svc'
		src_endpoint_static_route_list:
		dst='128.32.10.5', mask=24 => next_hop='128.32.33.5'
		dst='128.32.20.5', mask=24 => next_hop='128.32.33.5'
		dst_endpoint_static_route_list:
		dst='172.1.101.22', mask=24 => next_hop='172.10.33.5'