Merge pull request #16 from QualiSystems/development

Development

Author: LuizaNacshon

.travis.yml

@@ -0,0 +1,16 @@
+language: python
+python:
+    - "2.7"
+
+install:
+    - pip install -r requirements.txt
+    - pip install -r test_requirements.txt
+    - pip install coveralls
+
+script:
+    - python runtests.py --with-coverage  --cover-package=package
+    - python setup.py test
+    - python setup.py sdist --format zip
+
+after_success:
+    coveralls

MANIFEST.in

@@ -0,0 +1,2 @@
+include *.txt
+global-include *.ini

cloudshell/__init__.py

@@ -0,0 +1,2 @@
+from pkgutil import extend_path
+__path__ = extend_path(__path__, __name__)

cloudshell/networking/__init__.py

@@ -0,0 +1,2 @@
+from pkgutil import extend_path
+__path__ = extend_path(__path__, __name__)

cloudshell/networking/huawei/__init__.py

@@ -0,0 +1,2 @@
+from pkgutil import extend_path
+__path__ = extend_path(__path__, __name__)

cloudshell/networking/huawei/autoload/__init__.py

@@ -0,0 +1,2 @@
+from pkgutil import extend_path
+__path__ = extend_path(__path__, __name__)

cloudshell/networking/huawei/autoload/huawei_generic_snmp_autoload.py

