Commit 9b65d30a authored by Lluis Gifre Renom's avatar Lluis Gifre Renom
Browse files

Device component - gNMI OpenConfig driver: 

- Corrected interface parsing
- Activated Monitoring Thread
- Corrected paths and values in Monitoring Thread
parent 4935a708

src/device/service/drivers/gnmi_openconfig/GnmiSessionHandler.py

+7 −7
Original line number Diff line number Diff line
@@ -25,7 +25,7 @@ from .tools.Channel import get_grpc_channel 
from .tools.Path import path_from_string, path_to_string #, compose_path

from .tools.Subscriptions import Subscriptions

from .tools.Value import decode_value #, value_exists

#from .MonitoringThread import MonitoringThread

from .MonitoringThread import MonitoringThread



class GnmiSessionHandler:

    def __init__(self, address : str, port : int, settings : Dict, logger : logging.Logger) -> None:
@@ -41,7 +41,7 @@ class GnmiSessionHandler: 
        self._channel : Optional[grpc.Channel] = None

        self._stub : Optional[gNMIStub] = None

        self._yang_handler = YangHandler()

        #self._monit_thread = None

        self._monit_thread = None

        self._subscriptions = Subscriptions()

        self._in_subscriptions = queue.Queue()

        self._out_samples = queue.Queue()
@@ -68,16 +68,16 @@ class GnmiSessionHandler: 
            self._channel = get_grpc_channel(self._address, self._port, self._use_tls, self._logger)

            self._stub = gNMIStub(self._channel)

            check_capabilities(self._stub, self._username, self._password, timeout=120)

            #self._monit_thread = MonitoringThread(

            #    self._stub, self._logger, self._settings, self._in_subscriptions, self._out_samples)

            #self._monit_thread.start()

            self._monit_thread = MonitoringThread(

                self._stub, self._logger, self._settings, self._in_subscriptions, self._out_samples)

            self._monit_thread.start()

            self._connected.set()



    def disconnect(self):

        if not self._connected.is_set(): return

        with self._lock:

            #self._monit_thread.stop()

            #self._monit_thread.join()

            self._monit_thread.stop()

            self._monit_thread.join()

            self._channel.close()

            self._connected.clear()

src/device/service/drivers/gnmi_openconfig/MonitoringThread.py

+12 −6
Original line number Diff line number Diff line
@@ -147,10 +147,16 @@ class MonitoringThread(threading.Thread): 
                    timestamp = timestamp_local

                for update_entry in update.update:

                    str_path = path_to_string(update_entry.path)

                    if str_path.startswith('/interfaces/'):

                        # Add namespace, if missing

                        str_path_parts = str_path.split('/')

                        str_path_parts[1] = 'openconfig-interfaces:interfaces'

                        str_path = '/'.join(str_path_parts)

                    #if str_path != '/system/name/host-name': continue

                    #counter_name = update_entry.path[-1].name

                    value_type = update_entry.val.WhichOneof('value')

                    value = getattr(update_entry.val, value_type)

                    if isinstance(value, str):

                        if re.match(r'^[0-9]+$', value) is not None:

                            value = int(value)

                        elif re.match(r'^[0-9]*\.[0-9]*$', value) is not None:

src/device/service/drivers/gnmi_openconfig/handlers/Interface.py

+15 −25
Original line number Diff line number Diff line
@@ -149,8 +149,6 @@ class InterfaceHandler(_Handler): 
                    _subinterface['name'] = subinterface_state['name']

                if 'enabled' in subinterface_state:

                    _subinterface['enabled'] = subinterface_state['enabled']

                entry_subinterface_key = '{:s}/subinterface[{:d}]'.format(entry_interface_key, subinterface_index)

                entries.append((entry_subinterface_key, _subinterface))



                if 'vlan' in subinterface:

                    vlan = subinterface['vlan']
@@ -160,44 +158,36 @@ class InterfaceHandler(_Handler): 
                    if single_tagged is not None:

                        single_tagged_config = single_tagged['config']

                        vlan_id = single_tagged_config['vlan-id']



                        _vlan = {'vlan_id': vlan_id}

                        entry_vlan_key = '{:s}/vlan[single:{:s}]'.format(entry_subinterface_key, vlan_id)

                        entries.append((entry_vlan_key, _vlan))

                        _subinterface['vlan_id'] = vlan_id



                    if len(vlan_match) > 0:

                        raise Exception('Unsupported VLAN schema: {:s}'.format(str(vlan)))



                ipv4_addresses = subinterface.get('ipv4', {}).get('addresses', {}).get('address', [])

                if len(ipv4_addresses) > 1:

                    raise Exception('Multiple IPv4 Addresses not supported: {:s}'.format(str(ipv4_addresses)))

                for ipv4_address in ipv4_addresses:

                    LOGGER.debug('ipv4_address={:s}'.format(str(ipv4_address)))



                    ipv4_address_ip = ipv4_address['ip']

                    _subinterface['address_ip'] = ipv4_address['ip']

                    ipv4_address_state = ipv4_address.get('state', {})



                    _ipv4_address = {'ip': ipv4_address_ip}

                    if 'origin' in ipv4_address_state:

                        _ipv4_address['origin'] = ipv4_address_state['origin']

                    #if 'origin' in ipv4_address_state:

                    #    _subinterface['origin'] = ipv4_address_state['origin']

                    if 'prefix-length' in ipv4_address_state:

                        _ipv4_address['prefix'] = ipv4_address_state['prefix-length']



                    entry_ipv4_address_key = '{:s}/ipv4[{:s}]'.format(entry_subinterface_key, ipv4_address_ip)

                    entries.append((entry_ipv4_address_key, _ipv4_address))

                        _subinterface['address_prefix'] = ipv4_address_state['prefix-length']



                ipv6_addresses = subinterface.get('ipv6', {}).get('addresses', {}).get('address', [])

                if len(ipv6_addresses) > 1:

                    raise Exception('Multiple IPv6 Addresses not supported: {:s}'.format(str(ipv6_addresses)))

                for ipv6_address in ipv6_addresses:

                    LOGGER.debug('ipv6_address={:s}'.format(str(ipv6_address)))



                    ipv6_address_ip = ipv6_address['ip']

                    _subinterface['address_ipv6'] = ipv6_address['ip']

                    ipv6_address_state = ipv6_address.get('state', {})



                    _ipv6_address = {'ip': ipv6_address_ip}

                    if 'origin' in ipv6_address_state:

                        _ipv6_address['origin'] = ipv6_address_state['origin']

                    #if 'origin' in ipv6_address_state:

                    #    _subinterface['origin_ipv6'] = ipv6_address_state['origin']

                    if 'prefix-length' in ipv6_address_state:

                        _ipv6_address['prefix'] = ipv6_address_state['prefix-length']

                        _subinterface['address_prefix_ipv6'] = ipv6_address_state['prefix-length']



                    entry_ipv6_address_key = '{:s}/ipv6[{:s}]'.format(entry_subinterface_key, ipv6_address_ip)

                    entries.append((entry_ipv6_address_key, _ipv6_address))

                entry_subinterface_key = '{:s}/subinterface[{:d}]'.format(entry_interface_key, subinterface_index)

                entries.append((entry_subinterface_key, _subinterface))



        return entries