Exemplo n.º 1
0
    def _discoverProcesses(self):
        hostId = self.framework.getDestinationAttribute('hostId')

        processes = []
        try:
            discoverer = process_discoverer.getDiscovererByShell(self._getShell())
            processes = discoverer.discoverAllProcesses()
            if not processes:
                raise ValueError()
        except:
            logger.warnException("Failed to discover processes")

        if processes:
            process_discoverer.saveProcessesToProbeDb(processes, hostId, self.framework)
Exemplo n.º 2
0
    def _discoverProcesses(self):
        hostId = self.framework.getDestinationAttribute('hostId')

        processes = []
        try:
            discoverer = process_discoverer.getDiscovererByShell(
                self._getShell())
            processes = discoverer.discoverAllProcesses()
            if not processes:
                raise ValueError()
        except:
            logger.warnException("Failed to discover processes")

        if processes:
            process_discoverer.saveProcessesToProbeDb(processes, hostId,
                                                      self.framework)
def DiscoveryMain(Framework):
    vector = ObjectStateHolderVector()
    protocol = Framework.getDestinationAttribute('Protocol')
    client = None
    shell = None
    try:
        try:
            # connect to destination
            client = Framework.createClient()
            # wrap client with Shell
            shell = shellutils.ShellFactory().createShell(client)
        except AuthenticationException, ae:
            errormessages.resolveAndReport(ae.getMessage(), protocol,
                                           Framework)
        except:
            exInfo = logger.prepareJythonStackTrace('')
            errormessages.resolveAndReport(exInfo, protocol, Framework)
        else:

            language = Framework.getDestinationAttribute('language')
            hostCmdbId = Framework.getDestinationAttribute('hostId')

            # configure internationalization support
            if language and language != 'NA':
                langBund = Framework.getEnvironmentInformation().getBundle(
                    'langHost_Resources_By_TTY', language)
            else:
                langBund = Framework.getEnvironmentInformation().getBundle(
                    'langHost_Resources_By_TTY')

            # discovery
            discoverCPUs = Boolean.parseBoolean(
                Framework.getParameter('discoverCPUs'))
            discoverDisks = Boolean.parseBoolean(
                Framework.getParameter('discoverDisks'))
            discoveriSCSIInfo = Boolean.parseBoolean(
                Framework.getParameter('discoveriSCSIInfo'))
            discoverDrivers = Boolean.parseBoolean(
                Framework.getParameter('discoverDrivers'))
            discoverMemory = Boolean.parseBoolean(
                Framework.getParameter('discoverMemory'))
            discoverSoftware = Boolean.parseBoolean(
                Framework.getParameter('discoverInstalledSoftware'))
            discoverUsers = Boolean.parseBoolean(
                Framework.getParameter('discoverUsers'))
            discoverServices = Boolean.parseBoolean(
                Framework.getParameter('discoverServices'))
            discoverShares = Boolean.parseBoolean(
                Framework.getParameter('discoverShares'))
            discoverP2P = Boolean.parseBoolean(
                Framework.getParameter('discoverP2P'))

            try:

                hostOsh = modeling.createOshByCmdbIdString('host', hostCmdbId)

                if discoverShares:
                    try:
                        vector.addAll(_discoverSharedResources(shell, hostOsh))
                    except:
                        errorMessage = 'Failed to discover shared resources'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['share', protocol], errorMessage)

                if discoverCPUs:
                    try:
                        vector.addAll(
                            TTY_HR_CPU_Lib.disWinOS(hostCmdbId, shell,
                                                    Framework, langBund))
                    except:
                        errorMessage = 'Failed to discover CPUs'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['cpus', protocol], errorMessage)

                if discoverDisks:
                    try:
                        vector.addAll(TTY_HR_Disk_Lib.disWinOS(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover disks'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['disks', protocol], errorMessage)

                if discoverDrivers and shell.isWinOs():
                    try:
                        vector.addAll(
                            _discoverWindowsDeviceDriver(shell, hostOsh))
                    except:
                        errorMessage = 'Failed to discover windows device driver by powershell'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['windows device driver', protocol], errorMessage)

                if discoveriSCSIInfo:
                    try:
                        vector.addAll(
                            TTY_HR_Disk_Lib.disWinOSiSCSIInfo(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover iSCSI info'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['iSCSI', protocol], errorMessage)

                if discoverMemory:
                    try:
                        vector.addAll(
                            TTY_HR_Memory_Lib.disWinOS(hostCmdbId, shell,
                                                       Framework, langBund))
                    except:
                        errorMessage = 'Failed to discover memory'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['memory', protocol], errorMessage)

                processes = []
                try:
                    processesDiscoverer = process_discoverer.DiscovererByShellOnWindows(
                        shell)
                    processes = processesDiscoverer.discoverAllProcesses()
                    if not processes:
                        raise ValueError()
                except:
                    errorMessage = 'Failed to discover processes'
                    _logWarn(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['processes', protocol], errorMessage)

                if processes:
                    # save processes to DB
                    process_discoverer.saveProcessesToProbeDb(
                        processes, hostCmdbId, Framework)

                    # report processes
                    discoverProcesses = Boolean.parseBoolean(
                        Framework.getParameter('discoverProcesses'))
                    if discoverProcesses:
                        processReporter = process.Reporter()
                        for processObject in processes:
                            processVector = processReporter.reportProcess(
                                hostOsh, processObject)
                            vector.addAll(processVector)

                if discoverUsers:
                    try:
                        vector.addAll(_discoverUsers(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover users'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['users', protocol], errorMessage)

                cmdLineToInstalledSoftware = {}
                softNameToInstSoftOSH = {}
                if discoverSoftware:
                    try:
                        softwareOSHs = TTY_HR_Software_Lib.disWinOS(
                            hostCmdbId, shell, Framework, langBund,
                            softNameToInstSoftOSH)
                        if softwareOSHs:
                            vector.addAll(softwareOSHs)
                    except:
                        errorMessage = 'Failed to discover installed software'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE,
                                 ['installed software', protocol],
                                 errorMessage)

                servicesByCmd = Hashtable()
                if discoverServices:
                    try:
                        srvcOSHs = NTCMD_HR_REG_Service_Lib.doService(
                            shell, hostOsh, servicesByCmd, langBund, Framework)
                        vector.addAll(srvcOSHs)
                    except:
                        errorMessage = 'Failed to discover services'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE,
                                 ['services', protocol], errorMessage)

                connectivityEndPoints = []
                try:
                    tcpDiscoverer = Dis_TCP.getDiscovererByShell(
                        client, Framework, shell)
                    if tcpDiscoverer is not None:
                        tcpDiscoverer.discoverTCP()
                        connectivityEndPoints = tcpDiscoverer.getProcessEndPoints(
                        )
                except:
                    errorMessage = 'Failed to run TCP discovery'
                    _logWarn(
                        errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE,
                        ['tcp', protocol], errorMessage)

                appSign = applications.createApplicationSignature(
                    Framework, client, shell)

                if processes:
                    appSign.setProcessesManager(
                        applications.ProcessesManager(processes,
                                                      connectivityEndPoints))

                servicesInfo = applications.ServicesInfo(servicesByCmd)
                appSign.setServicesInfo(servicesInfo)

                softwareInfo = applications.InstalledSoftwareInfo(
                    cmdLineToInstalledSoftware, softNameToInstSoftOSH)
                appSign.setInstalledSoftwareInfo(softwareInfo)

                appSign.getApplicationsTopology(hostCmdbId)

                if discoverP2P:
                    try:
                        p2p = process_to_process.ProcessToProcess(Framework)
                        p2p.getProcessesToProcess()
                    except:
                        errorMessage = 'Failed to run p2p discovery'
                        _logWarn(errorcodes.FAILED_RUNNING_DISCOVERY,
                                 ['p2p', protocol], errorMessage)

            except JException, ex:
                exInfo = ex.getMessage()
                errormessages.resolveAndReport(exInfo, protocol, Framework)
            except:
def DiscoveryMain(Framework):
    vector = ObjectStateHolderVector()
    protocol = Framework.getDestinationAttribute('Protocol')
    client = None
    shell = None
    try:
        try:
            # connect to destination
            client = Framework.createClient()
            # wrap client with Shell
            shell = shellutils.ShellFactory().createShell(client)
        except AuthenticationException, ae:
            errormessages.resolveAndReport(ae.getMessage(), protocol, Framework)
        except:
            exInfo = logger.prepareJythonStackTrace('')
            errormessages.resolveAndReport(exInfo, protocol, Framework)
        else:

            language = Framework.getDestinationAttribute('language')
            hostCmdbId = Framework.getDestinationAttribute('hostId')

            # configure internationalization support
            if language and language != 'NA':
                langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY', language)
            else:
                langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY')

            # discovery
            discoverCPUs = Boolean.parseBoolean(Framework.getParameter('discoverCPUs'))
            discoverDisks = Boolean.parseBoolean(Framework.getParameter('discoverDisks'))
            discoveriSCSIInfo = Boolean.parseBoolean(Framework.getParameter('discoveriSCSIInfo'))
            discoverDrivers = Boolean.parseBoolean(Framework.getParameter('discoverDrivers'))
            discoverMemory = Boolean.parseBoolean(Framework.getParameter('discoverMemory'))
            discoverSoftware = Boolean.parseBoolean(Framework.getParameter('discoverInstalledSoftware'))
            discoverUsers = Boolean.parseBoolean(Framework.getParameter('discoverUsers'))
            discoverServices = Boolean.parseBoolean(Framework.getParameter('discoverServices'))
            discoverShares = Boolean.parseBoolean(Framework.getParameter('discoverShares'))
            discoverP2P = Boolean.parseBoolean(Framework.getParameter('discoverP2P'))

            try:

                hostOsh = modeling.createOshByCmdbIdString('host', hostCmdbId)

                if discoverShares:
                    try:
                        vector.addAll(_discoverSharedResources(shell, hostOsh))
                    except:
                        errorMessage = 'Failed to discover shared resources'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['share', protocol], errorMessage)

                if discoverCPUs:
                    try:
                        vector.addAll(TTY_HR_CPU_Lib.disWinOS(hostCmdbId, shell, Framework, langBund))
                    except:
                        errorMessage = 'Failed to discover CPUs'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['cpus', protocol], errorMessage)

                if discoverDisks:
                    try:
                        vector.addAll(TTY_HR_Disk_Lib.disWinOS(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover disks'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['disks', protocol], errorMessage)

                if discoverDrivers and shell.isWinOs():
                    try:
                        vector.addAll(_discoverWindowsDeviceDriver(shell, hostOsh))
                    except:
                        errorMessage = 'Failed to discover windows device driver by powershell'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['windows device driver', protocol], errorMessage)

                if discoveriSCSIInfo:
                    try:
                        vector.addAll(TTY_HR_Disk_Lib.disWinOSiSCSIInfo(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover iSCSI info'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['iSCSI', protocol], errorMessage)

                if discoverMemory:
                    try:
                        vector.addAll(TTY_HR_Memory_Lib.disWinOS(hostCmdbId, shell, Framework, langBund))
                    except:
                        errorMessage = 'Failed to discover memory'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['memory', protocol], errorMessage)

                processes = []
                try:
                    processesDiscoverer = process_discoverer.DiscovererByShellOnWindows(shell)
                    processes = processesDiscoverer.discoverAllProcesses()
                    if not processes:
                        raise ValueError()
                except:
                    errorMessage = 'Failed to discover processes'
                    _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['processes', protocol], errorMessage)

                if processes:
                    # save processes to DB
                    process_discoverer.saveProcessesToProbeDb(processes, hostCmdbId, Framework)

                    # report processes
                    discoverProcesses = Boolean.parseBoolean(Framework.getParameter('discoverProcesses'))
                    if discoverProcesses:
                        processReporter = process.Reporter()
                        for processObject in processes:
                            processVector = processReporter.reportProcess(hostOsh, processObject)
                            vector.addAll(processVector)

                if discoverUsers:
                    try:
                        vector.addAll(_discoverUsers(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover users'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['users', protocol], errorMessage)

                cmdLineToInstalledSoftware = {}
                softNameToInstSoftOSH = {}
                if discoverSoftware:
                    try:
                        softwareOSHs = TTY_HR_Software_Lib.disWinOS(hostCmdbId, shell, Framework, langBund, softNameToInstSoftOSH)
                        if softwareOSHs:
                            vector.addAll(softwareOSHs)
                    except:
                        errorMessage = 'Failed to discover installed software'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE, ['installed software', protocol], errorMessage)

                servicesByCmd = Hashtable()
                if discoverServices:
                    try:
                        srvcOSHs = NTCMD_HR_REG_Service_Lib.doService(shell, hostOsh, servicesByCmd, langBund, Framework)
                        vector.addAll(srvcOSHs)
                    except:
                        errorMessage = 'Failed to discover services'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE, ['services', protocol], errorMessage)

                connectivityEndPoints = []
                try:
                    tcpDiscoverer = Dis_TCP.getDiscovererByShell(client, Framework, shell)
                    if tcpDiscoverer is not None:
                        tcpDiscoverer.discoverTCP()
                        connectivityEndPoints = tcpDiscoverer.getProcessEndPoints()
                except:
                    errorMessage = 'Failed to run TCP discovery'
                    _logWarn(errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, ['tcp', protocol], errorMessage)

                appSign = applications.createApplicationSignature(Framework, client, shell)

                if processes:
                    appSign.setProcessesManager(applications.ProcessesManager(processes, connectivityEndPoints))

                servicesInfo = applications.ServicesInfo(servicesByCmd)
                appSign.setServicesInfo(servicesInfo)

                softwareInfo = applications.InstalledSoftwareInfo(cmdLineToInstalledSoftware, softNameToInstSoftOSH)
                appSign.setInstalledSoftwareInfo(softwareInfo)

                appSign.getApplicationsTopology(hostCmdbId)

                if discoverP2P:
                    try:
                        p2p = process_to_process.ProcessToProcess(Framework)
                        p2p.getProcessesToProcess()
                    except:
                        errorMessage = 'Failed to run p2p discovery'
                        _logWarn(errorcodes.FAILED_RUNNING_DISCOVERY, ['p2p', protocol], errorMessage)

            except JException, ex:
                exInfo = ex.getMessage()
                errormessages.resolveAndReport(exInfo, protocol, Framework)
            except:
Exemplo n.º 5
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    client = None
    try:
        client = createWmiClient(Framework)

        if client:
            protocol = Framework.getDestinationAttribute('Protocol')
            hostId = Framework.getDestinationAttribute('hostId')
            hostOsh = modeling.createOshByCmdbIdString('nt', hostId)

            _, warning = discover_or_warn('fibre channel HBAs',
                                discover_fc_hbas, Framework, hostOsh,
                                protocol, OSHVResult, protocol_name=protocol)
            if warning:
                logger.reportWarningObject(warning)

            discoverUsers = Boolean.parseBoolean(Framework.getParameter('discoverUsers'))
            if discoverUsers:
                try:
                    wmi_dis_user_lib.executeWmiQuery(client, Framework, OSHVResult, hostOsh)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['users', 'wmi'], 'Failed to discover users by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover users by wmi')

            discoverShares = Boolean.parseBoolean(Framework.getParameter('discoverShares'))
            if discoverShares:
                try:
                    wmi_dis_share_lib.executeWmiQuery(client, OSHVResult, hostOsh)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['shares', 'wmi'], 'Failed to discover shares by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover shares by wmi')

            discoverProcesses = Boolean.parseBoolean(Framework.getParameter('discoverProcesses'))
            processes = []

            try:
                processDiscoverer = process_discoverer.getDiscovererByWmi(client)
                processes = processDiscoverer.discoverAllProcesses()
                if not processes:
                    raise ValueError()
            except:
                errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['processes', 'wmi'], 'Failed to discover processes by wmi')
                logger.reportErrorObject(errobj)
                logger.errorException('Failed to discover processes by wmi')

            if processes:
                # save processes to DB
                process_discoverer.saveProcessesToProbeDb(processes, hostId, Framework)

                # report processes
                if discoverProcesses:
                    processReporter = process.Reporter()
                    for processObject in processes:
                        processesVector = processReporter.reportProcess(hostOsh, processObject)
                        OSHVResult.addAll(processesVector)

            discoverMemory = Boolean.parseBoolean(Framework.getParameter('discoverMemory'))
            if discoverMemory:
                try:
                    wmi_dis_memory_lib.executeWmiQuery(client, OSHVResult, hostOsh)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['memory', 'wmi'], 'Failed to discover memory by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover memory by wmi')

            discoverDisks = Boolean.parseBoolean(Framework.getParameter('discoverDisks'))
            if discoverDisks:
                try:
                    containerOsh = hostOsh or modeling.createHostOSH(client.getIpAddress())
                    NTCMD_HR_Dis_Disk_Lib.discoverDiskByWmic(client, OSHVResult, containerOsh)
                    NTCMD_HR_Dis_Disk_Lib.discoverPhysicalDiskByWmi(client, OSHVResult, containerOsh)

                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['disks', 'wmi'], 'Failed to discover disks by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover disks by wmi')

            discoverDrivers = Boolean.parseBoolean(Framework.getParameter('discoverDrivers'))
            if discoverDrivers:
                try:
                    containerOsh = hostOsh or modeling.createHostOSH(client.getIpAddress())
                    HR_Dis_Driver_Lib.discoverDriverByWmi(client, OSHVResult, containerOsh)

                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['drivers', 'wmi'], 'Failed to discover drivers by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover drivers by wmi')

            discoveriSCSIInfo = Boolean.parseBoolean(Framework.getParameter('discoveriSCSIInfo'))
            if discoveriSCSIInfo:
                try:
                    NTCMD_HR_Dis_Disk_Lib.discoveriSCSIInfo(client,OSHVResult, containerOsh)
                except:
                    logger.warn('Failed to connect with namespace Root\Microsoft\Windows\Storage')

            discoverCPUs = Boolean.parseBoolean(Framework.getParameter('discoverCPUs'))
            if discoverCPUs:
                try:
                    wmi_dis_cpu_lib.executeWmiQuery(client, OSHVResult, hostOsh)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['cpus', 'wmi'], 'Failed to discover cpus by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover cpus by wmi')

            discoverServices = Boolean.parseBoolean(Framework.getParameter('discoverServices'))
            servicesByCmd = Hashtable()
            if discoverServices:
                try:
                    servOSHV = wmi_dis_service_lib.executeWmiQuery(client, OSHVResult, servicesByCmd, hostOsh)
                    OSHVResult.addAll(servOSHV)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['services', 'wmi'], 'Failed to discover services by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover services by wmi')

            #NOTE: software discovery had to be the last in discovery chain
            discoverSoftware = Boolean.parseBoolean(Framework.getParameter('discoverInstalledSoftware'))
            softNameToInstSoftOSH = {}
            if discoverSoftware:
                (softNameToInstSoftOSH, client) = __discoverInstalledSoftware(Framework, OSHVResult, client)

            if not client:
                logger.warn("Application Signature will not be run since the client is not initialized")

            if client:

                appSign = applications.createApplicationSignature(Framework, client)
                if processes:
                    appSign.setProcessesManager(applications.ProcessesManager(processes, []))
                servicesInfo = applications.ServicesInfo(servicesByCmd)
                appSign.setServicesInfo(servicesInfo)

                softwareInfo = applications.InstalledSoftwareInfo(None, softNameToInstSoftOSH)
                appSign.setInstalledSoftwareInfo(softwareInfo)

                appSign.getApplicationsTopology(hostId)

    finally:
        if client != None:
            client.close()
    return OSHVResult
