Merge pull request #72 from QualiSystems/dev

cloudshell-networking-cisco-5.1.2

Author: Costya-Y

MANIFEST.in

@@ -1,2 +1,3 @@
 include *.txt
+recursive-include *.csv
 global-include *.ini

cloudshell/networking/cisco/autoload/cisco_generic_snmp_autoload.py

@@ -7,6 +7,7 @@
 from cloudshell.networking.cisco.autoload.snmp_if_table import SnmpIfTable
 
 from cloudshell.devices.autoload.autoload_builder import AutoloadDetailsBuilder
+from cloudshell.devices.autoload.device_names import get_device_name
 from cloudshell.devices.standards.networking.autoload_structure import *
 
 
@@ -15,6 +16,7 @@ class CiscoGenericSNMPAutoload(object):
     IF_ENTITY = "ifDescr"
     ENTITY_PHYSICAL = "entPhysicalDescr"
     SNMP_ERRORS = [r'No\s+Such\s+Object\s+currently\s+exists']
+    DEVICE_NAMES_MAP_FILE = os.path.join(os.path.dirname(__file__), os.pardir, "mibs", "device_names_map.csv")
 
     def __init__(self, snmp_handler, shell_name, shell_type, resource_name, logger):
         """Basic init with injected snmp handler and logger
@@ -113,18 +115,27 @@ def _is_valid_device_os(self, supported_os):
             return False
 
     def _get_device_model(self):
-        """Get device model form snmp SNMPv2 mib
+        """Get device model from the SNMPv2 mib
 
         :return: device model
         :rtype: str
         """
-
         result = ''
         match_name = re.search(r'::(?P<model>\S+$)', self.snmp_handler.get_property('SNMPv2-MIB', 'sysObjectID', '0'))
         if match_name:
-            result = match_name.groupdict()['model'].capitalize()
+            result = match_name.group('model')
+
         return result
 
+    def _get_device_model_name(self, device_model):
+        """Get device model name from the CSV file map
+
+        :param str device_model:  device model
+        :return: device model model
+        :rtype: str
+        """
+        return get_device_name(file_name=self.DEVICE_NAMES_MAP_FILE, sys_obj_id=device_model)
+
     def _get_device_os_version(self):
         """Get device OS Version form snmp SNMPv2 mib
 
@@ -150,6 +161,7 @@ def _get_device_details(self):
         self.resource.location = self.snmp_handler.get_property('SNMPv2-MIB', 'sysLocation', '0')
         self.resource.os_version = self._get_device_os_version()
         self.resource.model = self._get_device_model()
+        self.resource.model_name = self._get_device_model_name(self.resource.model)
         self.resource.vendor = vendor
 
     def _load_snmp_tables(self):
@@ -305,7 +317,7 @@ def _get_port_channels(self):
 
             else:
                 self.logger.error("Adding of {0} failed. Name is invalid".format(interface_model))
- 
+
         self.logger.info("Building Port Channels completed")
 
     def _get_ports_attributes(self, port_list):

cloudshell/networking/cisco/autoload/snmp_entity_table.py

@@ -70,7 +70,8 @@ def _get_sorted_modules_with_ports(self):
             if len(modules) > 1 and modules[-1] not in self._module_list:
                 self._analyze_module(modules[-1])
         module_relative_paths = sorted(self.relative_address, key=self.relative_address.get)
-        self._sorted_module_list = [module for module in module_relative_paths if module in self._module_list]
+        self._sorted_module_list = [module for module in module_relative_paths if
+                                    module in self._module_list and module not in self.exclusion_list]
 
     def _analyze_module(self, module):
         if module not in self.exclusion_list:
@@ -220,11 +221,13 @@ def get_relative_address(self, item_id):
         result = ''
         if int(item_id) not in self._filtered_chassis_list:
             parent_id = int(self._entity_table[item_id]['entPhysicalContainedIn'])
+            if parent_id in self.exclusion_list:
+                return result
             if parent_id not in self.relative_address.keys():
                 if parent_id in self._sorted_module_list:
                     result = self.get_resource_id(parent_id)
                 if result != '':
-                    result = self.get_relative_address(parent_id) + '/' + result
+                    result = "{}/{}".format(self.get_relative_address(parent_id), result)
                 else:
                     result = self.get_relative_address(parent_id)
             else:
@@ -243,12 +246,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'])
-            # while parent_id in self.ignore_entities_dict.keys():
-            #     parent_id = int(raw_entity_table[parent_id]['entPhysicalContainedIn'])
-            #     raw_entity_table[element]["entPhysicalContainedIn"] = parent_id
-            if self.exclusion_list:
-                if parent_id not in raw_entity_table or parent_id in self.exclusion_list:
-                    self.exclusion_list.append(element)
+            if (parent_id not in raw_entity_table and "chassis" not in raw_entity_table[element][
+                "entPhysicalClass"]) or parent_id in self.exclusion_list:
+                self.exclusion_list.append(element)
         return raw_entity_table
 
     def _populate_relative_addresses(self):
@@ -258,50 +258,12 @@ def _populate_relative_addresses(self):
         """
 
         port_list = list(self._port_list)
