def upload(self, entry, vendor, cs_session):
"""Upload discovered device on the CloudShell
:param autodiscovery.reports.base.Entry entry:
:param autodiscovery.models.vendor.PDUVendorDefinition vendor:
:param cloudshell.api.cloudshell_api.CloudShellAPISession cs_session:
:return:
"""
resource_name = self._upload_resource(
cs_session=cs_session,
entry=entry,
resource_family=vendor.family_name,
resource_model=vendor.model_name,
driver_name=vendor.driver_name)
if not resource_name:
raise ReportableException("Shell {} is not installed".format(
vendor.driver_name))
def test_execute_handles_reportable_exception(self):
"""Check that method will handle ReportableException and will generate report"""
vendor_settings = mock.MagicMock()
ip = "10.10.10.10"
snmp_community = "snmp community string"
device_data = mock.MagicMock(ip_range=[ip])
self.run_command._discover_device = mock.MagicMock(side_effect=ReportableException())
# act
self.run_command.execute(devices_ips=[device_data],
snmp_comunity_strings=[snmp_community],
vendor_settings=vendor_settings,
additional_vendors_data=None)
# verify
self.report.add_entry.assert_called_once_with(domain=device_data.domain,
ip=ip,
offline=False)
self.report.generate.assert_called_once_with()
self.logger.exception.assert_called_once()
def _add_resource_driver(self, cs_session, resource_name, driver_name):
"""Add appropriate driver to the created CloudShell resource
:param cloudshell.api.cloudshell_api.CloudShellAPISession cs_session:
:param str resource_name:
:param str driver_name:
:return:
"""
try:
cs_session.UpdateResourceDriver(resourceFullPath=resource_name,
driverName=driver_name)
except CloudShellAPIError as e:
if e.code == CloudshellAPIErrorCodes.UNABLE_TO_LOCATE_DRIVER:
self.logger.exception(
"Unable to locate driver {}".format(driver_name))
raise ReportableException(
"Shell {} is not installed on the CloudShell".format(
driver_name))
raise
def _get_snmp_handler(self, device_ip, snmp_comunity_strings):
"""Get SNMP Handler and valid community string for the device
:param str device_ip:
:param list[str] snmp_comunity_strings:
:return: tuple with QualiSnmp instance and valid SNMP community string
:rtype: (QualiSnmp, str)
"""
for snmp_community in snmp_comunity_strings:
self.logger.info(
"Trying community string '{}' for device with IP {}".format(
snmp_community, device_ip))
snmp_parameters = SNMPV2Parameters(ip=device_ip,
snmp_community=snmp_community)
try:
return QualiSnmp(snmp_parameters, self.logger), snmp_community
except Exception:
self.logger.warning(
"SNMP Community string '{}' is not valid for device with IP {}"
.format(snmp_community, device_ip))
raise ReportableException("SNMP timeout - no resource detected")
def execute(self, parsed_entries, additional_vendors_data):
"""
:param list[autodiscovery.reports.base.Entry] parsed_entries:
:param list[dict] additional_vendors_data:
:return:
"""
vendor_config = self.data_processor.load_vendor_config(
additional_vendors_data=additional_vendors_data)
for parsed_entry in parsed_entries:
self.logger.info("Uploading device with IP {}".format(
parsed_entry.ip))
self.output.send("Uploading device with IP {}".format(
parsed_entry.ip))
try:
with self.report.edit_entry(entry=parsed_entry) as entry:
if entry.status == entry.SUCCESS_STATUS:
continue
else:
entry.status = entry.SUCCESS_STATUS
vendor = vendor_config.get_vendor(
vendor_name=parsed_entry.vendor)
if vendor is None:
raise ReportableException(
"Unsupported vendor {}".format(
parsed_entry.vendor))
try:
handler = self.vendor_type_handlers_map[
vendor.vendor_type.lower()]
except KeyError:
raise ReportableException(
"Invalid vendor type '{}'. Possible values are: {}"
.format(vendor.vendor_type,
self.vendor_type_handlers_map.keys()))
cs_session = self.cs_session_manager.get_session(
cs_domain=entry.domain)
handler.upload(entry=entry,
vendor=vendor,
cs_session=cs_session)
except Exception:
self.output.send("Failed to discover {} device. {}".format(
parsed_entry.ip, parsed_entry.comment),
error=True)
self.logger.exception(
"Failed to upload {} device due to:".format(
parsed_entry.ip))
else:
self.output.send(
"Device with IP {} was successfully uploaded".format(
parsed_entry.ip))
self.logger.info(
"Device with IP {} was successfully uploaded".format(
parsed_entry.ip))
self.report.generate()
def execute(self, devices_ips, snmp_comunity_strings, vendor_settings,
additional_vendors_data):
"""Execute Auto-discovery command
:param list[autodiscovery.models.DeviceIPRange] devices_ips: list of devices IPs to discover
:param list snmp_comunity_strings: list of possible SNMP read community strings for the given devices
:param autodiscovery.models.vendor.VendorSettingsCollection vendor_settings: additional vendor settings
:param list[dict] additional_vendors_data: additional vendors configuration
:return:
"""
vendor_config = self.data_processor.load_vendor_config(
additional_vendors_data=additional_vendors_data)
for devices_ip_range in devices_ips:
cs_domain = devices_ip_range.domain
for device_ip in devices_ip_range.ip_range:
self.logger.info(
"Discovering device with IP {}".format(device_ip))
self.output.send(
"Discovering device with IP {}".format(device_ip))
try:
with self.report.add_entry(ip=device_ip,
domain=cs_domain,
offline=self.offline) as entry:
entry = self._discover_device(
entry=entry,
snmp_comunity_strings=snmp_comunity_strings)
vendor = vendor_config.get_vendor(
vendor_name=entry.vendor)
if vendor is None:
raise ReportableException(
"Unsupported vendor {}".format(entry.vendor))
try:
handler = self.vendor_type_handlers_map[
vendor.vendor_type.lower()]
except KeyError:
raise ReportableException(
"Invalid vendor type '{}'. Possible values are: {}"
.format(vendor.vendor_type,
self.vendor_type_handlers_map.keys()))
discovered_entry = handler.discover(
entry=entry,
vendor=vendor,
vendor_settings=vendor_settings)
if not self.offline:
cs_session = self.cs_session_manager.get_session(
cs_domain=cs_domain)
handler.upload(entry=discovered_entry,
vendor=vendor,
cs_session=cs_session)
except ReportableException as e:
self.output.send("Failed to discover {} device. {}".format(
device_ip, str(e)),
error=True)
self.logger.exception(
"Failed to discover {} device due to:".format(
device_ip))
except Exception:
self.output.send(
"Failed to discover {} device. See log for details".
format(device_ip),
error=True)
self.logger.exception(
"Failed to discover {} device due to:".format(
device_ip))
else:
self.output.send(
"Device with IP {} was successfully discovered".format(
device_ip))
self.logger.info(
"Device with IP {} was successfully discovered".format(
device_ip))
self.report.generate()