def _logWarn(errorCode, params, errorMessage): 'int, list(str), str -> None' if not (modeling.CmdbClassModel().version() >= 9.0): errorMessage = errormessages.makeErrorMessage(params[1].upper(), params[0], errormessages.ERROR_DISCOVERY_BY_PROTOCOL) logger.debugException(errorMessage) errobj = errorobject.createError(errorCode, params, errorMessage) logger.reportWarningObject(errobj)
def decorator(framework): vector = ObjectStateHolderVector() framework = RichFramework(framework) creds_manager = CredsManager(framework) creds = creds_manager.get_creds_for_destination(proto_name) creds = filter(Fn(is_cred_ok_fn, framework, creds_manager, __), creds) if not creds: logger.reportErrorObject(_create_missed_creds_error(proto_name)) else: connection_exs = [] discovery_exs = [] warnings = [] at_least_once_discovered = False for cred_id in creds: try: oshs, warnings = main_fn(framework, creds_manager, cred_id) vector.addAll(oshs) at_least_once_discovered = True if stop_on_first: break except ConnectionException, ce: logger.debugException(str(ce)) connection_exs.append(ce) except (DiscoveryException, Exception, JException), de: logger.debugException(str(de)) discovery_exs.append(de)
def collectData(self,hostId,sqlServerId, discoverConfigs = 1): self.connection.open() oshv = ObjectStateHolderVector() try: oshv.add(self.getServerProperties(sqlServerId,hostId)) dbMap = self.getDatabases(sqlServerId) #get the databases oshv.addAll(self.sqlDataBaseProps.getDatabases(dbMap,hostId,discoverConfigs)) oshv.addAll(self.sqlDataBaseProps.getStoredProcedures(dbMap)) #get the server configuration: logger.debug('discovering configs') try: oshv.add(self.sqlServerConfig.getServerConfiguration(sqlServerId)) oshv.add(self.sqlServerConfig.getServerStartup(sqlServerId)) self.sqlServerConfig.discoverPlans(oshv,sqlServerId,dbMap) except: logger.debugException(hostId.toString()) if self.discoveryOptions and self.discoveryOptions.discoverDbUser: users = self.getDbUsers(sqlServerId) Util.addFromMap(users,oshv) else: users = LinkedHashMap() oshv.addAll(self.getProcesses(hostId,sqlServerId,dbMap,users)) oshv.addAll(self.clusterConfiguration.collectData(sqlServerId)) #db configuration: oshv.addAll(self.getDbConf(dbMap,hostId,users)) logger.debug("sql db result for hostid:"+hostId.toString()) except: logger.debugException(hostId.toString()) self.connection.close() return oshv
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ipAddress = Framework.getDestinationAttribute('ip_address') credentialsId = Framework.getDestinationAttribute('credentialsId') hostId = Framework.getDestinationAttribute('hostId') hostOsh = ms_exchange_utils.restoreHostById(hostId) hostName = Framework.getDestinationAttribute('hostName') if not hostName or hostName == 'N/A': hostName = ms_exchange_utils.getHostNameFromWmi(Framework) if not hostName: errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION_NO_PROTOCOL, ['host name'], 'Failed to obtain host name') logger.reportErrorObject(errobj) return props = Properties() props.put(AgentConstants.PROP_WMI_NAMESPACE, WMI_NAMESPACE) try: wmiClient = Framework.createClient(props) wmiAgent = WmiAgent(wmiClient, Framework) try: discoverExchangeServer(wmiAgent, ipAddress, credentialsId, OSHVResult, Framework, hostOsh, hostName) finally: wmiClient.close() except Exception, ex: message = ex.getMessage() if (re.search("Invalid\sclass", message)): message = 'Unable to get Exchange data from WMI' logger.debugException(message) errormessages.resolveAndReport(message, WMI_PROTOCOL, Framework)
def DiscoveryMain(Framework): credentialsId = Framework.getDestinationAttribute('credentialsId') OSHVResult = ObjectStateHolderVector() matchers = SiebelAgent.SIEBEL_DEFAULT_ENTERPRISE_MATCHERS ip = Framework.getDestinationAttribute('ip_address') port = Framework.getDestinationAttribute('port') if port == 'NA': port = None try: client = None try: client = siebel_common.createClient(Framework, ip, matchers, credentialsId, port) username = client.getUserName() enterprise = client.getEnterprise() siteOSH = ObjectStateHolder('siebel_site') siteOSH.setAttribute('data_name', enterprise) siteOSH.setAttribute('gateway_address', ip) modeling.setAppSystemVendor(siteOSH) start_srvrmgr_discovery(client, ip, username, enterprise, siteOSH, Framework, OSHVResult) finally: if client is not None: client.close() except Exception, ex: strException = str(ex.getMessage()) errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework) logger.debugException('')
def discoverPhysicalVolumes(wmiProvider, OSHVec, hostOSH): queryBuilder = wmiProvider.getBuilder("MSFT_Disk") queryBuilder.addWmiObjectProperties("ObjectId", "Path", "FriendlyName", "SerialNumber", "Number", "Size") wmicAgent = wmiProvider.getAgent() idToOshMap = {} numberToOshMap = {} try: phyVolumes = wmicAgent.getWmiData(queryBuilder) except: logger.debugException("Failed getting partition to volume map via wmi") return idToOshMap for volume in phyVolumes: id = volume.ObjectId and volume.ObjectId.strip() or "" id = id.replace("&", "&") name = volume.Path and volume.Path.strip() or "" name = name.replace("&", "&") description = volume.FriendlyName serialNumber = volume.SerialNumber number = volume.Number size = volume.Size phyVolumeOsh = ObjectStateHolder("physicalvolume") phyVolumeOsh.setStringAttribute("name", name) phyVolumeOsh.setStringAttribute("description", description) phyVolumeOsh.setStringAttribute("serial_number", serialNumber) phyVolumeOsh.setStringAttribute("volume_id", id) phyVolumeOsh.setDoubleAttribute("volume_size", _bytesToMB(size)) phyVolumeOsh.setContainer(hostOSH) OSHVec.add(phyVolumeOsh) idToOshMap[id] = phyVolumeOsh numberToOshMap[number] = phyVolumeOsh return idToOshMap, numberToOshMap
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() shell = None protocol = Framework.getDestinationAttribute("Protocol") switchId = Framework.getDestinationAttribute("hostId") print "Switch id %s" % switchId errorMessage = None try: client = Framework.createClient() try: shellFactory = shellutils.ShellFactory() shell = shellFactory.createShell(client) switchOsh = modeling.createOshByCmdbId("switch", switchId) discoverer = NexusDiscoverer(Framework, shell, "", "", "", "") discoverer.discoverInterfacesAndIps() interfaces_dict = discoverer.hostDataObject.interfaces ports_map = parsePorts(interfaces_dict.values()) vlan_discoverer = layer2_shell_discoverer.VlanDiscoverer(shell) vlans = vlan_discoverer.discoverVlans() layer2_discoverer = layer2_shell_discoverer.Layer2Discoverer(shell) remote_peers_map = layer2_discoverer.discover() OSHVResult.addAll(layer2.reportTopology(switchOsh, interfaces_dict, vlans, remote_peers_map, ports_map)) finally: try: shell and shell.closeClient() except: logger.debugException("") logger.error("Unable to close shell") except JException, ex: errorMessage = ex.getMessage()
def discover(self, firstSuccessful=1): for ip, contextsByCredentialsMap in self.contextsMap.items(): logger.debug("Connecting by IP %s" % ip) for contextList in contextsByCredentialsMap.values(): for context in contextList: try: client = self._connectByContext(context) try: context.client = client self.connectionHandler.onConnection(context) if firstSuccessful: return finally: if client: client.close() except JException, ex: msg = ex.getMessage() logger.debug(msg) errormessages.resolveAndAddToCollections(msg, VcloudProtocol.DISPLAY, context.warnings, context.errors) self.connectionHandler.onFailure(context) except Exception, ex: msg = str(ex) logger.debugException(msg) errormessages.resolveAndAddToCollections(msg, VcloudProtocol.DISPLAY, context.warnings, context.errors) self.connectionHandler.onFailure(context)
def mapProcessToPortsInSpecialWay(self): '''Mapping processes to open ports by pfiles''' invalidIpsMessage = '' errMsg = '' status = TCPDiscovery.OK try: # this command run only on sh, ksh and bash. csh and tcsh are not supported yet marker = '_%s_' % int(time.time()) cmdLine = 'for i in `ps -e|awk \'{if($4 != "<defunct>") if($1 != "PID") print $1}\'`; do echo %s$i; nice pfiles $i 2>&1|awk "/S_IFSOCK|SOCK_STREAM|SOCK_DGRAM|port/ { print }"; done' % marker result = self.shUtils.execCmd(cmdLine, self.shUtils.getDefaultCommandTimeout() * 40)#@@CMD_PERMISION shell protocol execution procsToPorts = result.split(marker) for procToPort in procsToPorts: mappings = TCPDisBySunOSShell._parseProcessPorts(procToPort) for mapping in mappings: ip, port, pid, listen, prot = mapping self._addTcpData(str(ip), port, pid, listen, prot) except TimeoutException: errMsg = 'Failed to map processes to ports by pfiles - timeout, try to increase command timeout parameter' logger.debugException(errMsg) self.Framework.reportWarning(errMsg) except: errMsg = 'Failed to map processes to ports by pfiles:see communication log' logger.debugException(errMsg) self.Framework.reportError(errMsg) status = TCPDiscovery.ERROR if len(invalidIpsMessage) > 0: wrnMsg = 'There are invalid ips found while paring port by pfiles, check communication log' self.Framework.reportWarning(wrnMsg) logger.debug(wrnMsg + '\n' + invalidIpsMessage) return status
def iterate_over_args(main_fn, framework, cred_args, proto_name, stop_on_first): ''' @param cred_args: parameters you decided to iterate over ''' vector = ObjectStateHolderVector() framework = flow.RichFramework(framework) creds_manager = flow.CredsManager(framework) # as cred_args possibly generator or iterator, realize only first first_ = first(cred_args) if first_ is None: logger.reportErrorObject(flow._create_missed_creds_error(proto_name)) else: # restore cred_args cred_args = chain((first_,), cred_args) connection_exs = [] discovery_exs = [] warnings = [] at_least_once_discovered = False for args in cred_args: try: oshs, warnings_ = main_fn(framework, creds_manager, *args) warnings.extend(warnings_ or ()) vector.addAll(oshs) at_least_once_discovered = True if stop_on_first: break except flow.ConnectionException, ce: logger.debugException(str(ce)) connection_exs.append(ce) except (flow.DiscoveryException, Exception, JException), de: logger.debugException(str(de)) discovery_exs.append(de)
def discoverDnsZoneTopologies(dnsDiscoverer, zoneList, protocolName): r'''DnsDiscoverer, seq[str], str -> seq[_ZoneTopology] @note: make error reporting to the UI ''' topologies = [] try: zoneList = zoneList and map(dns.Zone, zoneList) zones = zoneList or dnsDiscoverer.listZones() isError = 0 for zone in zones: if (dns.isLocalhostZone(zone) or dns.isReverseZone(zone) or dns.isRootZone(zone)): continue topology = ZoneTopology(zone) try: logger.debug('transfer zone: %s' % zone) types = (RecordType.A, # IPv4 address RecordType.CNAME, # Alias RecordType.AAAA) # IPv6 address records = dnsDiscoverer.transferZone(zone, *types) topology.records.extend(records) except dns.DiscoveryException, dde: logger.warn('Failed to transfer zone "%s"' % zone) logger.debugException(str(dde)) isError = 1 else: topologies.append(topology) if isError: errCode = errorcodes.FAILED_TRANSFER_DNS_ZONE message = "Failed to transfer zone records for one or more zones" errobj = errorobject.createError(errCode, [protocolName], message) logger.reportWarningObject(errobj)
def mapProcessToPortsInSpecialWay(self): invalidIpsMessage = '' errMsg = '' status = TCPDiscovery.OK try: socket_descriptors = get_socket_descriptors_by_pfiles(self.shUtils) for pid, socket_descriptor in socket_descriptors: local_ip, local_port, is_listen, protocol_type, _, _ = socket_descriptor local_ip = local_ip and sanitizeIps(local_ip) if local_ip and (not ip_addr.isValidIpAddress(local_ip)): local_ip = netutils.resolveIP(self.shUtils, local_ip) if local_ip and (ip_addr.isValidIpAddress(local_ip)): self._addTcpData(local_ip, local_port, pid, is_listen, protocol_type) else: invalidIpsMessage = invalidIpsMessage + 'On parsing ports by pfiles invalid ip:<%s>\n' % local_ip except TimeoutException: errMsg = 'Failed to map processes to ports by pfiles - timeout, try to increase command timeout parameter' logger.debugException(errMsg) self.Framework.reportWarning(errMsg) except: errMsg = 'Failed to map processes to ports by pfiles:see communication log' logger.debugException(errMsg) self.Framework.reportError(errMsg) status = TCPDiscovery.ERROR if len(invalidIpsMessage) > 0: wrnMsg = 'There are invalid ips found while paring port by pfiles, check communication log' self.Framework.reportWarning(wrnMsg) logger.debug(wrnMsg + '\n' + invalidIpsMessage) return status
def getEth(self, managedSystemName): try: output = self.executeCommand('lshwres -r virtualio --rsubtype eth --level lpar -m \'' + managedSystemName + '\'') return self.getEntiesAsList(output, self._parseEth) except: logger.debug('Failed to discover eth information.') logger.debugException('')
def discoverSharedResourcesByWmic(client, hostOsh, oshVector): queryBuilder = wmiutils.WmicQueryBuilder('share') queryBuilder.addWmiObjectProperties('description', 'name', 'path') queryBuilder.addWhereClause("Path <> ''") wmicAgent = wmiutils.WmicAgent(client) shareItems = [] try: shareItems = wmicAgent.getWmiData(queryBuilder) except: logger.debugException('Failed getting shares information via wmic' ) return 0 collection = {} for shareItem in shareItems: shareName = shareItem.name shareDescription = shareItem.description sharePath = shareItem.path instance = SharedResource.Instance(shareName, shareDescription) element = collection.get(sharePath) if element is None: element = SharedResource(sharePath) element.addInstance(instance) collection[sharePath] = element for [path, resource] in collection.items(): createSharedResourceOsh(resource, hostOsh, oshVector) return 1
def _getLparProfiles(self, managedSystemName, lparFilter): try: output = self.executeCommand('lssyscfg -r prof -m \'' + managedSystemName + '\'' + ' --filter '+ lparFilter) return self.getEntriesAsDict(output, self._parseLparProfile) except: logger.debug('Failed to discover LPar Profile') logger.debugException('')
def _getLpars(self, managedSystemName): try: output = self.executeCommand('lssyscfg -r lpar -m \'' + managedSystemName + '\'') return self.getEntriesAsDict(output, self._parseLpar) except: logger.debug('Failed to get LPar information.') logger.debugException('')
def discoverExchangeServers(self): #@return list of ExchangeServer Do hostname = self._getHostNameByHostname() try: dagList = self._getClusteredConfiguration() except: dagList = [] logger.debug('The exchange configuration is not a clustered one.') logger.debugException('') mdbList = [] try: mdbList = self._getMailboxDatabaseConfiguration() ipResolver = dns_resolver.NsLookupDnsResolver(self._shell) for mdb in mdbList: if mdb.servers: for serverInfo in mdb.servers: try: serverInfo.ips = ipResolver.resolve_ips(serverInfo.name) except: logger.debug('Failed to resolve ip for server %s ' % serverInfo.name) except: logger.debug('Failed to discover Mailbox Database configuration.') logger.debugException('') exchangeServers = self._getExchangeServers(hostname, hostname) if exchangeServers: for exchangeServer in exchangeServers: exchangeServer.dagList = dagList exchangeServer.mdbList = mdbList return exchangeServers
def discoveriSCSISessionToDiskMap(wmiProvider): queryBuilder = wmiProvider.getBuilder("MSFT_iSCSISessionToDisk") queryBuilder.addWmiObjectProperties("Disk", "iSCSISession") wmicAgent = wmiProvider.getAgent() associations = [] map = {} try: associations = wmicAgent.getWmiData(queryBuilder) except: logger.debugException("Failed getting session to disk map via wmic") return map for association in associations: disk = association.Disk and association.Disk.strip() or "" disk = disk.split("=")[1].strip('"') if disk.find("\\\\\\\\") == 0: disk = disk.replace("\\\\", "\\") disk = disk.replace("&", "&") session = association.iSCSISession session = session.split("=")[1].strip('"') disks = map.get(session) or [] disks.append(disk) map[session] = disks return map
def doDiscovery(Framework, shell, ip, credentialId, codepage, shellName, warningsList, errorsList, uduid = None): vector = ObjectStateHolderVector() try: try: languageName = shell.osLanguage.bundlePostfix langBund = Framework.getEnvironmentInformation().getBundle('langNetwork', languageName) remoteHostnames = dns_resolver.NsLookupDnsResolver(shell).resolve_hostnames(ip) remoteHostFqdn = None if remoteHostnames: remoteHostFqdn = remoteHostnames[0] shellObj = createShellObj(shell, ip, langBund, languageName, codepage, remoteHostFqdn) try: vector.addAll(discover(shell, shellObj, ip, langBund, Framework, uduid)) finally: # create shell OSH if connection established if shellObj and not vector.size(): hostOsh = modeling.createHostOSH(ip) shellObj.setContainer(hostOsh) vector.add(shellObj) except Exception, ex: strException = ex.getMessage() errormessages.resolveAndAddToObjectsCollections(strException, shellName, warningsList, errorsList) except: msg = str(sys.exc_info()[1]) logger.debugException('') errormessages.resolveAndAddToObjectsCollections(msg, shellName, warningsList, errorsList)
def discoverPhysicalDiskByWmi(shell, OSHVec, hostOSH): wmiProvider = wmiutils.getWmiProvider(shell) queryBuilder = wmiProvider.getBuilder("Win32_DiskDrive") queryBuilder.addWmiObjectProperties("DeviceID", "SerialNumber", "Size") wmiAgent = wmiProvider.getAgent() diskDevices = [] try: diskDevices = wmiAgent.getWmiData(queryBuilder) except: logger.debugException("Failed getting physical disk via wmi") for diskDevice in diskDevices: diskOsh = ObjectStateHolder("disk_device") diskName = diskDevice.DeviceID and diskDevice.DeviceID.strip() or None if diskName: diskOsh.setStringAttribute("name", diskName.upper()) else: continue diskSerialNumber = diskDevice.SerialNumber and diskDevice.SerialNumber.strip() or None if diskSerialNumber: diskOsh.setStringAttribute("serial_number", diskSerialNumber) diskOsh.setStringAttribute("disk_type", "fixed_disk") diskSize = diskDevice.Size and diskDevice.Size.strip() or None # Byte to MB if diskSize: diskSize = int(diskSize) / 0x100000 diskOsh.setIntegerAttribute("disk_size", diskSize) diskOsh.setContainer(hostOSH) OSHVec.add(diskOsh)
def DiscoveryMain(Framework): shell = None try: try: protocolName = __getProtocolName(Framework) discoverSharePointUrls = Boolean.parseBoolean(Framework.getParameter('discoverSharePointUrls')) reportIntermediateWebService = Framework.getParameter('reportIntermediateWebService') if reportIntermediateWebService: reportIntermediateWebService = Boolean.parseBoolean(reportIntermediateWebService) else: #set default value reportIntermediateWebService = 1 relativeCommandTimeoutMultiplier = Framework.getParameter('relativeCommandTimeoutMultiplier') relativeCommandTimeoutMultiplier = int(relativeCommandTimeoutMultiplier) client = Framework.createClient() shell = ShellFactory().createShell(client) logger.debug('getting SharePoint discoverer for protocol %s' % protocolName) discoverer = sharepoint_win_shell.getDiscoverer(shell, protocolName, relativeCommandTimeoutMultiplier) logger.debug('got discoverer') resources = _discoverSharePoint(discoverer) resources.build() return resources.report(discoverSharePointUrls, reportIntermediateWebService) except SharePointException: logger.reportError() logger.debugException('') except JavaException, ex: strException = ex.getMessage() errormessages.resolveAndReport(strException, protocolName, Framework) except: strException = logger.prepareJythonStackTrace('') errormessages.resolveAndReport(strException, protocolName, Framework)
def handleWSDL(HOST_IP, MANAGER_PORT, wsdlDirRes, wsdlDir, appList, shellUtils, OSHVResult): lines = wsdlDirRes.split('\n') for line in lines: m = re.search('application-deployments[\\\\/](\w+)[\\\\/](\w+)[\\\\/]server-wsdl',line) if m != None: appName = m.group(1) wsdlName = m.group(2)+'.wsdl' wsdlFullPAth = '%s/%s/%s/server-wsdl/' % (wsdlDir, m.group(1), m.group(2)) appOSH = appList[appName] fileWsdlContent = None try: fileWsdlContent = shellUtils.safecat(wsdlFullPAth + wsdlName) if fileWsdlContent: tg = '<service name="(\w+)">.*oracle.scheme.host.port.and.context\}.(\w+)' compiled = re.compile(tg,re.S) matches = compiled.findall(fileWsdlContent.strip()) for match in matches: wsdlUrl = 'http://' + HOST_IP + ':' + MANAGER_PORT + '/integration/services/' + match[0] + '/' + match[1] + '?WSDL' res = getUrl(wsdlUrl, appOSH) OSHVResult.addAll(res) except: logger.debugException('Error reading file: %s' % (wsdlFullPAth + wsdlName))
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ipAddress = Framework.getDestinationAttribute('ip_address') credentialsId = Framework.getDestinationAttribute('credentialsId') hostId = Framework.getDestinationAttribute('hostId') hostOsh = ms_exchange_utils.restoreHostById(hostId) try: shellClient = Framework.createClient() client = PowerShellClient(shellClient, Framework) try: ExchangeServer = client.executeScenario("Exchange_Server_2007_Discovery.ps1") exchangeServerOsh = modeling.createExchangeServer(hostOsh, ipAddress, credentialsId, ExchangeServer.ExchangeSnapInVersion) exchangeServerOsh.setAttribute('guid', normalizeGuid(ExchangeServer.Guid)) exchangeServerOsh.setAttribute('fqdn', ExchangeServer.Fqdn) buildNumber = parseBuildNumber(ExchangeServer.AdminDisplayVersion) if buildNumber: exchangeServerOsh.setAttribute('build_number', buildNumber) #exchangeServerOsh.setAttribute('application_version_number', ExchangeServer.ExchangeSnapInVersion) versionNumber = parseExchangeVersion(ExchangeServer.AdminDisplayVersion) if versionNumber: exchangeServerOsh.setAttribute('application_version_number', exchange_version_mapping[versionNumber]) exchangeServerOsh.setAttribute('application_version', ExchangeServer.AdminDisplayVersion) exchangeServerOsh.setDateAttribute('creation_date', DATE_FORMAT.parse(ExchangeServer.WhenCreated)) OSHVResult.add(exchangeServerOsh) finally: client.close() except Exception, ex: logger.debugException('') strException = str(ex.getMessage()) errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
def ensureScannerExist(scannerPlatformConfig, Framework): logger.debug('Ensure Scanner Exist') #copying local scanner executable and config file to the remove machine BASEDIR = Framework.getProperty(InventoryUtils.STATE_PROPERTY_RESOLVED_BASEDIR) #scanner local executable file scannerExecutable = scannerPlatformConfig.getScannerExecutable() logger.debug('Scanner executable to be used:', scannerExecutable) #scanner remote executable file scannerRemoteExecutable = scannerPlatformConfig.getScannerRemoteExecutableName() #local location of scanner and config file scannerExecutableLocalPath = CollectorsParameters.PROBE_MGR_RESOURCES_DIR + 'ud_scanners' + str(File.separator) + scannerExecutable logger.debug('Scanner executable local path:', scannerExecutableLocalPath) if not checkResourceExists(Framework, scannerExecutableLocalPath): return 0 scannerExecutableRemotePath = BASEDIR + scannerRemoteExecutable logger.debug('Copy local ', scannerExecutableLocalPath, " to remote ", scannerExecutableRemotePath) client = Framework.getConnectedClient() try: client.uploadFile(scannerExecutableLocalPath, scannerExecutableRemotePath, 0) Framework.setProperty(InventoryUtils.SCANNER_EXECUTABLE_REMOTE_PATH, scannerExecutableRemotePath) except: errorMessage = str(sys.exc_info()[1]) logger.debugException('Error happened when uploading scanner:' + errorMessage) Framework.setStepExecutionStatus(WorkflowStepStatus.FAILURE) return 0 return 1
def DiscoveryMain(Framework): version = Framework.getDestinationAttribute('siebelVersion') siebelRootDir = Framework.getDestinationAttribute('siebelInstallDir') OSHVResult = ObjectStateHolderVector() appServerId = Framework.getDestinationAttribute('id') appServerOSH = modeling.createOshByCmdbIdString('siebel_app_server', appServerId) modeling.setAppServerType(appServerOSH) client = None try: client = Framework.createClient() discoverConfigFile(siebelRootDir,appServerOSH,client,version,OSHVResult) except: errmsg = 'Connection failed: %s' % str(sys.exc_info()[1]).strip() Framework.reportError(errmsg) logger.debugException(errmsg) if(client != None): try: client.close() except: pass return OSHVResult
def _get_initialized_execute_fn(client, run_timeout): try: return ovm_cli.initialize_env_with_xml_as_output(client, run_timeout) except Exception: msg = "Failed to initialize OVM CLI" logger.debugException(msg) raise ovm_flow.DiscoveryException(msg)
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() logger.info('Starting HACMP Applications') hostIP = Framework.getDestinationAttribute('ip_address') logger.debug ('Host IP: ',hostIP) cluster = Framework.getDestinationAttribute('cluster') hostOS = Framework.getDestinationAttribute('host_os') hostOS = hostOS or 'NA' protocolName = Framework.getDestinationAttribute('Protocol') hostId = Framework.getDestinationAttribute('hostId') ## Get Parameter Section cldisp_command = Framework.getParameter('cldisp_command') or 'cldisp' cllsif_command = Framework.getParameter('cllsif_command') or 'cllsif' try: client = Framework.createClient() shell = ShellUtils(client) # If we get good client connection , run the client commands to get the Application information for the cluster HostOSH = modeling.createOshByCmdbIdString('host', hostId) ClusterOSH = getclusterOSH(cluster) appDictionary = getapplicationInfo(shell, cldisp_command, Framework) resourceDictionary = getresourceinfo(shell, cllsif_command) OSHVResult.addAll(createserviceapplicationOSH (shell, appDictionary, resourceDictionary, HostOSH, ClusterOSH, Framework)) client.close() except JavaException, ex: strException = ex.getMessage() logger.debugException('') errormessages.resolveAndReport(strException, protocolName, Framework)
def getOracleServerNameByInstance(self): try: resultHost = self._client.executeQuery("select HOST_NAME from V$INSTANCE where upper(INSTANCE_NAME) = '%s'" % self._client.getSid().upper()) while resultHost.next(): return resultHost.getString(1) except: logger.debugException('')
def getOracleServerName(self): try: host_name_result = self._client.executeQuery("select UTL_INADDR.get_host_name(UTL_INADDR.get_host_address) from dual") while host_name_result.next(): return host_name_result.getString(1) except: logger.debugException('')
def getServices(dbClient): services = [] logger.debug('Query services for protocol type:', DbTypes.Oracle) try: res = dbClient.executeQuery("SELECT NAME, PDB from V$SERVICES WHERE NETWORK_NAME IS NOT NULL") while res.next(): name = res.getString(1) pdb = res.getString(2).strip() != '' and res.getString(2) != 'CDB$ROOT' service = db.OracleServiceName(name) service.setPdb(pdb) services.append(service) res.close() except: logger.debugException('') try: res = dbClient.executeQuery("SELECT NAME from V$SERVICES WHERE NETWORK_NAME IS NOT NULL") while res.next(): name = res.getString(1) service = db.OracleServiceName(name) services.append(service) res.close() except: logger.debugException('') return services
def DiscoveryMain(Framework): ip = Framework.getDestinationAttribute("ip") or None port = Framework.getDestinationAttribute("https_port") or None hostCmdbId = Framework.getDestinationAttribute("host_id") or None oshvector = ObjectStateHolderVector() hostOsh = modeling.createOshByCmdbIdString('node', hostCmdbId.strip()) if not (hostOsh and ip and port): logger.error("Incorrect input data: %s" % hostCmdbId.strip()) logger.reportError("Incorrect input data") return oshvector localShell = shellutils.ShellUtils(Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME)) dnsResolver = dns_resolver.FallbackResolver([dns_resolver.SocketDnsResolver(), dns_resolver.NsLookupDnsResolver(localShell)]) hosts = dnsResolver.resolve_hostnames(ip) logger.debug("Host names to check: %s" % hosts) errors = [] discoverResult = {} for hostname in hosts: try: logger.info("Getting certificate from %s:%s" % (hostname, port)) certificates = ssl_cert_discoverer.openSslSession(hostname, port, ssl_cert_discoverer.discoverCertificates) if certificates: logger.info("Got %s certificates" % len(certificates)) discoverResult[hostname] = certificates else: logger.warn("There are no any certificates on the %s:%s" % (hostname, port)) logger.reportError("There are no any certificates on the target host") except JException,ex: logger.debugException(ex.getMessage()) errors.append(ex.getMessage()) except Exception, ex: logger.debugException(ex.message) errors.append(ex.message)
def _simConnect(credId, ip, Framework): # Make sure the SIM JAR file is in place and loadable try: from com.hp.mx.soap.v5_1.client import MxpiMain5_1SoapBindingStub import VerifyAllHostnameVerifier except Throwable: message = "SIM SDK jar is missed. Refer documentation for details" logger.debugException(message) return Result(False, message) soapPort = Framework.getProtocolProperty(credId, PROTOCOL_ATTRIBUTE_PORT) soapProtocol = Framework.getProtocolProperty(credId, 'simprotocol_protocol') username = Framework.getProtocolProperty(credId, PROTOCOL_ATTRIBUTE_USERNAME) password = Framework.getProtocolProperty(credId, PROTOCOL_ATTRIBUTE_PASSWORD) localMxpiMain, simLogonToken = None, None try: localMxpiMain = _initializeMXPI(ip, soapPort, soapProtocol, MxpiMain5_1SoapBindingStub, VerifyAllHostnameVerifier) if localMxpiMain: simLogonToken = localMxpiMain.logon(username, password) if simLogonToken: return Result(True) else: raise Exception('Log-on failed') else: raise Exception('MXPI initialization failed') finally: ## Log off if log on is successful if localMxpiMain and simLogonToken: localMxpiMain.logoff(simLogonToken)
def discoverPoolMembers(self, nameToPool): queryBuilder = SnmpQueryBuilder('5.3.2.1') queryBuilder.addQueryElement(1, 'poolName') queryBuilder.addQueryElement(2, 'addressType') queryBuilder.addQueryElement(3, 'address', 'hexa') queryBuilder.addQueryElement(4, 'port') poolMembers = self.snmpAgent.getSnmpData(queryBuilder) for poolMember in poolMembers: ipAddress = self.convertToIp(poolMember.address) hostOsh = modeling.createHostOSH(ipAddress, 'host') serviceAddressOsh = modeling.createServiceAddressOsh(hostOsh, ipAddress, poolMember.port, modeling.SERVICEADDRESS_TYPE_TCP) try: #TODO: consider about avoiding try-except here self.add(modeling.createLinkOSH('member', nameToPool[poolMember.poolName], serviceAddressOsh)) self.add(hostOsh) self.add(serviceAddressOsh) except: errorMsg = 'Failed to link %s member with pool %s' % (ipAddress, poolMember.poolName) errobj = errorobject.createError(errorcodes.FAILED_LINKING_ELEMENTS, ['%s member' % ipAddress, 'pool %s' % poolMember.poolName], errorMsg) #TODO: Change log level to debug logger.debugException('errorMsg') logger.reportWarningObject(errobj)
def resolveClusterNameByShell(self, instance_name): try: regUtil = RegistryShellUtil(self.__client) instName = regUtil.doQuery(self.HKLM + self.SQL_SERVER_REG_KEY + self.SQL_SERVER_REG_INSTANCES_SUFIX) lines = instName.strip().split('\n') tokens = lines[0].split('REG_SZ') instName = tokens[1].strip() for line in lines: tokens = line.split('REG_SZ') if instance_name == tokens[0].strip(): instName = tokens[1].strip() clusterVal = regUtil.doQuery(self.HKLM + self.SQL_SERVER_REG_KEY + '\\' + instName + self.CLUSTER) lines = clusterVal.strip().split('\n') for line in lines: if line.find('ClusterName') > -1: tokens = line.split('REG_SZ') clusterVal = tokens[1].strip() return clusterVal except: logger.debugException( 'Failed getting cluster name. Assume single host installation')
def _discoverBasedOnProfilesUnsafe(sapUtils, oshPerInstance, system, systemOsh, discoverSapProfiles): '@types: SapUtils, dict[Instance, osh], System, osh, bool -> oshv' r = discoverTopologyBasedOnProfiles(sapUtils, system.getName(), systemOsh) pfNameToOsh, defaultPf, otherPfs = r pfSetByInstName = _groupPfsIniByInstanceName(otherPfs) instOshs = oshPerInstance.itervalues() vector = ObjectStateHolderVector() if discoverSapProfiles: vector.addAll(pfNameToOsh.values()) vector.addAll(_reportInstPfLinks(instOshs, pfNameToOsh, system)) defaultPfDoc = None if defaultPf: defaultPfDoc = IniParser.parseIniDoc(second(defaultPf)) try: logger.info("Trying to discover ASCS") vector.addAll(_discoverAscsInPf(defaultPfDoc, system, systemOsh, oshPerInstance)) except SapSystemInconsistentDataException, e: logger.debugException('') raise e except:
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ipAddress = Framework.getDestinationAttribute('ip_address') credentialsId = Framework.getDestinationAttribute('credentialsId') hostId = Framework.getDestinationAttribute('hostId') hostOsh = modeling.createOshByCmdbIdString('host', hostId) PROTOCOL_NAME = 'PowerShell' try: client = Framework.createClient() shell = shellutils.ShellUtils(client) discoverer = None try: for discovererClass in [ msexchange_win_shell.Exchange2007Discoverer, msexchange_win_shell.Exchange2010Discoverer ]: try: discoverer = discovererClass(shell) exchangeServers = discoverer.discover() for exchangeServer in exchangeServers: topoBuilder = msexchange.TopologyBuilder( exchangeServer, hostOsh, ipAddress, credentialsId) OSHVResult.addAll(topoBuilder.build()) break except msexchange_win_shell.AddSnapInException: logger.warn('Failed to import Snap-In.') discoverer = None if not discoverer: raise Exception( "Failed to discover MS-Exchange. See Logs for details.") finally: shell.closeClient() except JavaException, ex: logger.debugException('') strException = str(ex.getMessage()) errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
def _uddiRegistryConnect(credId, ip, Framework): r'''@types: str, str, Framework -> Result @raise java.lang.Exception on connection failure ''' protocol = ProtocolManager.getProtocolById(credId) url = protocol.getProtocolAttribute(UDDI_PROTOCOL_ATTRIBUTE_URL) props = java.util.Properties() props.setProperty(UDDI_PROTOCOL_ATTRIBUTE_URL, url) props.setProperty("ip_domain", ip) uddiAgent = None for uddiVersion in (3, 2): try: props.setProperty('uddi_version', str(uddiVersion)) uddiAgent = Framework.getAgent(AgentConstants.UDDI_AGENT, '', credId, props) return Result(True) except MissingSdkJarException, ex: logger.debugException(ex.getMessage()) return Result( False, "UDDI SDK jars are missed. Refer documentation for details") finally:
class BaseDiscoveryConnectionHandler(ConnectionHandler): def __init__(self, framework): ConnectionHandler.__init__(self) self.framework = framework self.connected = 0 self.connectionErrors = [] self.connectionWarnings = [] self.vcloudDiscoverer = None self.vcloudReporter = None def setDiscoverer(self, discoverer): self.vcloudDiscoverer = discoverer def setReporter(self, reporter): self.vcloudReporter = reporter def onConnection(self, context): if self.vcloudDiscoverer is None: raise ValueError("discoverer is not set") if self.vcloudReporter is None: raise ValueError("reporter is not set") self.connected = 1 try: cloud = self.vcloudDiscoverer.discover(context) vector = self.vcloudReporter.report(cloud) #logger.debug(vector.toXmlString()) self.framework.sendObjects(vector) self.framework.flushObjects() except JException, ex: msg = ex.getMessage() logger.debugException("") errormessages.resolveAndReport(msg, VcloudProtocol.DISPLAY, self.framework) except Exception, ex: msg = str(ex) logger.debugException("") errormessages.resolveAndReport(msg, VcloudProtocol.DISPLAY, self.framework)
def DiscoveryMain(Framework): vector = ObjectStateHolderVector() codePage = Framework.getCodePage() props = Properties() props.setProperty(BaseAgent.ENCODING, codePage) shell = None try: client = Framework.createClient(props) shell = shellutils.ShellFactory().createShell(client) dnsResolver = dns_resolver.NsLookupDnsResolver(shell) language = shell.osLanguage logger.debug("Using '%s' language bundle" % language.bundlePostfix) bundle = shellutils.getLanguageBundle('langMsCluster', language, Framework) clusterCmd = ms_cluster_discoverer.createClusterCmd(shell, bundle) if clusterCmd.isUsingCmd(): bundle = clusterCmd.detectLangBandle(Framework) clusterCmd.setBundle(bundle) vector.addAll(_discoverTopology(clusterCmd, bundle, dnsResolver)) except NoInstanceFound: errobj = errorobject.createError( errorcodes.MS_CLUSTER_INSTANCES_NOT_FOUND, None, 'MS cluster instances not found in discovery') logger.reportWarningObject(errobj) except: msg = str(sys.exc_info()[1]) logger.debugException(msg) if (msg.lower().find('timeout') > -1): errobj = errorobject.createError( errorcodes.CONNECTION_TIMEOUT_NO_PROTOCOL, None, 'Connection timed out - reactivate with larger timeout value') logger.reportErrorObject(errobj) logger.debugException('Connection timed out') else: errobj = errormessages.resolveError(msg, 'ntcmd') logger.reportErrorObject(errobj) logger.errorException(msg) try: shell and shell.closeClient() except: logger.debugException() logger.error("Unable to close shell") return vector
def iterate_over_args(main_fn, framework, cred_args, proto_name, stop_on_first): ''' @param cred_args: parameters you decided to iterate over ''' vector = ObjectStateHolderVector() framework = flow.RichFramework(framework) creds_manager = flow.CredsManager(framework) # as cred_args possibly generator or iterator, realize only first first_ = first(cred_args) if first_ is None: logger.reportErrorObject(flow._create_missed_creds_error(proto_name)) else: # restore cred_args cred_args = chain((first_,), cred_args) connection_exs = [] discovery_exs = [] java_exs = [] warnings = [] at_least_once_discovered = False for args in cred_args: try: oshs, warnings_ = main_fn(framework, creds_manager, *args) warnings.extend(warnings_ or ()) vector.addAll(oshs) at_least_once_discovered = True if stop_on_first: break except flow.ConnectionException, ce: logger.debugException('%s' % ce) connection_exs.append(ce) except (flow.DiscoveryException, Exception), de: logger.debugException('%s' % de) discovery_exs.append(de) except JException, je: logger.debugException('%s' % je) java_exs.append(je)
def discoverDiskByWmic(shell, OSHVec, hostOSH): wmiProvider = wmiutils.getWmiProvider(shell) queryBuilder = wmiProvider.getBuilder('Win32_LogicalDisk') queryBuilder.usePathCommand(1) queryBuilder.addWmiObjectProperties( 'DeviceID', 'DriveType', 'FreeSpace', 'ProviderName', 'Size', 'FileSystem', ) queryBuilder.addWhereClause('DriveType=3') wmicAgent = wmiProvider.getAgent() diskItems = [] try: diskItems = wmicAgent.getWmiData(queryBuilder) except: logger.debugException('Failed getting disks information via wmic') return 0 for diskItem in diskItems: #size in MB diskSize = diskItem.Size and diskItem.Size.strip() or None if diskSize: diskSize = _bytesToMB(diskSize) diskFreeSize = diskItem.FreeSpace and diskItem.FreeSpace.strip( ) or None if diskFreeSize: diskFreeSize = _bytesToMB(diskFreeSize) diskUsedSize = None if diskFreeSize is not None and diskFreeSize is not None: diskUsedSize = diskSize - diskFreeSize diskName = diskItem.DeviceID and diskItem.DeviceID.strip() or None if diskName: diskName = re.sub(':$', '', diskName) # if provderName is set - this is a remote disk diskProviderName = diskItem.ProviderName and diskItem.ProviderName.strip( ) or diskName diskType = diskItem.DriveType and int( diskItem.DriveType.strip()) or None logger.debug('found disk: %s, sizeInMB=%s, freespace=%s, type=%s' % (diskName, diskSize, diskFreeSize, diskType)) diskType = diskType and modeling.STORAGE_ID_TO_STORAGE_TYPE.get( diskType) or modeling.OTHER_STORAGE_TYPE diskOsh = modeling.createDiskOSH(hostOSH, diskName, diskType, size=diskSize, name=diskProviderName, usedSize=diskUsedSize) OSHVec.add(diskOsh) return 1
def getPushProperties(): pushProperties = HashMap() pushPropertiesFileStr = "%s%s%s" % (adapterConfigBaseDir, FILE_SEPARATOR, PUSH_PROPERTIES_FILE) properties = Properties() debugMode = 0 sortCSVFields = "" smartUpdateIgnoreFields = "" testConnNameSpace = "BMC.CORE" testConnClass = "BMC_ComputerSystem" try: logger.debug("Checking push properties file for debugMode [%s]" % pushPropertiesFileStr) fileInputStream = FileInputStream(pushPropertiesFileStr) properties.load(fileInputStream) # Property: debugMode try: debugModeStr = properties.getProperty("debugMode") if isNoneOrEmpty(debugModeStr) or string.lower( string.strip(debugModeStr)) == 'false': debugMode = 0 elif string.lower(string.strip(debugModeStr)) == 'true': debugMode = 1 except: logger.debugException( "Unable to read debugMode property from push.properties") if debugMode: logger.debug( "Debug mode = TRUE. XML data pushed to Remedy/Atrium will be persisted in the directory: %s" % adapterResBaseDir) else: logger.debug("Debug mode = FALSE") # Property: smartUpdateIgnoreFields try: smartUpdateIgnoreFields = properties.getProperty( "smartUpdateIgnoreFields") except: logger.debugException( "Unable to read smartUpdateIgnoreFields property from push.properties" ) # Property: sortCSVFields try: sortCSVFields = properties.getProperty("sortCSVFields") except: logger.debugException( "Unable to read sortCSVFields property from push.properties") # Property: testConnNameSpace try: testConnNameSpace = properties.getProperty("testConnNameSpace") except: logger.debugException( "Unable to read testConnNameSpace property from push.properties" ) # Property: testConnClass try: testConnClass = properties.getProperty("testConnClass") except: logger.debugException( "Unable to read testConnClass property from push.properties") fileInputStream.close() except: logger.debugException("Unable to process %s file." % PUSH_PROPERTIES_FILE) return debugMode, smartUpdateIgnoreFields, sortCSVFields, testConnNameSpace, testConnClass
listenedFull = hostDnsName + ':' + hostPrimaryIP + '@' + listenedIPs listenerName = listenerConf.getListenerName() listenerVersion = listenerConf.getVersion() listenerOSH = createListenerOSH(hostOSH, listenedFull, listenerName, listenerVersion) if listenerOSH: OSHVResult.add(listenerOSH) else: Framework.reportWarning('Failed to create listener OSH. Either host name or listened ips are not defined.') except: logger.debugException('') Framework.reportWarning('Failed to discover one or more listeners parameters.') finally: try: shell and shell.closeClient() except: logger.debugException('') logger.error('Unable to close shell') except JException, ex: errorMessage = ex.getMessage() except: errorObject = sys.exc_info()[1] if errorObject: errorMessage = str(errorObject) else: errorMessage = logger.prepareFullStackTrace('') if errorMessage: logger.debugException(errorMessage) errormessages.resolveAndReport(errorMessage, protocol, Framework) return OSHVResult
def discoverProcessesByWmic(client, OSHVResult, hostID, Framework, pid2Process=None): ''' Discover system processes, report them and save in probe DB. Shell, oshVector, str, Framework, map[str, str] -> bool @command: wmic process get commandLine, creationdate, executablepath, name, processId ''' wmiProvider = wmiutils.getWmiProvider(client) queryBuilder = wmiProvider.getBuilder('Win32_Process') queryBuilder.usePathCommand(1) #queryBuilder = wmiutils.WmicQueryBuilder('process') queryBuilder.addWmiObjectProperties('name', 'processId', 'commandLine', 'executablepath', 'creationdate') wmicAgent = wmiProvider.getAgent() processItems = [] try: processItems = wmicAgent.getWmiData(queryBuilder) except: logger.debugException('Failed getting processes information via wmic') return 0 pdu = None try: pdu = processdbutils.ProcessDbUtils(Framework) processList = [] hostOSH = None count = 0 for processItem in processItems: if not processItem.name: continue processName = processItem.name processNameLower = processName.lower() processPid = processItem.processId if processPid == '-1' or not processPid.isnumeric(): logger.debug( "Process '%s' is system process or has non numeric pid" % processName) continue processExecutablePath = processItem.executablepath processCommandLine = processItem.commandLine processStartupTimeString = processItem.creationdate processStartupTime = None if processStartupTimeString: try: startupDate = modeling.getDateFromUtcString( processStartupTimeString) processStartupTime = startupDate.getTime() except: errobj = errorobject.createError( errorcodes.PROCESS_STARTUP_TIME_ATTR_NOT_SET, ['NTCMD', processStartupTimeString], "%s: Process startup time attribute is not set due to error while parsing date string '%s'" % ('NTCMD', processStartupTimeString)) logger.reportWarningObject(errobj) # check whether process name is included in command line # Obtain first token containing process from the CMD line matchObj = re.match('(:?["\'](.*?)["\']|(.*?)\s)', processCommandLine) if matchObj and matchObj.groups(): firstCmdToken = matchObj.group(1).strip() else: firstCmdToken = processCommandLine.strip() #remove quotes firstCmdToken = re.sub('[\'"]', '', firstCmdToken).lower() #token has to end with process name if not firstCmdToken.endswith(processNameLower): extStartPos = processNameLower.rfind('.') if extStartPos != -1: pnameNoExt = processNameLower[0:extStartPos] if not firstCmdToken.endswith(pnameNoExt): processCommandLine = '%s %s' % (processName, processCommandLine) processArgs = None argsMatch = re.match('("[^"]+"|[^"]\S+)\s+(.+)$', processCommandLine) if argsMatch: processArgs = argsMatch.group(2) pdu.addProcess(hostID, processName, processPid, processCommandLine, processExecutablePath, processArgs, None, processStartupTime) if processPid in processList: logger.debug("Process: '%s' already reported" % processName) continue count += 1 processList.append(processPid) if OSHVResult is not None: if hostOSH == None: hostOSH = modeling.createOshByCmdbIdString('host', hostID) processOsh = modeling.createProcessOSH( processName, hostOSH, processCommandLine, processPid, processExecutablePath, None, None, processStartupTime) OSHVResult.add(processOsh) pdu.flushHostProcesses(hostID) if pid2Process is not None: pid2Process.putAll(pdu.getProcessCmdMap()) finally: if pdu != None: pdu.close() return 1
def _parseCdpLayer2Output(self, output): results = {} if output: blocks = re.split('----------------------------------------', output) for block in blocks: if not re.search('Device ID', block): continue m = re.search('System Name:\s+([\w\-\.\/]+)', block) system_name = m and m.group(1) if not system_name: continue m = re.search('Interface:\s+([\w\-\.\/]+),', block) local_interface_name = m and m.group(1) if not local_interface_name: continue remote_ips = [] elems = re.findall('IPv[46] Address:(.+)\r?\n?Platform', block, re.DOTALL) if m: for elem in elems: remote_ips = [ ip_addr.IPAddress(raw_ip.strip()) for raw_ip in elem.split(',') if ip_addr.isValidIpAddress(raw_ip.strip()) ] m = re.search('Platform:\s+([\w\-\.]+),', block) platform = m and m.group(1) # ''' # Capability Codes: R - Router, T - Trans-Bridge, B - Source-Route-Bridge # S - Switch, H - Host, I - IGMP, r - Repeater, # V - VoIP-Phone, D - Remotely-Managed-Device, # s - Supports-STP-Dispute # ''' m = re.search('Capabilities:\s+([\w\-\.]+)', block) type = m and m.group(1) mac = None iface_name = None m = re.search( 'Port\s+ID\s+\(outgoing\s+port\):\s+([\w\-\.\:\/]+)', block) #can be interface name, interface mac. if not m: continue if netutils.isValidMac(m.group(1)): mac = netutils.parseMac(m.group(1)) else: iface_name = m.group(1) m = re.search('Version:(.+)Advertisement', block, re.DOTALL) description = m and m.group(1).strip() try: remote_list = results.get(local_interface_name, []) remote_list.append( layer2.RemotePeer(system_name, iface_name, mac, remote_ips, platform, type, description)) results[local_interface_name] = remote_list except: logger.debugException('') return results
def DiscoveryMain(Framework): ipAddress = Framework.getDestinationAttribute('ip_address') discoveredPorts = Framework.getParameter('ports') or None useNMap = Framework.getParameter('useNMap') == 'true' nmapPath = Framework.getParameter('nmapPath') or None scanUDP = Framework.getParameter('scanUDP') == 'true' UDPports = Framework.getParameter('UDPports') or None UDPports = UDPports and UDPports.strip() connectTimeOut = int(Framework.getParameter('connectTimeOut')) #if we need to check host's reachability: if Framework.getParameter('checkIfIpIsReachable').lower() == 'true': if not netutils.pingIp(Framework, ipAddress, Framework.getParameter('pingTimeOut')): logger.debug('Could not connect to ', ipAddress, ' by ping') msg = 'Target host is not reachable' warningObject = errorobject.createError( errorcodes.CONNECTION_FAILED_NO_PROTOCOL_WITH_DETAILS, ['', msg], msg) logger.reportWarningObject(warningObject) return OSHVResult = ObjectStateHolderVector() hostOsh = modeling.createHostOSH(ipAddress) OSHVResult.add(hostOsh) cfgFile = Framework.getConfigFile( CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME) onlyKnownPorts = Framework.getParameter('checkOnlyKnownPorts') onlyKnownPorts = (onlyKnownPorts and onlyKnownPorts.lower() == 'true') portsList = getPorts(discoveredPorts and discoveredPorts.strip(), PortType.TCP, cfgFile, onlyKnownPorts) if scanUDP: if onlyKnownPorts and not UDPports: UDPports = '*' portsList.extend( getPorts(UDPports, PortType.UDP, cfgFile, onlyKnownPorts)) portsToDiscover = filter(lambda port: port.isDiscover, portsList) isConnectedPortFound = False useFallback = False if useNMap: # Nmap flow supports udp and tcp ports client = Framework.createClient( ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME) try: shell = shellutils.ShellFactory().createShell(client) fs = file_system.createFileSystem(shell) try: if nmapPath and fs.isDirectory(nmapPath): path_tool = NtPath() nmapPath = path_tool.join(nmapPath, nmap.NMAP_EXECUTABLES[1]) except PathNotFoundException: logger.warn("Specified directory \"%s\" is not exists." % nmapPath) if nmapPath and not nmap.NmapPathValidator.get(fs).validate( nmapPath): logger.warn( "Specified Nmap path \"%s\" is not exists. Trying the system path..." % nmapPath) nmapPath = None nmapDiscover = nmap.getByShell(shell, nmapPath) nmapVersion = nmapDiscover.getVersion() if not nmapVersion: raise Exception('Cannot get nmap version') logger.debug("Found nmap %s" % nmapVersion) nmapVersion = float(nmapVersion) if nmapVersion < 5.21: raise Exception("Not supported version of nmap found.") tcpPorts = [ port.getPortNumber() for port in portsToDiscover if port and port.getProtocolName() == 'tcp' and port.isIpInRange(ipAddress) ] udpPorts = [ port.getPortNumber() for port in portsToDiscover if port and port.getProtocolName() == 'udp' and port.isIpInRange(ipAddress) ] discoveredPorts = nmapDiscover.doPortScan(ipAddress, tcpPorts, udpPorts) portsNameByPortInfo = {} for port in portsToDiscover: port_names = portsNameByPortInfo.setdefault( (port.getProtocol(), port.getPortNumber()), []) port_names.append(port.portName) if discoveredPorts: isConnectedPortFound = True for port_info in discoveredPorts: port_names = portsNameByPortInfo.get(port_info, []) OSHVResult.addAll( reportPort(hostOsh, ipAddress, port_names, *port_info)) except: logger.debugException( "Nmap executing failed. Try to use default behavior...") logger.reportWarning("Nmap executing failed") useFallback = True if useFallback or not useNMap: # Old flow supports only TCP ports for port in portsToDiscover: if port.isIpInRange(ipAddress): if port.getProtocol() == PortType.UDP.getProtocol(): logger.warn( "UDP port scan is not supporting by default behavior. Skipping..." ) elif port.getProtocol() == PortType.TCP.getProtocol() and ( netutils.checkTcpConnectivity( ipAddress, port.getPortNumber(), connectTimeOut)): OSHVResult.addAll( reportPort(hostOsh, ipAddress, [port.portName], port.getProtocol(), port.getPortNumber())) #we found one connected port -> we need to add hostOsh to OSHVResult isConnectedPortFound = True #in case we didn't find any port, return nothing if not isConnectedPortFound: OSHVResult.clear() msg = 'None of specified ports were discovered on destination host' warningObject = errorobject.createError( errorcodes.CONNECTION_FAILED_NO_PROTOCOL_WITH_DETAILS, ['', msg], msg) logger.reportWarningObject(warningObject) return OSHVResult
daoService = None try: try: client = Framework.createClient(credentialsId, envBuilder.build()) logger.debug("Connected to AD") configurationNamingContext = getConfigurationNamingContext(client) domainSuffix = getDomainSuffix(configurationNamingContext) if not configurationNamingContext: raise ValueError, "Failed fetching configuration naming context from Active Directory" msmqDiscoverer = MsMqDiscoverer(client, Framework, ipAddress, domainSuffix) msmqDiscoverer.discover() msmqDiscoverer.addResultsToVector(OSHVResult) finally: if client is not None: try: client.close() except: logger.warn("Failed to close client") if OSHVResult.size() == 0: raise Exception, "Failed getting information about Microsoft Message Queue" except JException, ex: msg = ex.getMessage() logger.debugException('Unexpected LDAP Exception: ') errormessages.resolveAndReport(msg, LDAP_PROTOCOL_NAME, Framework) except: msg = str(sys.exc_info()[1]).strip() logger.debugException('Unexpected LDAP Exception: ') errormessages.resolveAndReport(msg, LDAP_PROTOCOL_NAME, Framework) return OSHVResult
def __parseVersionByConfigFiles(self, tomcatHomeDir): if not tomcatHomeDir: return None try: if self.separator == '\\': cmd = 'type "' + tomcatHomeDir + 'webapps' + self.separator + 'ROOT' + self.separator + 'RELEASE-NOTES.txt"' else: cmd = 'cat ' + tomcatHomeDir + 'webapps' + self.separator + 'ROOT' + self.separator + 'RELEASE-NOTES.txt' buff = self.__client.execCmd(cmd) if buff is not None: match = re.search('Apache Tomcat Version ([\.\d]+)', buff) if match is not None: return str(match.group(1)).strip() except: logger.debugException( 'Failed to resolve version from RELEASE-NOTES.txt') try: if self.separator == '\\': cmd = 'type "' + tomcatHomeDir + 'RELEASE-NOTES"' else: cmd = 'cat ' + tomcatHomeDir + 'RELEASE-NOTES' buff = self.__client.execCmd(cmd) if buff is not None: match = re.search( 'Apache Tomcat Version ([\.\d]+)', buff) or re.search( '\* Tomcat ([\.\d]+)', buff) if match is not None: return str(match.group(1)).strip() except: logger.debugException( 'Failed to resolve version from RELEASE-NOTES') try: if self.separator == '\\': cmd = 'type "' + tomcatHomeDir + 'RUNNING.txt"' else: cmd = 'cat ' + tomcatHomeDir + 'RUNNING.txt' buff = self.__client.execCmd(cmd) if buff is not None: match = re.search('Running The Tomcat ([\.\d]+)', buff) if match is not None: return str(match.group(1)).strip() except: logger.debugException('Failed to resolve version from RUNNING.txt') try: if self.separator == '\\': cmd = '"' + tomcatHomeDir + 'bin\\version.bat"' else: cmd = tomcatHomeDir + 'bin/version.sh' buff = self.__client.execCmd(cmd) if buff is not None: match = re.search('Server version: Apache Tomcat/([\.\d]+)', buff) if match is not None: return str(match.group(1)).strip() except: logger.debugException('Failed to resolve version from ') return None
def parseOpmnXml(opmnXML, HOST_IP, ORACLE_HOME, MANAGER_PORT, shellUtils, OSHVResult, Framework): builder = SAXBuilder(0) doc = builder.build(StringReader(opmnXML)) root = doc.getRootElement() ucmdbVersion = modeling.CmdbClassModel().version() processManager = root.getChildren() processManagerIterator = processManager.iterator() while processManagerIterator.hasNext(): currProcessManager = processManagerIterator.next() currElementName = currProcessManager.getName() if currElementName == 'process-manager': iasInstance = currProcessManager.getChildren() iasInstanceIterator = iasInstance.iterator() while iasInstanceIterator.hasNext(): currIasInstance = iasInstanceIterator.next() if currIasInstance.getName() == 'ias-instance': OracleApplicationServerName = currIasInstance.getAttributeValue('name') or currIasInstance.getAttributeValue('id') or 'Default Server' discoveredHost = modeling.createHostOSH(HOST_IP) # Create Oracle IAS oracleIASOSH = modeling.createJ2EEServer('oracleias', HOST_IP, int(MANAGER_PORT), discoveredHost, OracleApplicationServerName) OSHVResult.add(oracleIASOSH) iasComponent = currIasInstance.getChildren() iasComponentIterator = iasComponent.iterator() while iasComponentIterator.hasNext(): currIasComponent = iasComponentIterator.next() if 'ias-component' == currIasComponent.getName(): groupName = currIasComponent.getAttributeValue('id') # Create OC4J Group oc4jGroupOSH = ObjectStateHolder('oc4jgroup') oc4jGroupOSH.setContainer(oracleIASOSH) oc4jGroupOSH.setAttribute('data_name', groupName) OSHVResult.add(oc4jGroupOSH) #'process-type' processType = currIasComponent.getChildren() processTypeIterator = processType.iterator() while processTypeIterator.hasNext(): currProcessType = processTypeIterator.next() oc4jName = currProcessType.getAttributeValue('id') moduleId = currProcessType.getAttributeValue('module-id') if 'OC4J' == moduleId: oc4jOSH = ObjectStateHolder('oc4j') oc4jOSH.setContainer(oc4jGroupOSH) oc4jOSH.setAttribute('data_name', oc4jName) OSHVResult.add(oc4jOSH) try: serverXML = shellUtils.safecat('%s/j2ee/%s/config/server.xml' % (ORACLE_HOME, oc4jName)) tg = '<application name="(\w+)"' compiled = re.compile(tg,re.S) matches = compiled.findall(serverXML) appList = {} for match in matches: if ucmdbVersion < 9: applicationOSH = modeling.createApplicationOSH('application', match, oc4jOSH) else: applicationOSH = ObjectStateHolder('oc4j_app') applicationOSH.setAttribute('data_name',match) applicationOSH.setContainer(oc4jOSH) # OSHVResult.add(applicationOSH) appList[match] = applicationOSH except: logger.debugException() logger.warn('Failed to get server.xml') # Check if it holds web service wsdlDir = shellUtils.rebuildPath('%s/j2ee/%s/application-deployments/' % (ORACLE_HOME, OracleApplicationServerName)) fileMon = file_mon_utils.FileMonitor(Framework, shellUtils, OSHVResult, None, None) files = fileMon.getFilesInPath(wsdlDir, '*.wsdl') if (files == []): wsdlDir = shellUtils.rebuildPath('%s/j2ee/%s/application-deployments/' % (ORACLE_HOME, oc4jName)) logger.info('Pi Debug - parseOpmnXml() - trying with wsdlDir = %s' % wsdlDir) files = fileMon.getFilesInPath(wsdlDir, '*.wsdl') wsdlDirRes = '\n'.join(files) if wsdlDirRes.find('File Not Found') != -1: # NO WSDL continue else: # WSDL handleWSDL(HOST_IP, MANAGER_PORT, wsdlDirRes, wsdlDir, appList, shellUtils, OSHVResult)
OSHVResult = ObjectStateHolderVector() #ipAddress = Framework.getDestinationAttribute('ip_address') #credentialsId = Framework.getDestinationAttribute('credentialsId') hostId = Framework.getDestinationAttribute('hostId') language = getLanguage(Framework) bundle = hyperv.getBundleByLanguage(language, Framework) try: namespace = hyperv.WmiNamespaceLookUp(Framework).lookUp() factory = hyperv.WmiClientFactory(Framework, namespace) client = factory.createClient() wmiProvider = hyperv.WmiHypervAgentProvider(client, bundle) try: hyperv.discoverHypervHost(wmiProvider, hostId, Framework, OSHVResult, namespace) finally: client.close() except JException, ex: exInfo = ex.getMessage() errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework) except Exception, ex: logger.debugException('') exInfo = str(ex) errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework) return OSHVResult
logger.debug( "More than one set of credentials found, the first one is used" ) connection = connections[0] strategy = nnmi.getDiscoveryStrategy(Framework, configuration) strategy.discover(connection) except nnmi.IntegrationException, ex: msg = str(ex) logger.error(msg) errormessages.resolveAndReport(msg, nnmi.NNM_PROTOCOL_NAME, Framework) except JException, ex: msg = ex.getMessage() or '' logger.debugException(msg) match = re.match('.*\(404\)\/NmsSdkService/(.*)', msg, re.I) if match: logger.debug("Service %s is not accessible" % match.group(1)) else: logger.error(msg) errormessages.resolveAndReport(msg, nnmi.NNM_PROTOCOL_NAME, Framework) except: logger.errorException("") msg = logger.prepareFullStackTrace("") errormessages.resolveAndReport(msg, nnmi.NNM_PROTOCOL_NAME, Framework) return resultVector
def DiscoveryMain(Framework): """ Retrieving a list of LDAP ports we strive to connect to domain controller in member role first. So we have to choose the lowest port number in the list. """ protocolName = "LDAP" OSHVResult = ObjectStateHolderVector() baseDn = Framework.getParameter('baseDN') or None if baseDn == 'NA': baseDn = None ipAddress = Framework.getDestinationAttribute('ip_address') credentialsId = Framework.getDestinationAttribute('credentials_id') applicationPort = Framework.getDestinationAttribute("application_port") serviceAddressPort = Framework.getDestinationAttribute('port') if not applicationPort or applicationPort == 'NA': applicationPort = serviceAddressPort # build environment and connect envBuilder = active_directory_utils.LdapEnvironmentBuilder(applicationPort) client = Framework.createClient(credentialsId, envBuilder.build()) discoverer = oracle_ldap_discoverer.OracleLdapDiscoverer(client, baseDn) try: probe_client = Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME) probe_shell = shellutils.ShellFactory().createShell(probe_client) resolver = netutils.FallbackResolver([netutils.JavaDnsResolver(), netutils.DnsResolverByShell(probe_shell)]) # discover servers = discoverer.discover() # report endpoint_builder = netutils.ServiceEndpointBuilder() endpoint_reporter = netutils.EndpointReporter(endpoint_builder) oracle_builder = db_builder.Oracle() reporter = db.OracleTopologyReporter(oracle_builder, endpoint_reporter) for dbServer in servers: if dbServer: try: address = dbServer.address if not ip_addr.isValidIpAddress(address): ips = resolver.resolveIpsByHostname(address) if ips and len(ips) > 0: dbServer.address = str(ip_addr.IPAddress(ips[0])) # get Host OSH if not (dbServer.address and netutils.isValidIp(address) and not netutils.isLocalIp(address)): raise ValueError("Address for the specified server is not valid or is local") hostOsh = modeling.createHostOSH(dbServer.address) # report database OSHVResult.addAll(reporter.reportServerAndDatabases(dbServer, hostOsh)) # report TNS Listener listener = db.OracleListener(dbServer.address, dbServer.getPort()) OSHVResult.addAll(reporter.reportTnsListener(listener, hostOsh)) # report Oracle Service Names if dbServer.getServiceNames(): OSHVResult.addAll(reporter.reportServiceNameTopology(dbServer.getServiceNames(), listener.getOsh(), dbServer.getOsh())) except netutils.ResolveException: logger.error("Cannot resolve " + dbServer.address + ". Skip") except oracle_ldap_discoverer.OracleContextDiscoveryException, ex: msg = str(ex) logger.debugException(msg) logger.error(msg)
def get_fc_hbas(self, shell): result = defaultdict(list) executor = command.cmdlet.executeCommand(shell) esxcli = find_esxcli_impl(executor)() esxcli = esxcli.formatter('csv') esxcli_exec = command.get_exec_fn(esxcli, executor) storage = EsxcliStorageNamespace(esxcli) software = EsxcliSoftwareNamespace(esxcli) scsi_path_by_adapter_identifier = fptools.groupby(methodcaller('get', 'AdapterIdentifier'), esxcli_exec(storage.core.path.list())) adapters = esxcli_exec(storage.core.adapter.list()) grouped_adapters = dict((adapter.get('HBAName'), adapter) for adapter in adapters) grouped = defaultdict(list) for descriptor in esxcli_exec(storage.san.fc.list()): grouped[(descriptor.get('Adapter'), descriptor.get('NodeName'))].append(descriptor) get_vendor = Sfn(self.get_vendor) get_fchba_descriptor = Sfn(self._get_fchba_descriptor) for key, descriptors in grouped.iteritems(): try: vmhba, nodewwn = key nodewwn = wwn.parse_from_str(nodewwn) name = vmhba id_ = vmhba adapter_descriptor = grouped_adapters.get(vmhba) driverversion = None vendor = get_vendor(vmhba, executor) model = None fwversion = None serialnum = None if adapter_descriptor: id_ = adapter_descriptor.get('UID') driver = adapter_descriptor.get('Driver') vib_descriptor = esxcli_exec(software.vib.get(vibname=driver)) driverversion = vib_descriptor.get('Version') fchabdescriptor = get_fchba_descriptor(driver, vmhba, executor) if fchabdescriptor: model = fchabdescriptor.model fwversion = fchabdescriptor.firmwareversion serialnum = fchabdescriptor.serialnumber driverversion = fchabdescriptor.driverversion fchba = fc_hba_model.FcHba(id_, name, wwn=nodewwn, vendor=vendor, model=model, serial_number=serialnum, driver_version=driverversion, firmware_version=fwversion) ports = [] for fcdescriptor in descriptors: try: portwwn = fcdescriptor.get('PortName') porttype = fcdescriptor.get('PortType') portwwn = wwn.parse_from_str(portwwn) portid = fcdescriptor.get('PortID') port_speed = _parse_port_speed(fcdescriptor.get('Speed')) portid = Sfn(int)(portid, 16) adapter_identifier = self._compose_adapter_identifier(nodewwn, portwwn) scsi_paths = scsi_path_by_adapter_identifier.get(adapter_identifier) target_fcdescriptors = self._create_target_fchba_details(scsi_paths) ports.append((fc_hba_model.FcPort(portid, portwwn, porttype, None, port_speed), target_fcdescriptors)) except (command.ExecuteException, TypeError, ValueError), ex: logger.debugException('Failed to create fcport data object') result[fchba].extend(ports) except (command.ExecuteException, TypeError, ValueError), ex: logger.debugException('Failed to create fchba data object')
while resultSet.next(): componentType = resultSet.getString("COMP_TYPE") try: release = resultSet.getString("RELEASE") components.append( sap.SoftwareComponent( resultSet.getString("COMPONENT"), componentType, versionInfo=(release and sap.VersionInfo( release, patchLevel=resultSet.getString("EXTRELEASE")) or None))) except sap.SoftwareComponent.TypeIsNotRecognized, ex: logger.warn("%s: %s" % (str(ex), componentType)) except: logger.debugException("Failed to process component") return components @staticmethod def isEnglishCmpDescription(d): return sap.isSetToEnglishLanguage(d.language) def discoverComponents(self): r''' Collect all data from different queries about available software components @types: -> list[sap.SoftwareComponent]''' componentDescriptions = self.getComponentLocalizedDescriptions() # may exist several localized descriptions per component descrsByName = fptools.groupby( self.ComponentLocalizedDescription.getName, componentDescriptions) components = []
hostOsh = ms_exchange_utils.restoreHostById(hostId) hostName = Framework.getDestinationAttribute('hostName') if not hostName or hostName == 'N/A': hostName = ms_exchange_utils.getHostNameFromWmi(Framework) if not hostName: errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION_NO_PROTOCOL, ['host name'], 'Failed to obtain host name') logger.reportErrorObject(errobj) return props = Properties() props.put(AgentConstants.PROP_WMI_NAMESPACE, WMI_NAMESPACE) try: wmiClient = Framework.createClient(props) wmiAgent = WmiAgent(wmiClient, Framework) try: discoverExchangeServer(wmiAgent, ipAddress, credentialsId, OSHVResult, Framework, hostOsh, hostName) finally: wmiClient.close() except Exception, ex: message = ex.getMessage() if (re.search("Invalid\sclass", message)): message = 'Unable to get Exchange data from WMI' logger.debugException(message) errormessages.resolveAndReport(message, WMI_PROTOCOL, Framework) except: exInfo = str(sys.exc_info()[1]).strip() logger.debugException(message) errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework) return OSHVResult
try: result = readWSDL(wsdl_url, wsdl_url_data, importWsdlDocuments) wsdl_url_data = result[0] defintion = result[1] except UnknownHostException, ex: host = ex.getMessage() msg = "Unknown host: %s" % host logger.debugException("Failed reading url: '%s', reason: '%s'\n" % (wsdl_url, msg)) errormessages.resolveAndReport(msg, ClientsConsts.HTTP_PROTOCOL_NAME, Framework) return OSHVResult except JException, ex: msg = ex.getMessage() logger.debugException("Failed reading url: '%s', reason: '%s'\n" % (wsdl_url, msg)) msg = removeIp(msg, ' to ') errormessages.resolveAndReport(msg, ClientsConsts.HTTP_PROTOCOL_NAME, Framework) return OSHVResult except Exception, ex: msg = logger.prepareJythonStackTrace('') logger.debugException("Failed reading url: '%s'\n" % wsdl_url) errormessages.resolveAndReport(msg, ClientsConsts.HTTP_PROTOCOL_NAME, Framework) return OSHVResult if importWsdlDocuments == 1: getAllImportWsdlsNames(defintion, importWsdldNames) for importWsdldName in importWsdldNames:
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() SYSNAME = Framework.getDestinationAttribute('system_name') GET_TX_ACTIVE = Framework.getParameter('getActiveTransactions') == 'true' GET_TX_CHANGE = Framework.getParameter('getTransChanges') == 'true' GET_TX_ALL = Framework.getParameter('getAllTransactions') == 'true' report_app_components = Framework.getParameter( 'getAppComponents') == 'true' properties = Properties() instance_number = Framework.getDestinationAttribute('instance_nr') ip_address = Framework.getDestinationAttribute('ip_address') connection_client = Framework.getDestinationAttribute('connection_client') logger.debug('Connecting to a SAP system number:', str(instance_number)) properties.setProperty(Protocol.SAP_PROTOCOL_ATTRIBUTE_SYSNUMBER, instance_number) if (connection_client is not None) and (connection_client != 'NA'): logger.debug('Connecting to a SAP system with client:', str(connection_client)) properties.setProperty(Protocol.SAP_PROTOCOL_ATTRIBUTE_CLIENT, connection_client) if GET_TX_CHANGE: # get transaction change only parameters FROM_DATE = Framework.getParameter('transChangesFromDate') FROM_TIME = Framework.getParameter('transChangesFromTime') TO_DATE = Framework.getParameter('transChangesToDate') TO_TIME = Framework.getParameter('transChangesToTime') INTERVAL = Framework.getParameter('transChangesDaysInterval') if logger.isDebugEnabled(): logger.debug('FROM_DATE = ', FROM_DATE) logger.debug('FROM_TIME = ', FROM_TIME) logger.debug('TO_DATE = ', TO_DATE) logger.debug('TO_TIME = ', TO_TIME) properties.setProperty(SAPQueryClient.PARAM_FROM_DATE, FROM_DATE) properties.setProperty(SAPQueryClient.PARAM_FROM_TIME, FROM_TIME) properties.setProperty(SAPQueryClient.PARAM_TO_DATE, TO_DATE) properties.setProperty(SAPQueryClient.PARAM_TO_TIME, TO_TIME) if ((INTERVAL != None) and (INTERVAL != '0') and (INTERVAL != '')): properties.setProperty(SAPQueryClient.PARAM_INTERVAL, INTERVAL) loadOnInit = 0 if GET_TX_ACTIVE: properties.setProperty(SAPQueryClient.PARAM_FLAG_GET_USERS, 'false') loadOnInit = 1 errormsg = '' client = None try: try: # create SAP client client = Framework.createClient(properties) sapUtils = sapappsutils.SapAppsUtils(client, loadOnInit, saputils.SapUtils.NO_LOAD) except (NoClassDefFoundError, MissingJarsException, ExceptionInInitializerError): errormsg = 'SAP drivers are missing' logger.debugException(errormsg) except: errormsg = 'Connection failed' logger.debugException(errormsg) else: systemOsh, oshs = sap_abap.report_system(SYSNAME, instance_number, ip_address) OSHVResult.addAll(oshs) # Check if we need to collect all the application component. # (we can discover up to 60000 CIs per System - don't discover if it is not needed) if not report_app_components: logger.debug('Not sending application components to server') # build the application hierarchy even if not all of it is sent to the server mapDevcToOSH = None if GET_TX_CHANGE or GET_TX_ALL or GET_TX_ACTIVE or report_app_components: mapDevcToOSH, oshs = buildAppHierarchy(sapUtils, systemOsh, report_app_components) OSHVResult.addAll(oshs) # Check if we need to collect the changed transactions if GET_TX_CHANGE: try: logger.debug('Getting transaction change...') transactionChange(sapUtils, mapDevcToOSH, systemOsh, SYSNAME, OSHVResult) except NoSuchChangeException: Framework.reportWarning( 'No changes found in the given time range') except: logger.errorException( 'Failed retrieving transactions change') Framework.reportError( 'Failed retrieving transactions change') # Check if we need to collect all the transactions if GET_TX_ALL: try: logger.debug('Getting all transactions...') transactions(sapUtils, mapDevcToOSH, systemOsh, SYSNAME, OSHVResult) except: logger.errorException('Failed to get transactions') Framework.reportWarning('Failed to get transactions') # Check if we need to collect the active transactions if GET_TX_ACTIVE: try: logger.debug('Getting active transactions...') activeTransactions(sapUtils, mapDevcToOSH, systemOsh, SYSNAME, OSHVResult) except: logger.errorException( 'Failed retrieving active transactions') Framework.reportError( 'Failed retrieving active transactions') finally: if client is not None: client.close() if errormsg: Framework.reportError(errormsg) return OSHVResult
def discoverEsxLicensing(topology, module, client, framework): try: licensingDiscoverer = module.getLicensingDiscoverer(client, framework) if licensingDiscoverer: licensingDiscoverer.discoverEsx(topology) except NotSupportedException: msg = "Licensing information discovery is not supported by server with current protocol" framework.reportWarning(msg) except NoPermissionException, ex: priviledgeId = ex.getMessage() msg = "User does not have required '%s' permission, licensing information won't be reported" % priviledgeId framework.reportWarning(msg) except: framework.reportWarning("Failed to discover licensing information") logger.debugException() def discoverVirtualCenterLicensing(topology, module, client, framework): try: licensingDiscoverer = module.getLicensingDiscoverer(client, framework) if licensingDiscoverer: licensingDiscoverer.discoverVirtualCenter(topology) except NotSupportedException: msg = "Licensing information discovery is not supported by server with current protocol" framework.reportWarning(msg) except NoPermissionException, ex: priviledgeId = ex.getMessage() msg = "User does not have required '%s' permission, licensing information won't be reported" % priviledgeId framework.reportWarning(msg) except: framework.reportWarning("Failed to discover licensing information")
str(e)) else: warning = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg) discoveryWarnings.append(warning) else: try: # Build and report discovered account for further usage discoverer = IamDiscoverer(aimService) account = aws.Account(discoverer.getAccountId(aimService)) accountOsh = aws.Reporter(aws.Builder()).reportAccount(account) framework.sendObject(accountOsh) except Exception: # As account is a application system failed discovery of such # cannot be continued we try other credentials logger.debugException("Failed to create account") warning = errorobject.createError( errorcodes.FAILED_GETTING_INFORMATION, [protocolName], 'Failed to get information about Amazon account') discoveryWarnings.append(warning) # Every fail has to be remembered for reporting to the UI else: # Now we have account time to use it in discovery for connection in CONNECTIONS: # Apply filtering mechanism to find out what discoveries # are enabled discoveries = filter(isEnabledDiscovery, connection.discoveries) # Possible none of them are enabled so we have to check this # case too if discoveries:
def doHPCmd(client, ntcmd_obj, ip_address, langBund, Framework, host_cmdbid=None, host_key=None, host_macs=None, uduid=None, nat_ip=None): 'Shell, osh, str, Properties, Framework, .. -> oshVector' resultVector = ObjectStateHolderVector() ipAddress = ip_addr.IPAddress(ip_address) wmiProvider = wmiutils.WmicProvider(client) hostDiscoverer = WmiHostDiscoverer(wmiProvider) hostDo = hostDiscoverer.discover() hostDiscoverer = HostDiscovererByShell(client, langBund, Framework, hostDo) hostDiscoverer.discover() hostDo = hostDiscoverer.getResults() wmiDnsServersDiscoverer = WmiDnsServersDiscoverer(wmiProvider, ipAddress) wmiDnsServersDiscoverer.discover() dnsServersIpList = wmiDnsServersDiscoverer.getResults() if not dnsServersIpList: dnsServersDiscoverer = DnsServersDiscoverer(client, ipAddress, langBund, Framework) dnsServersDiscoverer.discover() dnsServersIpList = dnsServersDiscoverer.getResults() winsWmiServersDiscoverer = WmiWinsServersDiscoverer(wmiProvider, ipAddress) winsWmiServersDiscoverer.discover() winsServersIpList = winsWmiServersDiscoverer.getResults() if not winsServersIpList: winsServerDiscoverer = WinsServerDicoverer(client, ipAddress, langBund, Framework) winsServerDiscoverer.discover() winsServersIpList = winsServerDiscoverer.getResults() dhcpWmiServersDiscoverer = WmiDhcpServersDiscoverer(wmiProvider, ipAddress) dhcpWmiServersDiscoverer.discover() dhcpServersIpList = dhcpWmiServersDiscoverer.getResults() if not dhcpServersIpList: dhcpServerDiscoverer = DhcpServerDiscoverer(client, ipAddress, langBund, Framework) dhcpServerDiscoverer.discover() dhcpServersIpList = dhcpServerDiscoverer.getResults() interfaceDiscoverer = WmiInterfaceDiscoverer(wmiProvider, ipAddress) try: interfaceDiscoverer.discover() logger.debug('Interfaces successfully discovered via wmic.') try: shellIfaceDiscoverer = IpConfigInterfaceDiscoverer( client, ipAddress, Framework, langBund) shellIfaceDiscoverer.discover() ifaces = shellIfaceDiscoverer.getResults() interfaceDiscoverer.interfacesList.extend(ifaces) except: logger.debugException('') except: msg = logger.prepareFullStackTrace('') logger.debugException(msg) logger.warn( 'Failed getting interfaces information via wmic. Falling back to ipconfig.' ) interfaceDiscoverer = IpConfigInterfaceDiscoverer( client, ipAddress, Framework, langBund) interfaceDiscoverer.discover() hostDo.ipIsVirtual = interfaceDiscoverer.isIpVirtual() hostDo.ipIsNATed = interfaceDiscoverer.isIpNATed(nat_ip) interfacesList = interfaceDiscoverer.getResults() ucmdbversion = modeling.CmdbClassModel().version() topoBuilder = TopologyBuilder(interfacesList, hostDo, ipAddress, ntcmd_obj, dnsServersIpList, dhcpServersIpList, winsServersIpList, host_cmdbid, host_key, host_macs, ucmdbversion) topoBuilder.build() # access built host OSH to update UD UID attribute if topoBuilder.hostOsh and uduid: _updateHostUniversalDiscoveryUid(topoBuilder.hostOsh, uduid) topoBuilder.addResultsToVector(resultVector) return resultVector