def _getCandidateCredentials(Framework, remoteUDAUserName, ip): candidates = [] connectedUserName = str(remoteUDAUserName) if connectedUserName == 'root': logger.debug('Connected credential id is irrelevant for this host - connected to root user, no need for sudo') else: allCredIds = [] # Getting all ssh and telnet credentials defined for the ip allCredIds.extend(netutils.getAvailableProtocols(Framework, ClientsConsts.SSH_PROTOCOL_NAME, ip)) allCredIds.extend(netutils.getAvailableProtocols(Framework, ClientsConsts.TELNET_PROTOCOL_NAME, ip)) for credentialId in allCredIds: credential = ProtocolManager.getProtocolById(credentialId) # Get connected protocol details userName = credential.getProtocolAttribute(Protocol.PROTOCOL_ATTRIBUTE_USERNAME, '') sudoCommands = credential.getProtocolAttribute(Protocol.SSH_PROTOCOL_ATTRIBUTE_SUDO_COMMANDS, '') or \ credential.getProtocolAttribute(Protocol.TELNET_PROTOCOL_ATTRIBUTE_SUDO_COMMANDS, '') # Filter out those that don't have sudo defined or do not share same username if connectedUserName == userName and sudoCommands and len(sudoCommands) > 0: candidates.append(credentialId) return candidates
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 detectUDAAvailable(Framework, ip, credentialId=None): logger.debug("Start to detect UDA availability") if credentialId: credentialIds = [credentialId] else: import netutils credentialIds = netutils.getAvailableProtocols( Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, ip) props = Properties() props.setProperty('permitDDMi', 'true') props.setProperty(CollectorsConstants.DESTINATION_DATA_IP_ADDRESS, ip) for credentialId in credentialIds: props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, credentialId) try: logger.debug("Start to connect UDA") client = Framework.createClient(props) if client: return client except: pass return None
def getClient(Framework): macOnAgent = Framework.getTriggerCIDataAsList('mac_on_agent') or [] applicationIp = Framework.getTriggerCIDataAsList("application_ip") or [] ipAddressList = Framework.getTriggerCIDataAsList('ip_address') or [] arpMacList = Framework.getTriggerCIDataAsList('mac_on_ip') or [] credentialId = Framework.getTriggerCIData("credentials_id") possibleProtocol = ClientsConsts.SNMP_PROTOCOL_NAME candidateIPs = clientdiscoveryutils.getIPAddressListByApplicationMac(macOnAgent, applicationIp, arpMacList, ipAddressList) logger.debug("Try one by one on candidate ips:", candidateIPs) try: Framework.saveState(credentialId) #save the preferred credential id to framework. for candidateIP in candidateIPs: if candidateIP == 'NA': continue possibleCredentials = netutils.getAvailableProtocols(Framework, possibleProtocol, candidateIP, None) or [] protocolList = [] if possibleCredentials: for i in range(len(possibleCredentials)): protocolList.append(possibleProtocol) [newIPList, newProtocolList, newCredentialsIdList, newCodepageList] = clientdiscoveryutils.buildConnectionList([candidateIP], protocolList, possibleCredentials) for cre in newCredentialsIdList: client = _createSnmpClient(Framework, candidateIP, cre) if client: return client finally: Framework.clearState() #clear the preferred credential id from framework return None
def StepMain(Framework): # if we have shell credentials and we are able to connect with them then connect otherwise we should connect with agent ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') codepage = Framework.getCodePage() allShellProtocols = [] allShellCredentials = [] allShellIps = [] allShellCodePages = [] protocols = netutils.getAvailableProtocols(Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, ip, domain) for protocol in protocols: allShellProtocols.append(ClientsConsts.DDM_AGENT_PROTOCOL_NAME) allShellCredentials.append(protocol) allShellIps.append(ip) allShellCodePages.append(codepage) logger.debug('Will going to attempt to connect in this order: ', allShellCredentials) Framework.setProperty(InventoryUtils.STATE_PROPERTY_CONNECTION_PROTOCOLS, allShellProtocols) Framework.setProperty(InventoryUtils.STATE_PROPERTY_CONNECTION_CREDENIALS, allShellCredentials) Framework.setProperty(InventoryUtils.STATE_PROPERTY_CONNECTION_IPS, allShellIps) Framework.setProperty(InventoryUtils.STATE_PROPERTY_CONNECTION_CODEPAGES, allShellCodePages) InventoryUtils.executeStep(Framework, connectToRemoteNode, InventoryUtils.STEP_REQUIRES_CONNECTION, InventoryUtils.STEP_DOESNOT_REQUIRES_LOCK)
def DiscoveryMain(Framework): ip = Framework.getTriggerCIData('ip_address') credentialIds = netutils.getAvailableProtocols(Framework, 'ucs', ip) if not credentialIds: logger.warn('No generic credential for UCS') Framework.reportWarning('No generic credential for UCS') return ucs_id = Framework.getTriggerCIData('ucs_id') originFramework = Framework connectionManager = None connectedCredentialId = None for credentialId in credentialIds: logger.debug('Begin trying credential id:', credentialId) params = {'credentialsId': credentialId} tmpFramework = MyFramework(originFramework, parameters=params) manager = FrameworkBasedConnectionDataManager(tmpFramework, ip) try: client = manager.getClient() if client: logger.debug("Connected") connectionManager = manager connectedCredentialId = credentialId break except: logger.debugException('') logger.debug('Can not connection by credential:', credentialId) finally: if connectionManager: connectionManager.closeClient() if connectionManager: logger.debug('Connected by credential Id:', connectedCredentialId) vec = ObjectStateHolderVector() hostOsh = modeling.createHostOSH(ip) appOsh = modeling.createApplicationOSH('running_software', 'UCS', hostOsh, vendor='Cisco') appOsh.setAttribute('application_ip', ip) appOsh.setAttribute('credentials_id', connectedCredentialId) vec.add(hostOsh) vec.add(appOsh) return vec else: if ucs_id: logger.debug('Delete the ucs since it can not be connected:%s' % ucs_id) softwareOsh = modeling.createOshByCmdbId('running_software', ucs_id) Framework.deleteObject(softwareOsh) logger.warn( 'All credentials have been tried. No credential can connect to UCS by ip %s' % ip) Framework.reportWarning( 'All credentials have been tried. No credential can connect to UCS by ip %s' % ip)
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 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 _getCandidateCredentials(Framework, remoteUDAUserName, ip): candidates = [] connectedUserName = str(remoteUDAUserName) if connectedUserName == 'root': logger.debug( 'Connected credential id is irrelevant for this host - connected to root user, no need for sudo' ) else: allCredIds = [] # Getting all ssh and telnet credentials defined for the ip allCredIds.extend( netutils.getAvailableProtocols(Framework, ClientsConsts.SSH_PROTOCOL_NAME, ip)) allCredIds.extend( netutils.getAvailableProtocols(Framework, ClientsConsts.TELNET_PROTOCOL_NAME, ip)) for credentialId in allCredIds: credential = ProtocolManager.getProtocolById(credentialId) # Get connected protocol details userName = credential.getProtocolAttribute( Protocol.PROTOCOL_ATTRIBUTE_USERNAME, '') sudoCommands = credential.getProtocolAttribute(Protocol.SSH_PROTOCOL_ATTRIBUTE_SUDO_COMMANDS, '') or \ credential.getProtocolAttribute(Protocol.TELNET_PROTOCOL_ATTRIBUTE_SUDO_COMMANDS, '') # Filter out those that don't have sudo defined or do not share same username if connectedUserName == userName and sudoCommands and len( sudoCommands) > 0: candidates.append(credentialId) return candidates
def DiscoveryMain(Framework): ip = Framework.getTriggerCIData('ip_address') credentialIds = netutils.getAvailableProtocols(Framework, 'ucs', ip) if not credentialIds: logger.warn('No generic credential for UCS') Framework.reportWarning('No generic credential for UCS') return ucs_id = Framework.getTriggerCIData('ucs_id') originFramework = Framework connectionManager = None connectedCredentialId = None for credentialId in credentialIds: logger.debug('Begin trying credential id:', credentialId) params = {'credentialsId': credentialId} tmpFramework = MyFramework(originFramework, parameters=params) manager = FrameworkBasedConnectionDataManager(tmpFramework, ip) try: client = manager.getClient() if client: logger.debug("Connected") connectionManager = manager connectedCredentialId = credentialId break except: logger.debugException('') logger.debug('Can not connection by credential:', credentialId) finally: if connectionManager: connectionManager.closeClient() if connectionManager: logger.debug('Connected by credential Id:', connectedCredentialId) vec = ObjectStateHolderVector() hostOsh = modeling.createHostOSH(ip) appOsh = modeling.createApplicationOSH('running_software', 'UCS', hostOsh, vendor='Cisco') appOsh.setAttribute('application_ip', ip) appOsh.setAttribute('credentials_id', connectedCredentialId) vec.add(hostOsh) vec.add(appOsh) return vec else: if ucs_id: logger.debug('Delete the ucs since it can not be connected:%s' % ucs_id) softwareOsh = modeling.createOshByCmdbId('running_software', ucs_id) Framework.deleteObject(softwareOsh) logger.warn('All credentials have been tried. No credential can connect to UCS by ip %s' % ip) Framework.reportWarning('All credentials have been tried. No credential can connect to UCS by ip %s' % ip)
def DiscoveryMain(Framework): ip = Framework.getDestinationAttribute('ip_address') domain = Framework.getDestinationAttribute('ip_domain') codepage = Framework.getCodePage() shell = None credentialId = None OSHVResult = None warningsList = [] errorsList = [] protocolType = PowerShell.PROTOCOL_TYPE credentials = [] # use the latest used credentials if any lastConnectedCredential = Framework.loadState() lastConnectedCredential and credentials.append(lastConnectedCredential) # and other defined for triggered IP credentials.extend(netutils.getAvailableProtocols(Framework, protocolType, ip, domain)) if credentials: shell, credentialId = getShellUtils(Framework, protocolType, credentials, ip, codepage, warningsList, errorsList) else: msg = errormessages.makeErrorMessage(protocolType, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolType], msg) errorsList.append(errobj) if shell: # successfully connected, do discovery errorsList = [] warningsList = [] Framework.saveState(credentialId) OSHVResult = doDiscovery(Framework, shell, ip, credentialId, codepage, protocolType, warningsList, errorsList) else: if not len(errorsList): msg = errormessages.makeErrorMessage(protocolType, pattern=errormessages.ERROR_CONNECTION_FAILED) errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolType], msg) errorsList.append(errobj) Framework.clearState() for errobj in warningsList: logger.reportWarningObject(errobj) for errobj in errorsList: logger.reportErrorObject(errobj) return OSHVResult
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip') 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 getUDAAvailablePorts(Framework): ''' Get all available ports of UD protocol :param Framework: :return: array of available ports, if it's not configured, just return [2738, 7738] ''' logger.debug("Start to get all ports of UD protocol") credentialIds = netutils.getAvailableProtocols(Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, None) ports = set([2738, 7738]) for credentialId in credentialIds: protocolPort = Framework.getProtocolProperty(credentialId, CollectorsConstants.PROTOCOL_ATTRIBUTE_PORT, 'NA') if protocolPort is not None: ports.add( int(protocolPort) ) logger.debug("All ports of UD protocol: ", ports) return ports
def DiscoveryMain(Framework): credentialIds = netutils.getAvailableProtocols(Framework, 'ucs', None) if not credentialIds: logger.warn('No generic credential for UCS') Framework.reportWarning('No generic credential for UCS') return ucsURLList = getUCSURLs() if not ucsURLList: logger.error('UCS URL list file not found or Empty') Framework.reportError('UCS URL list file not found or Empty') else: for url in ucsURLList: logger.info('==========Begin working on:', url) resultVec = discoverySingleUCS(Framework, url, credentialIds) if resultVec: Framework.sendObjects(resultVec) Framework.flushObjects()
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 getUDAAvailablePorts(Framework): ''' Get all available ports of UD protocol :param Framework: :return: array of available ports, if it's not configured, just return [2738, 7738] ''' logger.debug("Start to get all ports of UD protocol") credentialIds = netutils.getAvailableProtocols( Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, None) ports = set([2738, 7738]) for credentialId in credentialIds: protocolPort = Framework.getProtocolProperty( credentialId, CollectorsConstants.PROTOCOL_ATTRIBUTE_PORT, 'NA') if protocolPort is not None: ports.add(int(protocolPort)) logger.debug("All ports of UD protocol: ", ports) return ports
def doConnection(Framework, ip, OSHVResult): SHELL_CLIENT_PROTOCOLS = _getSupportedShellProtocols(Framework) #powershell support POWERSHELL_PROTOCOL = shellutils.PowerShell.PROTOCOL_TYPE SHELL_CLIENT_PROTOCOLS.append(POWERSHELL_PROTOCOL) #todo:add other protocol if needed(wmi, etc.) codepage = Framework.getCodePage() warningsList = [] errorsList = [] credentialsByType = {} hostOsh = None # 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) if protocols: credentialsByType[clientType] = protocols client = None shell = None udaNotAlive = 0 credentialId = Framework.getDestinationAttribute('credentialsId') if credentialId: try: client = Framework.createClient() except (Exception, JException), jex: msg = str(jex) logger.debugException(msg) logger.debug( 'Fail to create client by existed credential id, try all credentials again' )
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 doConnection(Framework, ip, OSHVResult): SHELL_CLIENT_PROTOCOLS = _getSupportedShellProtocols(Framework) #powershell support POWERSHELL_PROTOCOL = shellutils.PowerShell.PROTOCOL_TYPE SHELL_CLIENT_PROTOCOLS.append(POWERSHELL_PROTOCOL) #todo:add other protocol if needed(wmi, etc.) codepage = Framework.getCodePage() warningsList = [] errorsList = [] credentialsByType = {} hostOsh = None # 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) if protocols: credentialsByType[clientType] = protocols client = None shell = None udaNotAlive = 0 credentialId = Framework.getDestinationAttribute('credentialsId') if credentialId: try: client = Framework.createClient() except (Exception, JException), jex: msg = str(jex) logger.debugException(msg) logger.debug('Fail to create client by existed credential id, try all credentials again')
def detectUDAAvailable(Framework, ip, credentialId=None): logger.debug("Start to detect UDA availability") if credentialId: credentialIds = [credentialId] else: import netutils credentialIds = netutils.getAvailableProtocols(Framework, ClientsConsts.DDM_AGENT_PROTOCOL_NAME, ip) props = Properties() props.setProperty('permitDDMi', 'true') props.setProperty(CollectorsConstants.DESTINATION_DATA_IP_ADDRESS, ip) for credentialId in credentialIds: props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, credentialId) try: logger.debug("Start to connect UDA") client = Framework.createClient(props) if client: return client except: pass return None
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 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): 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): """ @param Framework: @type Framework: com.hp.ucmdb.discovery.probe.services.dynamic.core.DynamicServiceFrameworkImpl @return: """ vector = ObjectStateHolderVector() ip = Framework.getDestinationAttribute('ip_address') credentialId = Framework.getDestinationAttribute('credentialId') final_success = False try: credentials = netutils.getAvailableProtocols(Framework, 'http', ip) logger.debug('All http credentials to try:', credentials) if credentials: # if existing credential id, move it to the first one if credentialId and credentialId in credentials: credentials.remove(credentialId) credentials.insert(0, credentialId) logger.debug('Move existing credential to first one:', credentials) for creId in credentials: session = None try: logger.debug('Try credential:', creId) conn = ConnectionManager(Framework, ip, creId) conn.validate() logger.debug('Try login ...') session = conn.getSession() logger.debug('Login done, begin reporting related CIs') host = Host.getAll(session)[0] hostname = host.getHostName() xen_server_osh = modeling.createHostOSH(ip, 'unix', None, hostname) xen_server_osh.setStringAttribute('host_osinstalltype', 'XenServer') # mark the unix as a XenServer serialNumber = host.getSerialNumber() if serialNumber: xen_server_osh.setStringAttribute('serial_number', serialNumber) virtual_osh = ObjectStateHolder('virtualization_layer') virtual_osh.setStringAttribute('name', 'Citrix Xen Hypervisor') virtual_osh.setStringAttribute('product_name', 'xen_hypervisor') virtual_osh.setStringAttribute('application_ip', ip) virtual_osh.setStringAttribute('credentials_id', conn.credentialsId) virtual_osh.setContainer(xen_server_osh) vector.add(virtual_osh) vector.add(xen_server_osh) final_success = True break except: logger.debugException('') finally: if session: try: conn.closeSession() except: pass else: logger.warn('No http credential found for ip:', ip) except: logger.debugException('') if final_success: logger.debug('Success finally.') else: logger.debug('No Citrix Xen Server detected') Framework.reportWarning('No Citrix Xen Server detected') return vector