Exemplo n.º 6
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    client = None
    framework = StatisticsFramework(Framework)
    try:
        try:
            client = framework.createClient()
        except:
#            No need to report twice, exception msg is sufficient
#            errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_NO_PROTOCOL, None, 'Connection failed')
#            logger.reportErrorObject(errobj)
            errMsg ='Exception while creating %s client: %s' % (ClientsConsts.SNMP_PROTOCOL_NAME, sys.exc_info()[1])
            errormessages.resolveAndReport(str(sys.exc_info()[1]), ClientsConsts.SNMP_PROTOCOL_NAME, framework)
            logger.debugException(errMsg)
        else:

            config = (flow.DiscoveryConfigBuilder(framework)
                      .dest_data_required_params_as_str('ip_address')
                      .dest_data_params_as_list('host_ips')
                      ).build()
            ipaddress = config.ip_address
            host_ips = filter(None, config.host_ips)

            ips = set(host_ips)
            ips.add(ipaddress)

            hostId = framework.getDestinationAttribute('hostId')
            hostOsh = modeling.createOshByCmdbIdString('host', hostId)

            discoverUsers = Boolean.parseBoolean(framework.getParameter('discoverUsers'))
            if discoverUsers:
                logger.debug('Starting to discover users')
                try:
                    snmp_dis_user_lib.doQueryOSUsers(client, OSHVResult)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['users', 'snmp'], 'Failed to discover users by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover users by snmp')


            discoverDisks = Boolean.parseBoolean(framework.getParameter('discoverDisks'))
            if discoverDisks:
                logger.debug('Starting to discover disks')
                try:
                    snmp_dis_disk_lib.doQueryDisks(client, OSHVResult)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['disks', 'snmp'], 'Failed to discover disks by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover disks by snmp')


            discoverProcesses = Boolean.parseBoolean(framework.getParameter('discoverProcesses'))
            processes = []

            logger.debug('Starting to discover processes')
            try:

                processDiscoverer = process_discoverer.getDiscovererBySnmp(client)
                processes = processDiscoverer.discoverAllProcesses()
                if not processes:
                    raise ValueError()
            except:
                errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['processes', 'snmp'], 'Failed to discover processes by snmp')
                logger.reportWarningObject(errobj)
                logger.errorException('Failed to discover processes by snmp')

            if processes:

                # save processes to DB
                process_discoverer.saveProcessesToProbeDb(processes, hostId, framework)

                # report processes
                if discoverProcesses:
                    processReporter = process.Reporter()
                    for processObject in processes:
                        processesVector = processReporter.reportProcess(hostOsh, processObject)
                        OSHVResult.addAll(processesVector)


            discoverServices = Boolean.parseBoolean(framework.getParameter('discoverServices'))
            if discoverServices:
                logger.debug('Starting to discover services')
                try:
                    snmp_dis_service_lib.doQuerySNMPService(client, OSHVResult)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['services', 'snmp'], 'Failed to discover services by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover services by snmp')


            discoverSoftware = Boolean.parseBoolean(framework.getParameter('discoverInstalledSoftware'))
            if discoverSoftware:
                logger.debug('Starting to discover software')
                try:
                    snmp_dis_software_lib.doQuerySoftware(client, OSHVResult)
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['software', 'snmp'], 'Failed to discover software by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover software by snmp')

            connectivityEndPoints = []
            try:
                tcpDiscoverer = Dis_TCP.TCPDisBySNMP(client, framework, ips=tuple(ips))
                if tcpDiscoverer is not None:
                    tcpDiscoverer.discoverTCP()
                    connectivityEndPoints = tcpDiscoverer.getProcessEndPoints()
            except:
                errorMessage = 'Failed to run tcp discovery by snmp'
                logger.debugException(errorMessage)
                errobj = errorobject.createError(errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, ['tcp', 'snmp'], errorMessage)
                logger.reportWarningObject(errobj)

            if processes:
                appSign = applications.createApplicationSignature(framework, client)
                appSign.setProcessesManager(applications.ProcessesManager(processes, connectivityEndPoints))
                appSign.getApplicationsTopology(hostId)

            discoverModules = Boolean.parseBoolean(framework.getParameter('discoverModules'))
            if discoverModules:
                logger.debug('Begin discover snmp modules...')
                try:
                    from snmp_model_finder import SnmpStateHolder
                    from snmp_model_finder import SnmpQueryHelper
                    from snmp_model_finder import ModelTypeMatcher
                    import snmp_model_discovery

                    snmpStateHolder = SnmpStateHolder()
                    cacheClient = None
                    # from discovery.client.snmp import SnmpClientCacheProxy

                    # cacheClient = SnmpClientCacheProxy(client, 'cache/'+ipaddress+'.cache')
                    snmpQueryHelper = SnmpQueryHelper(client)
                    mtm = ModelTypeMatcher(snmpStateHolder, snmpQueryHelper)
                    logger.debug('The target is matched:', mtm.match())
                    logger.debug('The type of the target is:', snmpStateHolder.getTypes())
                    vector = snmp_model_discovery.discoverAll(hostOsh, snmpStateHolder, snmpQueryHelper)
                    logger.debug('Discovered CI count:', vector.size())
                    OSHVResult.addAll(vector)
                    if cacheClient:
                        cacheClient.writeCache()
                except:
                    errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['modules', 'snmp'],
                                                     'Failed to discover modules by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover modules by snmp')
                logger.debug('End discover snmp modules')

    finally:
        if client != None:
            client.close()
    if OSHVResult.size() == 0 and framework.getSentObjectsCount() == 0:
        logger.reportWarning('SNMP: No data collected')
    return OSHVResult
