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