Merge pull request #74 from QualiSystems/dev

cloudshell-networking-cisco-5.2.6

Author: Costya-Y

.gitignore

@@ -61,3 +61,7 @@ target/
 #Ipython Notebook
 .ipynb_checkpoints
 .pypirc
+tests/networking/cisco/autoload/test_cisco_autoload.py
+tests/networking/cisco/autoload/autoload_structure.py
+/*.pyproj
+/.pytest_cache

cloudshell/networking/cisco/autoload/cisco_generic_snmp_autoload.py

@@ -290,12 +290,10 @@ def _get_port_channels(self):
         :return:
         """
 
-        if not self.if_table:
+        if not self.if_table.if_port_channels:
             return
-        port_channel_list = [if_entity for if_entity in self.if_table.if_entities if
-                             "port-channel" in if_entity.if_name.lower()]
         self.logger.info("Building Port Channels")
-        for if_port_channel in port_channel_list:
+        for if_port_channel in self.if_table.if_port_channels:
             interface_model = if_port_channel.if_name
             match_object = re.search(r"\d+$", interface_model)
             if match_object:

cloudshell/networking/cisco/autoload/snmp_entity_table.py

@@ -25,7 +25,8 @@ def __init__(self, snmp_handler, logger, if_table):
         self._sorted_module_list = []
         self._power_supply_list = []
         self._filtered_power_supply_list = []
-        self.port_exclude_pattern = r'stack|engine|management|mgmt|voice|foreign|cpu|control\s*ethernet\s*port'
+        self.port_exclude_pattern = r'stack|engine|management|mgmt|voice|foreign|' \
+                                    r'cpu|control\s*ethernet\s*port|console\s*port'
         # self.module_exclude_pattern = r''
         self.entity_to_container_pattern = "powershelf|cevsfp|cevxfr|cevxfp|cevContainer10GigBasePort|cevModulePseAsicPlim"
         # self.ignore_entity_pattern = "cevModule$|cevModuleDaughterCard$"
@@ -76,7 +77,12 @@ def _get_sorted_modules_with_ports(self):
     def _analyze_module(self, module):
         if module not in self.exclusion_list:
             module_parent_address = self.get_relative_address(module)
-            module_parent_address = module_parent_address[:3]
+            if not module_parent_address:
+                self._excluded_models.append(module)
+                return
+            module_parent_address_list = module_parent_address.split("/")
+            if len(module_parent_address_list) > 2:
+                module_parent_address = '{0}/{1}'.format(module_parent_address[0], module_parent_address[1])
 
             module_rel_path = module_parent_address + '/' + self.get_resource_id(module)
             i = 1
@@ -107,8 +113,8 @@ def _get_entity_table(self):
 
         result_dict = QualiMibTable('entPhysicalTable')
 
-        entity_table_critical_port_attr = {'entPhysicalContainedIn': 'str', 'entPhysicalClass': 'str',
-                                           'entPhysicalVendorType': 'str'}
+        # entity_table_critical_port_attr = {'entPhysicalContainedIn': 'str', 'entPhysicalClass': 'str',
+        #                                    'entPhysicalVendorType': 'str'}
         entity_table_optional_port_attr = {'entPhysicalDescr': 'str', 'entPhysicalName': 'str'}
 
         physical_indexes = self._snmp.get_table('ENTITY-MIB', 'entPhysicalParentRelPos')
@@ -119,27 +125,38 @@ def _get_entity_table(self):
                 self.exclusion_list.append(index)
                 continue
             temp_entity_table = physical_indexes[index].copy()
-            temp_entity_table.update(self._snmp.get_properties('ENTITY-MIB', index, entity_table_critical_port_attr)
+
+            temp_entity_table.update(self._snmp.get_properties('ENTITY-MIB', index, {"entPhysicalClass": "str"})
                                      [index])
-            if re.search(r"cevsensor|cevfan", temp_entity_table['entPhysicalVendorType'].lower()):
+            if re.search(r"cpu|fan|sensor", temp_entity_table['entPhysicalClass'].lower()):
+                self._logger.debug("Loaded {}, skipping.".format(temp_entity_table['entPhysicalClass']))
                 continue
+
+            temp_entity_table.update(self._snmp.get_properties('ENTITY-MIB', index, {"entPhysicalContainedIn": "str"})
+                                     [index])
             if temp_entity_table['entPhysicalContainedIn'] == '':
                 self.exclusion_list.append(index)
                 continue
 
-            if temp_entity_table['entPhysicalClass'] == '' or "other" in temp_entity_table['entPhysicalClass']:
+            temp_entity_table.update(self._snmp.get_properties('ENTITY-MIB', index, {"entPhysicalVendorType": "str"})
+                                     [index])
+            ent_physical_class = temp_entity_table.get("entPhysicalClass")
+            if not ent_physical_class or ent_physical_class == "''" or "other" in ent_physical_class:
                 vendor_type = temp_entity_table['entPhysicalVendorType']
                 if not vendor_type:
                     continue
                 vendor_type_match = re.search(vendor_type_match_pattern, vendor_type.lower())
+                index_entity_class = None
                 if vendor_type_match:
                     index_entity_class = self.ENTITY_VENDOR_TYPE_TO_CLASS_MAP[vendor_type_match.group()]
-                else:
-                    continue
                 if index_entity_class:
                     temp_entity_table['entPhysicalClass'] = index_entity_class
-            if re.search(self.entity_to_container_pattern, temp_entity_table['entPhysicalVendorType'].lower(),
-                         re.IGNORECASE):
+                elif not ent_physical_class or ent_physical_class == "''":
+                    self.exclusion_list.append(index)
+                    continue
+            if "module" in temp_entity_table['entPhysicalClass'].lower() \
+                    and re.search(self.entity_to_container_pattern, temp_entity_table['entPhysicalVendorType'].lower(),
+                                  re.IGNORECASE):
                 temp_entity_table['entPhysicalClass'] = 'container'
             else:
                 temp_entity_table['entPhysicalClass'] = temp_entity_table['entPhysicalClass'].replace("'", "")
@@ -165,6 +182,8 @@ def _get_entity_table(self):
                         and not re.search(self.port_exclude_pattern, temp_entity_table['entPhysicalDescr'],
                                           re.IGNORECASE):
                     port_entity = self._get_mapping(index, temp_entity_table[self.ENTITY_PHYSICAL])
+                    if not port_entity:
+                        port_entity = self._get_mapping(index, temp_entity_table["entPhysicalName"])
                     if port_entity and port_entity not in self.port_mapping.values():
                         self.port_mapping[index] = port_entity
                         self._port_list.append(index)
@@ -246,8 +265,9 @@ def _filter_entity_table(self, raw_entity_table):
         elements = raw_entity_table.sort_by_column('ParentRelPos').keys()
         for element in reversed(elements):
             parent_id = int(raw_entity_table[element]['entPhysicalContainedIn'])
-            if (parent_id not in raw_entity_table and "chassis" not in raw_entity_table[element][
-                "entPhysicalClass"]) or parent_id in self.exclusion_list:
+            element_class = raw_entity_table.get(element, dict()).get("entPhysicalClass")
+            if (parent_id not in raw_entity_table and element_class not in ["chassis",
+                                                                           "stack"]) or parent_id in self.exclusion_list:
                 self.exclusion_list.append(element)
         return raw_entity_table
 

cloudshell/networking/cisco/autoload/snmp_if_entity.py

@@ -1,67 +1,30 @@
 class SnmpIfEntity(object):
     IF_MIB = "IF-MIB"
-    IF_TYPE = "ifType"
-    IF_MTU = "ifMtu"
-    IF_SPEED = "ifHighSpeed"
     IF_NAME = "ifDescr"
-    IF_MAC = "ifPhysAddress"
     IF_ALIAS = "ifAlias"
 
     def __init__(self, snmp_handler, logger, index, port_attributes_snmp_tables):
         self.if_index = int(index)
         self._snmp = snmp_handler
         self._port_attributes_snmp_tables = port_attributes_snmp_tables
         self._logger = logger
-        self._if_type = "other"
-        self._if_speed = 0
-        self._if_mtu = 0
-        self._if_mac = ""
         self._ipv4 = ""
         self._ipv6 = ""
         self._if_alias = ""
-        self._if_name = None
-        self._adjacent = ""
-        self._duplex = ""
-        self._auto_neg = ""
-        self._port_channel_associated_port = ""
+        self._if_name = ""
 
     @property
     def if_name(self):
         if not self._if_name:
             self._if_name = self._snmp.get_property(self.IF_MIB, self.IF_NAME, self.if_index)
         return self._if_name
 
-    @property
-    def if_type(self):
-        if not self._if_type:
-            self._if_type = self._snmp.get_property(self.IF_MIB, self.IF_TYPE, self.if_index).replace('/', '').replace(
-                "'", '')
-        return self._if_type
-
     @property
     def if_port_description(self):
         if not self._if_alias:
             self._if_alias = self._snmp.get_property(self.IF_MIB, self.IF_ALIAS, self.if_index)
         return self._if_alias
 
-    @property
-    def if_speed(self):
-        if not self._if_speed:
-            self._if_speed = self._snmp.get_property(self.IF_MIB, self.IF_SPEED, self.if_index)
-        return self._if_speed
-
-    @property
-    def if_mtu(self):
-        if not self._if_mtu:
-            self._if_mtu = self._snmp.get_property(self.IF_MIB, self.IF_MTU, self.if_index)
-        return self._if_mtu
-
-    @property
-    def if_mac(self):
-        if not self._if_mac:
-            self._if_mac = self._snmp.get_property(self.IF_MIB, self.IF_MAC, self.if_index)
-        return self._if_mac
-
     @property
     def ipv4_address(self):
         if not self._ipv4:
@@ -74,96 +37,6 @@ def ipv6_address(self):
             self._ipv6 = self._get_ipv6()
         return self._ipv6
 
-    @property
-    def adjacent(self):
-        if not self._adjacent:
-            self._adjacent = self._get_adjacent()
-        return self._adjacent
-
-    @property
-    def duplex(self):
-        if not self._duplex:
-            self._duplex = self._get_duplex() or "Half"
-        return self._duplex
-
-    @property
-    def auto_negotiation(self):
-        if not self._auto_neg:
-            self._auto_neg = self._get_auto_neg() or "False"
-        return self._auto_neg
-
-    @property
-    def associated_port_list(self):
-        if not self._port_channel_associated_port:
-            self._port_channel_associated_port = self._get_associated_ports()
-        return self._port_channel_associated_port
-
-    def _get_associated_ports(self):
-        """Get all ports associated with provided port channel
-        :return:
-        """
-
-        result = []
-        for key, value in self._port_attributes_snmp_tables.port_channel_ports.iteritems():
-            if str(self.if_index) in value['dot3adAggPortAttachedAggID']:
-                result.append(key)
-        return result
-
-    def _get_adjacent(self):
-        """Get connected device interface and device name to the specified port id, using cdp or lldp protocols
-
-        :param interface_id: port id
-        :return: device's name and port connected to port id
-        :rtype string
-        """
-
-        result_template = '{remote_host} through {remote_port}'
-        result = ''
-        for key, value in self._port_attributes_snmp_tables.cdp_table.iteritems():
-            if str(key).startswith(str(self.if_index)):
-                port = self._snmp.get_property('CISCO-CDP-MIB', 'cdpCacheDevicePort', key)
-                result = result_template.format(remote_host=value.get('cdpCacheDeviceId', ''), remote_port=port)
-                break
-        if result == '' and self._port_attributes_snmp_tables.lldp_local_table:
-            interface_name = self.if_name.lower()
-            if interface_name:
-                key = self._port_attributes_snmp_tables.lldp_local_table.get(interface_name, None)
-                if key:
-                    for port_id, rem_table in self._port_attributes_snmp_tables.lldp_remote_table.iteritems():
-                        if ".{0}.".format(key) in port_id:
-                            remoute_sys_name = rem_table.get('lldpRemSysName', "")
-                            remoute_port_name = self._snmp.get_property('LLDP-MIB', 'lldpRemPortDesc', port_id)
-                            if remoute_port_name and remoute_sys_name:
-                                result = result_template.format(remote_host=remoute_sys_name,
-                                                                remote_port=remoute_port_name)
-                                break
-        return result
-
-    def _get_auto_neg(self):
-        """Get port auto negotiation status
-
-        :return return "True"
-        """
-
-        try:
-            auto_negotiation = self._snmp.get(('MAU-MIB', 'ifMauAutoNegAdminStatus', self.if_index, 1)).values()[0]
-            if 'enabled' in auto_negotiation.lower():
-                return 'True'
-        except Exception as e:
-            self._logger.error('Failed to load auto negotiation property for interface {0}'.format(e.message))
-
-    def _get_duplex(self):
-        """Get current duplex state
-
-        :return str "Full"
-        """
-
-        for key, value in self._port_attributes_snmp_tables.duplex_table.iteritems():
-            if 'dot3StatsIndex' in value.keys() and value['dot3StatsIndex'] == str(self.if_index):
-                interface_duplex = self._snmp.get_property('EtherLike-MIB', 'dot3StatsDuplexStatus', key)
-                if 'fullDuplex' in interface_duplex:
-                    return 'Full'
-
     def _get_ipv4(self):
         """Get IPv4 address details for provided port
 

cloudshell/networking/cisco/autoload/snmp_if_port_channel_entity.py

@@ -0,0 +1,25 @@
+from cloudshell.networking.cisco.autoload.snmp_if_entity import SnmpIfEntity
+
+
+class SnmpIfPortChannelEntity(SnmpIfEntity):
+    def __init__(self, snmp_handler, logger, index, port_attributes_snmp_tables, name=None):
+        super(SnmpIfPortChannelEntity, self).__init__(snmp_handler, logger, index, port_attributes_snmp_tables)
+        self._port_channel_associated_port = ""
+        self._if_name = name
+
+    @property
+    def associated_port_list(self):
+        if not self._port_channel_associated_port:
+            self._port_channel_associated_port = self._get_associated_ports()
+        return self._port_channel_associated_port
+
+    def _get_associated_ports(self):
+        """Get all ports associated with provided port channel
+        :return:
+        """
+
+        result = []
+        for key, value in self._port_attributes_snmp_tables.port_channel_ports.iteritems():
+            if str(self.if_index) in value['dot3adAggPortAttachedAggID']:
+                result.append(key)
+        return result