Exemplo n.º 7
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    client = None
    try:
        client = createWmiClient(Framework)

        if client:
            protocol = Framework.getDestinationAttribute('Protocol')
            hostId = Framework.getDestinationAttribute('hostId')
            hostOsh = modeling.createOshByCmdbIdString('nt', hostId)

            _, warning = discover_or_warn('fibre channel HBAs',
                                          discover_fc_hbas,
                                          Framework,
                                          hostOsh,
                                          protocol,
                                          OSHVResult,
                                          protocol_name=protocol)
            if warning:
                logger.reportWarningObject(warning)

            discoverUsers = Boolean.parseBoolean(
                Framework.getParameter('discoverUsers'))
            if discoverUsers:
                try:
                    wmi_dis_user_lib.executeWmiQuery(client, Framework,
                                                     OSHVResult, hostOsh)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['users', 'wmi'], 'Failed to discover users by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover users by wmi')

            discoverShares = Boolean.parseBoolean(
                Framework.getParameter('discoverShares'))
            if discoverShares:
                try:
                    wmi_dis_share_lib.executeWmiQuery(client, OSHVResult,
                                                      hostOsh)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['shares', 'wmi'], 'Failed to discover shares by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover shares by wmi')

            discoverProcesses = Boolean.parseBoolean(
                Framework.getParameter('discoverProcesses'))
            processes = []

            try:
                processDiscoverer = process_discoverer.getDiscovererByWmi(
                    client)
                processes = processDiscoverer.discoverAllProcesses()
                if not processes:
                    raise ValueError()
            except:
                errobj = errorobject.createError(
                    errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                    ['processes', 'wmi'],
                    'Failed to discover processes by wmi')
                logger.reportErrorObject(errobj)
                logger.errorException('Failed to discover processes by wmi')

            if processes:
                # save processes to DB
                process_discoverer.saveProcessesToProbeDb(
                    processes, hostId, Framework)

                # report processes
                if discoverProcesses:
                    processReporter = process.Reporter()
                    for processObject in processes:
                        processesVector = processReporter.reportProcess(
                            hostOsh, processObject)
                        OSHVResult.addAll(processesVector)

            discoverMemory = Boolean.parseBoolean(
                Framework.getParameter('discoverMemory'))
            if discoverMemory:
                try:
                    wmi_dis_memory_lib.executeWmiQuery(client, OSHVResult,
                                                       hostOsh)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['memory', 'wmi'], 'Failed to discover memory by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover memory by wmi')

            discoverDisks = Boolean.parseBoolean(
                Framework.getParameter('discoverDisks'))
            if discoverDisks:
                try:
                    containerOsh = hostOsh or modeling.createHostOSH(
                        client.getIpAddress())
                    NTCMD_HR_Dis_Disk_Lib.discoverDiskByWmic(
                        client, OSHVResult, containerOsh)
                    NTCMD_HR_Dis_Disk_Lib.discoverPhysicalDiskByWmi(
                        client, OSHVResult, containerOsh)

                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['disks', 'wmi'], 'Failed to discover disks by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover disks by wmi')

            discoverDrivers = Boolean.parseBoolean(
                Framework.getParameter('discoverDrivers'))
            if discoverDrivers:
                try:
                    containerOsh = hostOsh or modeling.createHostOSH(
                        client.getIpAddress())
                    HR_Dis_Driver_Lib.discoverDriverByWmi(
                        client, OSHVResult, containerOsh)

                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['drivers', 'wmi'],
                        'Failed to discover drivers by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover drivers by wmi')

            discoveriSCSIInfo = Boolean.parseBoolean(
                Framework.getParameter('discoveriSCSIInfo'))
            if discoveriSCSIInfo:
                try:
                    NTCMD_HR_Dis_Disk_Lib.discoveriSCSIInfo(
                        client, OSHVResult, containerOsh)
                except:
                    logger.warn(
                        'Failed to connect with namespace Root\Microsoft\Windows\Storage'
                    )

            discoverCPUs = Boolean.parseBoolean(
                Framework.getParameter('discoverCPUs'))
            if discoverCPUs:
                try:
                    wmi_dis_cpu_lib.executeWmiQuery(client, OSHVResult,
                                                    hostOsh)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['cpus', 'wmi'], 'Failed to discover cpus by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover cpus by wmi')

            discoverServices = Boolean.parseBoolean(
                Framework.getParameter('discoverServices'))
            servicesByCmd = Hashtable()
            if discoverServices:
                try:
                    servOSHV = wmi_dis_service_lib.executeWmiQuery(
                        client, OSHVResult, servicesByCmd, hostOsh)
                    OSHVResult.addAll(servOSHV)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['services', 'wmi'],
                        'Failed to discover services by wmi')
                    logger.reportErrorObject(errobj)
                    logger.errorException('Failed to discover services by wmi')

            #NOTE: software discovery had to be the last in discovery chain
            discoverSoftware = Boolean.parseBoolean(
                Framework.getParameter('discoverInstalledSoftware'))
            softNameToInstSoftOSH = {}
            if discoverSoftware:
                (softNameToInstSoftOSH,
                 client) = __discoverInstalledSoftware(Framework, OSHVResult,
                                                       client)

            if not client:
                logger.warn(
                    "Application Signature will not be run since the client is not initialized"
                )

            if client:

                appSign = applications.createApplicationSignature(
                    Framework, client)
                if processes:
                    appSign.setProcessesManager(
                        applications.ProcessesManager(processes, []))
                servicesInfo = applications.ServicesInfo(servicesByCmd)
                appSign.setServicesInfo(servicesInfo)

                softwareInfo = applications.InstalledSoftwareInfo(
                    None, softNameToInstSoftOSH)
                appSign.setInstalledSoftwareInfo(softwareInfo)

                appSign.getApplicationsTopology(hostId)

    finally:
        if client != None:
            client.close()
    return OSHVResult
