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