-        # module_list = list(self._module_list)
-        # for module in module_list:
-        #     if module in self.exclusion_list:
-        #         self._filtered_module_list.remove(module)
-        #         continue
-        #     module_parent_address = self.get_relative_address(module)
-        #     if len(module_parent_address.split("/")) > 2:
-        #         module_parent_address = module_parent_address[:3]
-        #
-        #     module_rel_path = module_parent_address + '/' + self.get_resource_id(module)
-        #     i = 1
-        #     while module_rel_path in self.relative_address.values():
-        #         i += 1
-        #         module_rel_path = '{0}/{1}'.format(module_parent_address, (int(self.get_resource_id(module)) + i))
-        #     self.relative_address[module] = module_rel_path
-        #     self._filtered_module_list.append(module)
-
         for port in port_list:
             if port not in self.exclusion_list:
-                self.relative_address[port] = self._get_port_relative_address(
-                    self.get_relative_address(port) + '/' + self.get_resource_id(port))
+                self.relative_address[port] = self.get_relative_address(port) + '/' + self.get_resource_id(port)
             else:
                 self._port_list.remove(port)
 
-    def _get_port_relative_address(self, relative_id):
-        """
-        Workaround for an issue when port and sub-module located on the same module and have same relative ids
-
-        :param relative_id:
-        :return: relative_address
-        """
-        if relative_id in self.relative_address.values():
-            if '/' in relative_id:
-                ids = relative_id.split('/')
-                ids[-1] = str(int(ids[-1]) + 1000)
-                result = '/'.join(ids)
-            else:
-                result = str(int(relative_id.split()[-1]) + 1000)
-            if relative_id in self.relative_address.values():
-                result = self._get_port_relative_address(result)
-        else:
-            result = relative_id
-        return result
-
     def _get_module_parents(self, module_id):
         """
         Retrieve all parent modules for a specific module

cloudshell/networking/cisco/command_actions/add_remove_vlan_actions.py

@@ -93,13 +93,9 @@ def set_vlan_to_interface(self, vlan_range, port_mode, port_name, qnq, c_tag,
                                 action_map=action_map,
                                 error_map=error_map).execute_command(port_mode=port_mode)
         if qnq:
-            CommandTemplateExecutor(self._cli_service,
-                                    vlan_command_template.L2_TUNNEL,
-                                    action_map=action_map,
-                                    error_map=error_map).execute_command()
+            self._get_l2_protocol_tunnel_cmd(action_map, error_map).execute_command()
 
         if 'trunk' not in port_mode:
-
             CommandTemplateExecutor(self._cli_service,
                                     vlan_command_template.SWITCHPORT_ALLOW_VLAN,
                                     action_map=action_map,
@@ -109,3 +105,9 @@ def set_vlan_to_interface(self, vlan_range, port_mode, port_name, qnq, c_tag,
                                     vlan_command_template.SWITCHPORT_ALLOW_VLAN,
                                     action_map=action_map,
                                     error_map=error_map).execute_command(port_mode_trunk='', vlan_range=vlan_range)
+
+    def _get_l2_protocol_tunnel_cmd(self, action_map=None, error_map=None):
+        return CommandTemplateExecutor(self._cli_service,
+                                vlan_command_template.L2_TUNNEL,
+                                action_map=action_map,
+                                error_map=error_map)

cloudshell/networking/cisco/command_actions/iface_actions.py

@@ -84,7 +84,11 @@ def clean_interface_switchport_config(self, current_config, action_map=None, err
                                         configuration.NO, action_map=action_map,
                                         error_map=error_map).execute_command(command=line_to_remove)
         if "switchport mode dot1q-tunnel" in current_config.lower():
-            CommandTemplateExecutor(self._cli_service,
-                                    vlan_command_template.NO_L2_TUNNEL, action_map=action_map,
-                                    error_map=error_map).execute_command()
+            self._get_no_l2_protocol_tunnel_cmd(action_map, error_map).execute_command()
         self._logger.debug("Completed cleaning interface switchport configuration")
+
+    def _get_no_l2_protocol_tunnel_cmd(self, action_map=None, error_map=None):
+        return CommandTemplateExecutor(self._cli_service,
+                                vlan_command_template.NO_L2_TUNNEL,
+                                action_map=action_map,
+                                error_map=error_map)

cloudshell/networking/cisco/flows/cisco_add_vlan_flow.py

@@ -10,6 +10,12 @@ class CiscoAddVlanFlow(AddVlanFlow):
     def __init__(self, cli_handler, logger):
         super(CiscoAddVlanFlow, self).__init__(cli_handler, logger)
 
+    def _get_vlan_actions(self, config_session):
+        return AddRemoveVlanActions(config_session, self._logger)
+
+    def _get_iface_actions(self, config_session):
+        return IFaceActions(config_session, self._logger)
+
     def execute_flow(self, vlan_range, port_mode, port_name, qnq, c_tag):
         """ Configures VLANs on multiple ports or port-channels
 