Exemplo n.º 8
0
                        processes = discoverer.discoverAllProcesses()
                        if not processes:
                            raise ValueError()
                    except:
                        errorMessage = "Failed to discover processes by shell"
                        logWarn(
                            Framework,
                            errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ["processes", protocol],
                            errorMessage,
                        )

                if processes:

                    # save processes to DB
                    process_discoverer.saveProcessesToProbeDb(processes, hostId, Framework)

                    # discover packages info
                    try:
                        packagesDiscoverer = process_discoverer.getPackagesDiscovererByShell(shell, platformTrait)
                        packageToExecutablePath = packagesDiscoverer.getPackagesByProcesses(processes)
                    except:
                        logger.warn("Failed to get package names by processes path")

                    # report processes
                    if discoverProcesses:
                        processReporter = process.Reporter()
                        for processObject in processes:
                            processesVector = processReporter.reportProcess(hostOsh, processObject)
                            OSHVResult.addAll(processesVector)
Exemplo n.º 9
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    client = None
    framework = StatisticsFramework(Framework)
    try:
        try:
            client = framework.createClient()
        except:
            #            No need to report twice, exception msg is sufficient
            #            errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_NO_PROTOCOL, None, 'Connection failed')
            #            logger.reportErrorObject(errobj)
            errMsg = 'Exception while creating %s client: %s' % (
                ClientsConsts.SNMP_PROTOCOL_NAME, sys.exc_info()[1])
            errormessages.resolveAndReport(str(sys.exc_info()[1]),
                                           ClientsConsts.SNMP_PROTOCOL_NAME,
                                           framework)
            logger.debugException(errMsg)
        else:

            config = (flow.DiscoveryConfigBuilder(
                framework).dest_data_required_params_as_str('ip_address').
                      dest_data_params_as_list('host_ips')).build()
            ipaddress = config.ip_address
            host_ips = filter(None, config.host_ips)

            ips = set(host_ips)
            ips.add(ipaddress)

            hostId = framework.getDestinationAttribute('hostId')
            hostOsh = modeling.createOshByCmdbIdString('host', hostId)

            discoverUsers = Boolean.parseBoolean(
                framework.getParameter('discoverUsers'))
            if discoverUsers:
                logger.debug('Starting to discover users')
                try:
                    snmp_dis_user_lib.doQueryOSUsers(client, OSHVResult)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['users', 'snmp'], 'Failed to discover users by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover users by snmp')

            discoverDisks = Boolean.parseBoolean(
                framework.getParameter('discoverDisks'))
            if discoverDisks:
                logger.debug('Starting to discover disks')
                try:
                    snmp_dis_disk_lib.doQueryDisks(client, OSHVResult)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['disks', 'snmp'], 'Failed to discover disks by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover disks by snmp')

            discoverProcesses = Boolean.parseBoolean(
                framework.getParameter('discoverProcesses'))
            processes = []

            logger.debug('Starting to discover processes')
            try:

                processDiscoverer = process_discoverer.getDiscovererBySnmp(
                    client)
                processes = processDiscoverer.discoverAllProcesses()
                if not processes:
                    raise ValueError()
            except:
                errobj = errorobject.createError(
                    errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                    ['processes', 'snmp'],
                    'Failed to discover processes by snmp')
                logger.reportWarningObject(errobj)
                logger.errorException('Failed to discover processes by snmp')

            if processes:

                # save processes to DB
                process_discoverer.saveProcessesToProbeDb(
                    processes, hostId, framework)

                # report processes
                if discoverProcesses:
                    processReporter = process.Reporter()
                    for processObject in processes:
                        processesVector = processReporter.reportProcess(
                            hostOsh, processObject)
                        OSHVResult.addAll(processesVector)

            discoverServices = Boolean.parseBoolean(
                framework.getParameter('discoverServices'))
            if discoverServices:
                logger.debug('Starting to discover services')
                try:
                    snmp_dis_service_lib.doQuerySNMPService(client, OSHVResult)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['services', 'snmp'],
                        'Failed to discover services by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException(
                        'Failed to discover services by snmp')

            discoverSoftware = Boolean.parseBoolean(
                framework.getParameter('discoverInstalledSoftware'))
            if discoverSoftware:
                logger.debug('Starting to discover software')
                try:
                    snmp_dis_software_lib.doQuerySoftware(client, OSHVResult)
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['software', 'snmp'],
                        'Failed to discover software by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException(
                        'Failed to discover software by snmp')

            connectivityEndPoints = []
            try:
                tcpDiscoverer = Dis_TCP.TCPDisBySNMP(client,
                                                     framework,
                                                     ips=tuple(ips))
                if tcpDiscoverer is not None:
                    tcpDiscoverer.discoverTCP()
                    connectivityEndPoints = tcpDiscoverer.getProcessEndPoints()
            except:
                errorMessage = 'Failed to run tcp discovery by snmp'
                logger.debugException(errorMessage)
                errobj = errorobject.createError(
                    errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE,
                    ['tcp', 'snmp'], errorMessage)
                logger.reportWarningObject(errobj)

            if processes:
                appSign = applications.createApplicationSignature(
                    framework, client)
                appSign.setProcessesManager(
                    applications.ProcessesManager(processes,
                                                  connectivityEndPoints))
                appSign.getApplicationsTopology(hostId)

            discoverModules = Boolean.parseBoolean(
                framework.getParameter('discoverModules'))
            if discoverModules:
                logger.debug('Begin discover snmp modules...')
                try:
                    from snmp_model_finder import SnmpStateHolder
                    from snmp_model_finder import SnmpQueryHelper
                    from snmp_model_finder import ModelTypeMatcher
                    import snmp_model_discovery

                    snmpStateHolder = SnmpStateHolder()
                    cacheClient = None
                    # from discovery.client.snmp import SnmpClientCacheProxy

                    # cacheClient = SnmpClientCacheProxy(client, 'cache/'+ipaddress+'.cache')
                    snmpQueryHelper = SnmpQueryHelper(client)
                    mtm = ModelTypeMatcher(snmpStateHolder, snmpQueryHelper)
                    logger.debug('The target is matched:', mtm.match())
                    logger.debug('The type of the target is:',
                                 snmpStateHolder.getTypes())
                    vector = snmp_model_discovery.discoverAll(
                        hostOsh, snmpStateHolder, snmpQueryHelper)
                    logger.debug('Discovered CI count:', vector.size())
                    OSHVResult.addAll(vector)
                    if cacheClient:
                        cacheClient.writeCache()
                except:
                    errobj = errorobject.createError(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['modules', 'snmp'],
                        'Failed to discover modules by snmp')
                    logger.reportWarningObject(errobj)
                    logger.errorException('Failed to discover modules by snmp')
                logger.debug('End discover snmp modules')

    finally:
        if client != None:
            client.close()
    if OSHVResult.size() == 0 and framework.getSentObjectsCount() == 0:
        logger.reportWarning('SNMP: No data collected')
    return OSHVResult