def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') host_id = Framework.getDestinationAttribute('hostId') errorsList = [] protocol = "ldap" credential_ids = Framework.getAvailableProtocols(ip, protocol) lastConnectedCredential = Framework.loadState() lastConnectedCredential and credential_ids.append(lastConnectedCredential) if not credential_ids: msg = errormessages.makeErrorMessage('webseal', pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, ['webseal'], msg) errorsList.append(errobj) client = Framework.createClient() credential_id = find_valid_credential(credential_ids, client, Framework) if credential_id: Framework.saveState(credential_id) OSHVResult.addAll(reportWebSeal(host_id, credential_id)) else: Framework.clearState() msg = errormessages.makeErrorMessage('Shell', pattern=errormessages.ERROR_FAILED_TO_CONNECT_TO_SERVER) errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, ['webseal'], msg) errorsList.append(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return OSHVResult
def DiscoveryMain(Framework): resultVector = ObjectStateHolderVector() ipAddress = Framework.getDestinationAttribute(DestinationProperty.IP_ADDRESS) if not ipAddress: msg = errormessages.makeErrorMessage(na.Protocol.DISPLAY, message="Invalid IP address") errorObject = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [na.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errorObject) return resultVector credentialsId = Framework.getParameter(DestinationProperty.CREDENTIALS_ID) if not credentialsId: msg = errormessages.makeErrorMessage(na.Protocol.DISPLAY, pattern=errormessages.ERROR_NO_CREDENTIALS) errorObject = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [na.Protocol.DISPLAY], msg) logger.reportErrorObject(errorObject) return resultVector queryTopologyPerDevice = _getBooleanParameter(JobParameter.QUERY_TOPOLOGY_PER_DEVICE, Framework, False) discovererClass = na_discover.SingleRequestsNaDiscoverer if queryTopologyPerDevice: discovererClass = na_discover.NaDiscovererPerDevice reportDeviceConfigs = _getBooleanParameter(JobParameter.REPORT_DEVICE_CONFIGS, Framework, False) logger.debug('reportDeviceConfigs: ', reportDeviceConfigs) reportDeviceModules = _getBooleanParameter(JobParameter.REPORT_DEVICE_MODULES, Framework, False) logger.debug('reportDeviceModules:', reportDeviceModules) client = None try: try: client = na_discover.createJavaClient(Framework, ipAddress, credentialsId) logger.debug("Topology is discovered by '%s'" % discovererClass.__name__) discoverer = discovererClass(client, ipAddress, Framework) discoverer.setDevicePageSize(500) discoverer.setReportDeviceConfigs(reportDeviceConfigs) discoverer.setReportDeviceModules(reportDeviceModules) discoverResult = discoverer.discover() if discoverResult: devicesById, connectivitiesByDeviceId = discoverResult reporter = na.NaReporter(Framework) reporter.setBulkThreshold(10000) reporter.setReportDeviceConfigs(reportDeviceConfigs) reporter.setReportDeviceModules(reportDeviceModules) reporter.report(devicesById, connectivitiesByDeviceId) finally: client and client.close() except MissingSdkJarException, ex: msg = errormessages.makeErrorMessage(na.Protocol.DISPLAY, message="Not all jar dependencies are found in class path") errorObject = errorobject.createError(errorcodes.MISSING_JARS_ERROR, [na.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errorObject)
def addToErrorObjectsCollections(self, warningsList, errorsList): cfg = self.errConfig if (warningsList is not None and self.errConfig.isWarn()): errobj = errorobject.createError(cfg.errorCode, self.params, self.msg) warningsList.append(errobj) elif (errorsList is not None and self.errConfig.isError()): errobj = errorobject.createError(cfg.errorCode, self.params, self.msg) errorsList.append(errobj)
def DiscoveryMain(Framework): ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') codepage = Framework.getCodePage() shell = None credentialId = None OSHVResult = None warningsList = [] errorsList = [] protocolType = PowerShell.PROTOCOL_TYPE credentials = [] # use the latest used credentials if any lastConnectedCredential = Framework.loadState() lastConnectedCredential and credentials.append(lastConnectedCredential) # and other defined for triggered IP credentials.extend( netutils.getAvailableProtocols(Framework, protocolType, ip, domain)) if credentials: shell, credentialId = getShellUtils(Framework, protocolType, credentials, ip, codepage, warningsList, errorsList) else: msg = errormessages.makeErrorMessage( protocolType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolType], msg) errorsList.append(errobj) if shell: # successfully connected, do discovery errorsList = [] warningsList = [] Framework.saveState(credentialId) OSHVResult = doDiscovery(Framework, shell, ip, credentialId, codepage, protocolType, warningsList, errorsList) else: if not len(errorsList): msg = errormessages.makeErrorMessage( protocolType, pattern=errormessages.ERROR_CONNECTION_FAILED) errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolType], msg) errorsList.append(errobj) Framework.clearState() for errobj in warningsList: logger.reportWarningObject(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return OSHVResult
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip_address') credential_id = Framework.getDestinationAttribute('credential_id') version = Framework.getDestinationAttribute('version') cmdb_id = Framework.getDestinationAttribute('cmdb_id') protocol = ProtocolManager.getProtocolById(credential_id) host = protocol.getProtocolAttribute('host') port = protocol.getProtocolAttribute('protocol_port') protocolName = ClientsConsts.HTTP_PROTOCOL_NAME if (host and ip != host) or not port: msg = errormessages.makeErrorMessage( protocolName, 'Invalid ip address or missing port in HTTP credential', pattern=errormessages.ERROR_OPERATION_FAILED) errobj = errorobject.createError(errorcodes.OPERATION_FAILED, [protocolName], msg) logger.reportErrorObject(errobj) else: props = Properties() props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, credential_id) props.setProperty('autoAcceptCerts', 'true') props.setProperty('host', ip) try: httpClient = Framework.createClient(props) builder = PolicyBuilder(ip, port, version, httpClient) doc = builder.createPolicyDoc() oamServerOSH = modeling.createOshByCmdbIdString( 'running_software', cmdb_id) policyOSH = modeling.createConfigurationDocumentOSH( 'policy.xml', '', doc, oamServerOSH) linkOSH = modeling.createLinkOSH('composition', oamServerOSH, policyOSH) OSHVResult.add(oamServerOSH) OSHVResult.add(policyOSH) OSHVResult.add(linkOSH) except UnauthorizedException, e: msg = 'Failed to authenticate: ' + e.getMessage() errobj = errorobject.createError( errorcodes.INVALID_USERNAME_PASSWORD, [protocolName], msg) logger.reportErrorObject(errobj) except JException, e: msg = 'URL is not accessable: ' + e.getMessage() errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg) logger.reportErrorObject(errobj)
def reportErrorMessage(self): '''Join all messages into one big message and report it as error or if no registered - report error "Tried all protocols" ''' if len(self.errorMsg) > 0: errorResult = '' for error in self.errorMsg: errorResult = errorResult + '\n' + str(error) errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_WITH_DETAILS, [str(self.getJ2eeServerType()), errorResult], errorResult) else: errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_NO_PROTOCOL_WITH_DETAILS, ['Tried all protocols'], 'Failed to connect using all protocols') logger.reportWarningObject(errobj)
def getresourceinfo(shell, cllsif_command): resourceDictionary = {} cmdResult = None rawCmdResult = None try: cmdForInterfaces = cllsif_command logger.debug(concatenate(' Executing command: ', cmdForInterfaces)) rawCmdResult = shell.execCmd(cmdForInterfaces) cmdResult = rawCmdResult.strip() except: msg = "Command Failure - Unable to get cluster resource information " errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION, None, msg) logger.reportErrorObject(errobj) logger.debug(msg) return resourceDictionary if not cmdResult: msg = "CLLSIF output was empty, unable to get cluster resources." errobj = errorobject.createError(errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg) logger.reportErrorObject(errobj) logger.debug(msg) return resourceDictionary keywords = ['not found'] for keyword in keywords: if re.search(keyword,cmdResult,re.I): msg = "cllsif command not in path, check cldisp command parameter and sudo path" errobj = errorobject.createError(errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg) logger.reportErrorObject(errobj) logger.debug(msg) return resourceDictionary if (re.search('\r\n', cmdResult)): cmdResult = cmdResult.split('\r\n') else: cmdResult = cmdResult.split('\n') ## Build a resource Dictionary from the cllsif data for line in cmdResult: line = line.strip() ## Parse out headers and blank lines if not line or re.match('#', line): continue name = type = network = nettype = attr = node = ipaddr = haddr = interfacename = globalname = netmask = hb_addr = site_name = None data = line.split(':') if (len(data) == 12): [name, type, network, nettype, attr, node, ipaddr, haddr, interfacename, globalname, netmask, hb_addr] = data elif (len(data) == 13): [name, type, network, nettype, attr, node, ipaddr, haddr, interfacename, globalname, netmask, hb_addr, site_name] = data resourceDictionary[name] = (name, type, network, nettype, attr, node, ipaddr, haddr, interfacename, globalname, netmask, hb_addr, site_name) return resourceDictionary
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 DiscoveryMain(Framework): ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') codepage = Framework.getCodePage() shell = None credentialId = None OSHVResult = None warningsList = [] errorsList = [] protocolType = PowerShell.PROTOCOL_TYPE credentials = [] # use the latest used credentials if any lastConnectedCredential = Framework.loadState() lastConnectedCredential and credentials.append(lastConnectedCredential) # and other defined for triggered IP credentials.extend(netutils.getAvailableProtocols(Framework, protocolType, ip, domain)) if credentials: shell, credentialId = getShellUtils(Framework, protocolType, credentials, ip, codepage, warningsList, errorsList) else: msg = errormessages.makeErrorMessage(protocolType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolType], msg) errorsList.append(errobj) if shell: # successfully connected, do discovery errorsList = [] warningsList = [] Framework.saveState(credentialId) OSHVResult = doDiscovery(Framework, shell, ip, credentialId, codepage, protocolType, warningsList, errorsList) else: if not len(errorsList): msg = errormessages.makeErrorMessage(protocolType, pattern=errormessages.ERROR_CONNECTION_FAILED) errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolType], msg) errorsList.append(errobj) Framework.clearState() for errobj in warningsList: logger.reportWarningObject(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return OSHVResult
def DiscoveryMain(Framework): resultVector = ObjectStateHolderVector() ipAddress = Framework.getDestinationAttribute(DestinationProperty.IP_ADDRESS) credentialsId = Framework.getDestinationAttribute(DestinationProperty.CREDENTIALS_ID) hypervisorCmdbId = Framework.getDestinationAttribute(DestinationProperty.HYPERVISOR_CMDB_ID) esxCmdbId = Framework.getDestinationAttribute(DestinationProperty.ESX_CMDB_ID) esxBiosUuid = Framework.getDestinationAttribute(DestinationProperty.ESX_BIOS_UUID) if not esxBiosUuid: msg = "ESX BIOS UUID from trigger data is empty" errorObject = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errorObject) logger.error(msg) return resultVector try: unitaryComputerSystem = discoverEsxInventory(ipAddress, credentialsId, esxBiosUuid, Framework) inventoryResultVector = reportEsxInventory(unitaryComputerSystem, esxCmdbId) resultVector.addAll(inventoryResultVector) virtualMachines = discoverEsxVirtualTopology(ipAddress, credentialsId, esxBiosUuid, Framework) if virtualMachines: virtualResultVector = reportVirtualTopology(virtualMachines, hypervisorCmdbId) resultVector.addAll(virtualResultVector) except JException, ex: msg = ex.getMessage() msg = cim_discover.translateErrorMessage(msg) logger.debug(msg) errormessages.resolveAndReport(msg, cim.Protocol.DISPLAY, Framework)
def discoverExchangeServer(wmiAgent, ipAddress, credentialsId, OSHVResult, Framework, hostOsh, hostName): queryBuilder = WmiQueryBuilder('Exchange_Server') queryBuilder.addWmiObjectProperties('FQDN', 'GUID', 'Type', 'MTADataPath', 'CreationTime', 'ExchangeVersion', 'MonitoringEnabled', 'AdministrativeNote', 'MessageTrackingEnabled', 'MessageTrackingLogFilePath', 'MessageTrackingLogFileLifetime') queryBuilder.addWhereClause('Name = \'%s\'' % hostName) Exchange_Servers = wmiAgent.getWmiData(queryBuilder) if len(Exchange_Servers) == 0: errobj = errorobject.createError(errorcodes.EMPTY_DATA_RECEIVED, ['Exchange servers', 'WMI'], 'No Exchange servers available via WMI') logger.reportWarningObject(errobj) return for Exchange_Server in Exchange_Servers: exchangeServerOsh = modeling.createExchangeServer(hostOsh, ipAddress, credentialsId, ms_exchange_utils.VERSION_2003) exchangeServerOsh.setAttribute('guid', extractId(Exchange_Server.GUID)) exchangeServerOsh.setAttribute('fqdn', Exchange_Server.FQDN) exchangeServerOsh.setAttribute('application_version_number', ms_exchange_utils.VERSION_2003) exchangeServerOsh.setAttribute('build_number', Exchange_Server.ExchangeVersion) exchangeServerOsh.setAttribute('data_description', Exchange_Server.AdministrativeNote) exchangeServerOsh.setAttribute('mta_data_path', Exchange_Server.MTADataPath) exchangeServerOsh.setBoolAttribute('is_monitoring_enabled', Exchange_Server.MonitoringEnabled) exchangeServerOsh.setAttribute('log_file_path', Exchange_Server.MessageTrackingLogFilePath) exchangeServerOsh.setBoolAttribute('message_tracking_enabled', Exchange_Server.MessageTrackingEnabled) exchangeServerOsh.setIntegerAttribute('log_file_lifetyme', Exchange_Server.MessageTrackingLogFileLifetime) exchangeServerOsh.setDateAttribute('creation_date', parseDate(Exchange_Server.CreationTime)) exchangeServerOsh.setAttribute('type', SERVER_TYPES[Exchange_Server.Type]) OSHVResult.add(hostOsh) OSHVResult.add(exchangeServerOsh)
def reportToFramework(self, framework): cfg = self.errConfig errobj = errorobject.createError(cfg.errorCode, self.params, self.msg) if cfg.isWarn(): logger.reportWarningObject(errobj) elif cfg.isError(): logger.reportErrorObject(errobj)
def DiscoveryMain(Framework): ipAddress = Framework.getDestinationAttribute('ip_address') shell = None try: client = Framework.createClient() shell = shellutils.ShellFactory().createShell(client) f5Discoverer = createF5Discoverer(shell, ipAddress) f5Discoverer.discover() return f5Discoverer.getTopology() except NoF5Exception: logger.reportWarning("No F5 LTM found on the remote machine") except: errorMsg = 'Failed to get general information' errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION, ['shell', 'general information'], errorMsg) logger.debugException(errorMsg) logger.reportWarningObject(errobj) finally: try: shell and shell.closeClient() except: logger.debugException('') logger.error('Unable to close shell')
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): vector = ObjectStateHolderVector() knownPortsConfigFile = Framework.getConfigFile(CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME) endpoint = Framework.getDestinationAttribute('ip_port_pair') address, port = endpoint.rsplit(':', 1) endpoint = netutils.createTcpEndpoint(address, port) ipServiceName = Framework.getDestinationAttribute('ip_service_name') if ipServiceName == 'sap_jmx': endpoint = convertToHttpEndpoint(endpoint) if endpoint: logger.debug('Current %s' % endpoint) vector, errors, warnings = _discover(Framework, knownPortsConfigFile, endpoint) logger.debug('Result vector size: %d' % vector.size()) logger.debug('Errors: %s' % errors) logger.debug('Warnings: %s' % warnings) fptools.each(logger.reportErrorObject, errors) fptools.each(logger.reportWarningObject, warnings) else: protocolName = 'sapjmxprotocol' protocolLabel = errormessages.protocolNames[protocolName] messagePattern = errormessages.NO_HTTP_ENDPOINTS_TO_PROCESS_ERROR msg = errormessages.makeErrorMessage(protocolName, pattern=messagePattern) errCode = errorcodes.NO_HTTP_ENDPOINTS_TO_PROCESS errobj = errorobject.createError(errCode, [protocolLabel], msg) logger.reportWarningObject(errobj) return vector
def discoverServices(self): serviceQueryBuilder = SnmpQueryBuilder(SVC_OID_OFFSET) serviceQueryBuilder.addQueryElement(1, 'svc_name') serviceQueryBuilder.addQueryElement(3, 'ip') serviceQueryBuilder.addQueryElement(4, 'protocol') serviceQueryBuilder.addQueryElement(5, 'port') serviceQueryBuilder.addQueryElement(41, 'ip_range') serviceQueryBuilder.addQueryElement(42, 'port_range') snmpRowElements = self.snmpAgent.getSnmpData(serviceQueryBuilder) poolMemberToPoolQueryBuilder = SnmpQueryBuilder(CNTSVC_OID_OFFSET) poolMemberToPoolQueryBuilder.addQueryElement(2, 'cnt_name') poolMemberToPoolQueryBuilder.addQueryElement(3, 'svc_name') poolMemberToPoolElements = self.snmpAgent.getSnmpData( poolMemberToPoolQueryBuilder) svcToCntMap = {} for poolMemberToPoolElement in poolMemberToPoolElements: cnt = self.resourcePools[poolMemberToPoolElement.cnt_name] cntList = svcToCntMap.get(poolMemberToPoolElement.svc_name, []) cntList.append(cnt) svcToCntMap[poolMemberToPoolElement.svc_name] = cntList for snmpRowElement in snmpRowElements: poolMember = modeling.createHostOSH(snmpRowElement.ip, 'host_node') # KB specific: fix of port translations serviceAddressPort = snmpRowElement.port serviceAddress = modeling.createServiceAddressOsh( poolMember, snmpRowElement.ip, serviceAddressPort, CNT_PROTOCOL_MAP[snmpRowElement.protocol]) self.OSHVResult.add(poolMember) if svcToCntMap.has_key(snmpRowElement.svc_name): cntList = svcToCntMap[snmpRowElement.svc_name] for cnt in cntList: # KB specific: if there is not any port translation between the input and output IPs ports, create the same port destinationPort = serviceAddressPort destinationAddress = serviceAddress if destinationPort == '0': inputServiceAddress = self.resourcePoolsToServiceAddress[ cnt.getAttributeValue('data_name')] destinationPort = inputServiceAddress.getAttributeValue( 'ipport_number') destinationAddress = modeling.createServiceAddressOsh( poolMember, snmpRowElement.ip, destinationPort, CNT_PROTOCOL_MAP[snmpRowElement.protocol]) self.OSHVResult.add(destinationAddress) self.OSHVResult.add( modeling.createLinkOSH('member', cnt, destinationAddress)) else: self.OSHVResult.add(serviceAddress) errobj = errorobject.createError( errorcodes.NO_SERVICE_FOUND_FOR_NODE, [snmpRowElement.svc_name], 'No service found for destination node') logger.reportWarningObject(errobj)
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() try: hostId = Framework.getDestinationAttribute('hostId') hostOsh = modeling.createOshByCmdbIdString('host_node', hostId) snmpClient = Framework.createClient() try: cssDiscoverer = createCssDiscoverer(snmpClient, Framework, OSHVResult, hostOsh) cssDiscoverer.discoverContentRules() cssDiscoverer.discoverServices() finally: snmpClient.close() except NoCssException: errobj = errorobject.createError( errorcodes.CSS_NOT_FOUND_ON_TARGET_HOST, None, 'CSS was not found on target host') logger.reportErrorObject(errobj) except: errorMessage = logger.prepareJythonStackTrace('') logger.error(errorMessage) errormessages.resolveAndReport(errorMessage, 'SNMP', Framework) return OSHVResult
def doQuery(self, queryStr): cmdRemoteAgent = self.DEFAULT_REG_TOOL + queryStr ntcmdErrStr = 'Remote command returned 1(0x1)' timeout = 180000 buffer = self.shell.execCmd(cmdRemoteAgent, timeout) # @@CMD_PERMISION ntcmd protocol execution logger.debug('Outputing ', cmdRemoteAgent, ': ...') reg_mamRc = self.shell.getLastCmdReturnCode() if (reg_mamRc != 0) or (buffer.find(ntcmdErrStr) != -1): logger.debug('reg ended unsuccessfully with return code:%d, error:%s' % (reg_mamRc, buffer)) logger.debug('Failed getting services info using reg.exe trying the reg_mam.exe') localFile = CollectorsParameters.BASE_PROBE_MGR_DIR + CollectorsParameters.getDiscoveryResourceFolder() + CollectorsParameters.FILE_SEPARATOR + self.REG_MAM_REG_TOOL remoteFile = self.shell.copyFileIfNeeded(localFile) cmdRemote = self.REG_MAM_REG_TOOL if not remoteFile: logger.warn('Failed copying %s' % cmdRemote) return cmdRemoteAgent = remoteFile + queryStr buffer = self.shell.execCmd(cmdRemoteAgent, timeout) # @@CMD_PERMISION ntcmd protocol execution regRc = self.shell.getLastCmdReturnCode() if (regRc != 0) or (buffer.find(ntcmdErrStr) != -1): errMessage = 'NTCMD: Failed getting services info.' errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION, ['NTCMD', 'services info'], errMessage) logger.reportWarningObject(errobj) logger.debug('Failed getting services info, reg_mam.exe ended with %d, error:%s' % (regRc, buffer)) return return buffer
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 getMAC(shell, int_name): cmdResult = None rawCmdResult = None mac = None entstat = None try: entstat_command = concatenate('entstat ', int_name) logger.debug(concatenate(' Executing command: ', entstat_command)) entstat = shell.execCmd(entstat_command) if entstat != None: m = re.search('Device Type: (.+)', entstat) description = None if(m): description = m.group(1).strip() m = re.search('Hardware Address: ([0-9a-f:]{17})', entstat) rawMac = None if(m): rawMac = m.group(1) mac = netutils.parseMac(rawMac) except: msg = " Failed getting MAC address for interface '%s'" % int_name errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION, None, msg) logger.reportWarningObject(errobj) logger.debug(msg) return None return mac
def __discoverInstalledSoftware(Framework, OSHVResult, client): discoverSoftwareOld = Boolean.parseBoolean( Framework.getParameter('discoverInstalledSoftwareByOldMechanism')) softNameToInstSoftOSH = {} try: if discoverSoftwareOld: #we close client here since in the software discovery we had to open another client #since we changing namespace and reference registry instead of wmi logger.debug( 'The software is discovered using old mechanism. This mechanism is very non-efficient and thus discovery might take time.' ) client.close() client = None wmi_dis_software_lib.mainFunction(Framework, OSHVResult, softNameToInstSoftOSH) #reopen general WMI client since it will be used in Plug-ins logger.debug("Reopening WMI client") client = createWmiClient(Framework) else: wmi_dis_software_lib.mainFunctionWithWbem(Framework, client, OSHVResult, softNameToInstSoftOSH) except: errobj = errorobject.createError( errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['software', 'wmi'], 'Failed to discover software by wmi') logger.reportErrorObject(errobj) logger.errorException('Failed to discover software by wmi') return (softNameToInstSoftOSH, client)
def getMAC(shell, int_name): cmdResult = None rawCmdResult = None mac = None entstat = None try: entstat_command = concatenate('entstat ', int_name) logger.debug(concatenate(' Executing command: ', entstat_command)) entstat = shell.execCmd(entstat_command) if entstat != None: m = re.search('Device Type: (.+)', entstat) description = None if (m): description = m.group(1).strip() m = re.search('Hardware Address: ([0-9a-f:]{17})', entstat) rawMac = None if (m): rawMac = m.group(1) mac = netutils.parseMac(rawMac) except: msg = " Failed getting MAC address for interface '%s'" % int_name errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION, None, msg) logger.reportWarningObject(errobj) logger.debug(msg) return None return mac
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 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 DiscoveryMain(Framework): warningsList = [] errorsList = [] oshvector = ObjectStateHolderVector() errobj = errorobject.INTERNAL_ERROR client = None ip_address = Framework.getDestinationAttribute('ip_address') ip_domain = Framework.getDestinationAttribute('ip_domain') credentials = netutils.getAvailableProtocols(Framework, protocolName, ip_address, ip_domain) if len(credentials) == 0: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) warningsList.append(errobj) logger.debug(msg) else: try: logger.info('Starting AS400 Connection.') for credential in credentials: client = Framework.createClient(credential) dicoverer = AS400Dicoverer(client) dicoverer.discover() oshvector.addAll(dicoverer.buildTopology()) except NoClassDefFoundError, error: # Trying to catch if as400 java package is not found msg = error.getMessage() if re.search("as400", msg, re.I): processException(errorsList,warningsList,"Third party library is not found. Please read the documentation about prerequisites for this job.") else: processException(errorsList,warningsList, msg) except:
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip') port = Framework.getDestinationAttribute('port') scp_id = Framework.getDestinationAttribute('scp_id') apache_id = Framework.getDestinationAttribute('apache_id') apache_ip = Framework.getDestinationAttribute('apache_ip') contexts = Framework.getTriggerCIDataAsList('contexts') context_ids = Framework.getTriggerCIDataAsList('context_ids') localShell = shellutils.ShellUtils(Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME)) protocolName = ClientsConsts.HTTP_PROTOCOL_NAME connectionFailedMsgs = [] protocolIds = findProperProtocolIds(ip, netutils.getAvailableProtocols(Framework, protocolName, ip) or []) if not protocolIds: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) logger.reportErrorObject(errobj) return OSHVResult httpClient, protocolId, version = findHttpProtocol(Framework, protocolName, protocolIds, ip, connectionFailedMsgs) if httpClient: apacheOsh = modeling.createOshByCmdbIdString('apache', apache_id) # create oam running software createOAMRunningSoftwareOsh(scp_id, ip, port, protocolId, version, apacheOsh, OSHVResult) # get oam policy content policy_content = getPolicyContent(httpClient, ip, protocolId, protocolName, version) # parse oam policy, get redirect urls authorization_policies = oam_policy_parser.parse_oam_policy(policy_content) redirect_policies = oam_policy_parser.get_redirect_policies(authorization_policies) # create oam dependency scp for index in range(0, len(contexts)): context, context_id = contexts[index], context_ids[index] if context_id: matched_policies = findMatchedRedirectPolicies(context, redirect_policies) apacheScpOsh = modeling.createOshByCmdbIdString('scp', context_id) for policy in matched_policies: createOAMDependenyScp(localShell, apacheOsh, apacheScpOsh, policy.redirect_url, apache_ip, OSHVResult) if not OSHVResult.size(): for msg in connectionFailedMsgs: errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg) logger.reportErrorObject(errobj) return OSHVResult
def reportErrorMessage(self): '''Join all messages into one big message and report it as error or if no registered - report error "Tried all protocols" ''' if len(self.errorMsg) > 0: errorResult = '' for error in self.errorMsg: errorResult = errorResult + '\n' + str(error) errobj = errorobject.createError( errorcodes.CONNECTION_FAILED_WITH_DETAILS, [str(self.getJ2eeServerType()), errorResult], errorResult) else: errobj = errorobject.createError( errorcodes.CONNECTION_FAILED_NO_PROTOCOL_WITH_DETAILS, ['Tried all protocols'], 'Failed to connect using all protocols') logger.reportWarningObject(errobj)
def processTCPResult(self): status = self.processTCPCmdResult() if status == TCPDisByLSOFableShell.LSOF_WRONG_VERSION_ERROR: message = 'It appears like lsof on destination %s does not work properly(wrong version?). Runs it with lsof disabled' % self.client.getIpAddress() logger.debug(message) errobj = errorobject.createError(errorcodes.LSOF_WRONG_VERSION, [self.client.getIpAddress()], message) logger.reportWarningObject(errobj) self.discoverTCPnoLSOF()
def getClusterVersion(shell, hostOS, AIX_ClusterPackageName): try: packageInfoCmd = None packageInfoStr = None version = None if (hostOS == 'NA'): rawCmdResult = shell.execCmd('uname') if (re.search('aix', rawCmdResult.lower())): hostOS = 'aix' else: raise ValueError, "OS type not found; unable to build command for query package version" else: hostOS = hostOS.lower().strip() ## Build the correct command based on platform if hostOS == 'aix': packageInfoCmd = concatenate('lslpp -l ', AIX_ClusterPackageName) else: return None ## Run the package query for HACMP version logger.debug(concatenate(' Executing command: ', packageInfoCmd)) packageInfoStr = shell.execCmd(packageInfoCmd) # Sample Output # cluster.license 5.4.0.0 COMMITTED HACMP Electronic License result = packageInfoStr.strip() ## Parse the result keywords = [ 'No package provides', 'No such file or directory', 'not installed', 'Error:' ] for keyword in keywords: if re.search(keyword, result, re.I): return None version = None lines = result.split('\n') for line in lines: m = re.search('^\s*\S+\s+(\d+[^ ]+)\s', line) if (m): version = m.group(1) logger.debug(concatenate(' Cluster package version: ', version)) break except: msg = "Could not execute Package Info Command " errobj = errorobject.createError( errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg) logger.reportWarningObject(errobj) logger.debug(msg) return None return version
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 DiscoveryMain(Framework): warningsList = [] errorsList = [] vector = ObjectStateHolderVector() ip_address = Framework.getDestinationAttribute('ip_address') ip_domain = Framework.getDestinationAttribute('ip_domain') protocolName = cim.Protocol.DISPLAY credentials = netutils.getAvailableProtocols(Framework, cim.Protocol.FULL, ip_address, ip_domain) credentials = smis_discoverer.getSmisCredentials(credentials, Framework) if len(credentials) == 0: msg = errormessages.makeErrorMessage( protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) warningsList.append(errobj) logger.debug(msg) smisNamespaces = smis_discoverer.getSmisNamespaces(Framework) if not smisNamespaces: msg = errormessages.makeErrorMessage(protocolName, "No SMI-S namespaces found") errobj = errorobject.createError( errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) errorsList.append(errobj) logger.reportErrorObject(errobj) return vector for credential in credentials: testedNamespace = None for namespaceObject in smisNamespaces: try: testedNamespace = cim_discover.testConnectionWithNamespace( Framework, ip_address, credential, namespaceObject) break except JException, ex: msg = ex.getMessage() msg = cim_discover.translateErrorMessage(msg) errormessages.resolveAndAddToObjectsCollections( msg, protocolName, warningsList, errorsList) except:
def parseLSOFListen(self, line, listenIpPorts): try: IpPortIpPortStatusListenArray = None protocol = modeling.TCP_PROTOCOL protocolName = 'tcp' try: IpPortIpPortStatusListenArray = re.search(self.TCPRegExp, line) if IpPortIpPortStatusListenArray != None: linkStatus = IpPortIpPortStatusListenArray.group(3) if linkStatus.find(self.LISTEN_str) == -1: return TCPDiscovery.OK except: return TCPDiscovery.OK if (IpPortIpPortStatusListenArray == None) and (self.UDPRegExp != None): try: IpPortIpPortStatusListenArray = re.search(self.UDPRegExp, line) protocol = modeling.UDP_PROTOCOL protocolName = 'udp' except: return TCPDiscovery.OK if IpPortIpPortStatusListenArray == None: return TCPDiscovery.OK pid = IpPortIpPortStatusListenArray.group(1) listenipPort = IpPortIpPortStatusListenArray.group(2) ip = listenipPort.split(':')[0] if not self.isIpv4(ip): logger.debug ('Skipping not valid IPv4 address %s' % ip) return TCPDiscovery.OK if not ip_addr.isValidIpAddress(ip) and not str(ip).startswith('0.'): errorMessage = 'On parsing listen ports by lsof for protocol ' + protocolName + ' extracted invalid ip:<' + ip + '>' logger.warn(errorMessage) errobj = errorobject.createError(errorcodes.IP_PARSING_ERROR, [protocolName, ip, 'On parsing listen ports by lsof'], errorMessage) logger.reportWarningObject(errobj) return TCPDiscovery.OK #if ip_addr.IPAddress(ip).get_is_loopback(): # return TCPDiscovery.OK port = listenipPort.split(':')[1] #sometimes we get on UDP something like this: #postmaste 2412 sfmdb 7u IPv4 0xe00000015f8ed100 0t0 UDP 127.0.0.1:49176->127.0.0.1:49176 #in this case split by ':' brings us at port 49176->127.0.0.1 port = re.search('\d+',port).group(0) #this is TCP port and we add it to port_process table for future connections discovery self._addTcpData(ip, port, pid, 1, protocol, listenIpPorts = listenIpPorts) return TCPDiscovery.OK except: logger.errorException('parseLSOFListen:failed to process TCP entry: ', line) return TCPDiscovery.ERROR
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip_address') credential_id = Framework.getDestinationAttribute('credential_id') version = Framework.getDestinationAttribute('version') cmdb_id = Framework.getDestinationAttribute('cmdb_id') protocol = ProtocolManager.getProtocolById(credential_id) host = protocol.getProtocolAttribute('host') port = protocol.getProtocolAttribute('protocol_port') protocolName = ClientsConsts.HTTP_PROTOCOL_NAME if (host and ip != host) or not port: msg = errormessages.makeErrorMessage(protocolName, 'Invalid ip address or missing port in HTTP credential', pattern=errormessages.ERROR_OPERATION_FAILED) errobj = errorobject.createError(errorcodes.OPERATION_FAILED, [protocolName], msg) logger.reportErrorObject(errobj) else: props = Properties() props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, credential_id) props.setProperty('autoAcceptCerts', 'true') props.setProperty('host', ip) try: httpClient = Framework.createClient(props) builder = PolicyBuilder(ip, port, version, httpClient) doc = builder.createPolicyDoc() oamServerOSH = modeling.createOshByCmdbIdString('running_software', cmdb_id) policyOSH = modeling.createConfigurationDocumentOSH('policy.xml', '', doc, oamServerOSH) linkOSH = modeling.createLinkOSH('composition', oamServerOSH, policyOSH) OSHVResult.add(oamServerOSH) OSHVResult.add(policyOSH) OSHVResult.add(linkOSH) except UnauthorizedException, e: msg = 'Failed to authenticate: ' + e.getMessage() errobj = errorobject.createError(errorcodes.INVALID_USERNAME_PASSWORD, [protocolName], msg) logger.reportErrorObject(errobj) except JException, e: msg = 'URL is not accessable: ' + e.getMessage() errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg) logger.reportErrorObject(errobj)
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() exchangeServerId = Framework.getDestinationAttribute('id') fqdn = Framework.getDestinationAttribute('fqdn') hostName = getHostName(Framework) exchangeServerOsh = ms_exchange_utils.restoreExchangeServerOSH( exchangeServerId) props = Properties() props.put(AgentConstants.PROP_WMI_NAMESPACE, WMI_NAMESPACE) try: wmiClient = Framework.createClient(props) wmiAgent = WmiAgent(wmiClient, Framework) try: exchangeDiscoverer = ExchangeDiscoverer(wmiAgent, exchangeServerOsh, Framework, OSHVResult, hostName) try: exchangeDiscoverer.doExchangeSystem(fqdn) exchangeDiscoverer.doFolderTrees() except: errorMsg = 'Failed to discover folder trees and public folders' logger.warnException(errorMsg) errobj = errorobject.createError( errorcodes.FAILED_DISCOVERING_RESOURCE, ['folder trees and public folders'], errorMsg) logger.reportWarningObject(errobj) if not exchangeDiscoverer.objectsDiscovered: errobj = errorobject.createError( errorcodes.MS_EXCHANGE_OBJECTS_NOT_FOUND, None, 'Microsoft Exchange objects not found in discovery') logger.reportErrorObject(errobj) finally: wmiClient.close() except: exInfo = logger.prepareJythonStackTrace('') errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework) return OSHVResult
def discoverServices(self): serviceQueryBuilder = SnmpQueryBuilder(SVC_OID_OFFSET) serviceQueryBuilder.addQueryElement(1, 'svc_name') serviceQueryBuilder.addQueryElement(3, 'ip') serviceQueryBuilder.addQueryElement(4, 'protocol') serviceQueryBuilder.addQueryElement(5, 'port') serviceQueryBuilder.addQueryElement(41, 'ip_range') serviceQueryBuilder.addQueryElement(42, 'port_range') snmpRowElements = self.snmpAgent.getSnmpData(serviceQueryBuilder) poolMemberToPoolQueryBuilder = SnmpQueryBuilder(CNTSVC_OID_OFFSET) poolMemberToPoolQueryBuilder.addQueryElement(2, 'cnt_name') poolMemberToPoolQueryBuilder.addQueryElement(3, 'svc_name') poolMemberToPoolElements = self.snmpAgent.getSnmpData(poolMemberToPoolQueryBuilder) svcToCntMap = {} for poolMemberToPoolElement in poolMemberToPoolElements: cnt = self.resourcePools[poolMemberToPoolElement.cnt_name] cntList = svcToCntMap.get(poolMemberToPoolElement.svc_name, []) cntList.append(cnt) svcToCntMap[poolMemberToPoolElement.svc_name] = cntList for snmpRowElement in snmpRowElements: poolMember = modeling.createHostOSH(snmpRowElement.ip, 'host_node') # KB specific: fix of port translations serviceAddressPort = snmpRowElement.port serviceAddress = modeling.createServiceAddressOsh(poolMember, snmpRowElement.ip, serviceAddressPort, CNT_PROTOCOL_MAP[snmpRowElement.protocol]) self.OSHVResult.add(poolMember) if svcToCntMap.has_key(snmpRowElement.svc_name): cntList = svcToCntMap[snmpRowElement.svc_name] for cnt in cntList: # KB specific: if there is not any port translation between the input and output IPs ports, create the same port destinationPort = serviceAddressPort destinationAddress = serviceAddress if destinationPort == '0': inputServiceAddress = self.resourcePoolsToServiceAddress[cnt.getAttributeValue('data_name')] destinationPort = inputServiceAddress.getAttributeValue('ipport_number') destinationAddress = modeling.createServiceAddressOsh(poolMember, snmpRowElement.ip, destinationPort, CNT_PROTOCOL_MAP[snmpRowElement.protocol]) self.OSHVResult.add(destinationAddress) self.OSHVResult.add(modeling.createLinkOSH('member', cnt, destinationAddress)) else: self.OSHVResult.add(serviceAddress) errobj = errorobject.createError(errorcodes.NO_SERVICE_FOUND_FOR_NODE, [snmpRowElement.svc_name], 'No service found for destination node') logger.reportWarningObject(errobj)
def processTCPResult(self): status = self.processTCPCmdResult() if status == TCPDisByLSOFableShell.LSOF_WRONG_VERSION_ERROR: message = 'It appears like lsof on destination %s does not work properly(wrong version?). Runs it with lsof disabled' % self.client.getIpAddress( ) logger.debug(message) errobj = errorobject.createError(errorcodes.LSOF_WRONG_VERSION, [self.client.getIpAddress()], message) logger.reportWarningObject(errobj) self.discoverTCPnoLSOF()
def doExchangeSystem(self, fqdn): queryBuilder = WmiQueryBuilder('Exchange_Server') queryBuilder.addWmiObjectProperties('Name', 'FQDN', 'DN', 'RoutingGroup', 'AdministrativeGroup') Exchange_Servers = self.wmiAgent.getWmiData(queryBuilder) if len(Exchange_Servers) == 0: errobj = errorobject.createError( errorcodes.EMPTY_DATA_RECEIVED, ['Exchange servers', 'WMI'], 'No Exchange servers available via WMI') logger.reportWarningObject(errobj) return for Exchange_Server in Exchange_Servers: ''' In case host name was not determined earlier, try to obtain it using Exchange_Server.FQDN property ''' if not self.exchangeServerName and fqdn == Exchange_Server.FQDN: self.exchangeServerName = Exchange_Server.Name exchangeSystemOsh = ObjectStateHolder('exchangesystem') exchangeSystemOsh.setAttribute( 'data_name', extractOrganizationNameFromDn(Exchange_Server.DN)) modeling.setAppSystemVendor(exchangeSystemOsh) self.add(exchangeSystemOsh) administrativeGroupOsh = ObjectStateHolder( 'exchange_administrative_group') administrativeGroupOsh.setAttribute( 'data_name', Exchange_Server.AdministrativeGroup) administrativeGroupOsh.setContainer(exchangeSystemOsh) self.add(administrativeGroupOsh) routingGroupOsh = ObjectStateHolder('routing_group') routingGroupOsh.setAttribute('data_name', Exchange_Server.RoutingGroup) routingGroupOsh.setContainer(administrativeGroupOsh) self.add(routingGroupOsh) if self.exchangeServerName and self.exchangeServerName.lower( ) == Exchange_Server.Name.lower(): self.add( modeling.createLinkOSH('member', administrativeGroupOsh, self.exchangeServerOsh)) self.add( modeling.createLinkOSH('member', routingGroupOsh, self.exchangeServerOsh)) self.add( modeling.createLinkOSH('member', exchangeSystemOsh, self.exchangeServerOsh)) self.exchangeSystemOsh = exchangeSystemOsh
def getPolicyContent(httpClient, ip, protocolId, protocolName, version): try: protocol = ProtocolManager.getProtocolById(protocolId) protocol_port = protocol.getProtocolAttribute('protocol_port') http_protocol = protocol.getProtocolAttribute('protocol') builder = oam_policy_builder.PolicyBuilder(http_protocol, ip, protocol_port, version, httpClient) return builder.createPolicyDoc() except JException, e: msg = 'URL is not accessable: ' + e.getMessage() errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg) logger.reportErrorObject(errobj)
def getClusterVersion(shell, hostOS, AIX_ClusterPackageName): try: packageInfoCmd = None packageInfoStr = None version = None if (hostOS == 'NA'): rawCmdResult = shell.execCmd('uname') if (re.search('aix', rawCmdResult.lower())): hostOS = 'aix' else: raise ValueError, "OS type not found; unable to build command for query package version" else: hostOS = hostOS.lower().strip() ## Build the correct command based on platform if hostOS == 'aix': packageInfoCmd = concatenate('lslpp -l ', AIX_ClusterPackageName) else: return None ## Run the package query for HACMP version logger.debug(concatenate(' Executing command: ', packageInfoCmd)) packageInfoStr = shell.execCmd(packageInfoCmd) # Sample Output # cluster.license 5.4.0.0 COMMITTED HACMP Electronic License result = packageInfoStr.strip() ## Parse the result keywords = ['No package provides', 'No such file or directory', 'not installed', 'Error:'] for keyword in keywords: if re.search(keyword,result,re.I): return None version = None lines = result.split('\n') for line in lines: m = re.search('^\s*\S+\s+(\d+[^ ]+)\s', line) if (m): version = m.group(1) logger.debug(concatenate(' Cluster package version: ', version)) break except: msg = "Could not execute Package Info Command " errobj = errorobject.createError(errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg) logger.reportWarningObject(errobj) logger.debug(msg) return None return version
def createWmiClient(Framework, namespace=None): try: if namespace: props = Properties() props.setProperty(AgentConstants.PROP_WMI_NAMESPACE, namespace) return Framework.createClient(props) else: return Framework.createClient() except: errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_NO_PROTOCOL, ["WMI"], 'Failed to connect') logger.reportErrorObject(errobj) logger.debugException('Failed to to connect')
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip_address = Framework.getTriggerCIDataAsList('ip_address') ip_domain = Framework.getTriggerCIDataAsList('ip_domain') credentialIds = Framework.getAvailableProtocols(ip_address[0], ProtocolManager.UDDI_REGISTRY) logger.debug('Len of credentials: %s' %str(len(credentialIds))) logger.debug('Start on Address:', ip_address[0], ', Domain:', ip_domain[0]) if credentialIds.__len__() == 0: msg = errormessages.makeErrorMessage(ProtocolManager.UDDI_REGISTRY, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [ProtocolManager.UDDI_REGISTRY], msg) logger.reportErrorObject(errobj) ip_domain = Framework.getDestinationAttribute("ip_domain") for credentialId in credentialIds: url = Framework.getProtocolProperty(credentialId, CollectorsConstants.UDDI_PROTOCOL_ATTRIBUTE_URL, '') if url == '': Framework.reportError('URL attribute is not specified in the UDDI protocol') continue # Check the URL try: logger.debug("Checking availability of %s" % url) netutils.doHttpGet(url, 20000, 'header').strip() except: Framework.reportWarning('Failed to connect to UDDI Registry using URL: ' + url) logger.debugException("Cannot connect to UDDI server") else: properties = Properties() properties.setProperty(CollectorsConstants.UDDI_PROTOCOL_ATTRIBUTE_URL, url) properties.setProperty("ip_domain", ip_domain) connected = False version = 0 for uddiVersion in (3, 2): if connected: break try: logger.debug('Using version UDDIv%d' % uddiVersion) properties.setProperty('uddi_version', str(uddiVersion)) logger.debug('Try to connect to UDDI Registry using url: ', url) Framework.getAgent(AgentConstants.UDDI_AGENT, '', credentialId, properties) logger.debug('Connected to UDDI Registry url: ', url) connected = True version = uddiVersion except MissingSdkJarException, ex: Framework.reportError('UDDI SDK jars are missed. Refer documentation for details') logger.debugException(ex.getMessage()) break except JException, java_exc: Framework.reportWarning("Cannot connect to UDDI server") logger.debugException('Failed to connect to UDDI Registry: ' + java_exc.getMessage()) except:
def mainFunction(Framework): warningsList = [] errorsList = [] _vector = ObjectStateHolderVector() ip_address = Framework.getDestinationAttribute('ip_address') macAddress = Framework.getDestinationAttribute('ip_mac_address') ip_domain = Framework.getDestinationAttribute('ip_domain') host_cmdbid = Framework.getDestinationAttribute('host_cmdbid') host_key = Framework.getDestinationAttribute('host_key') host_macs = Framework.getTriggerCIDataAsList('mac_addrs') ucmdb_version = modeling.CmdbClassModel().version() ip_address = __getIpObjectFromDestinationData(ip_address, macAddress) credentials = netutils.getAvailableProtocols(Framework, ClientsConsts.WMI_PROTOCOL_NAME, str(ip_address), ip_domain) if len(credentials) == 0: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) warningsList.append(errobj) logger.debug(msg) return (_vector, warningsList, errorsList) for credential in credentials: client = None try: debug_string = ip_domain + "\\" + str(ip_address) props = Properties() props.setProperty(CollectorsConstants.DESTINATION_DATA_IP_ADDRESS, str(ip_address)) logger.debug('try to get wmi agent for: ', debug_string) client = Framework.createClient(credential, props) logger.debug('got wmi agent for: ', debug_string) hostForLinkOSH = modeling.createHostOSH(str(ip_address)) # create wmi OSH wmiOSH = modeling.createWmiOSH(str(ip_address)) wmiOSH.setAttribute('credentials_id', client.getCredentialId()) wmiOSH.setContainer(hostForLinkOSH) _vector = doWMI(client, wmiOSH, ip_address, ip_domain, hostForLinkOSH, host_cmdbid, host_key, host_macs, ucmdb_version) if _vector.size() > 0: Framework.saveState(credential) del warningsList[:] del errorsList[:] break except Exception, ex: strException = str(ex.getMessage()) shouldStop = errormessages.resolveAndAddToObjectsCollections(strException, protocolName, warningsList, errorsList) if shouldStop: break except:
def executeUpdate(self, sql): st = None try: try: st = self.conn.createStatement() return st.executeUpdate(sql) except: error = 'Failed to execute sql ' + sql logger.errorException(error) errobj = errorobject.createError(errorcodes.FAILED_TO_EXECUTE_SQL, [sql], error) logger.reportErrorObject(errobj) finally: self.closeStatement(st)
def executeWmiQuery(wmiClient, Framework, vector, nodeOsh = None): '''WmiClient, Framework, oshVector -> None @deprecated use hostresources_win_wmi instead ''' try: containerOSH = nodeOsh or modeling.createHostOSH(wmiClient.getIpAddress()) wmiProvider = WmiAgentProvider(wmiClient) domainName = _getDomainName(wmiProvider) userResources = UserDiscoverer(wmiProvider).discoverByDomain(domainName) userResources.build(containerOSH) vector.addAll( userResources.report() ) except HostResourceDiscoveryException, hrde: errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION_NO_PROTOCOL, ['User discovery'], str(hrde)) logger.reportWarningObject(errobj)
def executeUpdate(self, sql): st = None try: try: st = self.conn.createStatement() return st.executeUpdate(sql) except: error = 'Failed to execute sql ' + sql logger.errorException(error) errobj = errorobject.createError( errorcodes.FAILED_TO_EXECUTE_SQL, [sql], error) logger.reportErrorObject(errobj) finally: self.closeStatement(st)
def clientDiscovery(Framework, ip): (vec, errObj) = mainFunction(Framework, 1, ip) logger.debug('OSHVector contains ', vec.size(), ' objects.') if vec.size() == 0: logger.debug('Failed to connect or no valid protocols defined. No Host CI will be created') if (errObj == None or errObj.errMsg == None or errObj.errMsg.strip() == ''): altErr = errorobject.createError(errorcodes.INTERNAL_ERROR ,None , 'Discovery failed due to internal error') logger.reportErrorObject(altErr) else: logger.reportWarningObject(errObj) else: Framework.sendObjects(vec) Framework.flushObjects() return None
def discoverA10_vthunder(self, a10_vthunder): queryBuilder = SnmpQueryBuilder(A10_OID_SYS) queryBuilder.addQueryElement(1, 'PrimaryVersion') queryBuilder.addQueryElement(2, 'SecondaryVersion') try: versionInformation = self.snmpAgent.getSnmpData(queryBuilder)[0] a10_vthunder.setAttribute('application_version', versionInformation.PrimaryVersion) except: errorMsg = 'Failed to get general information' errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION, ['snmp', 'general information'], errorMsg) logger.debugException(errorMsg) logger.reportWarningObject(errobj) self.discoverVirtualServers(a10_vthunder)
def createWmiClient(Framework, namespace=None): try: if namespace: props = Properties() props.setProperty(AgentConstants.PROP_WMI_NAMESPACE, namespace) return Framework.createClient(props) else: return Framework.createClient() except: errobj = errorobject.createError( errorcodes.CONNECTION_FAILED_NO_PROTOCOL, ["WMI"], 'Failed to connect') logger.reportErrorObject(errobj) logger.debugException('Failed to to connect')
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') host_id = Framework.getDestinationAttribute('hostId') errorsList = [] protocol = "ldap" credential_ids = Framework.getAvailableProtocols(ip, protocol) lastConnectedCredential = Framework.loadState() lastConnectedCredential and credential_ids.append(lastConnectedCredential) if not credential_ids: msg = errormessages.makeErrorMessage( 'webseal', pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, ['webseal'], msg) errorsList.append(errobj) client = Framework.createClient() credential_id = find_valid_credential(credential_ids, client, Framework) if credential_id: Framework.saveState(credential_id) OSHVResult.addAll(reportWebSeal(host_id, credential_id)) else: Framework.clearState() msg = errormessages.makeErrorMessage( 'Shell', pattern=errormessages.ERROR_FAILED_TO_CONNECT_TO_SERVER) errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, ['webseal'], msg) errorsList.append(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return OSHVResult
def parseTcpListenPorts(self, line, listenIpPorts): linkStatus = '' try: IpPortIpPortStatusListenArray = None protocol = modeling.TCP_PROTOCOL protocolName = 'tcp' try: IpPortIpPortStatusListenArray = re.compile(self.TCPRegExp).search(line) if IpPortIpPortStatusListenArray != None: linkStatus = IpPortIpPortStatusListenArray.group(5).upper() if (linkStatus.find(self.LISTEN_str) == -1) and (linkStatus.find("LISTEN") == -1): return TCPDiscovery.OK except: return TCPDiscovery.OK if (IpPortIpPortStatusListenArray == None) and (self.UDPRegExp != None) and (len(self.UDPRegExp) > 0): try: IpPortIpPortStatusListenArray = re.search(self.UDPRegExp, line) if (IpPortIpPortStatusListenArray != None) and len(IpPortIpPortStatusListenArray.groups()) == 3: linkStatus = IpPortIpPortStatusListenArray.group(3) protocol = modeling.UDP_PROTOCOL protocolName = 'udp' except: return TCPDiscovery.OK if IpPortIpPortStatusListenArray == None: return TCPDiscovery.OK ip = self.__parseIpv6(IpPortIpPortStatusListenArray.group(1)) port = IpPortIpPortStatusListenArray.group(2) if not ip_addr.isValidIpAddress(ip): errorMessage = 'On parsing listen ports by netstat for protocol ' + protocolName + ' extracted invalid ip:<' + ip + '>' logger.warn(errorMessage) errobj = errorobject.createError(errorcodes.IP_PARSING_ERROR, [protocolName, ip, 'On parsing listen ports by netstat'], errorMessage) logger.reportWarningObject(errobj) return TCPDiscovery.OK #if ip_addr.IPAddress(ip).get_is_loopback(): # return TCPDiscovery.OK pid = self.getPid(linkStatus) self._addTcpData(ip, port, pid, 1, protocol, listenIpPorts = listenIpPorts) return TCPDiscovery.OK except: logger.errorException('parseTcpListenPorts:failed to process TCP entry: ', line) return TCPDiscovery.ERROR
def getProcessesToProcess(self): if not self.shouldRun(): return rs = None try: try: self.buildProcessMap() st = self.getPreparedStatement(ProcessToProcess.P2PSQL) logger.debug(st) rs = st.executeQuery() while(rs.next()): SrcListen = rs.getBoolean('SrcListen') DstListen = rs.getBoolean('DstListen') if SrcListen and (not DstListen): self.buildTcpConnTopology(rs, 'dst', 'src') elif DstListen and (not SrcListen): self.buildTcpConnTopology(rs, 'src', 'dst') else: srcPrefered = self.isPreferedService(rs, 'src') dstPrefered = self.isPreferedService(rs, 'dst') if srcPrefered and (not dstPrefered): self.buildTcpConnTopology(rs, 'dst', 'src') elif dstPrefered and (not srcPrefered): self.buildTcpConnTopology(rs, 'src', 'dst') else: # we don't known which endpoint is listening, # so we can't set the link direction srcip = rs.getString('srcAddr') srcport = rs.getInt('srcPort') dstip = rs.getString('dstAddr') dstport = rs.getInt('dstPort') connString = '%s:%d %s:%d' % (srcip, srcport, dstip, dstport) logger.warn('process to process topology: ' 'Listen endpoint is unknown, skipping %s' % connString) except: error = 'Failed to fetch processes to process communication' logger.errorException(error) errobj = errorobject.createError(errorcodes.PROCESS_TO_PROCESS_FAILED, None, error) logger.reportErrorObject(errobj) finally: if rs: try: rs.close() except: pass self.conn.close()
def DiscoveryMain(Framework): warningsList = [] errorsList = [] vector = ObjectStateHolderVector() ip_address = Framework.getDestinationAttribute('ip_address') ip_domain = Framework.getDestinationAttribute('ip_domain') protocolName = cim.Protocol.DISPLAY credentials = netutils.getAvailableProtocols(Framework, cim.Protocol.FULL, ip_address, ip_domain) credentials = smis_discoverer.getSmisCredentials(credentials, Framework) if len(credentials) == 0: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) warningsList.append(errobj) logger.debug(msg) smisNamespaces = smis_discoverer.getSmisNamespaces(Framework) if not smisNamespaces: msg = errormessages.makeErrorMessage(protocolName, "No SMI-S namespaces found") errobj = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) errorsList.append(errobj) logger.reportErrorObject(errobj) return vector for credential in credentials: testedNamespace = None for namespaceObject in smisNamespaces: try: testedNamespace = cim_discover.testConnectionWithNamespace(Framework, ip_address, credential, namespaceObject) break except JException, ex: msg = ex.getMessage() msg = cim_discover.translateErrorMessage(msg) errormessages.resolveAndAddToObjectsCollections(msg, protocolName, warningsList, errorsList) except:
def filterEndpointsByPorts(Framework, endpoints, connections, warninglist): restrictPortNumber = Framework.getParameter('restrictPortNumber') restrictPortNumber = not restrictPortNumber or restrictPortNumber.lower() == 'true' or restrictPortNumber.lower() == 'on' logger.debug('Use %s to filter port: ' % CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME, restrictPortNumber and 'yes' or 'no') result = [] if restrictPortNumber: cfg_file = Framework.getConfigFile(CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME) ports = [port.getPortNumber() for port in cfg_file.getPorts(PortType.TCP)] filtered_connections = [x for x in connections if x and x.dstPort in ports] portlistbefiltered = set() for connection in connections: if not connection.dstPort in ports: portlistbefiltered.add(int(connection.dstPort)) if portlistbefiltered: portlistbefiltered = sorted(portlistbefiltered) portlistbefiltered = [str(x) for x in portlistbefiltered] portlistbefiltered = ', '.join(portlistbefiltered) logger.debug("The following outgoing ports are filtered because they are not in %s: %s" % (CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME, portlistbefiltered)) errobj = errorobject.createError(errorcodes.PORT_NOT_IN_CONFIGFILE, [CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME, portlistbefiltered], "The following outgoing ports are filtered because they are not in %s: %s" % (CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME, portlistbefiltered)) warninglist.append(errobj) else: filtered_connections = connections for endpoint in endpoints: local_endpoints = endpoint.getEndpoints() filtered = [] for endp in local_endpoints: connections = getConnectionsBySrcPort(endp.getPort(), filtered_connections) for connection in connections: filtered.append(netutils.Endpoint(connection.dstPort, endp.getProtocolType(), connection.dstAddr, 1, endp.getPortType())) logger.debug('filtered is %s ' % filtered) if filtered: result.append(netutils.ConnectivityEndpoint(endpoint.getKey(), filtered)) return result
def discoverRealGroups(self, realGroupIndexToVirtualServer): queryBuilder = SnmpQueryBuilder(REAL_GROUPS) queryBuilder.addQueryElement(1, 'index', 'int') queryBuilder.addQueryElement(2, 'realServers', 'hexa') queryBuilder.addQueryElement(8, 'groupName') realGroups = self.snmpAgent.getSnmpData(queryBuilder) serverList = self.discoverRealServers() self.discoverPortLinks() for realGroup in realGroups: cluster = ObjectStateHolder('loadbalancecluster') dataName = realGroup.groupName index = realGroup.index.strip() if not dataName: dataName = index cluster.setAttribute('data_name', dataName) self.OSHVResult.add(cluster) realPort = None if realGroupIndexToVirtualServer.has_key(index): virtualServerWrapper = realGroupIndexToVirtualServer[index] virtualServerWrapper.addResultsToVector(self.OSHVResult, cluster) realPort = realGroupIndexToVirtualServer[index].realPort else: logger.warn('Alteon real group index %s taken from oid 1.3.6.1.4.1.1872.2.5.4.1.1.3.3.1.1 does not match any virtual service\'s real group index taken from oid 1.3.6.1.4.1.1872.2.5.4.1.1.4.5.1' % index) errobj = errorobject.createError(errorcodes.FAILED_LINKING_ELEMENTS, ['real group %s' % dataName, 'virtual service'], 'Failed to link real group %s to virtual service' % dataName) logger.reportWarningObject(errobj) realServerNumbers = parseMappingString(realGroup.realServers.strip()) #reporting real ports from Virtual service table for each real server: for realServer in realServerNumbers: if serverList.has_key(realServer): if realPort: serviceAddress = modeling.createServiceAddressOsh(serverList[realServer].getServer(), serverList[realServer].getIPAddress(), realPort, modeling.SERVICEADDRESS_TYPE_TCP) self.OSHVResult.add(serviceAddress) self.OSHVResult.add(modeling.createLinkOSH('member', cluster, serviceAddress)) elif self.portMappings.has_key(realServer): portMapping = self.getPortMapping(realServerindex) for port in portMapping.getPorts(): serviceAddress = modeling.createServiceAddressOsh(serverList[realServer].getServer(), serverList[realServer].getIPAddress(), port, modeling.SERVICEADDRESS_TYPE_TCP) self.OSHVResult.add(serviceAddress) self.OSHVResult.add(modeling.createLinkOSH('member', cluster, serviceAddress)) else: serviceAddress = modeling.createServiceAddressOsh(serverList[realServer].getServer(), serverList[realServer].getIPAddress(), 0, modeling.SERVICEADDRESS_TYPE_TCP, 'unknown') self.OSHVResult.add(serviceAddress) self.OSHVResult.add(modeling.createLinkOSH('member', cluster, serviceAddress))