@@ -24,8 +30,8 @@ def execute_flow(self, vlan_range, port_mode, port_name, qnq, c_tag):
         self._logger.info("Add VLAN(s) {} configuration started".format(vlan_range))
 
         with self._cli_handler.get_cli_service(self._cli_handler.config_mode) as config_session:
-            iface_action = IFaceActions(config_session, self._logger)
-            vlan_actions = AddRemoveVlanActions(config_session, self._logger)
+            iface_action = self._get_iface_actions(config_session)
+            vlan_actions = self._get_vlan_actions(config_session)
             port_name = iface_action.get_port_name(port_name)
             vlan_actions.create_vlan(vlan_range)
 

cloudshell/networking/cisco/flows/cisco_load_firmware_flow.py

@@ -15,8 +15,9 @@ class CiscoLoadFirmwareFlow(LoadFirmwareFlow):
     FLASH = "flash:"
     KICKSTART_IMAGE = "kickstart"
 
-    def __init__(self, cli_handler, logger):
+    def __init__(self, cli_handler, logger, default_file_system=None):
         super(CiscoLoadFirmwareFlow, self).__init__(cli_handler, logger)
+        self._file_system = default_file_system or self.FLASH
 
     def execute_flow(self, path, vrf, timeout):
         """Load a firmware onto the device
@@ -34,7 +35,7 @@ def execute_flow(self, path, vrf, timeout):
 
         with self._cli_handler.get_cli_service(self._cli_handler.enable_mode) as enable_session:
             system_action = SystemActions(enable_session, self._logger)
-            dst_file_system = self.FLASH
+            dst_file_system = self._file_system
 
             firmware_dst_path = "{0}/{1}".format(dst_file_system, firmware_file_name)
 

cloudshell/networking/cisco/flows/cisco_remove_vlan_flow.py

@@ -10,6 +10,12 @@ class CiscoRemoveVlanFlow(RemoveVlanFlow):
     def __init__(self, cli_handler, logger):
         super(CiscoRemoveVlanFlow, self).__init__(cli_handler, logger)
 
+    def _get_vlan_actions(self, config_session):
+        return AddRemoveVlanActions(config_session, self._logger)
+
+    def _get_iface_actions(self, config_session):
+        return IFaceActions(config_session, self._logger)
+
     def execute_flow(self, vlan_range, port_name, port_mode, action_map=None, error_map=None):
         """ Remove configuration of VLANs on multiple ports or port-channels
 
@@ -23,8 +29,8 @@ def execute_flow(self, vlan_range, port_name, port_mode, action_map=None, error_
 
         self._logger.info("Remove Vlan {} configuration started".format(vlan_range))
         with self._cli_handler.get_cli_service(self._cli_handler.config_mode) as config_session:
-            iface_action = IFaceActions(config_session, self._logger)
-            vlan_actions = AddRemoveVlanActions(config_session, self._logger)
+            iface_action = self._get_iface_actions(config_session)
+            vlan_actions = self._get_vlan_actions(config_session)
             port_name = iface_action.get_port_name(port_name)
 
             current_config = iface_action.get_current_interface_config(port_name)