VOL-1397: Adtran-OLT - Initial containerization commit
- Need to move VERSION to base directory
Change-Id: I9d62d0607a011ce642e379fd92b35ec48b300070
diff --git a/adapters/adtran_common/flow/evc.py b/adapters/adtran_common/flow/evc.py
new file mode 100644
index 0000000..5e00bca
--- /dev/null
+++ b/adapters/adtran_common/flow/evc.py
@@ -0,0 +1,479 @@
+# Copyright 2017-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.
+
+import xmltodict
+import re
+import structlog
+from enum import IntEnum
+from twisted.internet import reactor, defer
+from twisted.internet.defer import inlineCallbacks, returnValue, succeed
+
+log = structlog.get_logger()
+
+EVC_NAME_FORMAT = 'VOLTHA-{}' # format(flow.id)
+EVC_NAME_REGEX_ALL = EVC_NAME_FORMAT.format('*')
+DEFAULT_STPID = 0x8100
+
+
+class EVC(object):
+ """
+ Class to wrap EVC functionality
+ """
+ class SwitchingMethod(IntEnum):
+ SINGLE_TAGGED = 1
+ DOUBLE_TAGGED = 2
+ MAC_SWITCHED = 3
+ DOUBLE_TAGGED_MAC_SWITCHED = 4
+ DEFAULT = SINGLE_TAGGED
+
+ @staticmethod
+ def xml(value):
+ if value is None:
+ value = EVC.SwitchingMethod.DEFAULT
+ if value == EVC.SwitchingMethod.SINGLE_TAGGED:
+ return '<single-tag-switched/>'
+ elif value == EVC.SwitchingMethod.DOUBLE_TAGGED:
+ return '<double-tag-switched/>'
+ elif value == EVC.SwitchingMethod.MAC_SWITCHED:
+ return '<mac-switched/>'
+ elif value == EVC.SwitchingMethod.DOUBLE_TAGGED_MAC_SWITCHED:
+ return '<double-tag-mac-switched/>'
+ raise ValueError('Invalid SwitchingMethod enumeration')
+
+ class Men2UniManipulation(IntEnum):
+ SYMMETRIC = 1
+ POP_OUT_TAG_ONLY = 2
+ DEFAULT = SYMMETRIC
+
+ @staticmethod
+ def xml(value):
+ if value is None:
+ value = EVC.Men2UniManipulation.DEFAULT
+ fmt = '<men-to-uni-tag-manipulation>{}</men-to-uni-tag-manipulation>'
+ if value == EVC.Men2UniManipulation.SYMMETRIC:
+ return fmt.format('<symmetric/>')
+ elif value == EVC.Men2UniManipulation.POP_OUT_TAG_ONLY:
+ return fmt.format('<pop-outer-tag-only/>')
+ raise ValueError('Invalid Men2UniManipulation enumeration')
+
+ class ElineFlowType(IntEnum):
+ NNI_TO_UNI = 1
+ UNI_TO_NNI = 2
+ NNI_TO_NNI = 3
+ UNI_TO_UNI = 4
+ ACL_FILTER = 5
+ UNKNOWN = 6
+ UNSUPPORTED = 7 # Or Invalid
+
+ def __init__(self, flow_entry):
+ self._installed = False
+ self._status_message = None
+ self._flow = flow_entry
+ self._name = self._create_name()
+ self._deferred = None
+ self._evc_maps = {} # Map Name -> evc-map
+
+ self._flow_type = EVC.ElineFlowType.UNKNOWN
+
+ # EVC related properties
+ self._enabled = True
+ self._men_ports = []
+ self._s_tag = None
+ self._stpid = None
+ self._switching_method = None
+ self.service_evc = False
+
+ self._ce_vlan_preservation = None
+ self._men_to_uni_tag_manipulation = None
+
+ try:
+ self._valid = self._decode()
+
+ except Exception as e:
+ log.exception('Failure during EVC decode', e=e)
+ self._valid = False
+
+ def __str__(self):
+ return "EVC-{}: MEN: {}, S-Tag: {}".format(self._name, self._men_ports, self._s_tag)
+
+ def _create_name(self):
+ #
+ # TODO: Take into account selection criteria and output to make the name
+ #
+ return EVC_NAME_FORMAT.format(self._flow.flow_id)
+
+ def _cancel_deferred(self):
+ d, self._deferred = self._deferred, None
+
+ try:
+ if d is not None and not d.called:
+ d.cancel()
+
+ except Exception as e:
+ pass
+
+ @property
+ def name(self):
+ return self._name
+
+ @property
+ def valid(self):
+ return self._valid
+
+ @property
+ def installed(self):
+ return self._installed
+
+ @installed.setter
+ def installed(self, value):
+ assert not value, 'EVC Install can only be reset'
+ self._installed = False
+
+ @property
+ def status(self):
+ return self._status_message
+
+ @status.setter
+ def status(self, value):
+ self._status_message = value
+
+ @property
+ def s_tag(self):
+ return self._s_tag
+
+ @property
+ def stpid(self):
+ return self._stpid
+
+ @stpid.setter
+ def stpid(self, value):
+ assert self._stpid is None or self._stpid == value, 'STPID can only be set once'
+ self._stpid = value
+
+ @property
+ def switching_method(self):
+ return self._switching_method
+
+ @switching_method.setter
+ def switching_method(self, value):
+ assert self._switching_method is None or self._switching_method == value,\
+ 'Switching Method can only be set once. EVC: {}'.format(self.name)
+ self._switching_method = value
+
+ @property
+ def ce_vlan_preservation(self):
+ return self._ce_vlan_preservation
+
+ @ce_vlan_preservation.setter
+ def ce_vlan_preservation(self, value):
+ assert self._ce_vlan_preservation is None or self._ce_vlan_preservation == value,\
+ 'CE VLAN Preservation can only be set once'
+ self._ce_vlan_preservation = value
+
+ @property
+ def men_to_uni_tag_manipulation(self):
+ return self._men_to_uni_tag_manipulation
+
+ @men_to_uni_tag_manipulation.setter
+ def men_to_uni_tag_manipulation(self, value):
+ assert self._men_to_uni_tag_manipulation is None or self._men_to_uni_tag_manipulation == value, \
+ 'MEN-to-UNI tag manipulation can only be set once'
+ self._men_to_uni_tag_manipulation = value
+
+ @property
+ def flow_entry(self):
+ # Note that the first flow used to create the EVC is saved and it may
+ # eventually get deleted while others still use the EVC. This should
+ # be okay as the downstream flow/signature table is used to maintain
+ # the lifetime on this EVC object.
+ return self._flow
+
+ @flow_entry.setter
+ def flow_entry(self, value):
+ self._flow = value
+
+ @property
+ def evc_maps(self):
+ """
+ Get all EVC Maps that reference this EVC
+ :return: list of EVCMap
+ """
+ return list(self._evc_maps.values()) if self._evc_maps is not None else []
+
+ @property
+ def evc_map_names(self):
+ """
+ Get all EVC Map names that reference this EVC
+ :return: list of EVCMap names
+ """
+ return list(self._evc_maps.keys()) if self._evc_maps is not None else []
+
+ def add_evc_map(self, evc_map):
+ if self._evc_maps is None:
+ self._evc_maps = dict()
+
+ if evc_map.name not in self._evc_maps:
+ self._evc_maps[evc_map.name] = evc_map
+
+ def remove_evc_map(self, evc_map):
+ if self._evc_maps is not None and evc_map.name in self._evc_maps:
+ del self._evc_maps[evc_map.name]
+
+ def schedule_install(self, delay=0):
+ """
+ Try to install EVC and all MAPs in a single operational sequence.
+ The delay parameter is used during recovery to allow multiple associated
+ EVC maps to be updated/modified independently before the parent EVC
+ is installed.
+
+ :param delay: (int) Seconds to delay before install
+ """
+ self._cancel_deferred()
+
+ self._deferred = reactor.callLater(delay, self._do_install) \
+ if self._valid else succeed('Not VALID')
+
+ return self._deferred
+
+ @staticmethod
+ def _xml_header(operation=None):
+ return '<evcs xmlns="http://www.adtran.com/ns/yang/adtran-evcs"{}><evc>'.\
+ format('' if operation is None else ' xc:operation="{}"'.format(operation))
+
+ @staticmethod
+ def _xml_trailer():
+ return '</evc></evcs>'
+
+ @inlineCallbacks
+ def _do_install(self):
+ # Install the EVC if needed
+ log.debug('do-install', valid=self._valid, installed=self._installed)
+
+ if self._valid and not self._installed:
+ # TODO: Currently install EVC and then MAPs. Can do it all in a single edit-config operation
+
+ xml = EVC._xml_header()
+ xml += '<name>{}</name>'.format(self.name)
+ xml += '<enabled>{}</enabled>'.format('true' if self._enabled else 'false')
+
+ if self._ce_vlan_preservation is not None:
+ xml += '<ce-vlan-preservation>{}</ce-vlan-preservation>'.format('false')
+
+ if self._s_tag is not None:
+ xml += '<stag>{}</stag>'.format(self._s_tag)
+ xml += '<stag-tpid>{}</stag-tpid>'.format(self._stpid or DEFAULT_STPID)
+ else:
+ xml += 'no-stag/'
+
+ for port in self._men_ports:
+ xml += '<men-ports>{}</men-ports>'.format(port)
+
+ # xml += EVC.Men2UniManipulation.xml(self._men_to_uni_tag_manipulation)
+ # xml += EVC.SwitchingMethod.xml(self._switching_method)
+ xml += EVC._xml_trailer()
+
+ log.debug('create-evc', name=self.name, xml=xml)
+ try:
+ # Set installed to true while request is in progress
+ self._installed = True
+ results = yield self._flow.handler.netconf_client.edit_config(xml)
+ self._installed = results.ok
+ self.status = '' if results.ok else results.error
+
+ except Exception as e:
+ log.exception('install-failed', name=self.name, e=e)
+ raise
+
+ # Install any associated EVC Maps
+
+ if self._installed:
+ for evc_map in self.evc_maps:
+ try:
+ yield evc_map.install()
+
+ except Exception as e:
+ evc_map.status = 'Exception during EVC-MAP Install: {}'.format(e.message)
+ log.exception('evc-map-install-failed', e=e)
+
+ returnValue(self._installed and self._valid)
+
+ def remove(self, remove_maps=True):
+ """
+ Remove EVC (and optional associated EVC-MAPs) from hardware
+ :param remove_maps: (boolean)
+ :return: (deferred)
+ """
+ if not self.installed:
+ return succeed('Not installed')
+
+ log.info('removing', evc=self, remove_maps=remove_maps)
+ dl = []
+
+ def _success(rpc_reply):
+ log.debug('remove-success', rpc_reply=rpc_reply)
+ self._installed = False
+
+ def _failure(results):
+ log.error('remove-failed', results=results)
+ self._installed = False
+
+ xml = EVC._xml_header('delete') + '<name>{}</name>'.format(self.name) + EVC._xml_trailer()
+ d = self._flow.handler.netconf_client.edit_config(xml)
+ d.addCallbacks(_success, _failure)
+ dl.append(d)
+
+ if remove_maps:
+ for evc_map in self.evc_maps:
+ dl.append(evc_map.remove())
+
+ return defer.gatherResults(dl, consumeErrors=True)
+
+ @inlineCallbacks
+ def delete(self, delete_maps=True):
+ """
+ Remove from hardware and delete/clean-up EVC Object
+ """
+ log.info('deleting', evc=self, delete_maps=delete_maps)
+
+ assert self._flow, 'Delete EVC must have flow reference'
+ try:
+ dl = [self.remove()]
+ self._valid = False
+
+ if delete_maps:
+ for evc_map in self.evc_maps:
+ dl.append(evc_map.delete(None)) # TODO: implement bulk-flow procedures
+
+ yield defer.gatherResults(dl, consumeErrors=True)
+
+ except Exception as e:
+ log.exception('removal', e=e)
+
+ self._evc_maps = None
+ f, self._flow = self._flow, None
+ if f is not None and f.handler is not None:
+ f.handler.remove_evc(self)
+
+ returnValue('Done')
+
+ def reflow(self, reflow_maps=True):
+ """
+ Attempt to install/re-install a flow
+ :param reflow_maps: (boolean) Flag indication if EVC-MAPs should be reflowed as well
+ :return: (deferred)
+ """
+ self._installed = False
+
+ if reflow_maps:
+ for evc_map in self.evc_maps:
+ evc_map.installed = False
+
+ return self.schedule_install()
+
+ def _decode(self):
+ """
+ Examine flow rules and extract appropriate settings for this EVC
+ """
+ if self._flow.handler.is_nni_port(self._flow.in_port):
+ self._men_ports.append(self._flow.handler.get_port_name(self._flow.in_port))
+ else:
+ self._status_message = 'EVCs with UNI ports are not supported'
+ return False # UNI Ports handled in the EVC Maps
+
+ self._s_tag = self._flow.vlan_id
+
+ if self._flow.inner_vid is not None:
+ self._switching_method = EVC.SwitchingMethod.DOUBLE_TAGGED
+
+ # For the Utility VLAN, multiple ingress ACLs (different GEMs) will need to
+ # be trapped on this EVC. Since these are usually untagged, we have to force
+ # the EVC to preserve CE VLAN tags.
+
+ if self._s_tag == self._flow.handler.utility_vlan:
+ self._ce_vlan_preservation = True
+
+ # Note: The following fields may get set when the first EVC-MAP
+ # is associated with this object. Once set, they cannot be changed to
+ # another value.
+ # self._stpid
+ # self._switching_method
+ # self._ce_vlan_preservation
+ # self._men_to_uni_tag_manipulation
+ return True
+
+ # BULK operations
+
+ @staticmethod
+ def remove_all(client, regex_=EVC_NAME_REGEX_ALL):
+ """
+ Remove all matching EVCs from hardware
+ :param client: (ncclient) NETCONF Client to use
+ :param regex_: (String) Regular expression for name matching
+ :return: (deferred)
+ """
+ # Do a 'get' on the evc config an you should get the names
+ get_xml = """
+ <filter xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <evcs xmlns="http://www.adtran.com/ns/yang/adtran-evcs">
+ <evc><name/></evc>
+ </evcs>
+ </filter>
+ """
+ log.debug('query', xml=get_xml, regex=regex_)
+
+ def request_failed(results, operation):
+ log.error('{}-failed'.format(operation), results=results)
+ # No further actions. Periodic poll later on will scrub any old EVCs if needed
+
+ def delete_complete(results):
+ log.debug('delete-complete', results=results)
+
+ def do_delete(rpc_reply, regexpr):
+ log.debug('query-complete', rpc_reply=rpc_reply)
+
+ if rpc_reply.ok:
+ result_dict = xmltodict.parse(rpc_reply.data_xml)
+ entries = result_dict['data']['evcs'] if 'evcs' in result_dict['data'] else {}
+
+ if 'evc' in entries:
+ p = re.compile(regexpr)
+
+ if isinstance(entries['evc'], list):
+ names = {entry['name'] for entry in entries['evc'] if 'name' in entry
+ and p.match(entry['name'])}
+ else:
+ names = set()
+ for item in entries['evc'].items():
+ if isinstance(item, tuple) and item[0] == 'name':
+ names.add(item[1])
+ break
+
+ if len(names) > 0:
+ del_xml = '<evcs xmlns="http://www.adtran.com/ns/yang/adtran-evcs"' + \
+ ' xc:operation = "delete">'
+ for name in names:
+ del_xml += '<evc>'
+ del_xml += '<name>{}</name>'.format(name)
+ del_xml += '</evc>'
+ del_xml += '</evcs>'
+ log.debug('removing', xml=del_xml)
+
+ return client.edit_config(del_xml)
+
+ return succeed('no entries')
+
+ d = client.get(get_xml)
+ d.addCallbacks(do_delete, request_failed, callbackArgs=[regex_], errbackArgs=['get'])
+ d.addCallbacks(delete_complete, request_failed, errbackArgs=['edit-config'])
+ return d