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:
