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 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 createIPEndpointOSHV(framework, ipAddress, portNum, portName, hostname = None, protocol = modeling.SERVICEADDRESS_TYPE_TCP):
OSHVResult = ObjectStateHolderVector()
if ip_addr.isValidIpAddress(hostname):
hostname = None
fqdn, aliasList = getHostNames(ipAddress, framework)
hostOSH = modeling.createHostOSH(ipAddress, 'node', None, fqdn)
ipOSH = modeling.createIpOSH(ipAddress, None, fqdn)
link = modeling.createLinkOSH('containment', hostOSH, ipOSH)
OSHVResult.add(hostOSH)
OSHVResult.add(ipOSH)
OSHVResult.add(link)
ipPort = modeling.createServiceAddressOsh(hostOSH, ipAddress, portNum, protocol, portName)
if fqdn:
ipPort.setStringAttribute('ipserver_address', fqdn)
if isValidFQDN(hostname):
ipPort.setStringAttribute('ipserver_address', hostname)
#ipPort.addAttributeToList('itrc_alias', sv)
#ipOSH.addAttributeToList('itrc_alias', sv)
#OSHVResult.add(modeling.createLinkOSH('usage', ipPort, ipOSH))
OSHVResult.add(ipPort)
return hostOSH, ipOSH, OSHVResult
def discoverReplication(self, mysqlOsh):
"""
Tries to find config variables related to mysql replication
@param ObjectStateHolder mysqlOsh mysql osh
@return list list of OSHs
"""
masterHostIp = self.getProperty('master-host')
if not masterHostIp:
return
if not netutils.isValidIp(masterHostIp):
try:
resolver = netutils.DnsResolverByShell(self.shell)
masterHostIp = resolver.resolveIpsByHostname(masterHostIp)[0]
except netutils.ResolveException:
logger.warn('Failed to resolve Master Host into IP')
return
masterPort = self.getProperty('master-port')
mysqlReplicationOsh = ObjectStateHolder('mysql_replication')
mysqlReplicationOsh.setAttribute('data_name', 'MySQL Replication')
mysqlReplicationOsh.setContainer(mysqlOsh)
self.setAttribute(mysqlReplicationOsh, 'master_user', self.REPL_ARGS_MAPPING)
self.setAttribute(mysqlReplicationOsh, 'master_connect_retry', self.REPL_ARGS_MAPPING)
masterHostOsh = modeling.createHostOSH(masterHostIp)
serviceAddressOsh = modeling.createServiceAddressOsh(masterHostOsh, masterHostIp, masterPort, modeling.SERVICEADDRESS_TYPE_TCP)
clientServerLink = modeling.createLinkOSH('client_server', mysqlReplicationOsh, serviceAddressOsh)
clientServerLink.setStringAttribute('clientserver_protocol', 'TCP')
clientServerLink.setLongAttribute('clientserver_destport', int(masterPort))
# masterMysqlOsh = modeling.createDatabaseOSH('mysql', 'MySQL. Port ' + masterPort, masterPort, masterHostIp, masterHostOsh)
# useLink = modeling.createLinkOSH('use', masterHostOsh, serviceAddressOsh)
return [masterHostOsh, serviceAddressOsh, clientServerLink, mysqlReplicationOsh]
def createIPEndpointOSHV(framework,
ipAddress,
portNum,
portName,
hostname=None,
protocol=modeling.SERVICEADDRESS_TYPE_TCP):
OSHVResult = ObjectStateHolderVector()
if ip_addr.isValidIpAddress(hostname):
hostname = None
fqdn, aliasList = getHostNames(ipAddress, framework)
hostOSH = modeling.createHostOSH(ipAddress, 'node', None, fqdn)
ipOSH = modeling.createIpOSH(ipAddress, None, fqdn)
link = modeling.createLinkOSH('containment', hostOSH, ipOSH)
OSHVResult.add(hostOSH)
OSHVResult.add(ipOSH)
OSHVResult.add(link)
ipPort = modeling.createServiceAddressOsh(hostOSH, ipAddress, portNum,
protocol, portName)
if fqdn:
ipPort.setStringAttribute('ipserver_address', fqdn)
if isValidFQDN(hostname):
ipPort.setStringAttribute('ipserver_address', hostname)
#ipPort.addAttributeToList('itrc_alias', sv)
#ipOSH.addAttributeToList('itrc_alias', sv)
#OSHVResult.add(modeling.createLinkOSH('usage', ipPort, ipOSH))
OSHVResult.add(ipPort)
return hostOSH, ipOSH, OSHVResult
def reportMqServerWithEndpoint(self, server):
r''' Make reporting of MQ server based on its IP where contains
is incomplete host built using IP address and if port specified
linked with corresponding service endpoint
@types: jms.MqServer -> ObjectStateHolderVector
@raise ValueError: JMS Server is not specified
@raise ValueError: MQ Server IP address is empty or not resolved
'''
if not server:
raise ValueError("JMS Server is not specified")
ip = server.address
if not (ip and netutils.isValidIp(ip)):
raise ValueError("MQ Server IP address is empty or not resolved")
vector = ObjectStateHolderVector()
hostOsh = modeling.createIpOSH(ip)
vector.add(hostOsh)
serverOsh = self.reportMqServer(server, hostOsh)
vector.add(serverOsh)
if server.getPort() is not None:
vector.add(modeling.createServiceAddressOsh(hostOsh, ip,
server.getPort(),
modeling.SERVICEADDRESS_TYPE_TCP
)
)
return vector
def _buildVirtualServiceAddress(self, alteonApplicationOsh):
#TODO: Determine protocol, currently it is always TCP
virtualServiceAddress = modeling.createServiceAddressOsh(self.osh, self.ipAddress,
self.virtualPort, modeling.SERVICEADDRESS_TYPE_TCP)
self.resultsVector.add(virtualServiceAddress)
ownerLink = modeling.createLinkOSH('owner', alteonApplicationOsh, self.osh)
self.resultsVector.add(ownerLink)
def reportMqServerWithEndpoint(self, server):
r''' Make reporting of MQ server based on its IP where contains
is incomplete host built using IP address and if port specified
linked with corresponding service endpoint
@types: jms.MqServer -> ObjectStateHolderVector
@raise ValueError: JMS Server is not specified
@raise ValueError: MQ Server IP address is empty or not resolved
'''
if not server:
raise ValueError("JMS Server is not specified")
ip = server.address
if not (ip and netutils.isValidIp(ip)):
raise ValueError("MQ Server IP address is empty or not resolved")
vector = ObjectStateHolderVector()
hostOsh = modeling.createIpOSH(ip)
vector.add(hostOsh)
serverOsh = self.reportMqServer(server, hostOsh)
vector.add(serverOsh)
if server.getPort() is not None:
vector.add(
modeling.createServiceAddressOsh(
hostOsh, ip, server.getPort(),
modeling.SERVICEADDRESS_TYPE_TCP))
return vector
def discoverContentRules(self):
contentRuleQueryBuilder = SnmpQueryBuilder(CNT_OID_OFFSET)
contentRuleQueryBuilder.addQueryElement(2, 'cnt_name')
contentRuleQueryBuilder.addQueryElement(4, 'ipserver_address')
contentRuleQueryBuilder.addQueryElement(5, 'ipport_type')
contentRuleQueryBuilder.addQueryElement(6, 'ipport_number')
contentRuleQueryBuilder.addQueryElement(68, 'ip_range')
snmpRowElements = self.snmpAgent.getSnmpData(contentRuleQueryBuilder)
for snmpRowElement in snmpRowElements:
virtualServer = modeling.createHostOSH(snmpRowElement.ipserver_address, 'clusteredservice')
virtualServerHostKey = virtualServer.getAttributeValue('host_key')
virtualServer.setAttribute('data_name', virtualServerHostKey)
self.OSHVResult.add(modeling.createLinkOSH('owner', self.css, virtualServer))
self.OSHVResult.add(virtualServer)
resourcePool = ObjectStateHolder('loadbalancecluster')
resourcePool.setStringAttribute('data_name', snmpRowElement.cnt_name)
self.OSHVResult.add(modeling.createLinkOSH('contained', resourcePool, virtualServer))
self.OSHVResult.add(resourcePool)
self.resourcePools[snmpRowElement.cnt_name] = resourcePool
serviceAddress = modeling.createServiceAddressOsh(virtualServer,
snmpRowElement.ipserver_address,
snmpRowElement.ipport_number,
CNT_PROTOCOL_MAP[snmpRowElement.ipport_type])
serviceAddress.setContainer(virtualServer)
self.OSHVResult.add(serviceAddress)
# KB specific: fix of port translations
self.resourcePoolsToServiceAddress[snmpRowElement.cnt_name] = serviceAddress
for i in range(int(snmpRowElement.ip_range)):
#TODO: Add all IPs from range
pass
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))
def _buildVirtualServiceAddress(self, alteonApplicationOsh):
# TODO: Determine protocol, currently it is always TCP
virtualServiceAddress = modeling.createServiceAddressOsh(
self.osh, self.ipAddress, self.virtualPort, modeling.SERVICEADDRESS_TYPE_TCP
)
self.resultsVector.add(virtualServiceAddress)
ownerLink = modeling.createLinkOSH("owner", alteonApplicationOsh, self.osh)
self.resultsVector.add(ownerLink)
def addServiceAddressOsh(hostOsh, OSHVResult, ip, portNumber, protocol, portName=None):
portType = PORT_TYPE_NAMES_DICT.get(protocol)
if portType:
if not portName:
portConfig = ConfigFilesManagerImpl.getInstance().getConfigFile(CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME)
portName = portConfig.getPortNameByNumberAndType(int(portNumber), str(portType))
serviceAddressOsh = modeling.createServiceAddressOsh(hostOsh, ip, portNumber, portType, portName)
OSHVResult.add(serviceAddressOsh)
def buildIpServiceEndPointOsh(osh, ipPort):
"""
@type ipPort: IpPort
@return: ObjectStateHolder
"""
ipPortOSH = modeling.createServiceAddressOsh(osh, ipPort.getIp(), ipPort.getPort(), modeling.SERVICEADDRESS_TYPE_TCP)
return ipPortOSH
def reportPort(hostOsh, ipAddress, port_names, port_type, port_number):
result = []
endpoint_port_type = modeling.SERVICEADDRESS_TYPE_TCP
if port_type == PortType.UDP.getProtocol():
endpoint_port_type = modeling.SERVICEADDRESS_TYPE_UDP
for port_name in port_names:
result.append(modeling.createServiceAddressOsh(hostOsh, ipAddress, port_number, endpoint_port_type, port_name))
return result
def buildEndpoints(endpoints, container_osh):
vector = ObjectStateHolderVector()
if not endpoints or not container_osh:
return vector
for endpoint in endpoints:
endpoint_osh = modeling.createServiceAddressOsh(container_osh, endpoint.ip, endpoint.port, endpoint.type)
vector.add(endpoint_osh)
return vector
def buildEndpoints(endpoints, container_osh):
vector = ObjectStateHolderVector()
if not endpoints or not container_osh:
return vector
for endpoint in endpoints:
endpoint_osh = modeling.createServiceAddressOsh(
container_osh, endpoint.ip, endpoint.port, endpoint.type)
vector.add(endpoint_osh)
return vector
def buildIpServiceEndPointOsh(osh, ipPort):
"""
@type ipPort: IpPort
@return: ObjectStateHolder
"""
ipPortOSH = modeling.createServiceAddressOsh(
osh, ipPort.getIp(), ipPort.getPort(),
modeling.SERVICEADDRESS_TYPE_TCP)
return ipPortOSH
def _createServiceEndpointByTransport(self, transport, hostOsh):
if transport.hostIp and transport.port and transport.port.isdigit():
try:
intPort = int(transport.port)
serviceEndpointOsh = modeling.createServiceAddressOsh(hostOsh, transport.hostIp, intPort,
modeling.SERVICEADDRESS_TYPE_TCP,
transport.protocol)
return serviceEndpointOsh
except:
logger.debug("Failed to convert port value to integer")
def _createServiceEndpointByTransport(self, transport, hostOsh):
if transport.hostIp and transport.port and transport.port.isdigit():
try:
intPort = int(transport.port)
serviceEndpointOsh = modeling.createServiceAddressOsh(
hostOsh, transport.hostIp, intPort,
modeling.SERVICEADDRESS_TYPE_TCP, transport.protocol)
return serviceEndpointOsh
except:
logger.debug("Failed to convert port value to integer")
def reportTopology(self, vector, sid, endpoints, hostOsh):
ip, port = endpoints[0]
oracleOsh = modeling.createDatabaseOSH('oracle', sid, port, str(ip), hostOsh)
vector.add(oracleOsh)
for ip, port in endpoints:
portOsh = modeling.createServiceAddressOsh(hostOsh, str(ip), port,
modeling.SERVICEADDRESS_TYPE_TCP)
vector.add(portOsh)
link = modeling.createLinkOSH('use', oracleOsh, portOsh)
vector.add(link)
def reportPort(hostOsh, ipAddress, port_names, port_type, port_number):
result = []
endpoint_port_type = modeling.SERVICEADDRESS_TYPE_TCP
if port_type == PortType.UDP.getProtocol():
endpoint_port_type = modeling.SERVICEADDRESS_TYPE_UDP
for port_name in port_names:
result.append(
modeling.createServiceAddressOsh(hostOsh, ipAddress, port_number,
endpoint_port_type, port_name))
return result
def reportTopology(self, vector, sid, endpoints, hostOsh):
ip, port = endpoints[0]
oracleOsh = modeling.createDatabaseOSH('oracle', sid, port, str(ip),
hostOsh)
vector.add(oracleOsh)
for ip, port in endpoints:
portOsh = modeling.createServiceAddressOsh(
hostOsh, str(ip), port, modeling.SERVICEADDRESS_TYPE_TCP)
vector.add(portOsh)
link = modeling.createLinkOSH('use', oracleOsh, portOsh)
vector.add(link)
def build(self):
domainName = DomainScopeManager.getDomainByIp(self.vServer.ip)
name = '%s:%s %s' % (self.vServer.ip, self.vServer.port, domainName)
vServerOsh = modeling.createCompleteHostOSH('cluster_resource_group', name, None, self.vServer.name)
ipOSH = modeling.createIpOSH(self.vServer.ip)
linkIpOSH = modeling.createLinkOSH('contained', vServerOsh, ipOSH)
ownership_link = modeling.createLinkOSH('ownership', self.netscaler_software_osh, vServerOsh)
vipServiceOsh = modeling.createServiceAddressOsh(vServerOsh, self.vServer.ip, self.vServer.port,
modeling.SERVICEADDRESS_TYPE_TCP, self.vServer.server_type)
self.osh = vServerOsh
return self.newVector(vServerOsh, ipOSH, ownership_link, linkIpOSH, vipServiceOsh)
def build(self):
vector = self.newVector()
backend_server_osh = modeling.createHostOSH(self.service.server.ip)
vector.add(backend_server_osh)
realIPServiceOsh = modeling.createServiceAddressOsh(backend_server_osh, self.service.ip, self.service.port,
modeling.SERVICEADDRESS_TYPE_TCP,
self.service.service_type)
vector.add(realIPServiceOsh)
vector.add(modeling.createLinkOSH('membership', self.lbcOsh, realIPServiceOsh))
return vector
def build(self):
vector = self.newVector()
backend_server_osh = modeling.createHostOSH(self.service.server.ip)
vector.add(backend_server_osh)
realIPServiceOsh = modeling.createServiceAddressOsh(
backend_server_osh, self.service.ip, self.service.port,
modeling.SERVICEADDRESS_TYPE_TCP, self.service.service_type)
vector.add(realIPServiceOsh)
vector.add(
modeling.createLinkOSH('membership', self.lbcOsh,
realIPServiceOsh))
return vector
def discoverDB(Framework, client, OSHVResult, reportedSids):
if not isMsSqlConnectionPortValid(Framework, client):
return
hostOSH = modeling.createHostOSH(client.getIpAddress(), 'node')
endpoint_builder = netutils.ServiceEndpointBuilder()
endpoint_reporter = netutils.EndpointReporter(endpoint_builder)
oracle_builder = db_builder.Oracle()
reporter = db.OracleTopologyReporter(oracle_builder, endpoint_reporter)
serviceName = client.getProperty(Protocol.SQL_PROTOCOL_ATTRIBUTE_DBSID)
sid = getDbSid(client).upper()
uniqueSID = (sid, client.getPort())
if uniqueSID in reportedSids:
logger.info('SID %s on port %s already reported' % (sid, client.getPort()))
if client.getProtocolDbType().lower() == DbTypes.Oracle:
logger.debug('report service:', serviceName)
listener = db.OracleListener(client.getIpAddress(), client.getPort())
OSHVResult.addAll(reporter.reportTnsListener(listener, hostOSH))
oracleServices = []
service = db.OracleServiceName(serviceName)
service.setCredentialId(client.getCredentialId())
oracleServices.append(service)
OSHVResult.addAll(reporter.reportServiceNameTopology(oracleServices, listener.getOsh()))
return
reportedSids.append(uniqueSID)
buildNumber = getBuildNumber(client)
edition = getEdition(client)
databaseServer = createDatabaseOSH(hostOSH, client, sid, client.getDbVersion(), client.getAppVersion(), buildNumber, edition)
addExtraInformationToDB(databaseServer, client)
ipCommunicationEndpoint = modeling.createServiceAddressOsh(hostOSH, client.getIpAddress(), str(client.getPort()), modeling.SERVICEADDRESS_TYPE_TCP)
usageLink = modeling.createLinkOSH('usage', databaseServer, ipCommunicationEndpoint)
OSHVResult.add(databaseServer)
OSHVResult.add(ipCommunicationEndpoint)
OSHVResult.add(usageLink)
if client.getProtocolDbType().lower() == DbTypes.Oracle:
services = getServices(client)
if services:
oracleServices = []
listener = db.OracleListener(client.getIpAddress(), client.getPort())
OSHVResult.addAll(reporter.reportTnsListener(listener, hostOSH))
for service in services:
if serviceName == service.getName():
service.setCredentialId(client.getCredentialId())
oracleServices.append(service)
OSHVResult.addAll(reporter.reportServiceNameTopology(oracleServices, listener.getOsh(), databaseServer))
def createServerAddressOsh(self, rs, prefix):
ipaddr = rs.getString(prefix + 'Addr')
port = rs.getInt(prefix + 'Port')
portName = self.getPortName(port)
[hostOsh, _] = self.createHostOsh(rs, prefix)
if not hostOsh:
return [None, None, None]
prot = rs.getInt('Prot')
if prot == modeling.TCP_PROTOCOL:
serviceType = modeling.SERVICEADDRESS_TYPE_TCP
else:
serviceType = modeling.SERVICEADDRESS_TYPE_UDP
saOsh = modeling.createServiceAddressOsh(hostOsh, ipaddr, port, serviceType, portName)
return [saOsh, portName, prot]
def discoverFarmMembers(self, farmNameToFarm):
queryBuilder = SnmpQueryBuilder(CISCO_ACE_OID_TABLE_SERVER)
queryBuilder.addQueryElement(1, 'farmName')
queryBuilder.addQueryElement(2, 'ipAddress')
queryBuilder.addQueryElement(3, 'port')
farmMembers = self.snmpAgent.getSnmpData(queryBuilder)
for farmMember in farmMembers:
farmMemberOsh = modeling.createHostOSH(farmMember.ipAddress, 'host')
serviceAddressOsh = modeling.createServiceAddressOsh(farmMemberOsh, farmMember.ipAddress,
farmMember.port, modeling.SERVICEADDRESS_TYPE_TCP)
self.OSHVResult.add(farmMemberOsh)
self.OSHVResult.add(serviceAddressOsh)
farmOsh = farmNameToFarm[farmMember.farmName]
self.OSHVResult.add(modeling.createLinkOSH('member', farmOsh, serviceAddressOsh))
def discoverPoolMembers(self, poolNameToPool):
queryBuilder = SnmpQueryBuilder('8.2.1')
queryBuilder.addQueryElement(1, 'poolName')
queryBuilder.addQueryElement(2, 'ipAddress')
queryBuilder.addQueryElement(3, 'port')
poolMembers = self.snmpAgent.getSnmpData(queryBuilder)
for poolMember in poolMembers:
poolMemberOsh = modeling.createHostOSH(poolMember.ipAddress, 'host')
serviceAddressOsh = modeling.createServiceAddressOsh(poolMemberOsh, poolMember.ipAddress,
poolMember.port, modeling.SERVICEADDRESS_TYPE_TCP)
self.OSHVResult.add(poolMemberOsh)
self.OSHVResult.add(serviceAddressOsh)
poolOsh = poolNameToPool[poolMember.poolName]
self.OSHVResult.add(modeling.createLinkOSH('member', poolOsh, serviceAddressOsh))
def discoverGroupMembers(self, serverNameToGroup):
queryBuilder = SnmpQueryBuilder(A10_OID_TABLE_SERVER)
queryBuilder.addQueryElement(1, 'server_name')
queryBuilder.addQueryElement(3, 'port')
queryBuilder.addQueryElement(4, 'ipAddress')
groupMembers = self.snmpAgent.getSnmpData(queryBuilder)
for groupMember in groupMembers:
groupMemberOsh = modeling.createHostOSH(groupMember.ipAddress, 'host')
serviceAddressOsh = modeling.createServiceAddressOsh(groupMemberOsh, groupMember.ipAddress,
groupMember.port, modeling.SERVICEADDRESS_TYPE_TCP)
self.OSHVResult.add(groupMemberOsh)
self.OSHVResult.add(serviceAddressOsh)
groupOsh = serverNameToGroup[groupMember.server_name]
self.OSHVResult.add(modeling.createLinkOSH('member', groupOsh, serviceAddressOsh))
def createOracleTopology(self, parsedData, applicationOsh):
vector = ObjectStateHolderVector()
if not parsedData["serverIp"] and parsedData["sid"]:
return vector
hostOsh = modeling.createHostOSH(parsedData["serverIp"])
dbOsh = modeling.createDatabaseOSH('oracle', parsedData["sid"], parsedData["port"], parsedData["serverIp"], hostOsh)
serviceEndPointOsh = modeling.createServiceAddressOsh(hostOsh, parsedData["serverIp"], parsedData["port"], 1)
clientServerLinkOsh = modeling.createLinkOSH('client_server', applicationOsh, serviceEndPointOsh)
clientServerLinkOsh.setStringAttribute('clientserver_protocol', 'tcp')
usageLinkOsh = modeling.createLinkOSH('usage', dbOsh, serviceEndPointOsh)
vector.add(hostOsh)
vector.add(dbOsh)
vector.add(serviceEndPointOsh)
vector.add(clientServerLinkOsh)
vector.add(usageLinkOsh)
return vector
def reportServiceEndpoints(ip, port, hostOsh, server=None, portName=None):
'''@types: str, int, ObjectStateHolder, jee.Server -> ObjectStateHolderVector
@raise ValueError: Failed to report service address. Not all required fields are specified
'''
if not (ip and port and hostOsh):
raise ValueError("Failed to report service address. Not all required fields are specified. %s" % locals())
vector = ObjectStateHolderVector()
if portName:
portName = str(portName)
serviceAddressOsh = modeling.createServiceAddressOsh(hostOsh, ip, port, modeling.SERVICEADDRESS_TYPE_TCP, portName)
vector.add(serviceAddressOsh)
logger.debug(server)
logger.debug(server.getOsh())
if server and server.getOsh():
link = modeling.createLinkOSH('use', server.getOsh(), serviceAddressOsh)
vector.add(link)
return vector
def addServiceAddressOsh(hostOsh,
OSHVResult,
ip,
portNumber,
protocol,
portName=None):
portType = PORT_TYPE_NAMES_DICT.get(protocol)
if portType:
if not portName:
portConfig = ConfigFilesManagerImpl.getInstance().getConfigFile(
CollectorsParameters.
KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME)
portName = portConfig.getPortNameByNumberAndType(
int(portNumber), str(portType))
serviceAddressOsh = modeling.createServiceAddressOsh(
hostOsh, ip, portNumber, portType, portName)
OSHVResult.add(serviceAddressOsh)
def build(self):
domainName = DomainScopeManager.getDomainByIp(self.vServer.ip)
name = '%s:%s %s' % (self.vServer.ip, self.vServer.port, domainName)
vServerOsh = modeling.createCompleteHostOSH('cluster_resource_group',
name, None,
self.vServer.name)
ipOSH = modeling.createIpOSH(self.vServer.ip)
linkIpOSH = modeling.createLinkOSH('contained', vServerOsh, ipOSH)
ownership_link = modeling.createLinkOSH('ownership',
self.netscaler_software_osh,
vServerOsh)
vipServiceOsh = modeling.createServiceAddressOsh(
vServerOsh, self.vServer.ip, self.vServer.port,
modeling.SERVICEADDRESS_TYPE_TCP, self.vServer.server_type)
self.osh = vServerOsh
return self.newVector(vServerOsh, ipOSH, ownership_link, linkIpOSH,
vipServiceOsh)
def discoverFarmMembers(self, farmNameToFarm):
queryBuilder = SnmpQueryBuilder(CISCO_ACE_OID_TABLE_SERVER)
queryBuilder.addQueryElement(1, 'farmName')
queryBuilder.addQueryElement(2, 'ipAddress')
queryBuilder.addQueryElement(3, 'port')
farmMembers = self.snmpAgent.getSnmpData(queryBuilder)
for farmMember in farmMembers:
farmMemberOsh = modeling.createHostOSH(farmMember.ipAddress,
'host')
serviceAddressOsh = modeling.createServiceAddressOsh(
farmMemberOsh, farmMember.ipAddress, farmMember.port,
modeling.SERVICEADDRESS_TYPE_TCP)
self.OSHVResult.add(farmMemberOsh)
self.OSHVResult.add(serviceAddressOsh)
farmOsh = farmNameToFarm[farmMember.farmName]
self.OSHVResult.add(
modeling.createLinkOSH('member', farmOsh, serviceAddressOsh))
def reportTopology(self, context, dbType, port, sid, dbHostIp):
if re.search('oracle', dbType, re.I):
dbType = 'oracle'
elif re.search('sql', dbType, re.I):
dbType = 'sqlserver'
else:
logger.error('Unsupported DB type for uCMDB configuration')
hostOSH = modeling.createHostOSH(dbHostIp)
ipOSH = modeling.createIpOSH(dbHostIp)
link = modeling.createLinkOSH('contained', hostOSH, ipOSH)
dbOSH = modeling.createDatabaseOSH(dbType, sid, port, dbHostIp, hostOSH)
serviceAddress = modeling.createServiceAddressOsh(hostOSH, dbHostIp,
port, modeling.SERVICEADDRESS_TYPE_TCP)
context.resultsVector.add(hostOSH)
context.resultsVector.add(ipOSH)
context.resultsVector.add(dbOSH)
context.resultsVector.add(link)
link = modeling.createLinkOSH('use', dbOSH, serviceAddress)
context.resultsVector.add(serviceAddress)
context.resultsVector.add(link)
def discoverContentRules(self):
contentRuleQueryBuilder = SnmpQueryBuilder(CNT_OID_OFFSET)
contentRuleQueryBuilder.addQueryElement(2, 'cnt_name')
contentRuleQueryBuilder.addQueryElement(4, 'ipserver_address')
contentRuleQueryBuilder.addQueryElement(5, 'ipport_type')
contentRuleQueryBuilder.addQueryElement(6, 'ipport_number')
contentRuleQueryBuilder.addQueryElement(68, 'ip_range')
snmpRowElements = self.snmpAgent.getSnmpData(contentRuleQueryBuilder)
for snmpRowElement in snmpRowElements:
virtualServer = modeling.createHostOSH(
snmpRowElement.ipserver_address, 'clusteredservice')
virtualServerHostKey = virtualServer.getAttributeValue('host_key')
virtualServer.setAttribute('data_name', virtualServerHostKey)
self.OSHVResult.add(
modeling.createLinkOSH('owner', self.css, virtualServer))
self.OSHVResult.add(virtualServer)
resourcePool = ObjectStateHolder('loadbalancecluster')
resourcePool.setStringAttribute('data_name',
snmpRowElement.cnt_name)
self.OSHVResult.add(
modeling.createLinkOSH('contained', resourcePool,
virtualServer))
self.OSHVResult.add(resourcePool)
self.resourcePools[snmpRowElement.cnt_name] = resourcePool
serviceAddress = modeling.createServiceAddressOsh(
virtualServer, snmpRowElement.ipserver_address,
snmpRowElement.ipport_number,
CNT_PROTOCOL_MAP[snmpRowElement.ipport_type])
serviceAddress.setContainer(virtualServer)
self.OSHVResult.add(serviceAddress)
# KB specific: fix of port translations
self.resourcePoolsToServiceAddress[
snmpRowElement.cnt_name] = serviceAddress
for i in range(int(snmpRowElement.ip_range)):
#TODO: Add all IPs from range
pass
def reportTopology(self, context, dbType, port, sid, dbHostIp):
if re.search('oracle', dbType, re.I):
dbType = 'oracle'
elif re.search('sql', dbType, re.I):
dbType = 'sqlserver'
else:
logger.error('Unsupported DB type for uCMDB configuration')
hostOSH = modeling.createHostOSH(dbHostIp)
ipOSH = modeling.createIpOSH(dbHostIp)
link = modeling.createLinkOSH('contained', hostOSH, ipOSH)
dbOSH = modeling.createDatabaseOSH(dbType, sid, port, dbHostIp,
hostOSH)
serviceAddress = modeling.createServiceAddressOsh(
hostOSH, dbHostIp, port, modeling.SERVICEADDRESS_TYPE_TCP)
context.resultsVector.add(hostOSH)
context.resultsVector.add(ipOSH)
context.resultsVector.add(dbOSH)
context.resultsVector.add(link)
link = modeling.createLinkOSH('use', dbOSH, serviceAddress)
context.resultsVector.add(serviceAddress)
context.resultsVector.add(link)
def reportServiceEndpoints(ip, port, hostOsh, server=None, portName=None):
'''@types: str, int, ObjectStateHolder, jee.Server -> ObjectStateHolderVector
@raise ValueError: Failed to report service address. Not all required fields are specified
'''
if not (ip and port and hostOsh):
raise ValueError(
"Failed to report service address. Not all required fields are specified. %s"
% locals())
vector = ObjectStateHolderVector()
if portName:
portName = str(portName)
serviceAddressOsh = modeling.createServiceAddressOsh(
hostOsh, ip, port, modeling.SERVICEADDRESS_TYPE_TCP, portName)
vector.add(serviceAddressOsh)
logger.debug(server)
logger.debug(server.getOsh())
if server and server.getOsh():
link = modeling.createLinkOSH('use', server.getOsh(),
serviceAddressOsh)
vector.add(link)
return vector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ips = Framework.getTriggerCIDataAsList('ip_address')
ports = Framework.getTriggerCIDataAsList('http_port')
webserverFactory = WebServerFactory()
for ip in ips:
containerHostOSH = modeling.createHostOSH(ip)
for port in ports:
serverHeader = doHttp(ip, port, Framework)
if not serverHeader:
continue
serverHeaderStr = serverHeader.toString().strip()
webserverOSH = webserverFactory.createWebServer(serverHeaderStr, ip, port, containerHostOSH)
if webserverOSH:
serviceAddrOsh = modeling.createServiceAddressOsh(containerHostOSH, ip, port, modeling.SERVICEADDRESS_TYPE_TCP)
uselink = modeling.createLinkOSH('use', webserverOSH, serviceAddrOsh)
OSHVResult.add(webserverOSH)
OSHVResult.add(serviceAddrOsh)
OSHVResult.add(uselink)
return OSHVResult
def discoverReplication(self, mysqlOsh):
"""
Tries to find config variables related to mysql replication
@param ObjectStateHolder mysqlOsh mysql osh
@return list list of OSHs
"""
masterHostIp = self.getProperty('master-host')
if not masterHostIp:
return
if not netutils.isValidIp(masterHostIp):
try:
resolver = netutils.DnsResolverByShell(self.shell)
masterHostIp = resolver.resolveIpsByHostname(masterHostIp)[0]
except netutils.ResolveException:
logger.warn('Failed to resolve Master Host into IP')
return
masterPort = self.getProperty('master-port')
mysqlReplicationOsh = ObjectStateHolder('mysql_replication')
mysqlReplicationOsh.setAttribute('data_name', 'MySQL Replication')
mysqlReplicationOsh.setContainer(mysqlOsh)
self.setAttribute(mysqlReplicationOsh, 'master_user',
self.REPL_ARGS_MAPPING)
self.setAttribute(mysqlReplicationOsh, 'master_connect_retry',
self.REPL_ARGS_MAPPING)
masterHostOsh = modeling.createHostOSH(masterHostIp)
serviceAddressOsh = modeling.createServiceAddressOsh(
masterHostOsh, masterHostIp, masterPort,
modeling.SERVICEADDRESS_TYPE_TCP)
clientServerLink = modeling.createLinkOSH('client_server',
mysqlReplicationOsh,
serviceAddressOsh)
clientServerLink.setStringAttribute('clientserver_protocol', 'TCP')
clientServerLink.setLongAttribute('clientserver_destport',
int(masterPort))
# masterMysqlOsh = modeling.createDatabaseOSH('mysql', 'MySQL. Port ' + masterPort, masterPort, masterHostIp, masterHostOsh)
# useLink = modeling.createLinkOSH('use', masterHostOsh, serviceAddressOsh)
return [
masterHostOsh, serviceAddressOsh, clientServerLink,
mysqlReplicationOsh
]
def processIpPort(Framework, OSHVResult, ipOrDnsOrAlias, port, localShell, dnsServers = None):
logger.debug('Resolving ip port for [', ipOrDnsOrAlias, '] and [', port, ']')
resolvedIp = resolveIpFromDns(Framework, ipOrDnsOrAlias, localShell, dnsServers)
if resolvedIp is not None:
try:
ipOSH = modeling.createIpOSH(resolvedIp)
OSHVResult.add(ipOSH)
if port:
matcher = PORT_PATTERN.matcher(String(port))
if matcher.find():
purePort = matcher.group(PORT_GROUP_FROM_PATTERN)
hostOSH = modeling.createHostOSH(resolvedIp)
portOsh = modeling.createServiceAddressOsh(hostOSH, resolvedIp, purePort, modeling.SERVICEADDRESS_TYPE_TCP)
portOsh.setAttribute("name", String(port))
OSHVResult.add(portOsh)
else:
errorMessage = 'An invalid (non-numeric) port value was found in the configuration file [' + port + '] and will be skipped'
Framework.reportWarning(errorMessage)
logger.warn(errorMessage)
except:
Framework.reportWarning(logger.prepareJythonStackTrace(''))
logger.debug('Failed to process ip:[', resolvedIp, '] with port [', port, ']')
def createOracleTopology(self, parsedData, applicationOsh):
vector = ObjectStateHolderVector()
if not parsedData["serverIp"] and parsedData["sid"]:
return vector
hostOsh = modeling.createHostOSH(parsedData["serverIp"])
dbOsh = modeling.createDatabaseOSH('oracle', parsedData["sid"],
parsedData["port"],
parsedData["serverIp"], hostOsh)
serviceEndPointOsh = modeling.createServiceAddressOsh(
hostOsh, parsedData["serverIp"], parsedData["port"], 1)
clientServerLinkOsh = modeling.createLinkOSH('client_server',
applicationOsh,
serviceEndPointOsh)
clientServerLinkOsh.setStringAttribute('clientserver_protocol', 'tcp')
usageLinkOsh = modeling.createLinkOSH('usage', dbOsh,
serviceEndPointOsh)
vector.add(hostOsh)
vector.add(dbOsh)
vector.add(serviceEndPointOsh)
vector.add(clientServerLinkOsh)
vector.add(usageLinkOsh)
return vector
def discoverPoolMembers(self, nameToPool):
queryBuilder = SnmpQueryBuilder('5.3.2.1')
queryBuilder.addQueryElement(1, 'poolName')
queryBuilder.addQueryElement(2, 'addressType')
queryBuilder.addQueryElement(3, 'address', 'hexa')
queryBuilder.addQueryElement(4, 'port')
poolMembers = self.snmpAgent.getSnmpData(queryBuilder)
for poolMember in poolMembers:
ipAddress = self.convertToIp(poolMember.address)
hostOsh = modeling.createHostOSH(ipAddress, 'host')
serviceAddressOsh = modeling.createServiceAddressOsh(hostOsh, ipAddress,
poolMember.port, modeling.SERVICEADDRESS_TYPE_TCP)
try:
#TODO: consider about avoiding try-except here
self.add(modeling.createLinkOSH('member', nameToPool[poolMember.poolName], serviceAddressOsh))
self.add(hostOsh)
self.add(serviceAddressOsh)
except:
errorMsg = 'Failed to link %s member with pool %s' % (ipAddress, poolMember.poolName)
errobj = errorobject.createError(errorcodes.FAILED_LINKING_ELEMENTS, ['%s member' % ipAddress, 'pool %s' % poolMember.poolName], errorMsg)
#TODO: Change log level to debug
logger.debugException('errorMsg')
logger.reportWarningObject(errobj)
def _buildRealServiceAddress(self):
realServiceAddress = modeling.createServiceAddressOsh(
self.osh, self.ipAddress, self.realPort, modeling.SERVICEADDRESS_TYPE_TCP
)
self.resultsVector.add(realServiceAddress)
def makeDbOSHs(dbDict, database_ip_service_endpoints=None, localClient=None):
try:
debugPrint(3, "[" + SCRIPT_NAME + ":makeDbOSHs]")
oshVector = ObjectStateHolderVector()
for dbName in dbDict.keys():
try:
dbType = (dbDict[dbName])[DBTYPE_INDEX]
ipAddress = (dbDict[dbName])[IP_INDEX]
serverPort = (dbDict[dbName])[PORT_INDEX]
installPath = (dbDict[dbName])[PATH_INDEX]
version = (dbDict[dbName])[VERSION_INDEX]
serverStatus = (dbDict[dbName])[STATUS_INDEX]
## Make Host, IP, and serverPort OSHs
hostOSH = modeling.createHostOSH(ipAddress, "host")
ipOSH = modeling.createIpOSH(ipAddress)
oshVector.add(hostOSH)
oshVector.add(ipOSH)
oshVector.add(modeling.createLinkOSH("contained", hostOSH, ipOSH))
## Make DB osh
dbServerOSH = None
if dbType.lower() == "microsoftsqlserver":
dbServerOSH = ObjectStateHolder("sqlserver")
dbServerOSH.setStringAttribute("data_name", "MSSQL DB")
dbServerOSH.setStringAttribute("vendor", "microsoft_corp")
dbServerOSH.setStringAttribute("product_name", "sql_server_database")
if version is not None and version != UNKNOWN:
version_description = PRODUT_NUMBER_TO_PRODUCT_VERSION_NAME_MAP.get(version, version)
dbServerOSH.setStringAttribute("build_number", version)
version = version_description
elif dbType.lower() == "oracle":
dbServerOSH = ObjectStateHolder(dbType)
dbServerOSH.setStringAttribute("data_name", "Oracle DB")
dbServerOSH.setStringAttribute("vendor", "oracle_corp")
dbServerOSH.setStringAttribute("product_name", "oracle_database")
elif dbType.lower() == "db2":
dbServerOSH = ObjectStateHolder(dbType)
dbServerOSH.setStringAttribute("data_name", "IBM DB2")
dbServerOSH.setStringAttribute("vendor", "ibm_corp")
dbServerOSH.setStringAttribute("product_name", "db2_database")
else:
debugPrint("[" + SCRIPT_NAME + ":makeDbOSHs] Unknown database type <%s>!! Skipping..." % dbType)
continue
if serverPort != None and serverPort != UNKNOWN:
dbServerOSH.setIntegerAttribute("application_port", serverPort)
dbServerOSH.setStringAttribute("database_dbport", serverPort)
if version != None and version != UNKNOWN:
dbServerOSH.setStringAttribute("application_version", version)
if installPath != None and installPath != UNKNOWN:
dbServerOSH.setStringAttribute("application_path", installPath)
dbServerOSH.setStringAttribute("database_dbinstallpath", installPath)
if serverStatus.lower().strip() == "not running":
dbServerOSH.setStringAttribute("data_description", serverStatus)
else:
dbServerOSH.setStringAttribute("data_description", "")
dbServerOSH.setStringAttribute("database_dbtype", dbType)
dbServerOSH.setStringAttribute("application_ip", ipAddress)
dbServerOSH.setStringAttribute("database_dbsid", dbName)
dbServerOSH.setStringAttribute("application_category", "Database")
dbServerOSH.setContainer(hostOSH)
oshVector.add(dbServerOSH)
if serverPort != None and serverPort != UNKNOWN:
try:
serverPort = int(serverPort)
except ValueError:
logger.debug("failed convert to int: %s" % serverPort)
else:
ipServerOSH = modeling.createServiceAddressOsh(
hostOSH, ipAddress, serverPort, modeling.SERVICEADDRESS_TYPE_TCP, dbType
)
oshVector.add(ipServerOSH)
oshVector.add(modeling.createLinkOSH("usage", dbServerOSH, ipServerOSH))
if database_ip_service_endpoints and database_ip_service_endpoints.get(dbName):
for ip_service_endpoint in database_ip_service_endpoints.get(dbName):
ip_address, port_number = ip_service_endpoint.split(":")
try:
port_number = int(port_number)
except ValueError:
logger.debug("failed convert to int: %s" % port_number)
else:
if ip_address != ipAddress or port_number != serverPort:
ipServerOSH = modeling.createServiceAddressOsh(
hostOSH, ip_address, port_number, modeling.SERVICEADDRESS_TYPE_TCP, dbType
)
oshVector.add(ipServerOSH)
oshVector.add(modeling.createLinkOSH("usage", dbServerOSH, ipServerOSH))
except:
# excInfo = str(sys.exc_info()[1])
excInfo = logger.prepareJythonStackTrace("")
debugPrint(
"[" + SCRIPT_NAME + ":makeDbOSHs] Cannot make OSH for <%s>: <%s>" % (dbDict[dbName], excInfo)
)
pass
return oshVector
except:
# excInfo = str(sys.exc_info()[1])
excInfo = logger.prepareJythonStackTrace("")
debugPrint("[" + SCRIPT_NAME + ":makeDbOSHs] Exception: <%s>" % excInfo)
pass
def discover_private(self):
ports = self.servicesPorts(0)
query = 'select ipaddress, port, Protocol from Port_Process '
if (ports != None) and (len(ports) > 0):
query = query + ' where listen and port IN (' + ports + ')'
logger.debug('ListenPorts,sql:', query)
conn = self.Framework.getProbeDatabaseConnection('TCPDISCOVERY')
st = None
result = None
try:
try:
if logger.isDebugEnabled():
logger.debug(query)
st = conn.createStatement()
result = st.executeQuery(query)
dataFound = 0
while result.next():
dataFound = 1
address = result.getString('ipaddress');
port = result.getInt('port');
prot = result.getInt('Protocol');
if not self.shouldInclude(address, 1):
if logger.isDebugEnabled():
logger.debug("ignoring ip out of scope: " + address)
continue
ipOSH = modeling.createIpOSH(address)
self.Framework.sendObject(ipOSH)
hostOSH = modeling.createHostOSH(address)
portName = self.knownPortsConfigFile.getPortName(prot, port)
if portName == None:
portName = str(port)
portType = modeling.SERVICEADDRESS_TYPE_TCP
if prot == modeling.UDP_PROTOCOL:
portType = modeling.SERVICEADDRESS_TYPE_UDP
serverPortOSH = modeling.createServiceAddressOsh(hostOSH, address, port, portType, portName)
containedLinkOSH = modeling.createLinkOSH('contained', hostOSH, ipOSH)
self.Framework.sendObject(hostOSH)
self.Framework.sendObject(serverPortOSH)
self.Framework.sendObject(containedLinkOSH)
if not dataFound:
self.Framework.reportWarning("No data to process, please check if Host Resources jobs had already run")
except:
msg = sys.exc_info()[1]
exInfo = '%s' % msg
if exInfo.find('ResultSet closed') != -1:
error = 'Connection to probe database closed'
details = str("Please increase job execution max time and/or configure parameter 'appilog.agent.netflow.heldTimeoutConnection' in DiscoveryProbe.properties file")
errobj = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [error, details], error + details)
logger.reportErrorObject(errobj)
else:
errobj = errorobject.createError(errorcodes.FAILED_TO_EXECUTE_SQL, [exInfo], exInfo)
logger.reportErrorObject(errobj)
finally:
if result != None:
try:
result.close
except:
pass
conn.close(st)
conn.close()
def discover_private(self):
query = self.buildQuery()
conn = self.Framework.getProbeDatabaseConnection('TCPDISCOVERY')
st = None
result = None
try:
st = conn.createStatement()
result = st.executeQuery(query)
currDestination = None
clientsCount = 0
octetsCount = 0
packetsCount = 0
OSHVResult = ObjectStateHolderVector()
addPortInAnyCase = 0
dstIpOSH = None
dstHostOSH = None
serverPortOsh = None
portName = -1
firstTimeSeenPort = 1
dataFound = 0
while result.next():
dataFound = 1
listen = result.getBoolean('ListenPort')
if listen:
srcAddr = result.getString('SrcAddr')
dstAddr = result.getString('DstAddr')
dstPort = result.getString('DstPort')
else:
srcAddr = result.getString('DstAddr')
dstAddr = result.getString('SrcAddr')
dstPort = result.getString('SrcPort')
if self.ignoreLocalConnections and (srcAddr == dstAddr):
continue
if (not self.shouldInclude(dstAddr, listen)) or self.isIgnoredIp(dstAddr):
continue
srcIgnored = self.isIgnoredIp(srcAddr) or (not self.shouldInclude(srcAddr, not listen))
protocolNumber = result.getString('Prot')
destination = dstAddr + ":" + dstPort
if logger.isDebugEnabled():
logger.debug('Current connection:', srcAddr, '->', destination)
if destination != currDestination:
if OSHVResult != None:
if addPortInAnyCase or self.matchPortConditions(octetsCount, packetsCount, clientsCount):
self.Framework.sendObjects(OSHVResult)
currDestination = destination
clientsCount = 0
octetsCount = 0
packetsCount = 0
OSHVResult = ObjectStateHolderVector()
addPortInAnyCase = self.checkIfAddPortInAnyCase(result)
firstTimeSeenPort = 1
else:
firstTimeSeenPort = 0
if firstTimeSeenPort:
dstIpOSH = modeling.createIpOSH(dstAddr)
dstHostOSH = modeling.createHostOSH(dstAddr)
if not self.onlyHostDependLinks:
OSHVResult.add(dstIpOSH)
OSHVResult.add(dstHostOSH)
portName = ''
if int(protocolNumber) == NetlinksServices.UDP_PROTOCOL:
portTypeEnum = NetlinksServices.UDP_PORT_TYPE_ENUM
portName = self.knownPortsConfigFile.getUdpPortName(int(dstPort))
else:
portTypeEnum = NetlinksServices.TCP_PORT_TYPE_ENUM
portName = self.knownPortsConfigFile.getTcpPortName(int(dstPort))
if portName == None:
portName = dstPort
if logger.isDebugEnabled():
logger.debug('Port ', str(dstPort), ' with name ', portName)
serverPortOsh = modeling.createServiceAddressOsh(dstHostOSH, dstAddr, int(dstPort), portTypeEnum, portName)
OSHVResult.add(serverPortOsh)
srcIpOSH = None
srcHostOSH = None
if not srcIgnored:
srcIpOSH = modeling.createIpOSH(srcAddr)
srcHostOSH = modeling.createHostOSH(srcAddr)
if not self.onlyHostDependLinks:
OSHVResult.add(srcIpOSH)
OSHVResult.add(srcHostOSH)
if not self.onlyHostDependLinks:
containedLink = modeling.createLinkOSH('contained', srcHostOSH, srcIpOSH)
OSHVResult.add(containedLink)
if firstTimeSeenPort:
containedLink = modeling.createLinkOSH('contained', dstHostOSH, dstIpOSH)
OSHVResult.add(containedLink)
octets = 0
packets = 0
clients = 0
if self.updateUtilizationInfo:
octets = result.getInt('dOctets')
packets = result.getInt('dPkts')
if self.shouldCountClients:
clients = result.getInt('cnt')
clientsCount = clientsCount + clients
octetsCount = octetsCount + octets
packetsCount = packetsCount + packets
self.createObjects(OSHVResult, dstIpOSH, dstHostOSH, dstPort, serverPortOsh, portName, protocolNumber, srcIpOSH, srcHostOSH, octets, packets, srcIgnored)
if not dataFound:
self.Framework.reportWarning("No data to process, please check if Host Resources jobs had already run")
if addPortInAnyCase or self.matchPortConditions(octetsCount, packetsCount, clientsCount):
self.Framework.sendObjects(OSHVResult)
#except JException,ex:
# ex.printStackTrace()
finally:
if result != None:
try:
result.close
except:
pass
st.close()
# conn.close(st)
conn.close()
def discover_private(self):
query = self.buildQuery()
conn = self.Framework.getProbeDatabaseConnection('TCPDISCOVERY')
st = None
result = None
try:
st = conn.createStatement()
result = st.executeQuery(query)
currDestination = None
clientsCount = 0
octetsCount = 0
packetsCount = 0
OSHVResult = ObjectStateHolderVector()
addPortInAnyCase = 0
dstIpOSH = None
dstHostOSH = None
serverPortOsh = None
portName = -1
firstTimeSeenPort = 1
dataFound = 0
while result.next():
dataFound = 1
listen = result.getBoolean('ListenPort')
if listen:
srcAddr = result.getString('SrcAddr')
dstAddr = result.getString('DstAddr')
dstPort = result.getString('DstPort')
else:
srcAddr = result.getString('DstAddr')
dstAddr = result.getString('SrcAddr')
dstPort = result.getString('SrcPort')
if self.ignoreLocalConnections and (srcAddr == dstAddr):
continue
if (not self.shouldInclude(
dstAddr, listen)) or self.isIgnoredIp(dstAddr):
continue
srcIgnored = self.isIgnoredIp(srcAddr) or (
not self.shouldInclude(srcAddr, not listen))
protocolNumber = result.getString('Prot')
destination = dstAddr + ":" + dstPort
if logger.isDebugEnabled():
logger.debug('Current connection:', srcAddr, '->',
destination)
if destination != currDestination:
if OSHVResult != None:
if addPortInAnyCase or self.matchPortConditions(
octetsCount, packetsCount, clientsCount):
self.Framework.sendObjects(OSHVResult)
currDestination = destination
clientsCount = 0
octetsCount = 0
packetsCount = 0
OSHVResult = ObjectStateHolderVector()
addPortInAnyCase = self.checkIfAddPortInAnyCase(result)
firstTimeSeenPort = 1
else:
firstTimeSeenPort = 0
if firstTimeSeenPort:
dstIpOSH = modeling.createIpOSH(dstAddr)
dstHostOSH = modeling.createHostOSH(dstAddr)
if not self.onlyHostDependLinks:
OSHVResult.add(dstIpOSH)
OSHVResult.add(dstHostOSH)
portName = ''
if int(protocolNumber) == NetlinksServices.UDP_PROTOCOL:
portTypeEnum = NetlinksServices.UDP_PORT_TYPE_ENUM
portName = self.knownPortsConfigFile.getUdpPortName(
int(dstPort))
else:
portTypeEnum = NetlinksServices.TCP_PORT_TYPE_ENUM
portName = self.knownPortsConfigFile.getTcpPortName(
int(dstPort))
if portName == None:
portName = dstPort
if logger.isDebugEnabled():
logger.debug('Port ', str(dstPort), ' with name ',
portName)
serverPortOsh = modeling.createServiceAddressOsh(
dstHostOSH, dstAddr, int(dstPort), portTypeEnum,
portName)
OSHVResult.add(serverPortOsh)
srcIpOSH = None
srcHostOSH = None
if not srcIgnored:
srcIpOSH = modeling.createIpOSH(srcAddr)
srcHostOSH = modeling.createHostOSH(srcAddr)
if not self.onlyHostDependLinks:
OSHVResult.add(srcIpOSH)
OSHVResult.add(srcHostOSH)
if not self.onlyHostDependLinks:
containedLink = modeling.createLinkOSH(
'contained', srcHostOSH, srcIpOSH)
OSHVResult.add(containedLink)
if firstTimeSeenPort:
containedLink = modeling.createLinkOSH(
'contained', dstHostOSH, dstIpOSH)
OSHVResult.add(containedLink)
octets = 0
packets = 0
clients = 0
if self.updateUtilizationInfo:
octets = result.getInt('dOctets')
packets = result.getInt('dPkts')
if self.shouldCountClients:
clients = result.getInt('cnt')
clientsCount = clientsCount + clients
octetsCount = octetsCount + octets
packetsCount = packetsCount + packets
self.createObjects(OSHVResult, dstIpOSH, dstHostOSH, dstPort,
serverPortOsh, portName, protocolNumber,
srcIpOSH, srcHostOSH, octets, packets,
srcIgnored)
if not dataFound:
self.Framework.reportWarning(
"No data to process, please check if Host Resources jobs had already run"
)
if addPortInAnyCase or self.matchPortConditions(
octetsCount, packetsCount, clientsCount):
self.Framework.sendObjects(OSHVResult)
#except JException,ex:
# ex.printStackTrace()
finally:
if result != None:
try:
result.close
except:
pass
st.close()
# conn.close(st)
conn.close()
def _buildServiceAddress(self):
serviceAddressOsh = modeling.createServiceAddressOsh(self.osh, self.ipAddress, self.port, modeling.SERVICEADDRESS_TYPE_TCP)
self.resultsVector.add(serviceAddressOsh)
def osh_createTcpConnectionsOsh(lparOsh, primaryIP, knownPortsConfigFile,
connections):
str_containment = 'containment'
_vector = ObjectStateHolderVector()
ignoreLocalConnections = 0 ## ER: parameterize
probeName = CollectorsParameters.getValue(
CollectorsParameters.KEY_COLLECTORS_PROBE_NAME)
for conn in connections:
dstPort = ''
dstAddr = ''
srcAddr = ''
srcPort = ''
id = conn[5]
#(dstAddr, dstPort) = _getIpPortFromSocket(localSocket, primaryIP)
dstAddr = conn[2].strip()
if dstAddr == '0.0.0.0' or dstAddr == '127.0.0.1':
dstAddr = primaryIP.strip()
dstPort = conn[3].strip()
state = conn[9].strip()
#(srcAddr, srcPort) = _getIpPortFromSocket(foreignSocket, primaryIP)
if upper(state) == 'ESTABLISH':
srcAddr = conn[0].strip()
srcPort = conn[1].strip()
if srcAddr == '127.0.0.1':
srcAddr = primaryIP.strip()
if ignoreLocalConnections and (srcAddr == dstAddr):
continue
if isNotNull(dstAddr):
destination = '%s:%s' % (dstAddr, dstPort)
logger.debug('[', state, '] Current connection: ', srcAddr, ' -> ',
destination)
# create destination (server) IP and Host --------------------------
dstIpOsh = modeling.createIpOSH(dstAddr)
if isNotNull(probeName):
dstIpOsh.setAttribute('ip_probename', probeName)
dstHostOsh = None
if isNotNull(lparOsh):
dstHostOsh = lparOsh
else:
dstHostOsh = modeling.createHostOSH(dstAddr)
dstContainedLinkOsh = modeling.createLinkOSH(
str_containment, dstHostOsh, dstIpOsh)
_vector.add(dstIpOsh)
_vector.add(dstHostOsh)
_vector.add(dstContainedLinkOsh)
# create destination service address object ------------------------
portTypeEnum = TCP_PORT_TYPE_ENUM
portName = knownPortsConfigFile.getTcpPortName(int(dstPort))
if upper(state) == 'UDP':
portTypeEnum = UDP_PORT_TYPE_ENUM
portName = knownPortsConfigFile.getUdpPortName(int(dstPort))
if isNull(portName):
portName = dstPort
serverPortOsh = modeling.createServiceAddressOsh(
dstHostOsh, dstAddr, int(dstPort), portTypeEnum, portName)
_vector.add(serverPortOsh)
if isNotNull(srcAddr):
# create source (client) IP and Host ---------------------------
srcIpOsh = modeling.createIpOSH(srcAddr)
if isNotNull(probeName):
srcIpOsh.setAttribute('ip_probename', probeName)
srcHostOsh = modeling.createHostOSH(srcAddr)
srcContainedLinkOsh = modeling.createLinkOSH(
str_containment, srcHostOsh, srcIpOsh)
_vector.add(srcIpOsh)
_vector.add(srcHostOsh)
_vector.add(srcContainedLinkOsh)
# create client-server links -----------------------------------
_vector.add(
_createClientServerLinkOsh(dstPort,
serverPortOsh, portName,
lower(state), srcIpOsh))
# create client server dependency links ------------------------
_vector.add(
_createClientServerDependencyLinkOsh(
dstHostOsh, dstPort, srcHostOsh, portName))
return _vector
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))
def _buildRealServiceAddress(self):
realServiceAddress = modeling.createServiceAddressOsh(self.osh, self.ipAddress,
self.realPort, modeling.SERVICEADDRESS_TYPE_TCP)
self.resultsVector.add(realServiceAddress)
def osh_createTcpConnectionsOsh(lparOsh, primaryIP, knownPortsConfigFile, connections):
str_containment = 'containment'
_vector = ObjectStateHolderVector()
ignoreLocalConnections = 0 ## ER: parameterize
probeName = CollectorsParameters.getValue(CollectorsParameters.KEY_COLLECTORS_PROBE_NAME)
for conn in connections:
dstPort = ''
dstAddr = ''
srcAddr = ''
srcPort = ''
id = conn[5]
#(dstAddr, dstPort) = _getIpPortFromSocket(localSocket, primaryIP)
dstAddr = conn[2].strip()
if dstAddr == '0.0.0.0' or dstAddr == '127.0.0.1':
dstAddr = primaryIP.strip()
dstPort = conn[3].strip()
state = conn[9].strip()
#(srcAddr, srcPort) = _getIpPortFromSocket(foreignSocket, primaryIP)
if upper(state) == 'ESTABLISH':
srcAddr = conn[0].strip()
srcPort = conn[1].strip()
if srcAddr == '127.0.0.1':
srcAddr = primaryIP.strip()
if ignoreLocalConnections and (srcAddr == dstAddr):
continue
if isNotNull(dstAddr):
destination = '%s:%s' % (dstAddr, dstPort)
logger.debug('[', state, '] Current connection: ', srcAddr, ' -> ', destination)
# create destination (server) IP and Host --------------------------
dstIpOsh = modeling.createIpOSH(dstAddr)
if isNotNull(probeName):
dstIpOsh.setAttribute('ip_probename', probeName)
dstHostOsh = None
if isNotNull(lparOsh):
dstHostOsh = lparOsh
else:
dstHostOsh = modeling.createHostOSH(dstAddr)
dstContainedLinkOsh = modeling.createLinkOSH(str_containment, dstHostOsh, dstIpOsh)
_vector.add(dstIpOsh)
_vector.add(dstHostOsh)
_vector.add(dstContainedLinkOsh)
# create destination service address object ------------------------
portTypeEnum = TCP_PORT_TYPE_ENUM
portName = knownPortsConfigFile.getTcpPortName(int(dstPort))
if upper(state) == 'UDP':
portTypeEnum = UDP_PORT_TYPE_ENUM
portName = knownPortsConfigFile.getUdpPortName(int(dstPort))
if isNull(portName):
portName = dstPort
serverPortOsh = modeling.createServiceAddressOsh(dstHostOsh, dstAddr, int(dstPort), portTypeEnum, portName)
_vector.add(serverPortOsh)
if isNotNull(srcAddr):
# create source (client) IP and Host ---------------------------
srcIpOsh = modeling.createIpOSH(srcAddr)
if isNotNull(probeName):
srcIpOsh.setAttribute('ip_probename', probeName)
srcHostOsh = modeling.createHostOSH(srcAddr)
srcContainedLinkOsh = modeling.createLinkOSH(str_containment, srcHostOsh, srcIpOsh)
_vector.add(srcIpOsh)
_vector.add(srcHostOsh)
_vector.add(srcContainedLinkOsh)
# create client-server links -----------------------------------
_vector.add(_createClientServerLinkOsh(dstPort, serverPortOsh, portName, lower(state), srcIpOsh))
# create client server dependency links ------------------------
_vector.add(_createClientServerDependencyLinkOsh(dstHostOsh, dstPort, srcHostOsh, portName))
return _vector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
businessElementId = Framework.getDestinationAttribute('id')
urlString = Framework.getDestinationAttribute('url')
jobId = Framework.getDiscoveryJobId()
dnsServers = Framework.getParameter('dnsServers') or None
localShell = None
if dnsServers:
dnsServers = [
dnsServer for dnsServer in dnsServers.split(',')
if dnsServer and dnsServer.strip()
] or None
if dnsServers:
logger.debug('Using dns servers: ', dnsServers)
localShell = shellutils.ShellUtils(
Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME))
if not urlString:
msg = "There is no specified URL in the input BusinessElement CI"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
try:
urlString = urlString[1:len(urlString) - 1]
if netutils.isValidIp(urlString):
createHostOSHwithIP(OSHVResult, urlString)
return OSHVResult
urlObject = URL(urlString)
hostname = urlObject.getHost()
if not hostname:
logger.debug("Hostname is not defined in URL '%s'" % urlString)
raise MalformedURLException()
urlObjectResolver = URLObjectResolver(urlObject)
protocol = urlObjectResolver.getProtocolFromUrlObject()
if not protocol:
msg = "Failed to resolve the http/https protocol from specified URL"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
port = urlObjectResolver.getPortFromUrlObject()
if not port:
msg = "Failed to resolve the port number from specified URL"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
# get topology
# create business element CI and attach the url as configuration document CI to it
bizOSH = modeling.createOshByCmdbIdString('business_element',
businessElementId)
urlConfigOSH = modeling.createConfigurationDocumentOSH(
'url.txt', '', urlString, bizOSH)
linkBizUrlConifg = modeling.createLinkOSH('composition', bizOSH,
urlConfigOSH)
OSHVResult.add(bizOSH)
OSHVResult.add(urlConfigOSH)
OSHVResult.add(linkBizUrlConifg)
hostDNSName = None
if not netutils.isValidIp(hostname):
# Treat the host name as its DNS name if it is not a valid ip address
hostDNSName = hostname
ipAddresses = []
if dnsServers:
ipAddresses = urlObjectResolver.getIpFromUrlObjectWithDnsList(
dnsServers, localShell)
else:
ipAddresses = urlObjectResolver.getIpFromUrlObject()
for ipAddress in ipAddresses:
logger.debug('Reporting ip address: ', ipAddresses)
if not ipAddress or not netutils.isValidIp(
ipAddress) or netutils.isLocalIp(ipAddress):
msg = "Failed to resolve the IP address of server from specified URL"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
hostOSH, ipOSH = createHostOSHwithIP(OSHVResult, ipAddress)
if hostDNSName:
ipOSH.setAttribute('authoritative_dns_name', hostDNSName)
# create UriEndpoint and relations between business element and UriEndpoint
urlOSH = modeling.createServiceURLAddressOsh(hostOSH, urlString)
linkBizUrl = modeling.createLinkOSH('usage', bizOSH, urlOSH)
OSHVResult.add(urlOSH)
OSHVResult.add(linkBizUrl)
# create ipServiceEndpoint and relations between UriEndpoint and ipServiceEndpoint
ipPort = modeling.createServiceAddressOsh(
hostOSH, ipAddress, port, modeling.SERVICEADDRESS_TYPE_TCP)
linkUrlIP = modeling.createLinkOSH('dependency', urlOSH, ipOSH)
OSHVResult.add(ipPort)
OSHVResult.add(linkUrlIP)
except MalformedURLException:
msg = "Specified URL '%s' is malformed" % urlString
errormessages.resolveAndReport(msg, jobId, Framework)
except:
msg = logger.prepareJythonStackTrace("")
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
businessElementId = Framework.getDestinationAttribute('id')
urlString = Framework.getDestinationAttribute('url')
jobId = Framework.getDiscoveryJobId()
dnsServers = Framework.getParameter('dnsServers') or None
localShell = None
if dnsServers:
dnsServers = [dnsServer for dnsServer in dnsServers.split(',') if dnsServer and dnsServer.strip()] or None
if dnsServers:
logger.debug('Using dns servers: ', dnsServers)
localShell = shellutils.ShellUtils(Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME))
if not urlString:
msg = "There is no specified URL in the input BusinessElement CI"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
try:
urlString = urlString[1:len(urlString)-1]
if netutils.isValidIp(urlString):
createHostOSHwithIP(OSHVResult, urlString)
return OSHVResult
urlObject = URL(urlString)
hostname = urlObject.getHost()
if not hostname:
logger.debug("Hostname is not defined in URL '%s'" % urlString)
raise MalformedURLException()
urlObjectResolver = URLObjectResolver(urlObject)
protocol = urlObjectResolver.getProtocolFromUrlObject()
if not protocol:
msg = "Failed to resolve the http/https protocol from specified URL"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
port = urlObjectResolver.getPortFromUrlObject()
if not port:
msg = "Failed to resolve the port number from specified URL"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
# get topology
# create business element CI and attach the url as configuration document CI to it
bizOSH = modeling.createOshByCmdbIdString('business_element', businessElementId)
urlConfigOSH = modeling.createConfigurationDocumentOSH('url.txt', '', urlString, bizOSH)
linkBizUrlConifg = modeling.createLinkOSH('composition', bizOSH, urlConfigOSH)
OSHVResult.add(bizOSH)
OSHVResult.add(urlConfigOSH)
OSHVResult.add(linkBizUrlConifg)
hostDNSName = None
if not netutils.isValidIp(hostname):
# Treat the host name as its DNS name if it is not a valid ip address
hostDNSName = hostname
ipAddresses = []
if dnsServers:
ipAddresses = urlObjectResolver.getIpFromUrlObjectWithDnsList(dnsServers, localShell)
else:
ipAddresses = urlObjectResolver.getIpFromUrlObject()
for ipAddress in ipAddresses:
logger.debug('Reporting ip address: ', ipAddresses)
if not ipAddress or not netutils.isValidIp(ipAddress) or netutils.isLocalIp(ipAddress):
msg = "Failed to resolve the IP address of server from specified URL"
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
hostOSH, ipOSH = createHostOSHwithIP(OSHVResult, ipAddress)
if hostDNSName:
ipOSH.setAttribute('authoritative_dns_name', hostDNSName)
# create UriEndpoint and relations between business element and UriEndpoint
urlOSH = modeling.createServiceURLAddressOsh(hostOSH, urlString)
linkBizUrl = modeling.createLinkOSH('usage', bizOSH, urlOSH)
OSHVResult.add(urlOSH)
OSHVResult.add(linkBizUrl)
# create ipServiceEndpoint and relations between UriEndpoint and ipServiceEndpoint
ipPort = modeling.createServiceAddressOsh(hostOSH, ipAddress, port, modeling.SERVICEADDRESS_TYPE_TCP)
linkUrlIP = modeling.createLinkOSH('dependency', urlOSH, ipOSH)
OSHVResult.add(ipPort)
OSHVResult.add(linkUrlIP)
except MalformedURLException:
msg = "Specified URL '%s' is malformed" % urlString
errormessages.resolveAndReport(msg, jobId, Framework)
except:
msg = logger.prepareJythonStackTrace("")
errormessages.resolveAndReport(msg, jobId, Framework)
return OSHVResult