@@ -0,0 +1,204 @@
+import re
+import inject
+from cloudshell.shell.core.driver_context import AutoLoadDetails
+from cloudshell.networking.autoload.networking_autoload_resource_attributes import NetworkingStandardRootAttributes
+from cloudshell.networking.huawei.autoload.mib_attributes import MibAttributes
+
+
+class HuaweiGenericSNMPAutoload(MibAttributes):
+
+    def __init__(self, snmp_handler=None, logger=None, supported_os=None):
+        """Basic init with huawei router mib attribuites handler and logger
+
+        :param snmp_handler:
+        :param logger:
+        :return:
+        """
+
+        MibAttributes.__init__(self, snmp_handler, logger, supported_os)
+        self._logger = logger
+        self._excluded_models = []
+        self.supported_os = supported_os
+
+    @property
+    def logger(self):
+        if self._logger is None:
+            try:
+                self._logger = inject.instance('logger')
+            except:
+                raise Exception('HuaweiAutoload', 'Logger is none or empty')
+        return self._logger
+
+    def discover(self):
+        """Load device structure and attributes: chassis, modules, submodules, ports, port-channels and power supplies
+
+        :return: AutoLoadDetails object
+        """
+#
+        self._is_valid_device_os()
+
+        self.logger.info('*'*10)
+        self.logger.info('Starting huawei SNMP discovery process')
+
+        self.load_huawei_mib()
+        self._get_device_details()
+        self.snmp.load_mib(['HUAWEI-PORT-MIB'])
+        self._load_snmp_objects_and_tables()
+
+
+        if len(self.chassis_list) < 1:
+            self.logger.error('Entity table error, no chassis found')
+            return AutoLoadDetails(list(), list())
+
+        for chassis in self.chassis_list:
+            if chassis not in self.exclusion_list:
+                chassis_id = self._get_resource_id(chassis)
+                if chassis_id == '-1':
+                    chassis_id = '0'
+                self.relative_path[chassis] = chassis_id
+
+        self._filter_lower_bay_containers()
+        self.get_module_list()
+        self.add_relative_paths()
+        self._get_chassis_attributes(self.chassis_list)
+        self._get_ports_attributes()
+        self._get_module_attributes()
+        self._get_power_ports()
+        self._get_port_channels()
+
+        result = AutoLoadDetails(resources=self.resources, attributes=self.attributes)
+
+        self.logger.info('*'*10)
+        self.logger.info('Discover completed. The following Structure have been loaded:' +
+                          '\nModel, Name, Relative Path, Uniqe Id')
+
+        for resource in self.resources:
+            self.logger.info('{0},\t\t{1},\t\t{2},\t\t{3}'.format(resource.model, resource.name,
+                                                                   resource.relative_address, resource.unique_identifier))
+        self.logger.info('------------------------------')
+        for attribute in self.attributes:
+            self.logger.info('{0},\t\t{1},\t\t{2}'.format(attribute.relative_address, attribute.attribute_name,
+                                                           attribute.attribute_value))
+
+        self.logger.info('*'*10)
+        self.logger.info('SNMP discovery Completed')
+        return result
+
+    def _is_valid_device_os(self):
+        """Validate device OS using snmp
+        :return: True or False
+        """
+
+        version = None
+        if not self.supported_os:
+            config = inject.instance('config')
+            self.supported_os = config.SUPPORTED_OS
+        system_description = self.sys_descr
+        print system_description
+        match_str = re.sub('[\n\r]+', ' ', system_description.upper())
+        res = re.search('\s+(VRP)\s*', match_str)
+        if res:
+            version = res.group(0).strip(' \s\r\n')
+        if version and version in self.supported_os:
+            return
+
+        self.logger.info('System description from device: \'{0}\''.format(system_description))
+
+        error_message = 'Incompatible driver! Please use correct resource driver for {0} operation system(s)'. \
+            format(str(tuple(self.supported_os)))
+        self.logger.error(error_message)
+        raise Exception(error_message)
+
+
+
+
+
+    def _filter_lower_bay_containers(self):
+
+        upper_container = None
+        lower_container = None
+        containers = self.entity_mib_table.filter_by_column('Class', "container").sort_by_column('ParentRelPos').keys()
+        for container in containers:
+            vendor_type = self.snmp.get_property('ENTITY-MIB', 'entPhysicalVendorType', container)
+            if 'uppermodulebay' in vendor_type.lower():
+                upper_container = container
+            if 'lowermodulebay' in vendor_type.lower():
+                lower_container = container
+        if lower_container and upper_container:
+            child_upper_items_len = len(self.entity_mib_table.filter_by_column('ContainedIn', str(upper_container)
+                                                                           ).sort_by_column('ParentRelPos').keys())
+            child_lower_items = self.entity_mib_table.filter_by_column('ContainedIn', str(lower_container)
+                                                                   ).sort_by_column('ParentRelPos').keys()
+            for child in child_lower_items:
+                self.entity_mib_table[child]['entPhysicalContainedIn'] = upper_container
+                self.entity_mib_table[child]['entPhysicalParentRelPos'] = str(child_upper_items_len + int(
+                    self.entity_mib_table[child]['entPhysicalParentRelPos']))
+
+
+
+    def _add_resource(self, resource):
+        """Add object data to resources and attributes lists
+
+        :param resource: object which contains all required data for certain resource
+        """
+
+        self.resources.append(resource.get_autoload_resource_details())
+        self.attributes.extend(resource.get_autoload_resource_attributes())
+
+
+
+
+
+    def _filter_entity_table(self, raw_entity_table):
+        """Filters out all elements if their parents, doesn't exist, or listed in self.exclusion_list
+
+        :param raw_entity_table: entity table with unfiltered elements
+        """
+
+        elements = raw_entity_table.filter_by_column('ContainedIn').sort_by_column('ParentRelPos').keys()
+        for element in reversed(elements):
+            parent_id = int(self.entity_mib_table[element]['entPhysicalContainedIn'])
+
+            if parent_id not in raw_entity_table or parent_id in self.exclusion_list:
+                self.exclusion_list.append(element)
+
+
+    def _get_device_details(self):
+        """Get root element attributes
+
+        """
+
+        self.logger.info('Start loading Switch Attributes')
+        result = {'system_name': self.sys_name,
+                  'vendor': self.vendor,
+                  'model': self._get_device_model(),
+                  'location': self.sys_location,
+                  'contact': self.sys_contact,
+                  'version': ''}
+        software_dscription = self.sys_descr
+        print software_dscription
+        match_version = re.search('Version\s+(?P<software_version>\S+)\S*\s+',
+                                  software_dscription)
+        if match_version:
+            result['version'] = match_version.groupdict()['software_version'].replace(',', '')
+
+        root = NetworkingStandardRootAttributes(**result)
+        self.attributes.extend(root.get_autoload_resource_attributes())
+        self.logger.info('Finished Loading Switch Attributes')
+
+
+
+    def _get_device_model(self):
+        """Get device model form snmp SNMPv2 mib
+
+        :return: device model
+        :rtype: str
+        """
+
+        result = ''
+        match_name = re.search(r'::(?P<model>\S+$)', self.snmp_object_id)
+        if match_name:
+            result = match_name.groupdict()['model'].capitalize()
+        return result
+
+