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 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): 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 initConnectionConfigurations(self): contextsMap = {} for ip in self.ips: credentialsIdList = self.framework.getAvailableProtocols(ip, VcloudProtocol.SHORT) if not credentialsIdList: logger.warn("No credentials for IP %s found" % ip) msg = errormessages.makeErrorMessage(VcloudProtocol.DISPLAY, None, errormessages.ERROR_NO_CREDENTIALS) connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.warnings.append(msg) self.connectionHandler.onFailure(connectionContext) continue contextsByCredentialsId = {} for credentialsId in credentialsIdList: connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.credentialsId = credentialsId contexts = [] self.urlGenerator.generate(connectionContext) for url in self.urlGenerator: connectionContextWithUrl = copy.copy(connectionContext) connectionContextWithUrl.urlString = url contexts.append(connectionContextWithUrl) if contexts: contextsByCredentialsId[credentialsId] = contexts if contextsByCredentialsId: contextsMap[ip] = contextsByCredentialsId self.contextsMap = contextsMap
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 _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 = [] 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 _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): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute("ip_address") ip_domain = Framework.getDestinationAttribute("ip_domain") cmdb_id = Framework.getDestinationAttribute("cmdb_id") protocolName = ClientsConsts.HTTP_PROTOCOL_NAME connectionFailedMsgs = [] protocolIds = findProperProtocolIds( ip, netutils.getAvailableProtocols(Framework, protocolName, ip, ip_domain) 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) else: for protocolId in protocolIds: protocol = ProtocolManager.getProtocolById(protocolId) port = protocol.getProtocolAttribute("protocol_port") for version in SUPPORTED_OAM_VERSION: props = Properties() props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, protocolId) props.setProperty("autoAcceptCerts", "true") props.setProperty("host", ip) try: httpClient = Framework.createClient(props) httpClient.getAsString( "http://%s:%s/oam/services/rest/%s/ssa/policyadmin/appdomain" % (ip, port, version) ) oamOsh = modeling.createOshByCmdbId("running_software", cmdb_id) oamOsh.setStringAttribute("credentials_id", protocolId) oamOsh.setStringAttribute("version", version) OSHVResult.add(oamOsh) except SocketTimeoutException, e: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_TIMEOUT) connectionFailedMsgs.append(msg) except JException, e: msg = "URL is not accessable: " + e.getMessage() # logger.debugException(msg) connectionFailedMsgs.append(msg) finally:
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 discover(self, firstSuccessful=1): if not self.contextsMap: raise ValueError("No connection configurations were found") for contextsByCredentialsMap in self.contextsMap.values(): for contextList in contextsByCredentialsMap.values(): for context in contextList: try: client = self._connectByContext(context) try: self._fillInSuccessContext(client, context) logger.debug("Connected to VMware server, type %s, version %s, client type %s" % (context.apiType, context.apiVersion, context.clientType)) self.connectionHandler.onConnection(context) if firstSuccessful: return finally: if client: client.close() except AxisFault, axisFault: faultType = _vmware_vim_base.getFaultType(axisFault) if faultType == AxisFaultType.INVALID_LOGIN: msg = errormessages.makeErrorMessage(_vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_INVALID_USERNAME_PASSWORD) logger.debug(msg) context.errors.append(msg) else: msg = None if faultType == AxisFaultType.NO_PERMISSION: priviledgeId = axisFault.getPrivilegeId() msg = "User does not have required '%s' permission" % priviledgeId logger.debug(msg) else: msg = axisFault.getFaultString() dump = axisFault.dumpToString() logger.debug(dump) errormessages.resolveAndAddToCollections(msg, _vmware_vim_base.VimProtocol.DISPLAY, context.warnings, context.errors) self.connectionHandler.onFailure(context) except JavaException, ex: msg = ex.getMessage() logger.debug(msg) errormessages.resolveAndAddToCollections(msg, _vmware_vim_base.VimProtocol.DISPLAY, context.warnings, context.errors) self.connectionHandler.onFailure(context) except: msg = logger.prepareJythonStackTrace('')
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 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() ip = Framework.getDestinationAttribute('ip_address') ip_domain = Framework.getDestinationAttribute('ip_domain') cmdb_id = Framework.getDestinationAttribute('cmdb_id') protocolName = ClientsConsts.HTTP_PROTOCOL_NAME connectionFailedMsgs = [] protocolIds = findProperProtocolIds(ip, netutils.getAvailableProtocols(Framework, protocolName, ip, ip_domain) 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) else: for protocolId in protocolIds: protocol = ProtocolManager.getProtocolById(protocolId) port = protocol.getProtocolAttribute('protocol_port') for version in SUPPORTED_OAM_VERSION: props = Properties() props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, protocolId) props.setProperty('autoAcceptCerts', 'true') props.setProperty('host', ip) try: httpClient = Framework.createClient(props) httpClient.getAsString('http://%s:%s/oam/services/rest/%s/ssa/policyadmin/appdomain' % (ip, port, version)) oamOsh = modeling.createOshByCmdbId('running_software', cmdb_id) oamOsh.setStringAttribute('credentials_id', protocolId) oamOsh.setStringAttribute('version', version) OSHVResult.add(oamOsh) except SocketTimeoutException, e: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_TIMEOUT) connectionFailedMsgs.append(msg) except JException, e: msg = 'URL is not accessable: ' + e.getMessage() # logger.debugException(msg) connectionFailedMsgs.append(msg) finally:
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 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): 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 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 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 initConnectionConfigurations(self): contextsMap = {} for ip in self.ips: credentialsIdList = [] if self.credentialId: #credentials is specified, only use this one credentialsIdList.append(self.credentialId) else: credentialsIdList = self.framework.getAvailableProtocols(ip, _vmware_vim_base.VimProtocol.SHORT) if not credentialsIdList: logger.warn("No credentials for IP %s found" % ip) msg = errormessages.makeErrorMessage(_vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_NO_CREDENTIALS) connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.warnings.append(msg) self.connectionHandler.onFailure(connectionContext) continue contextsByCredentialsId = {} for credentialsId in credentialsIdList: connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.credentialsId = credentialsId contexts = [] self.urlGenerator.generate(connectionContext) for url in self.urlGenerator: connectionContextWithUrl = copy.copy(connectionContext) connectionContextWithUrl.urlString = url contexts.append(connectionContextWithUrl) if contexts: contextsByCredentialsId[credentialsId] = contexts if contextsByCredentialsId: contextsMap[ip] = contextsByCredentialsId self.contextsMap = contextsMap
def findHttpProtocol(Framework, protocolName, protocolIds, ip, connectionFailedMsgs): for protocolId in protocolIds: protocol = ProtocolManager.getProtocolById(protocolId) protocol_port = protocol.getProtocolAttribute('protocol_port') http_protocol = protocol.getProtocolAttribute('protocol') for version in oam_policy_builder.SUPPORTED_OAM_VERSION: props = Properties() props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, protocolId) props.setProperty('autoAcceptCerts', 'true') props.setProperty('host', ip) try: httpClient = Framework.createClient(props) httpClient.getAsString('%s://%s:%s/oam/services/rest/%s/ssa/policyadmin/appdomain' % ( http_protocol, ip, protocol_port, version)) return httpClient, protocolId, version except SocketTimeoutException: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_TIMEOUT) connectionFailedMsgs.append(msg) except JException, e: msg = 'URL is not accessable: ' + e.getMessage() connectionFailedMsgs.append(msg)
def initConnectionConfigurations(self): ''' Initialize all connection configurations ''' contextsMap = {} for ip in self.ips: credentialsIdList = [] if self.credentialId: #credentials is specified, only use this one credentialsIdList.append(self.credentialId) else: credentialsIdList = self._getCredentialsForIp(ip) if not credentialsIdList: logger.warn("No credentials for IP %s found" % ip) msg = errormessages.makeErrorMessage( cim.Protocol.DISPLAY, None, errormessages.ERROR_NO_CREDENTIALS) connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.warnings.append(msg) self.connectionHandler.onFailure(connectionContext) continue contextsByCredentialsId = {} for credentialId in credentialsIdList: connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.credentialId = credentialId contextsByCredentialsId[credentialId] = [connectionContext] if contextsByCredentialsId: contextsMap[ip] = contextsByCredentialsId self.contextsMap = contextsMap
def onConnection(self, context): if self.discoveryFunction is None: raise ValueError("discoveryFunction is not set") self.connected = 1 try: vector = self.discoveryFunction(context, self.framework) if vector is not None: logger.debug(" -- Sending vector of %s objects" % vector.size()) if self._logVector: logger.debug(vector.toXmlString()) self.framework.sendObjects(vector) self.framework.flushObjects() except AxisFault, axisFault: faultType = _vmware_vim_base.getFaultType(axisFault) if faultType == AxisFaultType.INVALID_LOGIN: msg = errormessages.makeErrorMessage(_vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_INVALID_USERNAME_PASSWORD) logger.debug(msg) self.framework.reportError(msg) else: msg = None if faultType == AxisFaultType.NO_PERMISSION: priviledgeId = axisFault.getPrivilegeId() msg = "User does not have required '%s' permission" % priviledgeId else: msg = axisFault.dumpToString() logger.debug(msg) errormessages.resolveAndReport(msg, _vmware_vim_base.VimProtocol.DISPLAY, self.framework)
def initConnectionConfigurations(self): ''' Initialize all connection configurations ''' contextsMap = {} for ip in self.ips: credentialsIdList = [] if self.credentialId: #credentials is specified, only use this one credentialsIdList.append(self.credentialId) else: credentialsIdList = self._getCredentialsForIp(ip) if not credentialsIdList: logger.warn("No credentials for IP %s found" % ip) msg = errormessages.makeErrorMessage(cim.Protocol.DISPLAY, None, errormessages.ERROR_NO_CREDENTIALS) connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.warnings.append(msg) self.connectionHandler.onFailure(connectionContext) continue contextsByCredentialsId = {} for credentialId in credentialsIdList: connectionContext = ConnectionContext() connectionContext.ipAddress = ip connectionContext.credentialId = credentialId contextsByCredentialsId[credentialId] = [connectionContext] if contextsByCredentialsId: contextsMap[ip] = contextsByCredentialsId self.contextsMap = contextsMap
def _create_missed_creds_error(proto_name): msg = errormessages.makeErrorMessage( proto_name, pattern=errormessages.ERROR_NO_CREDENTIALS) return errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, (proto_name,), msg)
def DiscoveryMain(Framework): SHELL_CLIENT_PROTOCOLS = _getSupportedShellProtocols(Framework) ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') codepage = Framework.getCodePage() useLastState = Framework.getParameter('useLastSuccessConnection') vector = ObjectStateHolderVector() warningsList = [] errorsList = [] # preparing empty dictionary for storing credentials later credentialsByType = {} # take the latest used credentials if any lastState = None if useLastState and useLastState.lower() == 'true': lastState = Framework.loadState() if lastState: credentialsByType[None] = [lastState] # try to get ip address by mac address from ARP Cache macAddress = Framework.getDestinationAttribute('ip_mac_address') foundIp = clientdiscoveryutils.getIPAddressOnlyFromMacAddress(macAddress) if foundIp: ip = foundIp # Gather credentials for protocols for clientType in SHELL_CLIENT_PROTOCOLS: # getting an ordered list of credentials for the given client type and storing them in the credentials dictionary protocols = netutils.getAvailableProtocols(Framework, clientType, ip, domain) if protocols: credentialsByType[clientType] = protocols ########################################################################################################## ##################################Start Special processing for Universal Discovery Agent################## # take Universal Discovery Agent credentials if new Universal Discovery Agent installed on that IP connectedDDMAgentCredentials = None if useLastState and useLastState.lower() == 'true': connectedDDMAgentCredentials = Framework.loadGlobalState(ip) client = None udaNotAlive = 0 if connectedDDMAgentCredentials: logger.debug('Found global state credentials ', connectedDDMAgentCredentials, ' of installed agent on ip:', ip) client = createClient(Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, [connectedDDMAgentCredentials], ip, codepage, warningsList, errorsList) # If we are successfully connected if client: logger.debug('Succeeded to connect with global state credentials ', client.getCredentialId(), ' of installed agent') Framework.saveState(client.getCredentialId()) else: logger.debug('Failed to connect with global state credentials ', connectedDDMAgentCredentials, ' on ip:', ip) udaNotAlive = 1 #AgentUtils.clearGlobalState(Framework) # only for case where no connection established before if not client: # checks whether there are credential for specified protocol if credentialsByType: if lastState: client = createClientFromLastState(Framework, lastState, warningsList, errorsList) if not client: logger.debug('Failed to create client using last state properties. Will try to connect using other credentials.') if not client: for clientType in SHELL_CLIENT_PROTOCOLS: credentials = credentialsByType.get(clientType) if credentials: client = createClient(Framework, clientType, credentials, ip, codepage, warningsList, errorsList) if client: warningsList = [] errorsList = [] # save credentials id for further reuse Framework.saveState(client.getCredentialId()) break else: for shellType in SHELL_CLIENT_PROTOCOLS: msg = errormessages.makeErrorMessage(shellType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [shellType], msg) warningsList.append(errobj) if not client: Framework.clearState() else: # successfully connected, do discovery shell = None clientType = client.getClientType() connectedOSCredentialID = None try: try: shellFactory = shellutils.ShellFactory() shell = shellFactory.createShell(client, clientType) connectedOSCredentialID = ConnectedOSCredentialFinder.findCredential(Framework, shell, client, errorsList, warningsList) # If we got a default value, we just pass None later # Else - we need to signal the existing client which can be only UDA by now that it has a credential # to take sudo password from, if it needs it if (not connectedOSCredentialID or connectedOSCredentialID == ConnectedOSCredentialFinder.NO_CONNECTED_CRED_ID): connectedOSCredentialID = None else: try: client.setConnectedShellCredentialID(connectedOSCredentialID) except: logger.warn('Failed to setConnectedShellCredentialID, sudo commands may not work in this run') vector.addAll(doDiscovery(Framework, shell, client, ip, codepage, connectedOSCredentialID)) except (Exception, JException), jex: msg = str(jex) logger.debugException(msg) errormessages.resolveAndAddToObjectsCollections(msg, clientType, warningsList, errorsList) finally: if udaNotAlive and client: logger.debug('find another shell can be connected. ', shell) logger.debug('Removing the connected uda shell because it failed to connect') agentOsh = ObjectStateHolder(ClientsConsts.DDM_AGENT_PROTOCOL_NAME) agentOsh.setAttribute('application_ip', ip) agentOsh.setAttribute('data_name', ClientsConsts.DDM_AGENT_PROTOCOL_NAME) #agentOsh.setAttribute('application_port', shell.getPort()) agentOsh.setContainer(modeling.createHostOSH(ip)) Framework.deleteObject(agentOsh) Framework.flushObjects() Framework.clearGlobalState(ip) if shell: try: shell.closeClient() except: errobj = errorobject.createError(errorcodes.CLIENT_NOT_CLOSED_PROPERLY, None, "Client was not closed properly") warningsList.append(errobj) logger.warnException('') # close client anyway if client and client.close(): pass # create shell OSH if connection established but discovery failed if not vector.size(): logger.warn('Discovery failed, though shell object will be created') hostOsh = modeling.createHostOSH(ip, filter_client_ip=True) if hostOsh: languageName = None langBund = Framework.getEnvironmentInformation().getBundle('langNetwork', languageName) shellOsh = createShellObj(client, client, ip, langBund, languageName, codepage, connectedShellCredId=connectedOSCredentialID) shellOsh.setContainer(hostOsh) vector.add(shellOsh) else: logger.warn('Failed to create node and shell since IP is of a Client range type, not enough data for reconciliation.') for errobj in warningsList: logger.reportWarningObject(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return vector
for clientType in SHELL_CLIENT_PROTOCOLS: credentials = credentialsByType.get(clientType) if credentials: client = HostConnectionByShell.createClient( Framework, clientType, credentials, ip, codepage, warningsList, errorsList) if client: warningsList = [] errorsList = [] # save credentials id for further reuse Framework.saveState(client.getCredentialId()) break else: for shellType in SHELL_CLIENT_PROTOCOLS: #error messages, need to refactor msg = errormessages.makeErrorMessage( shellType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [shellType], msg) errorsList.append(errobj) if not client: Framework.clearState() else: # successfully connected, do discovery clientType = client.getClientType() connectedOSCredentialID = None try: try: shellFactory = shellutils.ShellFactory()
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() client = None hostOsh = None shell = None ## Destination data hostId = Framework.getDestinationAttribute('hostId') or None bwId = Framework.getDestinationAttribute('bwId') or None bwPath = Framework.getDestinationAttribute('bwPath') or None protocol = Framework.getDestinationAttribute('Protocol') ip_address = Framework.getDestinationAttribute('ip_address') tmpDirPath = Framework.getParameter('temp_directory') or '/tmp' isDiscoverJms = Framework.getParameter('discover_jms_topology') or "true" isDiscoverJms = Boolean.valueOf(isDiscoverJms) ## Container HOST OSH if hostId: hostOsh = modeling.createOshByCmdbIdString('node', hostId.strip()) OSHVResult.add(hostOsh) logger.debug('[' + __name__ + ':DiscoveryMain] Got HOSTID <%s>' % hostId) ## Pre-discovered Business Works CI bwOsh = None if bwId: bwOsh = modeling.createOshByCmdbIdString('tibco_business_works', bwId.strip()) logger.debug('[' + __name__ + ':DiscoveryMain] Got bwId <%s>' % bwId) else: errMsg = '[' + __name__ + ':DiscoveryMain] Invalid TibcoBusinessWorks CI ID received from server. This BW will not be processed' logger.error(errMsg) logger.reportError(errMsg) return OSHVResult if not tmpDirPath: errMsg = '[' + __name__ + ':DiscoveryMain] temp_directory parameter has not been set correctly. Discovery cannot continue until this parameter is set with a remote directory with write permissions.' logger.error(errMsg) logger.reportError(errMsg) return OSHVResult try: try: client = Framework.createClient() shell = shellutils.ShellFactory().createShell(client) credList = Framework.getAvailableProtocols(ip_address, tibco.TIBCO_PROTOCOL) logger.info("Found tibco credentials: %s" % len(credList)) fs = tibco_discoverer.createFileSystem(shell) bw = tibco_discoverer.BusinessWorksDiscoverer( ).findBWVersionFromPath(bwPath) domains = tibco_discoverer.BusinessWorksDomainDiscoverer( shell, fs).discover(bwPath) traHomeDiscoverer = tibco_discoverer.TicboTraHomeDiscoverer(shell) traHomes = traHomeDiscoverer.discover() fallbackDnsResolver = tibco_discoverer.FallbackResolver([ netutils.JavaDnsResolver(), netutils.DnsResolverByShell(shell) ]) dnsResolver = tibco_discoverer.CachedResolver(fallbackDnsResolver) if traHomes and bw: traPath = traHomes[0] for domain in domains: logger.info("Visit %s" % domain) try: applications = None # Check if we have any credential for TIBCO if credList: for credId in credList: adminCommand = tibco_discoverer.AppManageAdminCommand( client, credId, "./") adapterDiscoverer = tibco_discoverer.TibcoAdapterDiscoverer( dnsResolver) appDiscoverer = tibco_discoverer.BusinessWorksApplicationDiscoverer( shell, fs, adminCommand, adapterDiscoverer) applications = appDiscoverer.discover( domain.getName(), traPath, tmpDirPath, discoverJmsTopology=isDiscoverJms) if applications: tibco.each(domain.addApplication, applications) else: msg = errormessages.makeErrorMessage( tibco.TIBCO_PROTOCOL, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [tibco.TIBCO_PROTOCOL], msg) logger.reportErrorObject(errobj) bw.addDomain(domain) except tibco_discoverer.TibcoDiscovererException, exc: logger.debugException(str(exc)) errorobj = errorobject.createError( errorcodes. FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, ['tibco', 'error: %s' % str(exc)], str(exc)) logger.reportErrorObject(errorobj) except: logger.debugException('') exInfo = logger.prepareJythonStackTrace( '[' + __name__ + ':DiscoveryMain] Error connecting: ') errormessages.resolveAndReport(exInfo, protocol, Framework) else: # Reporting logger.debug("--- Start reporting ---") reporter = tibco.TopologyReporter(tibco.TopologyBuilder()) bwOsh = reporter.reportBusinessWorks(bw, hostOsh, bwId) OSHVResult.add(bwOsh) endpointReporter = netutils.EndpointReporter( netutils.ServiceEndpointBuilder()) for domain in domains: domainOsh = reporter.reportBusinessWorksDomain(domain) OSHVResult.add(domainOsh) OSHVResult.add(reporter.reportBWAndDomainLink( domainOsh, bwOsh)) for app in domain.getApplications(): appOsh = reporter.reportBusinessWorksApp(app, bwOsh) OSHVResult.add(appOsh) if app.getJmsServers(): for jmsServer in app.getJmsServers(): # Trying to resolver host name try: ip = netutils.getLowestIp( dnsResolver.resolveIpsByHostname( jmsServer.hostname)) if ip: jmsServer.hostname = ip except Exception, ex: logger.debugException(str(ex)) if netutils.isValidIp( jmsServer.hostname ) and not netutils.isLoopbackIp( jmsServer.hostname): jmsHostOsh = modeling.createHostOSH( jmsServer.hostname) emsServerOsh = reporter.reportEMSServer( tibco.EmsServer(), jmsHostOsh) jmsServerOsh = reporter.reportJmsServer( jmsServer, emsServerOsh) endpoint = netutils.createTcpEndpoint( jmsServer.hostname, jmsServer.getPort()) serviceOsh = endpointReporter.reportEndpoint( endpoint, jmsHostOsh) linkOsh = reporter.reportEmsServerServiceAddressLink( emsServerOsh, serviceOsh) OSHVResult.add(emsServerOsh) OSHVResult.add(jmsHostOsh) OSHVResult.add(jmsServerOsh) OSHVResult.add(serviceOsh) OSHVResult.add(linkOsh) for jmsQueue in app.getJmsQueues(): OSHVResult.addAll( reporter.reportJmsDestinationTopology( jmsQueue, jmsServerOsh, appOsh)) for jmsTopic in app.getJmsTopics(): OSHVResult.addAll( reporter.reportJmsDestinationTopology( jmsTopic, jmsServerOsh, appOsh)) if app.getAdapters(): for adapter in app.getAdapters(): OSHVResult.addAll( reporter.reportAdapterTopology( adapter, appOsh)) finally: if shell: ## Close shell connection shell.closeClient() return OSHVResult
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() urlString = Framework.getDestinationAttribute(PARAM_SERVER_URL) credentialsId = Framework.getDestinationAttribute(PARAM_CREDENTIALS_ID) #ipAddress = Framework.getDestinationAttribute(PARAM_IP_ADDRESS) client = None try: try: clientFactory = vmware_vim.ClientFactory(Framework, urlString, credentialsId) client = clientFactory.createClient() if client is not None: agent = client.getAgent() apiVersion = vmware_vim.getApiVersion(agent) logger.debug("Target API version: %s" % apiVersion) apiType = vmware_vim.getApiType(agent) logger.debug("Target API type: %s" % apiType) logger.debug("Client type: %s" % agent.getClientType()) crossClientHelper = vmware_vim.getCrossClientHelper(agent) module = vmware_vim.getVmwareModuleByApiVersion(apiVersion) config = vmware_vim.GlobalConfig(Framework) licensingDiscoverer = module.getLicensingDiscoverer(agent, crossClientHelper, Framework) licensingReporter = module.getLicensingReporter(crossClientHelper, Framework) topologyDiscoverer = module.getTopologyDiscoverer(agent, apiType, crossClientHelper, Framework, config) topologyDiscoverer.setLicensingDiscoverer(licensingDiscoverer) topologyReporter = module.getTopologyReporter(apiType, crossClientHelper, Framework, config) topologyReporter.setLicensingReporter(licensingReporter) topologyListener = _vmware_vim_base.EsxReportingTopologyListener(Framework) topologyListener.setTopologyReporter(topologyReporter) topologyDiscoverer.setTopologyListener(topologyListener) topologyDiscoverer.discover() else: raise ValueError, "Failed to connect to VMware ESX Server" except AxisFault, axisFault: faultType = _vmware_vim_base.getFaultType(axisFault) if faultType == 'InvalidLogin': msg = errormessages.makeErrorMessage(_vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_INVALID_USERNAME_PASSWORD) logger.debug(msg) Framework.reportError(msg) elif faultType == 'NoPermission': priviledgeId = axisFault.getPrivilegeId() msg = "User does not have required '%s' permission" % priviledgeId logger.debug(msg) errormessages.resolveAndReport(msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework) else: msg = axisFault.dumpToString() logger.debug(msg) errormessages.resolveAndReport(msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework) except Exception, ex: msg = ex.getMessage() logger.debug(msg) errormessages.resolveAndReport(msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework)
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() urlString = Framework.getDestinationAttribute(PARAM_SERVER_URL) credentialsId = Framework.getDestinationAttribute(PARAM_CREDENTIALS_ID) #ipAddress = Framework.getDestinationAttribute(PARAM_IP_ADDRESS) client = None try: try: clientFactory = vmware_vim.ClientFactory(Framework, urlString, credentialsId) client = clientFactory.createClient() if client is not None: agent = client.getAgent() apiVersion = vmware_vim.getApiVersion(agent) logger.debug("Target API version: %s" % apiVersion) apiType = vmware_vim.getApiType(agent) logger.debug("Target API type: %s" % apiType) logger.debug("Client type: %s" % agent.getClientType()) crossClientHelper = vmware_vim.getCrossClientHelper(agent) module = vmware_vim.getVmwareModuleByApiVersion(apiVersion) config = vmware_vim.GlobalConfig(Framework) licensingDiscoverer = module.getLicensingDiscoverer( agent, crossClientHelper, Framework) licensingReporter = module.getLicensingReporter( crossClientHelper, Framework) topologyDiscoverer = module.getTopologyDiscoverer( agent, apiType, crossClientHelper, Framework, config) topologyDiscoverer.setLicensingDiscoverer(licensingDiscoverer) topologyReporter = module.getTopologyReporter( apiType, crossClientHelper, Framework, config) topologyReporter.setLicensingReporter(licensingReporter) topologyListener = _vmware_vim_base.EsxReportingTopologyListener( Framework) topologyListener.setTopologyReporter(topologyReporter) topologyDiscoverer.setTopologyListener(topologyListener) topologyDiscoverer.discover() else: raise ValueError, "Failed to connect to VMware ESX Server" except AxisFault, axisFault: faultType = _vmware_vim_base.getFaultType(axisFault) if faultType == 'InvalidLogin': msg = errormessages.makeErrorMessage( _vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_INVALID_USERNAME_PASSWORD) logger.debug(msg) Framework.reportError(msg) elif faultType == 'NoPermission': priviledgeId = axisFault.getPrivilegeId() msg = "User does not have required '%s' permission" % priviledgeId logger.debug(msg) errormessages.resolveAndReport( msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework) else: msg = axisFault.dumpToString() logger.debug(msg) errormessages.resolveAndReport( msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework) except Exception, ex: msg = ex.getMessage() logger.debug(msg) errormessages.resolveAndReport( msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework)
if not client: for clientType in SHELL_CLIENT_PROTOCOLS: credentials = credentialsByType.get(clientType) if credentials: client = HostConnectionByShell.createClient(Framework, clientType, credentials, ip, codepage, warningsList, errorsList) if client: warningsList = [] errorsList = [] # save credentials id for further reuse Framework.saveState(client.getCredentialId()) break else: for shellType in SHELL_CLIENT_PROTOCOLS: #error messages, need to refactor msg = errormessages.makeErrorMessage(shellType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [shellType], msg) errorsList.append(errobj) if not client: Framework.clearState() else: # successfully connected, do discovery clientType = client.getClientType() connectedOSCredentialID = None try: try: shellFactory = shellutils.ShellFactory() shell = shellFactory.createShell(client, clientType)
def DiscoveryMain(Framework): urlString = Framework.getDestinationAttribute(PARAM_SERVER_URL) credentialsId = Framework.getDestinationAttribute(PARAM_CREDENTIALS_ID) connectionRetryNumber = Framework.getParameter(PARAM_CONNECTION_RETRY_NUMBER) continuousMonitoring = Framework.getParameter(PARAM_EVENT_BASED_DISCOVERY_ENABLED) historyHours = Framework.getParameter(PARAM_HYSTORY_HOURS) isJobMonitoringSupported = _vmware_vim_base.isJobStateMonitoringSupported(Framework) if not isJobMonitoringSupported: Framework.reportWarning('You are running job on UCMDB 8.03 or earlier, it cannot be gracefully stopped, only by restarting the probe.') try: client = None try: clientFactory = vmware_vim.ClientFactory(Framework, urlString, credentialsId) client = clientFactory.createClient() if client: agent = client.getAgent() apiVersion = vmware_vim.getApiVersion(agent) logger.debug("Target API version: %s" % apiVersion) logger.debug("Client type: %s" % agent.getClientType()) crossClientHelper = vmware_vim.getCrossClientHelper(agent) module = vmware_vim.getVmwareModuleByApiVersion(apiVersion) monitor = module.getEventMonitor(agent, crossClientHelper, Framework) monitor.setContinuousMonitoring(continuousMonitoring) monitor.setHistoryHours(historyHours) monitor.setRetryNumber(connectionRetryNumber) #monitor.setPageSize(5) #monitor.setFilterRecreationIntervalMinutes(5) vmMigratedEventListener = module.getVmMigratedEventListener(agent, crossClientHelper) vmMigratedEventReporter = module.getVmMigratedEventReporter(crossClientHelper, Framework) vmMigratedEventListener._addReporter(vmMigratedEventReporter) monitor.addListener(vmMigratedEventListener) vmPoweredOnEventListener = module.getVmPoweredOnEventListener(agent, crossClientHelper) vmPoweredOnEventReporter = module.getVmPoweredOnEventReporter(crossClientHelper, Framework) vmPoweredOnEventListener._addReporter(vmPoweredOnEventReporter) monitor.addListener(vmPoweredOnEventListener) if isJobMonitoringSupported: jobMonitoringTask = _vmware_vim_base.JobStateCheckTask(monitor, Framework) jobMonitoringThread = Thread(jobMonitoringTask) jobMonitoringThread.start() monitor.start() finally: client and client.close() except AxisFault, axisFault: faultType = _vmware_vim_base.getFaultType(axisFault) if faultType == 'InvalidLogin': msg = errormessages.makeErrorMessage(_vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_INVALID_USERNAME_PASSWORD) logger.debug(msg) Framework.reportError(msg) elif faultType == 'NoPermission': priviledgeId = axisFault.getPrivilegeId() msg = "User does not have required '%s' permission" % priviledgeId logger.debug(msg) errormessages.resolveAndReport(msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework) else: msg = axisFault.dumpToString() logger.debug(msg) errormessages.resolveAndReport(msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework)
def mainFunction(Framework, isClient, ip_address = None): _vector = ObjectStateHolderVector() errStr = '' ip_domain = Framework.getDestinationAttribute('ip_domain') host_cmdbid = Framework.getDestinationAttribute('host_cmdbid') host_key = Framework.getDestinationAttribute('host_key') host_macs = Framework.getTriggerCIDataAsList('mac_addrs') ip_arp_mac = Framework.getDestinationAttribute('ip_mac') # try to get ip address by mac address from ARP Cache foundIp = clientdiscoveryutils.getIPAddressOnlyFromMacAddress(ip_arp_mac) if foundIp: ip_address = foundIp if (ip_address == None): ip_address = Framework.getDestinationAttribute('ip_address') if (ip_domain == None): ip_domain = DomainScopeManager.getDomainByIp(ip_address, None) protocols = netutils.getAvailableProtocols(Framework, ClientsConsts.SNMP_PROTOCOL_NAME, ip_address, ip_domain) if len(protocols) == 0: errStr = 'No credentials defined for the triggered ip' logger.debug(errStr) errObj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [ClientsConsts.SNMP_PROTOCOL_NAME], errStr) return (_vector, errObj) connected = 0 for protocol in protocols: client = None try: try: logger.debug('try to get snmp agent for: %s:%s' % (ip_address, ip_domain)) if (isClient == TRUE): properties = Properties() properties.setProperty(CollectorsConstants.DESTINATION_DATA_IP_ADDRESS, ip_address) properties.setProperty(CollectorsConstants.DESTINATION_DATA_IP_DOMAIN, ip_domain) client = Framework.createClient(protocol, properties) else: properties = Properties() properties.setProperty(CollectorsConstants.DESTINATION_DATA_IP_ADDRESS, ip_address) client = Framework.createClient(protocol, properties) logger.debug('Running test connection queries') testConnection(client) Framework.saveState(protocol) logger.debug('got snmp agent for: %s:%s' % (ip_address, ip_domain)) isMultiOid = client.supportMultiOid() logger.debug('snmp server isMultiOid state=%s' %isMultiOid) # create snmp OSH snmpOSH = modeling.createSnmpOSH(ip_address, client.getPort()) snmpOSH.setAttribute('application_timeout', client.getTimeout()) snmpOSH.setAttribute('snmp_port', client.getPort()) snmpOSH.setAttribute('credentials_id', client.getCredentialId()) snmpOSH.setAttribute('snmp_retry', client.getRetries()) snmpOSH.setAttribute('snmp_timeout', client.getTimeout()) #obtain SNMP protocol version snmpVersion = definedSnmpProtocolVersion(protocol, Framework) snmpOSH.setAttribute('application_version_number', snmpVersion) if ip_arp_mac and ip_arp_mac != 'NA': snmpOSH.setAttribute('arp_mac', ip_arp_mac) if isMultiOid == 1: snmpOSH.setBoolAttribute('snmp_supportmultioid', 1) else: snmpOSH.setBoolAttribute('snmp_supportmultioid', 0) _vector = doSnmp(client, isClient, snmpOSH, ip_address, ip_domain, Framework, host_cmdbid, host_key, host_macs) client.close() client = None if _vector.size() > 0: connected = 1 break except BroadcastIpDiscoveryException: msg = "Job has been triggered on broadcast IP, no results will be reported" errObj = errorobject.createError(errorcodes.NO_RESULTS_WILL_BE_REPORTED, ["Job has been triggered on broadcast IP"], msg) if client != None: client.close() client = None return (_vector, errObj) except: if client != None: client.close() client = None logger.debugException('Unexpected SNMP_AGENT Exception:') lastExceptionStr = str(sys.exc_info()[1]).strip() finally: if client != None: client.close() client = None error = errorobject.INTERNAL_ERROR if (not connected): errStr = errormessages.makeErrorMessage('SNMP', pattern=errormessages.ERROR_CONNECTION_FAILED) error = errorobject.createError(errorcodes.CONNECTION_FAILED, ['SNMP'], errStr) logger.debug(errStr) Framework.clearState() elif (_vector.size() == 0): error = errormessages.resolveError(lastExceptionStr, 'SNMP') return (_vector, error)
def DiscoveryMain(Framework): SHELL_CLIENT_PROTOCOLS = _getSupportedShellProtocols(Framework) ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') codepage = Framework.getCodePage() useLastState = Framework.getParameter('useLastSuccessConnection') vector = ObjectStateHolderVector() warningsList = [] errorsList = [] # preparing empty dictionary for storing credentials later credentialsByType = {} # take the latest used credentials if any lastState = None if useLastState and useLastState.lower() == 'true': lastState = Framework.loadState() if lastState: credentialsByType[None] = [lastState] # try to get ip address by mac address from ARP Cache macAddress = Framework.getDestinationAttribute('ip_mac_address') foundIp = clientdiscoveryutils.getIPAddressOnlyFromMacAddress(macAddress) if foundIp: ip = foundIp # Gather credentials for protocols for clientType in SHELL_CLIENT_PROTOCOLS: # getting an ordered list of credentials for the given client type and storing them in the credentials dictionary protocols = netutils.getAvailableProtocols(Framework, clientType, ip, domain) if protocols: credentialsByType[clientType] = protocols ########################################################################################################## ##################################Start Special processing for Universal Discovery Agent################## # take Universal Discovery Agent credentials if new Universal Discovery Agent installed on that IP connectedDDMAgentCredentials = None if useLastState and useLastState.lower() == 'true': connectedDDMAgentCredentials = Framework.loadGlobalState(ip) client = None udaNotAlive = 0 if connectedDDMAgentCredentials: logger.debug('Found global state credentials ', connectedDDMAgentCredentials, ' of installed agent on ip:', ip) client = createClient(Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, [connectedDDMAgentCredentials], ip, codepage, warningsList, errorsList) # If we are successfully connected if client: logger.debug('Succeeded to connect with global state credentials ', client.getCredentialId(), ' of installed agent') Framework.saveState(client.getCredentialId()) else: logger.debug('Failed to connect with global state credentials ', connectedDDMAgentCredentials, ' on ip:', ip) udaNotAlive = 1 #AgentUtils.clearGlobalState(Framework) # only for case where no connection established before if not client: # checks whether there are credential for specified protocol if credentialsByType: if lastState: client = createClientFromLastState(Framework, lastState, warningsList, errorsList) if not client: logger.debug( 'Failed to create client using last state properties. Will try to connect using other credentials.' ) if not client: for clientType in SHELL_CLIENT_PROTOCOLS: credentials = credentialsByType.get(clientType) if credentials: client = createClient(Framework, clientType, credentials, ip, codepage, warningsList, errorsList) if client: warningsList = [] errorsList = [] # save credentials id for further reuse Framework.saveState(client.getCredentialId()) break else: for shellType in SHELL_CLIENT_PROTOCOLS: msg = errormessages.makeErrorMessage( shellType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [shellType], msg) warningsList.append(errobj) if not client: Framework.clearState() else: # successfully connected, do discovery shell = None clientType = client.getClientType() connectedOSCredentialID = None try: try: shellFactory = shellutils.ShellFactory() shell = shellFactory.createShell(client, clientType) connectedOSCredentialID = ConnectedOSCredentialFinder.findCredential( Framework, shell, client, errorsList, warningsList) # If we got a default value, we just pass None later # Else - we need to signal the existing client which can be only UDA by now that it has a credential # to take sudo password from, if it needs it if (not connectedOSCredentialID or connectedOSCredentialID == ConnectedOSCredentialFinder.NO_CONNECTED_CRED_ID): connectedOSCredentialID = None else: try: client.setConnectedShellCredentialID( connectedOSCredentialID) except: logger.warn( 'Failed to setConnectedShellCredentialID, sudo commands may not work in this run' ) vector.addAll( doDiscovery(Framework, shell, client, ip, codepage, connectedOSCredentialID)) except (Exception, JException), jex: msg = str(jex) logger.debugException(msg) errormessages.resolveAndAddToObjectsCollections( msg, clientType, warningsList, errorsList) finally: if udaNotAlive and client: logger.debug('find another shell can be connected. ', shell) logger.debug( 'Removing the connected uda shell because it failed to connect' ) agentOsh = ObjectStateHolder( ClientsConsts.DDM_AGENT_PROTOCOL_NAME) agentOsh.setAttribute('application_ip', ip) agentOsh.setAttribute('data_name', ClientsConsts.DDM_AGENT_PROTOCOL_NAME) #agentOsh.setAttribute('application_port', shell.getPort()) agentOsh.setContainer(modeling.createHostOSH(ip)) Framework.deleteObject(agentOsh) Framework.flushObjects() Framework.clearGlobalState(ip) if shell: try: shell.closeClient() except: errobj = errorobject.createError( errorcodes.CLIENT_NOT_CLOSED_PROPERLY, None, "Client was not closed properly") warningsList.append(errobj) logger.warnException('') # close client anyway if client and client.close(): pass # create shell OSH if connection established but discovery failed if not vector.size(): logger.warn( 'Discovery failed, though shell object will be created') hostOsh = modeling.createHostOSH(ip, filter_client_ip=True) if hostOsh: languageName = None langBund = Framework.getEnvironmentInformation().getBundle( 'langNetwork', languageName) shellOsh = createShellObj( client, client, ip, langBund, languageName, codepage, connectedShellCredId=connectedOSCredentialID) shellOsh.setContainer(hostOsh) vector.add(shellOsh) else: logger.warn( 'Failed to create node and shell since IP is of a Client range type, not enough data for reconciliation.' ) for errobj in warningsList: logger.reportWarningObject(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return vector
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() protocol = cim.Protocol.DISPLAY credentialsId = Framework.getDestinationAttribute('credentialsId') ipAddress = Framework.getDestinationAttribute('ip_address') smisNamespaces = smis_discoverer.getSmisNamespaces(Framework) if not smisNamespaces: msg = errormessages.makeErrorMessage(cim.Protocol.DISPLAY, "No SMI-S namespaces found") errobj = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errobj) return OSHVResult errorMessges = [] for namespaceObject in smisNamespaces: client = None namespace = namespaceObject.getName() try: try: client = cim_discover.createClient(Framework, ipAddress, namespace, credentialsId) logger.debug('Connected to namespace "%s"' % namespace) storageFabricDiscoverer = smis_discoverer.getStorageFabricDiscoverer(namespace) if storageFabricDiscoverer: storageFabrics = storageFabricDiscoverer.discover(client) switch2FabricLinksDiscover = smis_discoverer.getSwitch2FabricLinksDiscoverDiscoverer(namespace) switch2FabricMap = {} if switch2FabricLinksDiscover: switch2FabricMap = switch2FabricLinksDiscover.discover(client) fcSwitchs = [] hosts = [] switchDiscoverer = smis_discoverer.getSwitchComputerSystemDiscoverer(namespace) if switchDiscoverer: (fcSwitchs, hosts) = switchDiscoverer.discover(client) fcPorts = [] fcPortsDiscover = smis_discoverer.getFcPortDiscoverer(namespace) if fcPortsDiscover: fcPorts = fcPortsDiscover.discover(client) connections = {} portConnectionDiscover = smis_discoverer.getFCPortConnectionsDiscover(namespace) if portConnectionDiscover: connections = portConnectionDiscover.discover(client) topoBuilder = smis.TopologyBuilder() OSHVResult.addAll(topoBuilder.reportFcSwitchTopolopy(storageFabrics,fcSwitchs,hosts,fcPorts,switch2FabricMap,connections)) return OSHVResult systemDiscoverer = smis_discoverer.getStorageSystemDiscoverer(namespace) storageSystems = systemDiscoverer.discover(client) storageProcessorDiscoverer = smis_discoverer.getStorageProcessorDiscoverer(namespace) storageProcessors = storageProcessorDiscoverer.discover(client) physicalDrives = [] localFchPorts = [] pools = [] lvs = [] endPoints = [] portDiscoverer = smis_discoverer.getFcPortDiscoverer(namespace) localFchPorts = portDiscoverer.discover(client) poolDiscoverer = smis_discoverer.getStoragePoolDiscoverer(namespace) pools = poolDiscoverer.discover(client) lvDiscoverer = smis_discoverer.getLogicalVolumeDiscoverer(namespace) lvs = lvDiscoverer.discover(client) pvDiscoverer = smis_discoverer.getPhysicalVolumeDiscoverer(namespace) pvs = pvDiscoverer.discover(client) logger.debug(localFchPorts) endPointDiscoverer = smis_discoverer.getRemoteEndpointDiscoverer(namespace) endPoints = endPointDiscoverer.discover(client) endPointToVolumeDiscoverer = smis_discoverer.getEndPointToVolumeDiscoverer(namespace) endpointLinks = endPointToVolumeDiscoverer.discover(client) lunMappings = [] lunMaksingMappingViewDiscover = smis_discoverer.getLunMaskingMappingViewDiscover(namespace) if lunMaksingMappingViewDiscover: lunMappings = lunMaksingMappingViewDiscover.discover(client) pv2poolLinks = {} pv2poolLinksDiscover = smis_discoverer.getPhysicalVolume2StoragePoolLinksDiscover(namespace) if pv2poolLinksDiscover: pv2poolLinks = pv2poolLinksDiscover.discover(client) ## #building topology topoBuilder = smis.TopologyBuilder() OSHVResult.addAll(topoBuilder.reportTopology(storageSystems=storageSystems, ports=localFchPorts, pools=pools, lvs=lvs, endPoints=endPoints, storageProcessors = storageProcessors, pvs = pvs, endpointLinks = endpointLinks, lunMappings = lunMappings, pv2poolLinks = pv2poolLinks)) errorMessges = [] break finally: try: client and client.close() except: logger.error("Unable to close client") except JavaException, ex: logger.debugException('') msg = ex.getMessage() msg = cim_discover.translateErrorMessage(msg) errorMessges.append(msg) #errormessages.resolveAndReport(msg, protocol, Framework) except:
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:
ipAddress = Framework.getDestinationAttribute(DestinationProperty.IP_ADDRESS) connectionHandler = vmware_cim_discover.DefaultDiscoveryConnectionHandler(Framework, discoverConnectedEsx) connectionDiscoverer = None try: connectionDiscoverer = vmware_cim_discover.ConnectionDiscoverer(Framework, connectionHandler) except (cim_discover.MissingConfigFileException, vmware_cim_discover.RuntimeException), ex: msg = str(ex) errorObject = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errorObject) logger.error(msg) return resultVector connectionDiscoverer.addIp(ipAddress) connectionDiscoverer.initConnectionConfigurations() try: connectionDiscoverer.discover() except vmware_cim_discover.NoConnectionConfigurationsException: msg = errormessages.makeErrorMessage(cim.Protocol.DISPLAY, pattern=errormessages.ERROR_NO_CREDENTIALS) errorObject = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [cim.Protocol.DISPLAY], msg) logger.reportErrorObject(errorObject) else: if not connectionHandler.connected: connectionHandler.reportConnectionErrors() return resultVector
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() protocol = cim.Protocol.DISPLAY credentialsId = Framework.getDestinationAttribute('credentialsId') ipAddress = Framework.getDestinationAttribute('ip_address') smisNamespaces = smis_discoverer.getSmisNamespaces(Framework) if not smisNamespaces: msg = errormessages.makeErrorMessage(cim.Protocol.DISPLAY, "No SMI-S namespaces found") errobj = errorobject.createError( errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errobj) return OSHVResult errorMessges = [] for namespaceObject in smisNamespaces: client = None namespace = namespaceObject.getName() try: try: client = cim_discover.createClient(Framework, ipAddress, namespace, credentialsId) logger.debug('Connected to namespace "%s"' % namespace) storageFabricDiscoverer = smis_discoverer.getStorageFabricDiscoverer( namespace) if storageFabricDiscoverer: storageFabrics = storageFabricDiscoverer.discover(client) switch2FabricLinksDiscover = smis_discoverer.getSwitch2FabricLinksDiscoverDiscoverer( namespace) switch2FabricMap = {} if switch2FabricLinksDiscover: switch2FabricMap = switch2FabricLinksDiscover.discover( client) fcSwitchs = [] hosts = [] switchDiscoverer = smis_discoverer.getSwitchComputerSystemDiscoverer( namespace) if switchDiscoverer: (fcSwitchs, hosts) = switchDiscoverer.discover(client) fcPorts = [] fcPortsDiscover = smis_discoverer.getFcPortDiscoverer( namespace) if fcPortsDiscover: fcPorts = fcPortsDiscover.discover(client) connections = {} portConnectionDiscover = smis_discoverer.getFCPortConnectionsDiscover( namespace) if portConnectionDiscover: connections = portConnectionDiscover.discover(client) topoBuilder = smis.TopologyBuilder() OSHVResult.addAll( topoBuilder.reportFcSwitchTopolopy( storageFabrics, fcSwitchs, hosts, fcPorts, switch2FabricMap, connections)) return OSHVResult systemDiscoverer = smis_discoverer.getStorageSystemDiscoverer( namespace) storageSystems = systemDiscoverer.discover(client) storageProcessorDiscoverer = smis_discoverer.getStorageProcessorDiscoverer( namespace) storageProcessors = storageProcessorDiscoverer.discover(client) physicalDrives = [] localFchPorts = [] pools = [] lvs = [] endPoints = [] portDiscoverer = smis_discoverer.getFcPortDiscoverer(namespace) localFchPorts = portDiscoverer.discover(client) poolDiscoverer = smis_discoverer.getStoragePoolDiscoverer( namespace) pools = poolDiscoverer.discover(client) lvDiscoverer = smis_discoverer.getLogicalVolumeDiscoverer( namespace) lvs = lvDiscoverer.discover(client) pvDiscoverer = smis_discoverer.getPhysicalVolumeDiscoverer( namespace) pvs = pvDiscoverer.discover(client) logger.debug(localFchPorts) endPointDiscoverer = smis_discoverer.getRemoteEndpointDiscoverer( namespace) endPoints = endPointDiscoverer.discover(client) endPointToVolumeDiscoverer = smis_discoverer.getEndPointToVolumeDiscoverer( namespace) endpointLinks = endPointToVolumeDiscoverer.discover(client) lunMappings = [] lunMaksingMappingViewDiscover = smis_discoverer.getLunMaskingMappingViewDiscover( namespace) if lunMaksingMappingViewDiscover: lunMappings = lunMaksingMappingViewDiscover.discover( client) pv2poolLinks = {} pv2poolLinksDiscover = smis_discoverer.getPhysicalVolume2StoragePoolLinksDiscover( namespace) if pv2poolLinksDiscover: pv2poolLinks = pv2poolLinksDiscover.discover(client) ## #building topology topoBuilder = smis.TopologyBuilder() OSHVResult.addAll( topoBuilder.reportTopology( storageSystems=storageSystems, ports=localFchPorts, pools=pools, lvs=lvs, endPoints=endPoints, storageProcessors=storageProcessors, pvs=pvs, endpointLinks=endpointLinks, lunMappings=lunMappings, pv2poolLinks=pv2poolLinks)) errorMessges = [] break finally: try: client and client.close() except: logger.error("Unable to close client") except JavaException, ex: logger.debugException('') msg = ex.getMessage() msg = cim_discover.translateErrorMessage(msg) errorMessges.append(msg) #errormessages.resolveAndReport(msg, protocol, Framework) except:
def doApplication(Framework, ip, OSHVResult, client, shell, hostOsh): clientType = client.getClientType() language = Framework.getDestinationAttribute('language') portToDiscover = Framework.getDestinationAttribute("PORT") scp_id = Framework.getDestinationAttribute("SCP_ID") portInNetstat = False processMapOnPort = {} signatureFound = False filterRunningSoftwareByPort = Framework.getParameter('filterRunningSoftwareByPort') logger.debug("Start to do host application") logger.debug("ip:", ip) #hostOsh = modeling.createHostOSH(ip) platformTrait = None processes = [] packageToExecutablePath = {} CLUSTERLIST = ["Microsoft Cluster SW"] if shell.isWinOs(): uname = 'Win' #client = shell if (language != None) and (language != 'NA'): langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY', language) else: langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY') try: wmicPath = Framework.getParameter('wmicPath') if wmicPath: shell.execCmd('set PATH=%PATH%;' + wmicPath) except: logger.debug('Failed to add default wmic location to the PATH variable.') else: if shell.getClientType() == 'ssh': uname = netutils.getOSName(client, 'uname -a') else: uname = netutils.getOSName(client, 'uname') langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY', 'eng') # get platform details try: platformTrait = process_discoverer.getPlatformTrait(shell) if platformTrait is None: raise ValueError() except: logger.warnException("Failed to determine platform") # discover processes if platformTrait and not uname == 'VMkernel': try: discoverer = process_discoverer.getDiscovererByShell(shell, platformTrait) processes = discoverer.discoverAllProcesses() if not processes: raise ValueError() except: errorMessage = 'Failed to discover processes by shell' TTY_HR_Main.logWarn(Framework, errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['processes', clientType], errorMessage) if processes: # save processes to DB #process_discoverer.saveProcessesToProbeDb(processes, hostId, Framework) # discover packages info try: packagesDiscoverer = process_discoverer.getPackagesDiscovererByShell(shell, platformTrait) packageToExecutablePath = packagesDiscoverer.getPackagesByProcesses(processes) except: logger.warn("Failed to get package names by processes path") # report processes #if discoverProcesses: connectivityEndPoints = [] connections = [] runningApplications = [] errorsList = [] #No tcp and p2p discovery for vmkernel if not uname == 'VMkernel': try: tcpDiscoverer = asm_Disc_TCP.getDiscovererByShell(client, Framework, shell) if tcpDiscoverer is not None: tcpDiscoverer.pdu = asm_Disc_TCP.TcpStateHolder(None) tcpDiscoverer.discoverTCP() connections = tcpDiscoverer.pdu.tcp_connections connectivityEndPoints = tcpDiscoverer.getProcessEndPoints() except: errorMessage = 'Failed to run tcp discovery by shell' TTY_HR_Main.logWarn(Framework, errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, ['tcp', clientType], errorMessage) #if workInTopDown: linkOshv = ObjectStateHolderVector() processReporter = process.Reporter() processBuilder = process.ProcessBuilder() for connectivityEndPoint in connectivityEndPoints: processid = connectivityEndPoint.getKey() endpoints = connectivityEndPoint.getEndpoints() #logger.debug('#processid=', processid) #logger.debug('#endpoints=', endpoints) for processObject in processes: #logger.debug('#processObject.getPid()=', processObject.getPid()) #logger.debug('#processObject.getName()=', processObject.getName()) if 4 < processid == processObject.getPid() and processObject.getName() != 'svchost.exe': processOSH, _ = processReporter.report(hostOsh, processObject, processBuilder) for endpoint in endpoints: if str(portToDiscover) == str(endpoint.getPort()): portInNetstat = True processMapOnPort[processid] = processObject builder = netutils.ServiceEndpointBuilder() reporter = netutils.EndpointReporter(builder) ipServerOSH = reporter.reportEndpoint(endpoint, hostOsh) linkOsh = modeling.createLinkOSH('usage', processOSH, ipServerOSH) linkOshv.add(linkOsh) break if not portInNetstat: errorMessage = errormessages.makeErrorMessage(clientType, message=portToDiscover, pattern=errormessages.ERROR_FINDING_PROCESS_BY_PORT) logger.debugException("port cannot be found:", portToDiscover) errobj = errorobject.createError(errorcodes.FAILED_FINDING_PROCESS_BY_PORT, [portToDiscover], errorMessage) errorsList.append(errobj) OSHVResult.addAll(linkOshv) framework_delegator = Framework_delegator.FrameworkDelegator() appSign = asm_applications.createASMApplicationSignature(Framework, framework_delegator, client, shell) if processes: appSign.setProcessesManager(applications.ProcessesManager(processes, connectivityEndPoints)) servicesByCmd = Hashtable() servicesInfo = applications.ServicesInfo(servicesByCmd) appSign.setServicesInfo(servicesInfo) cmdLineToInstalledSoftware = {} softNameToInstSoftOSH = {} softwareInfo = applications.InstalledSoftwareInfo(cmdLineToInstalledSoftware, softNameToInstSoftOSH) appSign.setInstalledSoftwareInfo(softwareInfo) runningApplications = appSign.getApplicationsTopologyUsingHostOsh(hostOsh) logger.debug('runningApplications=%s' % runningApplications) logger.debug('adding netstat port results') for application in runningApplications: pids = [str(x.getPid()) for x in application.getProcesses() if x] logger.debug('pids for application:%s %s' % (application.getName(), pids)) if pids in processMapOnPort.keys(): signatureFound = True for connectivityEndPoint in connectivityEndPoints: processid = connectivityEndPoint.getKey() endpoints = connectivityEndPoint.getEndpoints() if str(processid) in pids: for endpoint in endpoints: logger.debug('adding port:', endpoint.getPort()) framework_delegator.addNetstatPortResult(application.getName(), endpoint.getPort()) if (not signatureFound) and processMapOnPort.values(): errorMessage = errormessages.makeErrorMessage( clientType, message="%s listening on port %s" % (processMapOnPort.values(), portToDiscover), pattern=errormessages.ERROR_FINDING_APPSIG_BY_PROCESS) logger.debugException("no listening port found for process %s and port %s" % (processMapOnPort.values(), portToDiscover)) errobj = errorobject.createError(errorcodes.FAILED_FINDING_APPSIG_BY_PROCESS, [repr(processMapOnPort.values()), portToDiscover], errorMessage) errorsList.append(errobj) filteredRunningApplications = [] if filterRunningSoftwareByPort and filterRunningSoftwareByPort == 'true': logger.debug('try to filter running applications using port:', portToDiscover) logger.debug('application list using port filter', framework_delegator.getApplicationNamesByPort(portToDiscover)) for runningApplication in runningApplications: if runningApplication.getName() in framework_delegator.getApplicationNamesByPort(portToDiscover): logger.debug("adding application: ", runningApplication.getName()) filteredRunningApplications.append(runningApplication) elif runningApplication.getName() in CLUSTERLIST: logger.debug("include cluster related ci: ", runningApplication.getName()) filteredRunningApplications.append(runningApplication) OSHVResult.addAll( framework_delegator.getResultVectorByApplicationName(runningApplication.getName())) else: logger.debug("remove application: ", runningApplication.getName()) logger.debug('filteredRunningApplications=%s' % filteredRunningApplications) if not filteredRunningApplications: logger.debug("running software for port was not found:", portToDiscover) for resultVector in framework_delegator.getResultVectorsByPort(portToDiscover): OSHVResult.addAll(resultVector) #create ownership between runningsoftware and scp logger.debug("create ownership between runningsoftware and scp") for runningApplication in filteredRunningApplications: logger.debug("APP:", runningApplication.getName()) OSHVResult.addAll(scp.createOwnerShip(scp_id, runningApplication.getOsh())) else: logger.debug('filterRunningSoftwareByPort is %s, will report all running software discovered') for runningApplication in runningApplications: filteredRunningApplications.append(runningApplication) OSHVResult.addAll(framework_delegator.getResultVectorByApplicationName(runningApplication.getName())) OSHVResult.addAll(scp.createOwnerShip(scp_id, runningApplication.getOsh())) logger.debug("crgMap = ", appSign.crgMap) vector = ObjectStateHolderVector() vector.addAll(OSHVResult) if appSign.crgMap: for osh in vector: oshClass = osh.getObjectClass() #weak node if oshClass == 'node' and osh.getAttributeValue('host_iscomplete') == 0 and osh.getAttributeValue( 'host_key'): ip = osh.getAttributeValue('host_key').split(' ')[0] if ip in appSign.crgMap.keys(): logger.debug("replace weak node:", osh.getAttribute("host_key")) OSHVResult.remove(osh) OSHVResult.add(appSign.crgMap[ip]) #root container elif osh.getAttribute('root_container'): obj = osh.getAttribute("root_container").getObjectValue() if obj.getObjectClass() == 'node' and obj.getAttributeValue( 'host_iscomplete') == 0 and obj.getAttributeValue('host_key'): logger.debug("replace root_container:", osh) ip = obj.getAttributeValue('host_key').split(' ')[0] if ip in appSign.crgMap.keys(): logger.debug("replace root_container:", obj.getAttribute("host_key")) osh.setContainer(appSign.crgMap[ip]) return filteredRunningApplications, processes, connectivityEndPoints, connections, errorsList
# 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: trace = logger.prepareJythonStackTrace('') errormessages.resolveAndAddToObjectsCollections(trace, protocolName, warningsList, errorsList) if client != None: client.close() if (_vector.size() <= 0): Framework.clearState() if (len(warningsList) == 0) and (len(errorsList) == 0): msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_GENERIC) logger.debug(msg) errobj = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL, [protocolName], msg) errorsList.append(errobj) return (_vector, warningsList, errorsList)
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 DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ms_domain_name = Framework.getDestinationAttribute('ms_domain_name') if not ms_domain_name: ms_domain_name = 'NULL' try: netUtil = MsNetworkUtil() hostsOutput = netUtil.doNetServerEnum('NULL',SV_TYPE_SERVER, ms_domain_name) if hostsOutput != None: discoverUnknownIPs = 1 try: strDiscoverUnknownIPs = Framework.getParameter('discoverUnknownIPs'); discoverUnknownIPs = Boolean.parseBoolean(strDiscoverUnknownIPs); except: pass oshMsDomain = ObjectStateHolder('msdomain') oshMsDomain.setStringAttribute('data_name', ms_domain_name) alreadyDiscoveredIps = HashMap() for hostInfo in hostsOutput: hostType = Long(hostInfo[1]).longValue() hostName = (str(hostInfo[0])).lower() try: ip = InetAddress.getByName(hostInfo[0]).getHostAddress() if netutils.isLocalIp(ip): continue cachedHostName = alreadyDiscoveredIps.get(ip) if cachedHostName != None: logger.debug('IP ', ip, ' already reported for host ' + cachedHostName, ' current host ', hostName, ' - skipping') continue else: logger.debug('Discovered IP ' + ip + ' for host ' + hostName) alreadyDiscoveredIps.put(ip, hostName) ipDomain = DomainScopeManager.getDomainByIp(ip) if not discoverUnknownIPs and ipDomain == 'unknown': logger.debug('ip: ' + ip + ' is out of probe range and will be excluded') continue if SV_TYPE_CLUSTER_NT & hostType: logger.debug('Not reporting the entry %s because it is a Cluster' % hostName) continue hostOsType = 'nt' if SV_TYPE_SERVER_UNIX & hostType: hostOsType = 'unix' oshHost = modeling.createHostOSH(ip, hostOsType) oshHost.setStringAttribute("host_hostname", hostName) OSHVResult.add(oshHost) link = modeling.createLinkOSH('member', oshMsDomain, oshHost) OSHVResult.add(link) ipOSH = modeling.createIpOSH(ip) OSHVResult.add(ipOSH) contained = modeling.createLinkOSH('contained', oshHost, ipOSH) OSHVResult.add(contained) except: errorMsg = str(sys.exc_info()[1]).strip() logger.warn('Failed to resolve host ', hostInfo[0], ' : ', errorMsg) else: message = 'Failed to discover hosts on MS Domain' logger.warn(message) logger.reportWarning(message) except: errorMsg = str(sys.exc_info()[1]).strip() logger.errorException('Failed to discovery MS Domains') errorMessage = errormessages.makeErrorMessage("msdomain", errorMsg, errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS) errobj = errorobject.createError(errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST, ["msdomain", errorMsg], errorMessage) logger.reportErrorObject(errobj) return OSHVResult
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ms_domain_name = Framework.getDestinationAttribute('ms_domain_name') if not ms_domain_name: ms_domain_name = 'NULL' try: netUtil = MsNetworkUtil() hostsOutput = netUtil.doNetServerEnum('NULL', SV_TYPE_SERVER, ms_domain_name) if hostsOutput != None: discoverUnknownIPs = 1 try: strDiscoverUnknownIPs = Framework.getParameter( 'discoverUnknownIPs') discoverUnknownIPs = Boolean.parseBoolean( strDiscoverUnknownIPs) except: pass oshMsDomain = ObjectStateHolder('msdomain') oshMsDomain.setStringAttribute('data_name', ms_domain_name) alreadyDiscoveredIps = HashMap() for hostInfo in hostsOutput: hostType = Long(hostInfo[1]).longValue() hostName = (str(hostInfo[0])).lower() try: ip = InetAddress.getByName(hostInfo[0]).getHostAddress() if netutils.isLocalIp(ip): continue cachedHostName = alreadyDiscoveredIps.get(ip) if cachedHostName != None: logger.debug( 'IP ', ip, ' already reported for host ' + cachedHostName, ' current host ', hostName, ' - skipping') continue else: logger.debug('Discovered IP ' + ip + ' for host ' + hostName) alreadyDiscoveredIps.put(ip, hostName) ipDomain = DomainScopeManager.getDomainByIp(ip) if not discoverUnknownIPs and ipDomain == 'unknown': logger.debug( 'ip: ' + ip + ' is out of probe range and will be excluded') continue if SV_TYPE_CLUSTER_NT & hostType: logger.debug( 'Not reporting the entry %s because it is a Cluster' % hostName) continue hostOsType = 'nt' if SV_TYPE_SERVER_UNIX & hostType: hostOsType = 'unix' oshHost = modeling.createHostOSH(ip, hostOsType) oshHost.setStringAttribute("host_hostname", hostName) OSHVResult.add(oshHost) link = modeling.createLinkOSH('member', oshMsDomain, oshHost) OSHVResult.add(link) ipOSH = modeling.createIpOSH(ip) OSHVResult.add(ipOSH) contained = modeling.createLinkOSH('contained', oshHost, ipOSH) OSHVResult.add(contained) except: errorMsg = str(sys.exc_info()[1]).strip() logger.warn('Failed to resolve host ', hostInfo[0], ' : ', errorMsg) else: message = 'Failed to discover hosts on MS Domain' logger.warn(message) logger.reportWarning(message) except: errorMsg = str(sys.exc_info()[1]).strip() logger.errorException('Failed to discovery MS Domains') errorMessage = errormessages.makeErrorMessage( "msdomain", errorMsg, errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS) errobj = errorobject.createError( errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST, ["msdomain", errorMsg], errorMessage) logger.reportErrorObject(errobj) return OSHVResult
errormessages.resolveAndAddToObjectsCollections( trace, protocolName, warningsList, errorsList) if testedNamespace is not None: hostOsh = modeling.createHostOSH(ip_address) smisOsh = cim.createCimOsh(ip_address, hostOsh, credential, smis.CimCategory.SMIS) smisOsh.setStringAttribute('application_category', 'Storage') vector.add(hostOsh) vector.add(smisOsh) warningsList = [] errorsList = [] break if vector.size() <= 0: Framework.clearState() if (len(warningsList) == 0) and (len(errorsList) == 0): msg = errormessages.makeErrorMessage( protocolName, pattern=errormessages.ERROR_GENERIC) logger.debug(msg) errobj = errorobject.createError( errorcodes.INTERNAL_ERROR_WITH_PROTOCOL, [protocolName], msg) errorsList.append(errobj) if errorsList: for errorObj in errorsList: logger.reportErrorObject(errorObj) if warningsList: for warnObj in warningsList: logger.reportErrorObject(warnObj) return vector
def DiscoveryMain(Framework): # import must be placed here as they are conflicts with import list in checkcred.py import jee import jmx import jee_connection import jee_discoverer import weblogic import weblogic_discoverer import protocol ports = jee_connection.getDestinationPorts(Framework) ip, domain = jee_connection.getIpAndDomain(Framework) ip = jee.IpDescriptor(ip) resultVector = ObjectStateHolderVector() protocolName = ClientsConsts.WEBLOGIC_PROTOCOL_NAME # FIND AVAILABLE PROTOCOLS protocols = jee_connection.getAvailableProtocols(Framework, protocolName, ip.value()) if not protocols: msg = errormessages.makeErrorMessage( protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) logger.reportErrorObject(errobj) else: # PREPARE CONNECTION MECHANISM platform = jee.Platform.WEBLOGIC spec = jee_connection.SpecificationByPorts(platform, ports) configManager = jee_connection.SucceededPortsConfigManager() factory = jee_connection.Factory(protocols, spec) connectionFailedMsgs = [] discoveryFailedMsgs = [] # ITERATOR OVER AVAILABLE CONNECTION CONFIGURATIONS AND MAKE ATTEMP TO ESTABLISH CONNECTION # TO THE PORT THAT HAVE NOT BEEN DISCOVERED PREVIOUSLY while factory.hasNextConnectionConfig(): try: config = factory.next() if configManager.isSimilarConfigSucceeded(config): continue client = factory.createClient(Framework, config) except (Exception, JException), exc: logger.warnException( "Failed to establish connection using %s" % config) connectionFailedMsgs.append(str(exc)) else: try: try: # CONNECTION ESTABLISHED - DISCOVER dnsResolver = jee_discoverer.DnsResolverDecorator( netutils.JavaDnsResolver(), client.getIpAddress()) credentialsfulServerRole = weblogic.HasCredentialInfoRole( client.getUserName(), client.getCredentialId(), protocolType=protocol.getAttribute( config.protocolObj, AgentConstants.PROP_WEBLOGIC_PROTOCOL), trustFileName=config.getProperty( AgentConstants.PROP_WEBLOGIC_TRUST_FILE_NAME), keyPemPath=config.getProperty( AgentConstants.PROP_WEBLOGIC_KEY_PEM_PATH), certPemPath=config.getProperty( AgentConstants.PROP_WEBLOGIC_CERT_PEM_PATH)) # set port used for this connection credentialsfulServerRole.connectionPort.set( client.getPort()) # prepare builders and reporters reporter = jee.ServerTopologyReporter( weblogic.ServerTopologyBuilder()) # maker domain topology discovery discoverer = weblogic_discoverer.ServerDiscovererByJmx( jmx.Provider(client)) domain = discoverer.discoverRunningServersInDomain() resultVector.addAll( jee_discoverer.discoverDomainTopology( config.portNumber.value(), client.getIpAddress(), domain, dnsResolver, credentialsfulServerRole, weblogic.ServerRole, reporter)) configManager.processAsSuccessful(config) except (Exception, JException), exc: logger.warnException("Failed to make a discovery") discoveryFailedMsgs.append(str(exc)) finally: if client is not None: client.close() else:
destinations = [] if emsQueues or emsTopics: emsQueues and destinations.extend(emsQueues) emsTopics and destinations.extend(emsTopics) emsDataItem = tibco_discoverer.EmsTopology(emsServer, jmsServer, destinations) emsTopology.append(emsDataItem) except tibco_discoverer.TibcoDiscovererException, ex: reportError(str(ex), tibco.TIBCO_PROTOCOL, Framework) except Exception, ex: reportError(str(ex), protocol, Framework) except JException, ex: msg = ex.getMessage() logger.debugException(msg) errormessages.resolveAndReport(msg, protocol, Framework) else: msg = errormessages.makeErrorMessage(tibco.TIBCO_PROTOCOL, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [ tibco.TIBCO_PROTOCOL ], msg) logger.reportErrorObject(errobj) except: exInfo = logger.prepareJythonStackTrace('Error connecting: ') errormessages.resolveAndReport(exInfo, protocol, Framework) logger.debug("--- Start reporting ---") reporter = tibco.TopologyReporter(tibco.TopologyBuilder()) endpointReporter = netutils.EndpointReporter(netutils.ServiceEndpointBuilder()) for emsTopologyItem in emsTopology: emsOsh = reporter.reportEMSServer(emsTopologyItem.getEmsServer(), hostOsh) OshvResult.add(emsOsh) jmsServer = emsTopologyItem.getJmsServer()
def DiscoveryMain(Framework): urlString = Framework.getDestinationAttribute(PARAM_SERVER_URL) credentialsId = Framework.getDestinationAttribute(PARAM_CREDENTIALS_ID) connectionRetryNumber = Framework.getParameter( PARAM_CONNECTION_RETRY_NUMBER) continuousMonitoring = Framework.getParameter( PARAM_EVENT_BASED_DISCOVERY_ENABLED) historyHours = Framework.getParameter(PARAM_HYSTORY_HOURS) isJobMonitoringSupported = _vmware_vim_base.isJobStateMonitoringSupported( Framework) if not isJobMonitoringSupported: Framework.reportWarning( 'You are running job on UCMDB 8.03 or earlier, it cannot be gracefully stopped, only by restarting the probe.' ) try: client = None try: clientFactory = vmware_vim.ClientFactory(Framework, urlString, credentialsId) client = clientFactory.createClient() if client: agent = client.getAgent() apiVersion = vmware_vim.getApiVersion(agent) logger.debug("Target API version: %s" % apiVersion) logger.debug("Client type: %s" % agent.getClientType()) crossClientHelper = vmware_vim.getCrossClientHelper(agent) module = vmware_vim.getVmwareModuleByApiVersion(apiVersion) monitor = module.getEventMonitor(agent, crossClientHelper, Framework) monitor.setContinuousMonitoring(continuousMonitoring) monitor.setHistoryHours(historyHours) monitor.setRetryNumber(connectionRetryNumber) #monitor.setPageSize(5) #monitor.setFilterRecreationIntervalMinutes(5) vmMigratedEventListener = module.getVmMigratedEventListener( agent, crossClientHelper) vmMigratedEventReporter = module.getVmMigratedEventReporter( crossClientHelper, Framework) vmMigratedEventListener._addReporter(vmMigratedEventReporter) monitor.addListener(vmMigratedEventListener) vmPoweredOnEventListener = module.getVmPoweredOnEventListener( agent, crossClientHelper) vmPoweredOnEventReporter = module.getVmPoweredOnEventReporter( crossClientHelper, Framework) vmPoweredOnEventListener._addReporter(vmPoweredOnEventReporter) monitor.addListener(vmPoweredOnEventListener) if isJobMonitoringSupported: jobMonitoringTask = _vmware_vim_base.JobStateCheckTask( monitor, Framework) jobMonitoringThread = Thread(jobMonitoringTask) jobMonitoringThread.start() monitor.start() finally: client and client.close() except AxisFault, axisFault: faultType = _vmware_vim_base.getFaultType(axisFault) if faultType == 'InvalidLogin': msg = errormessages.makeErrorMessage( _vmware_vim_base.VimProtocol.DISPLAY, None, errormessages.ERROR_INVALID_USERNAME_PASSWORD) logger.debug(msg) Framework.reportError(msg) elif faultType == 'NoPermission': priviledgeId = axisFault.getPrivilegeId() msg = "User does not have required '%s' permission" % priviledgeId logger.debug(msg) errormessages.resolveAndReport( msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework) else: msg = axisFault.dumpToString() logger.debug(msg) errormessages.resolveAndReport( msg, _vmware_vim_base.VimProtocol.DISPLAY, Framework)
def DiscoveryMain(Framework): # import must be placed here as they are conflicts with import list in checkcred.py import jee import jmx import jee_connection import jee_discoverer import weblogic import weblogic_discoverer import protocol ports = jee_connection.getDestinationPorts(Framework) ip, domain = jee_connection.getIpAndDomain(Framework) ip = jee.IpDescriptor(ip) resultVector = ObjectStateHolderVector() protocolName = ClientsConsts.WEBLOGIC_PROTOCOL_NAME # FIND AVAILABLE PROTOCOLS protocols = jee_connection.getAvailableProtocols(Framework, protocolName, ip.value()) if not protocols: msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) logger.reportErrorObject(errobj) else: # PREPARE CONNECTION MECHANISM platform = jee.Platform.WEBLOGIC spec = jee_connection.SpecificationByPorts(platform, ports) configManager = jee_connection.SucceededPortsConfigManager() factory = jee_connection.Factory(protocols, spec) connectionFailedMsgs = [] discoveryFailedMsgs = [] # ITERATOR OVER AVAILABLE CONNECTION CONFIGURATIONS AND MAKE ATTEMP TO ESTABLISH CONNECTION # TO THE PORT THAT HAVE NOT BEEN DISCOVERED PREVIOUSLY while factory.hasNextConnectionConfig(): try: config = factory.next() if configManager.isSimilarConfigSucceeded(config): continue client = factory.createClient(Framework, config) except (Exception, JException), exc: logger.warnException("Failed to establish connection using %s" % config) connectionFailedMsgs.append(str(exc)) else: try: try: # CONNECTION ESTABLISHED - DISCOVER dnsResolver = jee_discoverer.DnsResolverDecorator( netutils.JavaDnsResolver(), client.getIpAddress() ) credentialsfulServerRole = weblogic.HasCredentialInfoRole( client.getUserName(), client.getCredentialId(), protocolType=protocol.getAttribute( config.protocolObj, AgentConstants.PROP_WEBLOGIC_PROTOCOL ), trustFileName=config.getProperty(AgentConstants.PROP_WEBLOGIC_TRUST_FILE_NAME), keyPemPath=config.getProperty(AgentConstants.PROP_WEBLOGIC_KEY_PEM_PATH), certPemPath=config.getProperty(AgentConstants.PROP_WEBLOGIC_CERT_PEM_PATH), ) # set port used for this connection credentialsfulServerRole.connectionPort.set(client.getPort()) # prepare builders and reporters reporter = jee.ServerTopologyReporter(weblogic.ServerTopologyBuilder()) # maker domain topology discovery discoverer = weblogic_discoverer.ServerDiscovererByJmx(jmx.Provider(client)) domain = discoverer.discoverRunningServersInDomain() resultVector.addAll( jee_discoverer.discoverDomainTopology( config.portNumber.value(), client.getIpAddress(), domain, dnsResolver, credentialsfulServerRole, weblogic.ServerRole, reporter, ) ) configManager.processAsSuccessful(config) except (Exception, JException), exc: logger.warnException("Failed to make a discovery") discoveryFailedMsgs.append(str(exc)) finally: if client is not None: client.close() else:
def _create_missed_creds_error(proto_name): msg = errormessages.makeErrorMessage( proto_name, pattern=errormessages.ERROR_NO_CREDENTIALS) return errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, (proto_name, ), msg)
Framework, connectionHandler) except (cim_discover.MissingConfigFileException, vmware_cim_discover.RuntimeException), ex: msg = str(ex) errorObject = errorobject.createError( errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg) logger.reportErrorObject(errorObject) logger.error(msg) return resultVector connectionDiscoverer.addIp(ipAddress) connectionDiscoverer.initConnectionConfigurations() try: connectionDiscoverer.discover() except vmware_cim_discover.NoConnectionConfigurationsException: msg = errormessages.makeErrorMessage( cim.Protocol.DISPLAY, pattern=errormessages.ERROR_NO_CREDENTIALS) errorObject = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [cim.Protocol.DISPLAY], msg) logger.reportErrorObject(errorObject) else: if not connectionHandler.connected: connectionHandler.reportConnectionErrors() return resultVector
framework.sendObjects(vector) # At this point we have one successful discovery oneDiscoveryHappened = 1 except (JException, Exception), e: logger.debugException(str(e)) warning = errorobject.createError( errorcodes.INTERNAL_ERROR, None, "%s failed" % discovery.description) discoveryWarnings.append(warning) # === Error cases handling === # Discovery finished and we have to show reasons in the UI: # # * No credentials found for _aws_ protocol if not credentials: msg = errormessages.makeErrorMessage( protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) logger.reportErrorObject(errobj) # * Among enabled flows no successful discovery elif not oneDiscoveryHappened: errobj = errorobject.createError(errorcodes.FAILED_RUNNING_DISCOVERY, ['Amazon Cloud'], 'Failed to make discovery') logger.reportErrorObject(errobj) # * Other, like connection troubles or failed discovery map(logger.reportErrorObject, discoveryErrors) map(logger.reportWarningObject, discoveryWarnings) return ObjectStateHolderVector()
def DiscoveryMain(Framework): # import must be placed here as they are conflicts with import list in checkcred.py import jee import jmx import entity import jee_connection import jee_discoverer import websphere import websphere_discoverer ports = jee_connection.getDestinationPorts(Framework) ip = jee.IpDescriptor(Framework.getDestinationAttribute('ip_address')) platform = jee.Platform.WEBSPHERE # ESTABLISH CONNECTION # find all available protocols for the WebSphere protocolName = ClientsConsts.WEBSPHERE_PROTOCOL_NAME protocols = jee_connection.getAvailableProtocols(Framework, protocolName, ip.value()) resultVector = ObjectStateHolderVector() if not protocols: msg = errormessages.makeErrorMessage( protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg) logger.reportErrorObject(errobj) else: # iterate over configurations defined for each protocol and try to establish connection dnsResolver = jee_discoverer.DnsResolverDecorator( netutils.JavaDnsResolver(), ip.value()) spec = jee_connection.SpecificationByPorts(platform, ports) spec.addProperty( 'server_was_config', 'services:connectors:SOAP_CONNECTOR_ADDRESS:host,services:connectors:SOAP_CONNECTOR_ADDRESS:port,clusterName' ) spec.addProperty('datasource_was_config', 'jndiName,URL,propertySet,connectionPool') factory = jee_connection.Factory(protocols, spec) connectionFailedMsgs = [] discoveryFailedMsgs = [] while factory.hasNextConnectionConfig(): try: config = factory.next() client = factory.createClient(Framework, config) provider = jmx.Provider(client) hostOsh = modeling.createHostOSH(ip.value()) except JException, je: logger.warnException( "Failed to establish connection using %s" % config) connectionFailedMsgs.append(je.getMessage()) else: # connection established try: try: credentialsfulServerRole = websphere.HasCredentialInfoRole( client.getUserName(), credentialsId=client.getCredentialId(), keystoreFilePath=config.protocolObj. getProtocolAttribute( CollectorsConstants. WEBSPHERE_PROTOCOL_ATTRIBUTE_KEYSTORE), trustStoreFilePath=config.protocolObj. getProtocolAttribute( CollectorsConstants. WEBSPHERE_PROTOCOL_ATTRIBUTE_TRUSTSTORE)) # create builder and reporter for server topology reporter = jee.ServerTopologyReporter( websphere.ServerTopologyBuilder()) # make discovery itself discoverer = websphere_discoverer.ServerDiscovererByJmx( jmx.Provider(client)) domain = discoverer.discoverServersInDomain() resultVector.addAll( jee_discoverer.discoverDomainTopology( config.portNumber.value(), client.getIpAddress(), domain, dnsResolver, credentialsfulServerRole, websphere.ServerRole, reporter, setDomainIp=0)) #trying to find config file serverindex to report ports for node in domain.getNodes(): for server in node.getServers(): logger.debug( "trying to find config file serverindex for server: ", server) filePath = 'cells\\' + domain.getName( ) + '\\nodes\\' + server.nodeName + "\\" + 'serverindex.xml' logger.debug('file path:', filePath) try: fileContent = websphere_discoverer.getFileContent( provider, filePath) logger.debug('fileContent: ', fileContent) matches = re.findall( 'port\s*=\s*\"(\d+)\"', fileContent) if matches: for match in matches: print("Found port:%s" % match) resultVector.addAll( reportServiceEndpoints( ip.value(), match, hostOsh, server)) except: logger.debug('Document not found: ', filePath) # sentObjectsCount += vector.size() # _sendVectorImmediately(Framework, vector) except (Exception, JException), exc: logger.warnException("Failed to discover") discoveryFailedMsgs.append(str(exc)) finally: if client is not None: client.close() else: