Merge pull request #68 from QualiSystems/dev

gen1 support

Author: Costya-Y

.coveragerc

@@ -0,0 +1,4 @@
+[report]
+omit =
+    */mibs/*
+    *__init__*

.travis.yml

@@ -1,19 +1,19 @@
 language: python
 python:
-- '2.7'
-
-before_install:
-    - pip install coveralls
-    - pip install -r requirements.txt
-    - pip install -r test_requirements.txt
+    - "2.7"
 
 install:
-    - python setup.py install
+    - 'if [ ${TRAVIS_BRANCH} \!= "master" ] && [ -f dev_requirements.txt ]; then
+        pip install --extra-index-url https://testpypi.python.org/pypi -r dev_requirements.txt;
+        python setup.py develop --no-deps;
+      else
+        python setup.py install;
+      fi'
+    - pip install -r test_requirements.txt
+    - pip install coveralls
 
 script:
-    - nosetests
-    - python setup.py develop
-    - python setup.py sdist --format zip
+    - nosetests --with-coverage --cover-package=cloudshell.networking.cisco tests
 
 after_success:
     - coveralls

README.md

@@ -1,2 +1,12 @@
-# CloudShell shell core package powered by QualiSystems
-![alt tag](https://travis-ci.org/QualiSystems/cloudshell-networking-cisco.svg)
+# cloudshell-networking-cisco
+[![Build status](https://travis-ci.org/QualiSystems/cloudshell-networking-cisco.svg?branch=dev)](https://travis-ci.org/QualiSystems/cloudshell-networking-cisco)
+[![Coverage Status](https://coveralls.io/repos/github/QualiSystems/cloudshell-networking-cisco/badge.svg)](https://coveralls.io/github/QualiSystems/cloudshell-networking-cisco)
+[![PyPI version](https://badge.fury.io/py/cloudshell-networking-cisco.svg)](https://badge.fury.io/py/cloudshell-networking-cisco)
+[![Dependency Status](https://dependencyci.com/github/QualiSystems/cloudshell-networking-cisco/badge)](https://dependencyci.com/github/QualiSystems/cloudshell-networking-cisco)
+[![Stories in Ready](https://badge.waffle.io/QualiSystems/cloudshell-networking-cisco.svg?label=ready&title=Ready)](http://waffle.io/QualiSystems/cloudshell-networking-cisco)
+
+<p align="center">
+<img src="https://github.com/QualiSystems/devguide_source/raw/master/logo.png"></img>
+</p>
+
+# CloudShell Networking Cisco

cloudshell/networking/cisco/autoload/cisco_generic_snmp_autoload.py

@@ -0,0 +1,187 @@
+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 = ""
+
+    @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:
+            self._ipv4 = self._get_ipv4()
+        return self._ipv4
+
+    @property
+    def ipv6_address(self):
+        if not self._ipv6:
+            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
+
+        :return str IPv4 Address
+        """
+
+        if self._port_attributes_snmp_tables.ip_v4_table:
+            for key, value in self._port_attributes_snmp_tables.ip_v4_table.iteritems():
+                if 'ipAdEntIfIndex' in value and int(value['ipAdEntIfIndex']) == self.if_index:
+                    return key
+
+    def _get_ipv6(self):
+        """Get IPv6 address details for provided port
+
+        :return str IPv6 Address
+        """
+
+        if self._port_attributes_snmp_tables.ip_v6_table:
+            for key, value in self._port_attributes_snmp_tables.ip_v6_table.iteritems():
+                if 'ipAdEntIfIndex' in value and int(value['ipAdEntIfIndex']) == self.if_index:
+                    return key

cloudshell/networking/cisco/autoload/snmp_entity_table.py

@@ -0,0 +1,52 @@
+import re
+from cloudshell.networking.cisco.autoload.snmp_if_entity import SnmpIfEntity
+from cloudshell.networking.cisco.autoload.snmp_port_attr_tables import SnmpPortAttrTables
+
+
+class SnmpIfTable(object):
+    def __init__(self, snmp_handler, logger):
+        self._snmp = snmp_handler
+        self._logger = logger
+        self._load_snmp_tables()
+        self._if_entities_dict = dict()
+        self.port_attributes_snmp_tables = SnmpPortAttrTables(snmp_handler, logger)
+
+    @property
+    def if_entities(self):
+        if not self._if_entities_dict:
+            self._get_if_entities()
+        return self._if_entities_dict.values()
+
+    def get_if_entity_by_index(self, if_index):
+        if not self._if_entities_dict:
+            self._get_if_entities()
+        return self._if_entities_dict.get(if_index)
+
+    def _get_if_entities(self):
+        for index in self._if_table.keys():
+            self._if_entities_dict[index] = SnmpIfEntity(snmp_handler=self._snmp, logger=self._logger,
+                                                         index=index,
+                                                         port_attributes_snmp_tables=self.port_attributes_snmp_tables)
+
+    def _load_snmp_tables(self):
+        """ Load all cisco required snmp tables
+
+        :return:
+        """
+
+        self._logger.info('Start loading MIB tables:')
+        self._if_table = self._snmp.get_table('IF-MIB', "ifIndex")
+        self._logger.info('ifIndex table loaded')
+
+        self._logger.info('MIB Tables loaded successfully')
+
+    def get_if_index_from_port_name(self, port_name, port_filter_list):
+        port_if_re = re.findall('\d+', port_name)
+        if port_if_re:
+            if_table_re = "/".join(port_if_re)
+            for interface in self.if_entities:
+                if not re.search("ethernet|other", interface.if_type, re.IGNORECASE):
+                    continue
+                if re.search(r"^(?!.*null|.*{0})\D*{1}(/\D+|$)".format(port_filter_list, if_table_re),
+                             interface.if_name, re.IGNORECASE):
+                    return interface

cloudshell/networking/cisco/autoload/snmp_if_entity.py

@@ -0,0 +1,62 @@
+class SnmpPortAttrTables(object):
+    def __init__(self, snmp_handler, logger):
+        self._snmp = snmp_handler
+        self._logger = logger
+        self._lldp_remote_table = dict()
+        self._lldp_local_table = dict()
+        self._cdp_table = dict()
+        self._duplex_table = dict()
+        self._ip_v4_table = dict()
+        self._ip_v6_table = dict()
+        self._port_channel_ports = dict()
+
+    @property
+    def lldp_remote_table(self):
+        if not self._lldp_remote_table:
+            self._lldp_remote_table = self._snmp.get_table('LLDP-MIB', 'lldpRemSysName')
+            self._logger.info('lldpRemSysName table loaded')
+        return self._lldp_remote_table
+
+    @property
+    def lldp_local_table(self):
+        if not self._lldp_remote_table:
+            lldp_local_table = self._snmp.get_table('LLDP-MIB', 'lldpLocPortDesc')
+            if lldp_local_table:
+                self._lldp_local_table = dict([(v['lldpLocPortDesc'].lower(), k) for k, v in lldp_local_table.iteritems()])
+            self._logger.info('lldpLocPortDesc table loaded')
+        return self._lldp_remote_table
+
+    @property
+    def cdp_table(self):
+        if not self._cdp_table:
+            self._cdp_table = self._snmp.get_table('CISCO-CDP-MIB', 'cdpCacheDeviceId')
+            self._logger.info('cdpCacheDeviceId table loaded')
+        return self._cdp_table
+
+    @property
+    def duplex_table(self):
+        if not self._duplex_table:
+            self._duplex_table = self._snmp.get_table('EtherLike-MIB', 'dot3StatsIndex')
+            self._logger.info('dot3StatsIndex table loaded')
+        return self._duplex_table
+
+    @property
+    def ip_v4_table(self):
+        if not self._ip_v4_table:
+            self._ip_v4_table = self._snmp.get_table('IP-MIB', 'ipAddrTable')
+            self._logger.info('ipAddrTable table loaded')
+        return self._ip_v4_table
+
+    @property
+    def ip_v6_table(self):
+        if not self._ip_v6_table:
+            self._ip_v6_table = self._snmp.get_table('IPV6-MIB', 'ipv6AddrEntry')
+            self._logger.info('ipv6AddrEntry table loaded')
+        return self._ip_v6_table
+
+    @property
+    def port_channel_ports(self):
+        if not self._port_channel_ports:
+            self._port_channel_ports = self._snmp.get_table('IEEE8023-LAG-MIB', 'dot3adAggPortAttachedAggID')
+            self._logger.info('dot3adAggPortAttachedAggID table loaded')
+        return self._port_channel_ports

cloudshell/networking/cisco/autoload/snmp_if_table.py

@@ -96,15 +96,17 @@ def _enter_config_mode(self, session, logger):
         output = session.hardware_expect(ConfigCommandMode.ENTER_COMMAND,
                                          '{0}|{1}'.format(ConfigCommandMode.PROMPT, EnableCommandMode.PROMPT), logger)
 
-        if not re.search(ConfigCommandMode.PROMPT, output):
-            retries = 0
-            while not re.search(r"[Cc]onfiguration [Ll]ocked", output, re.IGNORECASE) or retries == max_retries:
-                time.sleep(5)
-                output = session.hardware_expect(ConfigCommandMode.ENTER_COMMAND,
-                                                 '{0}|{1}'.format(ConfigCommandMode.PROMPT, EnableCommandMode.PROMPT),
-                                                 logger)
-            if not re.search(ConfigCommandMode.PROMPT, output):
-                raise Exception('_enter_config_mode', error_message)
+        config_mode_match = re.search(ConfigCommandMode.PROMPT, output)
+        retries = 0
+        while (not config_mode_match) and retries <= max_retries:
+            time.sleep(5)
+            output = session.hardware_expect(ConfigCommandMode.ENTER_COMMAND,
+                                             '{0}|{1}'.format(ConfigCommandMode.PROMPT, EnableCommandMode.PROMPT),
+                                             logger)
+            config_mode_match = re.search(ConfigCommandMode.PROMPT, output)
+            retries += 1
+        if not config_mode_match:
+            raise Exception('_enter_config_mode', error_message)
 
     def _enter_enable_mode(self, session, logger):
         """

cloudshell/networking/cisco/autoload/snmp_port_attr_tables.py

@@ -38,8 +38,6 @@ def verify_interface_configured(vlan_range, current_config):
     def create_vlan(self, vlan_range, action_map=None, error_map=None):
         """Create vlan entity on the device
 
-        :param session: current session
-        :param logger:  logger
         :param vlan_range: range of vlans to be created
         :param action_map: actions will be taken during executing commands, i.e. handles yes/no prompts
         :param error_map: errors will be raised during executing commands, i.e. handles Invalid Commands errors