def discoverAllInstances(client, config): r''' Can be only applied for discovery by JMX due to deserialization limitatations of WebServices client @types: BaseSapJmxClient, DiscoveryConfig -> oshv''' discoverer = sap_jee_discoverer.ClusterDiscoverer(client) clusterInfo = discoverer.getClusterInfo() cluster = clusterInfo.cluster instances = clusterInfo.instances system = sap.System(cluster.getName()) systemOsh, clusterOsh, vector = _reportSapSystem(system) linkReporter = sap.LinkReporter() ipsPerInst = zip(map(_resolveInstInfoHostname, instances), instances) hasResolvedIps = first endReporter = netutils.EndpointReporter(netutils.ServiceEndpointBuilder()) for ips, instInfo in filter(hasResolvedIps, ipsPerInst): inst = instInfo.instance instOsh, hostOsh, iVector = reportInst(inst, system, systemOsh, clusterOsh, ips, reportInstName=True) vector.addAll(iVector) resolve = sap_jee_discoverer._resolvedEndpointAddress for endp in flatten(keep(resolve, instInfo.endpoints)): endpOsh = endReporter.reportEndpoint(endp, hostOsh) vector.add(endpOsh) vector.add(linkReporter.reportUsage(instOsh, endpOsh)) return vector
def reportProcessToPort(hostId, processes, endpoints): if not (processes and endpoints): return vector = ObjectStateHolderVector() hostOsh = modeling.createOshByCmdbId('node', hostId) vector.add(hostOsh) proc_builder = ProcessBuilder() key_to_endpoints_map = {} [ key_to_endpoints_map.update({x.getKey(): x.getEndpoints()}) for x in endpoints ] for process in processes: processOsh = proc_builder.buildProcessOsh(process) processOsh.setContainer(hostOsh) vector.add(processOsh) remotes = key_to_endpoints_map.get(process.getPid()) if remotes: for remote in remotes: if not netutils.isValidIp(remote.getAddress()): logger.debug(remote, ' is not a valid ip') continue builder = netutils.ServiceEndpointBuilder() reporter = netutils.EndpointReporter(builder) nodeOsh = reporter.reportHostFromEndpoint(remote) endpointOsh = reporter.reportEndpoint(remote, nodeOsh) linkOsh = modeling.createLinkOSH('client_server', processOsh, endpointOsh) linkOsh.setStringAttribute('clientserver_protocol', 'tcp') vector.add(nodeOsh) vector.add(endpointOsh) vector.add(linkOsh) return vector
def _reportHostByEndpoints(endpoints): ''' Return node osh, list of endpoint OSHs and all oshs in one list @types: list[Endpoint] -> osh, list[osh], oshv''' hostReporter = sap.HostReporter(sap.HostBuilder()) ips = map(netutils.Endpoint.getAddress, endpoints) hostOsh, vector = hostReporter.reportHostWithIps(*ips) reporter = netutils.EndpointReporter(netutils.ServiceEndpointBuilder()) oshs = [reporter.reportEndpoint(e, hostOsh) for e in endpoints] return hostOsh, oshs, oshs + [hostOsh] + list(vector)
def _reportEndpointLinkedToSoftware(endpoint, containerOsh, softwareOsh): r''' @type endpoint: netutils.Endpoint @rtype: tuple[ObjectStateHolder, ObjectStateHolderVector] @return: pair of endpoint OSH and vector with all reported links ''' endpointBuilder = netutils.ServiceEndpointBuilder() endpointReporter = netutils.EndpointReporter(endpointBuilder) endpointOsh = endpointReporter.reportEndpoint(endpoint, containerOsh) vec = ObjectStateHolderVector() vec.add(endpointOsh) vec.add(LinkReporter().reportUsage(softwareOsh, endpointOsh)) return endpointOsh, vec
def _reportServerEndp(endpoint, processOsh, applicationOsh=None): vector = ObjectStateHolderVector() builder = netutils.ServiceEndpointBuilder() endpointReporter = netutils.EndpointReporter(builder) linkR = sap.LinkReporter() hostOsh = endpointReporter.reportHostFromEndpoint(endpoint) endpOsh = endpointReporter.reportEndpoint(endpoint, hostOsh) vector.add(hostOsh) vector.add(endpOsh) # client-server link with dispatcher process vector.add(linkR.reportClientServerRelation(processOsh, endpOsh)) if applicationOsh: vector.add(linkR.reportClientServerRelation(applicationOsh, endpOsh)) return endpOsh, hostOsh, vector
def __init__( self, running_software_builder=RunningSoftwareBuilder(), webseal_server_builder=WebsealServerBuilder(), policy_server_builder=PolicyServerBuilder(), junction_builder=JunctionBuilder(), ldap_software_builder=LdapBuilder(), ): self.running_software_builder = running_software_builder self.webseal_server_builder = webseal_server_builder self.policy_server_builder = policy_server_builder self.junction_builder = junction_builder self.ldap_software_builder = ldap_software_builder self.host_reporter = host_topology.Reporter() self.endpoint_reporter = netutils.EndpointReporter( netutils.ServiceEndpointBuilder()) self.link_reporter = LinkReporter()
def process(self, context): r''' @types: applications.ApplicationSignatureContext ''' shell = context.client dnsResolver = netutils.DnsResolverByShell(shell) addressToEndpoints = {} for nsOption in self._nsOptions: parsedEndpoints = buildEndpointsFromNsOption(nsOption, dnsResolver) addressToEndpoints.setdefault(nsOption.address, []).extend(parsedEndpoints) hostBuilder = HostBuilder() linkReporter = LinkReporter() endpointBuilder = netutils.ServiceEndpointBuilder() endpointReporter = netutils.EndpointReporter(endpointBuilder) endpointsOshs = [] for address, endpoints in addressToEndpoints.items(): hostOsh = hostBuilder.buildHostByHostname(parseHostnameFromAddress(address)) context.resultsVector.add(hostOsh) ips = map(netutils.Endpoint.getAddress, endpoints) ipOshs = map(modeling.createIpOSH, ips) fptools.each(context.resultsVector.add, ipOshs) reportContainment = fptools.partiallyApply(linkReporter.reportContainment, hostOsh, fptools._) fptools.each(context.resultsVector.add, map(reportContainment, ipOshs)) endpointsOshs.extend(map(fptools.partiallyApply(endpointReporter.reportEndpoint, fptools._, hostOsh), endpoints)) applicationOsh = context.application.applicationOsh for endpointsOsh in endpointsOshs: context.resultsVector.add(endpointsOsh) clientServerOsh = linkReporter.reportClientServerRelation(applicationOsh, endpointsOsh) context.resultsVector.add(clientServerOsh)
def _reportWdEndpoints(instPf, serverOsh, shell, connectionIp): #x) report end-points of web-dispatcher itself and resolve them dispatcherEndpoints = instPf.getDispatcherEndpoints() resolveEndpointAddress = _getEndpResolveFn(shell, connectionIp) endpoints = flatten(keep(resolveEndpointAddress, dispatcherEndpoints)) vector = ObjectStateHolderVector() builder = netutils.ServiceEndpointBuilder() endpointReporter = netutils.EndpointReporter(builder) linkReporter = sap.LinkReporter() for endpoint in endpoints: hostOsh = endpointReporter.reportHostFromEndpoint(endpoint) vector.add(hostOsh) endpointOsh = endpointReporter.reportEndpoint(endpoint, hostOsh) vector.add(endpointOsh) vector.add(linkReporter.reportUsage(serverOsh, endpointOsh)) return vector
def createOAMOsh(endpoint, apacheOsh, vector): """ Create OAM osh on oam endpoint, oam node & client server relation """ logger.debug('submit OAM endpoint: %s' % endpoint) builder = netutils.ServiceEndpointBuilder() reporter = netutils.EndpointReporter(builder) nodeOsh = reporter.reportHostFromEndpoint(endpoint) endpointOsh = reporter.reportEndpoint(endpoint, nodeOsh) linkOsh = modeling.createLinkOSH('client_server', apacheOsh, endpointOsh) linkOsh.setStringAttribute('clientserver_protocol', 'tcp') oamServerOsh = modeling.createApplicationOSH('running_software', 'Oracle Access Management', nodeOsh, None, 'oracle_corp') usageOsh = modeling.createLinkOSH('usage', oamServerOsh, endpointOsh) vector.add(nodeOsh) vector.add(endpointOsh) vector.add(linkOsh) vector.add(oamServerOsh) vector.add(usageOsh)
def discover(shell, iisOSH, hostIPs, iis_version, webservice_ext_filter=[]): appCmdDiscover = AppCmdDiscover(shell, hostIPs) endpoint_builder = netutils.ServiceEndpointBuilder() builder = iis_reporter.TopologyBuilder() endpoint_reporter = netutils.EndpointReporter(endpoint_builder) resolver = dns_resolver.create(shell=None) odbcBuilder = odbc_reporter.TopologyBuilder(resolver) odbcReporter = odbc_reporter.Reporter(odbcBuilder) odbc_data_cache = discover_odbc_info(shell) reporter = iis_reporter.TopologyReporter(builder, endpoint_reporter, odbcReporter, odbc_data_cache) app_pools = appCmdDiscover.discover_app_pools() vdirs = appCmdDiscover.discover_vdirs(webservice_ext_filter) apps = appCmdDiscover.discover_apps(vdirs, shell, webservice_ext_filter) sites = appCmdDiscover.discover_sites(app_pools, apps) topology = reporter.reportTopology(app_pools.values(), sites, iisOSH, iis_version, webservice_ext_filter) return topology
def reportTrexHostNode(hostNode, topology, isBiaProduct): r'@types: TrexTopologyConfig.HostNode, TrexTopologyConfig, bool -> ObjectStateHolderVector' trexBuilder = sap_trex.Builder() trexReporter = sap_trex.Reporter(trexBuilder) hostReporter = sap_trex.HostReporter(sap_trex.HostBuilder()) endpointReporter = netutils.EndpointReporter( netutils.ServiceEndpointBuilder()) linkReporter = sap.LinkReporter() softwareBuilder = sap.SoftwareBuilder() # x) create sap system system = hostNode.system vector = ObjectStateHolderVector() # process NameServer endpoints and ignore loopback endpoints isLoopbackEndpoint = lambda e: netutils.isLoopbackIp(e.getAddress()) _, endpoints = fptools.partition(isLoopbackEndpoint, hostNode.nameServerEndpoints) # x) create host OSH hostOsh = hostReporter.reportHostByHostname(hostNode.name) vector.add(hostOsh) # x) report IPs ips = map(netutils.Endpoint.getAddress, endpoints) ipOshs = map(modeling.createIpOSH, ips) fptools.each(vector.add, ipOshs) #vector.addAll(ipOshs) # x) report containment between host nad ips reportContainment = fptools.partiallyApply(linkReporter.reportContainment, hostOsh, fptools._) fptools.each(vector.add, map(reportContainment, ipOshs)) # x) report end-points reportEndpoint = fptools.partiallyApply(endpointReporter.reportEndpoint, fptools._, hostOsh) endpointOshs = map(reportEndpoint, endpoints) fptools.each(vector.add, endpointOshs) # x) report TREX instance itself instanceOsh = trexReporter.reportInstance(first(system.getInstances()), hostOsh) # x) mark as BIA or plain-TREX productName = (isBiaProduct and sap_trex.Product.BIA.instanceProductName or sap_trex.Product.TREX.instanceProductName) softwareBuilder.updateDiscoveredProductName(instanceOsh, productName) # x) set name server role (master, slave or 1st master) nameServerPort = first(endpoints).getPort() nameServerEndpoint = netutils.createTcpEndpoint(hostNode.name, nameServerPort) topologyGlobals = topology.getGlobals() isMaster = nameServerEndpoint in (fptools.safeFunc( topologyGlobals.getMasterEndpoints)() or ()) isActiveMaster = nameServerEndpoint in (fptools.safeFunc( topologyGlobals.getActiveMasterEndpoints)() or ()) trexBuilder.updateNameServerMode( instanceOsh, (isMaster and (isActiveMaster and sap_trex.NameServerMode.FIRST_MASTER or sap_trex.NameServerMode.MASTER) or sap_trex.NameServerMode.SLAVE)) vector.add(instanceOsh) # x) DO NOT report 'membership' between system and instance # Explanation: # sometimes you can discover systems that don't have relationship to current host. # This can lead to incorrect merging of to systems (inside OSH vector) # systemOsh = trexReporter.reportSystem(system) # vector.add(systemOsh) # vector.add(linkReporter.reportMembership(systemOsh, instanceOsh)) # x) report 'usage' between instance and endpoints of name-server reportUsage = fptools.partiallyApply(linkReporter.reportUsage, instanceOsh, fptools._) fptools.each(vector.add, map(reportUsage, endpointOshs)) return vector
osh = self.software_builder.updateHostname(osh, hostname) logger.info("Discover message server port") try: listen_endpoints = app.getEndpointsByProcess(process) ip_endpoints = self.get_service_endpoints(shell, system, listen_endpoints, app) osh.setIntegerAttribute('application_port', int(ip_endpoints[0].getPort())) except (JException, Exception), e: logger.warn("Failed to get process endpoints. %s" % e) else: linkReporter = sap.LinkReporter() vector = context.resultsVector service_name = sap.MessageServerBuilder.SERVICE_NAME for ip_endpoint in ip_endpoints: host_osh = app.getHostOsh() ip_endpoint_builder = netutils.ServiceEndpointBuilder() reporter = netutils.EndpointReporter(ip_endpoint_builder) ip_endpoint_osh = reporter.reportEndpoint(ip_endpoint, host_osh) ip_endpoint_builder.setNameAttr(ip_endpoint_osh, service_name) vector.add(linkReporter.reportUsage(osh, ip_endpoint_osh)) vector.add(ip_endpoint_osh) def get_version_cmd(self, bin_path): return GetMsgServerVersionInfo(bin_path) def get_service_endpoints(self, shell, system, endpoints, application_server): r''' Get endpoints used by message server fo SAP System logon via SAP Logon tool @types: Shell, System, list[Endpoint], Application -> list[Endpoint] ''' #sapms<SID> <PORT>/<tcp|udp> # comment service_name = 'sapms%s' % re.escape(system.getName())
def _reportGatewayEndpoint(ip, port, containerOsh): '@types: str, str, osh -> osh' endpoint = netutils.createTcpEndpoint(ip, port) reporter = netutils.EndpointReporter(netutils.ServiceEndpointBuilder()) return reporter.reportEndpoint(endpoint, containerOsh)
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 DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() client = None hostOsh = None shell = None ## Destination data hostId = Framework.getDestinationAttribute('hostId') or None bwId = Framework.getDestinationAttribute('bwId') or None bwPath = Framework.getDestinationAttribute('bwPath') or None protocol = Framework.getDestinationAttribute('Protocol') ip_address = Framework.getDestinationAttribute('ip_address') tmpDirPath = Framework.getParameter('temp_directory') or '/tmp' isDiscoverJms = Framework.getParameter('discover_jms_topology') or "true" isDiscoverJms = Boolean.valueOf(isDiscoverJms) ## Container HOST OSH if hostId: hostOsh = modeling.createOshByCmdbIdString('node', hostId.strip()) OSHVResult.add(hostOsh) logger.debug('[' + __name__ + ':DiscoveryMain] Got HOSTID <%s>' % hostId) ## Pre-discovered Business Works CI bwOsh = None if bwId: bwOsh = modeling.createOshByCmdbIdString('tibco_business_works', bwId.strip()) logger.debug('[' + __name__ + ':DiscoveryMain] Got bwId <%s>' % bwId) else: errMsg = '[' + __name__ + ':DiscoveryMain] Invalid TibcoBusinessWorks CI ID received from server. This BW will not be processed' logger.error(errMsg) logger.reportError(errMsg) return OSHVResult if not tmpDirPath: errMsg = '[' + __name__ + ':DiscoveryMain] temp_directory parameter has not been set correctly. Discovery cannot continue until this parameter is set with a remote directory with write permissions.' logger.error(errMsg) logger.reportError(errMsg) return OSHVResult try: try: client = Framework.createClient() shell = shellutils.ShellFactory().createShell(client) credList = Framework.getAvailableProtocols(ip_address, tibco.TIBCO_PROTOCOL) logger.info("Found tibco credentials: %s" % len(credList)) fs = tibco_discoverer.createFileSystem(shell) bw = tibco_discoverer.BusinessWorksDiscoverer( ).findBWVersionFromPath(bwPath) domains = tibco_discoverer.BusinessWorksDomainDiscoverer( shell, fs).discover(bwPath) traHomeDiscoverer = tibco_discoverer.TicboTraHomeDiscoverer(shell) traHomes = traHomeDiscoverer.discover() fallbackDnsResolver = tibco_discoverer.FallbackResolver([ netutils.JavaDnsResolver(), netutils.DnsResolverByShell(shell) ]) dnsResolver = tibco_discoverer.CachedResolver(fallbackDnsResolver) if traHomes and bw: traPath = traHomes[0] for domain in domains: logger.info("Visit %s" % domain) try: applications = None # Check if we have any credential for TIBCO if credList: for credId in credList: adminCommand = tibco_discoverer.AppManageAdminCommand( client, credId, "./") adapterDiscoverer = tibco_discoverer.TibcoAdapterDiscoverer( dnsResolver) appDiscoverer = tibco_discoverer.BusinessWorksApplicationDiscoverer( shell, fs, adminCommand, adapterDiscoverer) applications = appDiscoverer.discover( domain.getName(), traPath, tmpDirPath, discoverJmsTopology=isDiscoverJms) if applications: tibco.each(domain.addApplication, applications) else: msg = errormessages.makeErrorMessage( tibco.TIBCO_PROTOCOL, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError( errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [tibco.TIBCO_PROTOCOL], msg) logger.reportErrorObject(errobj) bw.addDomain(domain) except tibco_discoverer.TibcoDiscovererException, exc: logger.debugException(str(exc)) errorobj = errorobject.createError( errorcodes. FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, ['tibco', 'error: %s' % str(exc)], str(exc)) logger.reportErrorObject(errorobj) except: logger.debugException('') exInfo = logger.prepareJythonStackTrace( '[' + __name__ + ':DiscoveryMain] Error connecting: ') errormessages.resolveAndReport(exInfo, protocol, Framework) else: # Reporting logger.debug("--- Start reporting ---") reporter = tibco.TopologyReporter(tibco.TopologyBuilder()) bwOsh = reporter.reportBusinessWorks(bw, hostOsh, bwId) OSHVResult.add(bwOsh) endpointReporter = netutils.EndpointReporter( netutils.ServiceEndpointBuilder()) for domain in domains: domainOsh = reporter.reportBusinessWorksDomain(domain) OSHVResult.add(domainOsh) OSHVResult.add(reporter.reportBWAndDomainLink( domainOsh, bwOsh)) for app in domain.getApplications(): appOsh = reporter.reportBusinessWorksApp(app, bwOsh) OSHVResult.add(appOsh) if app.getJmsServers(): for jmsServer in app.getJmsServers(): # Trying to resolver host name try: ip = netutils.getLowestIp( dnsResolver.resolveIpsByHostname( jmsServer.hostname)) if ip: jmsServer.hostname = ip except Exception, ex: logger.debugException(str(ex)) if netutils.isValidIp( jmsServer.hostname ) and not netutils.isLoopbackIp( jmsServer.hostname): jmsHostOsh = modeling.createHostOSH( jmsServer.hostname) emsServerOsh = reporter.reportEMSServer( tibco.EmsServer(), jmsHostOsh) jmsServerOsh = reporter.reportJmsServer( jmsServer, emsServerOsh) endpoint = netutils.createTcpEndpoint( jmsServer.hostname, jmsServer.getPort()) serviceOsh = endpointReporter.reportEndpoint( endpoint, jmsHostOsh) linkOsh = reporter.reportEmsServerServiceAddressLink( emsServerOsh, serviceOsh) OSHVResult.add(emsServerOsh) OSHVResult.add(jmsHostOsh) OSHVResult.add(jmsServerOsh) OSHVResult.add(serviceOsh) OSHVResult.add(linkOsh) for jmsQueue in app.getJmsQueues(): OSHVResult.addAll( reporter.reportJmsDestinationTopology( jmsQueue, jmsServerOsh, appOsh)) for jmsTopic in app.getJmsTopics(): OSHVResult.addAll( reporter.reportJmsDestinationTopology( jmsTopic, jmsServerOsh, appOsh)) if app.getAdapters(): for adapter in app.getAdapters(): OSHVResult.addAll( reporter.reportAdapterTopology( adapter, appOsh)) finally: if shell: ## Close shell connection shell.closeClient() return OSHVResult
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() cmclconfig_path = getParameter(Framework, 'cmclconfig_path', '/etc/cmcluster/') cmclconfig_files_pattern = getParameter(Framework, 'cmclconfig_file', 'ascii') client = None try: try: client = Framework.createClient() shell = ShellUtils(client) clusterDiscoverer = ServiceGuardClusterDiscoverer(shell) cluster = clusterDiscoverer.discover() if cluster.packages: # in case any running packages were discovered, # try to discover package mount points, ips and networks # which do not appear in cmview command output addPkgInfoDiscoverer = AdditionalPackageResourcesDiscoverer( shell) packageNameToPackageMap = addPkgInfoDiscoverer.discover( cmclconfig_path, cluster) #merging data into the stored packages DO for package in cluster.packages: addPackage = packageNameToPackageMap.get(package.name) if addPackage: package.mountPoints = addPackage.mountPoints package.additionalIpList = addPackage.additionalIpList package.ipNetworkList = addPackage.ipNetworkList endpointReporter = netutils.EndpointReporter( netutils.ServiceEndpointBuilder()) quorumServerReporter = service_guard.QuorumServerReporter( service_guard.QuorumServerBuilder(), endpointReporter) vector = Reporter(quorumServerReporter).report(cluster) OSHVResult.addAll(vector) softwareInformationList = [] for discoverer in (OracleDiscoverer(shell), OracleIasDiscoverer(shell)): try: softwareInformationList.extend(discoverer.discover()) except: logger.debugException('') if softwareInformationList: relationsBuilder = PackageToRunningSoftwareTopologyBuilder( cluster) OSHVResult.addAll( relationsBuilder.build(softwareInformationList)) if cluster.osh != None: discoverConfigFiles(Framework, cluster.osh, shell, cmclconfig_path, cmclconfig_files_pattern, OSHVResult) else: errobj = errorobject.createError( errorcodes.SERVICE_GUARD_CLUSTER_NOT_FOUND, None, 'Service Guard Cluster not found in discovery') logger.reportWarningObject(errobj) except: msg = sys.exc_info()[1] strmsg = '%s' % msg if (strmsg.lower().find('timeout') > -1): errobj = errorobject.createError( errorcodes.CONNECTION_TIMEOUT_NO_PROTOCOL, None, 'Connection timed out') logger.reportErrorObject(errobj) logger.debugException('Connection timed out') else: errobj = errormessages.resolveError(strmsg, 'shell') logger.reportErrorObject(errobj) logger.errorException(strmsg) finally: if client != None: client.close() return OSHVResult
def doApplication(Framework, ip, OSHVResult, client, shell, hostOsh): clientType = client.getClientType() language = Framework.getDestinationAttribute('language') portToDiscover = Framework.getDestinationAttribute("PORT") scp_id = Framework.getDestinationAttribute("SCP_ID") portInNetstat = False processMapOnPort = {} signatureFound = False filterRunningSoftwareByPort = Framework.getParameter('filterRunningSoftwareByPort') logger.debug("Start to do host application") logger.debug("ip:", ip) #hostOsh = modeling.createHostOSH(ip) platformTrait = None processes = [] packageToExecutablePath = {} CLUSTERLIST = ["Microsoft Cluster SW"] if shell.isWinOs(): uname = 'Win' #client = shell if (language != None) and (language != 'NA'): langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY', language) else: langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY') try: wmicPath = Framework.getParameter('wmicPath') if wmicPath: shell.execCmd('set PATH=%PATH%;' + wmicPath) except: logger.debug('Failed to add default wmic location to the PATH variable.') else: if shell.getClientType() == 'ssh': uname = netutils.getOSName(client, 'uname -a') else: uname = netutils.getOSName(client, 'uname') langBund = Framework.getEnvironmentInformation().getBundle('langHost_Resources_By_TTY', 'eng') # get platform details try: platformTrait = process_discoverer.getPlatformTrait(shell) if platformTrait is None: raise ValueError() except: logger.warnException("Failed to determine platform") # discover processes if platformTrait and not uname == 'VMkernel': try: discoverer = process_discoverer.getDiscovererByShell(shell, platformTrait) processes = discoverer.discoverAllProcesses() if not processes: raise ValueError() except: errorMessage = 'Failed to discover processes by shell' TTY_HR_Main.logWarn(Framework, errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['processes', clientType], errorMessage) if processes: # save processes to DB #process_discoverer.saveProcessesToProbeDb(processes, hostId, Framework) # discover packages info try: packagesDiscoverer = process_discoverer.getPackagesDiscovererByShell(shell, platformTrait) packageToExecutablePath = packagesDiscoverer.getPackagesByProcesses(processes) except: logger.warn("Failed to get package names by processes path") # report processes #if discoverProcesses: connectivityEndPoints = [] connections = [] runningApplications = [] errorsList = [] #No tcp and p2p discovery for vmkernel if not uname == 'VMkernel': try: tcpDiscoverer = asm_Disc_TCP.getDiscovererByShell(client, Framework, shell) if tcpDiscoverer is not None: tcpDiscoverer.pdu = asm_Disc_TCP.TcpStateHolder(None) tcpDiscoverer.discoverTCP() connections = tcpDiscoverer.pdu.tcp_connections connectivityEndPoints = tcpDiscoverer.getProcessEndPoints() except: errorMessage = 'Failed to run tcp discovery by shell' TTY_HR_Main.logWarn(Framework, errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, ['tcp', clientType], errorMessage) #if workInTopDown: linkOshv = ObjectStateHolderVector() processReporter = process.Reporter() processBuilder = process.ProcessBuilder() for connectivityEndPoint in connectivityEndPoints: processid = connectivityEndPoint.getKey() endpoints = connectivityEndPoint.getEndpoints() #logger.debug('#processid=', processid) #logger.debug('#endpoints=', endpoints) for processObject in processes: #logger.debug('#processObject.getPid()=', processObject.getPid()) #logger.debug('#processObject.getName()=', processObject.getName()) if 4 < processid == processObject.getPid() and processObject.getName() != 'svchost.exe': processOSH, _ = processReporter.report(hostOsh, processObject, processBuilder) for endpoint in endpoints: if str(portToDiscover) == str(endpoint.getPort()): portInNetstat = True processMapOnPort[processid] = processObject builder = netutils.ServiceEndpointBuilder() reporter = netutils.EndpointReporter(builder) ipServerOSH = reporter.reportEndpoint(endpoint, hostOsh) linkOsh = modeling.createLinkOSH('usage', processOSH, ipServerOSH) linkOshv.add(linkOsh) break if not portInNetstat: errorMessage = errormessages.makeErrorMessage(clientType, message=portToDiscover, pattern=errormessages.ERROR_FINDING_PROCESS_BY_PORT) logger.debugException("port cannot be found:", portToDiscover) errobj = errorobject.createError(errorcodes.FAILED_FINDING_PROCESS_BY_PORT, [portToDiscover], errorMessage) errorsList.append(errobj) OSHVResult.addAll(linkOshv) framework_delegator = Framework_delegator.FrameworkDelegator() appSign = asm_applications.createASMApplicationSignature(Framework, framework_delegator, client, shell) if processes: appSign.setProcessesManager(applications.ProcessesManager(processes, connectivityEndPoints)) servicesByCmd = Hashtable() servicesInfo = applications.ServicesInfo(servicesByCmd) appSign.setServicesInfo(servicesInfo) cmdLineToInstalledSoftware = {} softNameToInstSoftOSH = {} softwareInfo = applications.InstalledSoftwareInfo(cmdLineToInstalledSoftware, softNameToInstSoftOSH) appSign.setInstalledSoftwareInfo(softwareInfo) runningApplications = appSign.getApplicationsTopologyUsingHostOsh(hostOsh) logger.debug('runningApplications=%s' % runningApplications) logger.debug('adding netstat port results') for application in runningApplications: pids = [str(x.getPid()) for x in application.getProcesses() if x] logger.debug('pids for application:%s %s' % (application.getName(), pids)) if pids in processMapOnPort.keys(): signatureFound = True for connectivityEndPoint in connectivityEndPoints: processid = connectivityEndPoint.getKey() endpoints = connectivityEndPoint.getEndpoints() if str(processid) in pids: for endpoint in endpoints: logger.debug('adding port:', endpoint.getPort()) framework_delegator.addNetstatPortResult(application.getName(), endpoint.getPort()) if (not signatureFound) and processMapOnPort.values(): errorMessage = errormessages.makeErrorMessage( clientType, message="%s listening on port %s" % (processMapOnPort.values(), portToDiscover), pattern=errormessages.ERROR_FINDING_APPSIG_BY_PROCESS) logger.debugException("no listening port found for process %s and port %s" % (processMapOnPort.values(), portToDiscover)) errobj = errorobject.createError(errorcodes.FAILED_FINDING_APPSIG_BY_PROCESS, [repr(processMapOnPort.values()), portToDiscover], errorMessage) errorsList.append(errobj) filteredRunningApplications = [] if filterRunningSoftwareByPort and filterRunningSoftwareByPort == 'true': logger.debug('try to filter running applications using port:', portToDiscover) logger.debug('application list using port filter', framework_delegator.getApplicationNamesByPort(portToDiscover)) for runningApplication in runningApplications: if runningApplication.getName() in framework_delegator.getApplicationNamesByPort(portToDiscover): logger.debug("adding application: ", runningApplication.getName()) filteredRunningApplications.append(runningApplication) elif runningApplication.getName() in CLUSTERLIST: logger.debug("include cluster related ci: ", runningApplication.getName()) filteredRunningApplications.append(runningApplication) OSHVResult.addAll( framework_delegator.getResultVectorByApplicationName(runningApplication.getName())) else: logger.debug("remove application: ", runningApplication.getName()) logger.debug('filteredRunningApplications=%s' % filteredRunningApplications) if not filteredRunningApplications: logger.debug("running software for port was not found:", portToDiscover) for resultVector in framework_delegator.getResultVectorsByPort(portToDiscover): OSHVResult.addAll(resultVector) #create ownership between runningsoftware and scp logger.debug("create ownership between runningsoftware and scp") for runningApplication in filteredRunningApplications: logger.debug("APP:", runningApplication.getName()) OSHVResult.addAll(scp.createOwnerShip(scp_id, runningApplication.getOsh())) else: logger.debug('filterRunningSoftwareByPort is %s, will report all running software discovered') for runningApplication in runningApplications: filteredRunningApplications.append(runningApplication) OSHVResult.addAll(framework_delegator.getResultVectorByApplicationName(runningApplication.getName())) OSHVResult.addAll(scp.createOwnerShip(scp_id, runningApplication.getOsh())) logger.debug("crgMap = ", appSign.crgMap) vector = ObjectStateHolderVector() vector.addAll(OSHVResult) if appSign.crgMap: for osh in vector: oshClass = osh.getObjectClass() #weak node if oshClass == 'node' and osh.getAttributeValue('host_iscomplete') == 0 and osh.getAttributeValue( 'host_key'): ip = osh.getAttributeValue('host_key').split(' ')[0] if ip in appSign.crgMap.keys(): logger.debug("replace weak node:", osh.getAttribute("host_key")) OSHVResult.remove(osh) OSHVResult.add(appSign.crgMap[ip]) #root container elif osh.getAttribute('root_container'): obj = osh.getAttribute("root_container").getObjectValue() if obj.getObjectClass() == 'node' and obj.getAttributeValue( 'host_iscomplete') == 0 and obj.getAttributeValue('host_key'): logger.debug("replace root_container:", osh) ip = obj.getAttributeValue('host_key').split(' ')[0] if ip in appSign.crgMap.keys(): logger.debug("replace root_container:", obj.getAttribute("host_key")) osh.setContainer(appSign.crgMap[ip]) return filteredRunningApplications, processes, connectivityEndPoints, connections, errorsList
def DiscoveryMain(Framework): """ Retrieving a list of LDAP ports we strive to connect to domain controller in member role first. So we have to choose the lowest port number in the list. """ protocolName = "LDAP" OSHVResult = ObjectStateHolderVector() baseDn = Framework.getParameter('baseDN') or None if baseDn == 'NA': baseDn = None ipAddress = Framework.getDestinationAttribute('ip_address') credentialsId = Framework.getDestinationAttribute('credentials_id') applicationPort = Framework.getDestinationAttribute("application_port") serviceAddressPort = Framework.getDestinationAttribute('port') if not applicationPort or applicationPort == 'NA': applicationPort = serviceAddressPort # build environment and connect envBuilder = active_directory_utils.LdapEnvironmentBuilder(applicationPort) client = Framework.createClient(credentialsId, envBuilder.build()) discoverer = oracle_ldap_discoverer.OracleLdapDiscoverer(client, baseDn) try: probe_client = Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME) probe_shell = shellutils.ShellFactory().createShell(probe_client) resolver = netutils.FallbackResolver([netutils.JavaDnsResolver(), netutils.DnsResolverByShell(probe_shell)]) # discover servers = discoverer.discover() # report endpoint_builder = netutils.ServiceEndpointBuilder() endpoint_reporter = netutils.EndpointReporter(endpoint_builder) oracle_builder = db_builder.Oracle() reporter = db.OracleTopologyReporter(oracle_builder, endpoint_reporter) for dbServer in servers: if dbServer: try: address = dbServer.address if not ip_addr.isValidIpAddress(address): ips = resolver.resolveIpsByHostname(address) if ips and len(ips) > 0: dbServer.address = str(ip_addr.IPAddress(ips[0])) # get Host OSH if not (dbServer.address and netutils.isValidIp(address) and not netutils.isLocalIp(address)): raise ValueError("Address for the specified server is not valid or is local") hostOsh = modeling.createHostOSH(dbServer.address) # report database OSHVResult.addAll(reporter.reportServerAndDatabases(dbServer, hostOsh)) # report TNS Listener listener = db.OracleListener(dbServer.address, dbServer.getPort()) OSHVResult.addAll(reporter.reportTnsListener(listener, hostOsh)) # report Oracle Service Names if dbServer.getServiceNames(): OSHVResult.addAll(reporter.reportServiceNameTopology(dbServer.getServiceNames(), listener.getOsh(), dbServer.getOsh())) except netutils.ResolveException: logger.error("Cannot resolve " + dbServer.address + ". Skip") except oracle_ldap_discoverer.OracleContextDiscoveryException, ex: msg = str(ex) logger.debugException(msg) logger.error(msg)
def process(self, context): r''' @types: applications.ApplicationSignatureContext ''' # ==================== DISCOVERY shell = context.client fs = file_system.createFileSystem(shell) pathtools = file_system.getPath(fs) # 1) get process related application application = context.application connectionIp = application.getConnectionIp() # 2) find out process where path to the instance profile is stored logger.info(" Get executable path of main process ") mainProcess = application.getMainProcesses()[0] # 3) logger.info("Found out path to instance profile") instanceProfilePath = self.__getProfilePath(mainProcess) # 4) logger.info("Instance profile path: ", instanceProfilePath, ". Get content") getContent = fptools.safeFunc(self.__getContent, Exception) profileFile = (instanceProfilePath and getContent(shell, pathtools, instanceProfilePath)) if not profileFile: logger.warn("Failed to get content of instance profile") return # 5) parse content using instance and default profile parsers logger.info("Make configuration parsing") iniParser = sap_discoverer.IniParser() instancePfParser = sap_discoverer.InstanceProfileParser(iniParser) try: instanceProfile = instancePfParser.parseContent( profileFile.content) except Exception: logger.warnException("Failed to parse instance profile") else: traceConfig = None runtimeConfig = None sapInstance = instanceProfile.instance sapInstance = sap.Instance(sapInstance.name + sapInstance.number, sapInstance.number, sapInstance.hostname) # 6) Process runtime.properties that contains information about # Solution Manager and SLD if present logger.info("Create agent layout") logger.info("Get content of runtime properties") agentLayout = fptools.safeFunc( sap_smd_discoverer.createAgentLayoutFromBinPath)( (pathtools.isAbsolute(mainProcess.executablePath) and mainProcess.executablePath or discoverExecutablePath(shell, mainProcess)), fs, pathtools) if agentLayout: propertiesFile = getContent( shell, pathtools, agentLayout.getRuntimePropertiesPath()) if propertiesFile: parser = sap_smd_discoverer.RuntimePropertiesParser( sap_discoverer.IniParser()) try: runtimeConfig = parser.parse(propertiesFile.content) except Exception: logger.warnException( "Failed to parse runtime properties") logger.info("Find out version information") devSmdAgentFile = getContent( shell, pathtools, agentLayout.getDevSmdAgentConfigFile()) if devSmdAgentFile: configParser = sap_smd_discoverer.DevSmdAgentConfigParser() # find config with corresponding PID (of main process) hasMainProcessPid = lambda c, pid=mainProcess.getPid( ): c.pid == pid traceConfig = fptools.findFirst( hasMainProcessPid, configParser.parse(devSmdAgentFile.content)) if not traceConfig: logger.warn( "Failed to find trace information for the main process" ) # === REPORT === smdAgentOsh = application.getOsh() vector = context.resultsVector endpointReporter = netutils.EndpointReporter( netutils.ServiceEndpointBuilder()) configFileReporter = file_topology.Reporter( file_topology.Builder()) linkReporter = sap.LinkReporter() smdAgentBuilder = sap_smd.Builder() softwareBuilder = sap.SoftwareBuilder() softwareReporter = sap.SoftwareReporter(sap.SoftwareBuilder()) resolverByShell = netutils.DnsResolverByShell(shell) processOsh = mainProcess.getOsh() # x) update name of application using instance name softwareBuilder.updateName(smdAgentOsh, sapInstance.getName()) # x) configuration files related to running_software vector.add(configFileReporter.report(profileFile, smdAgentOsh)) if traceConfig: # x) update version information in application smdAgentOsh = softwareBuilder.updateVersionInfo( smdAgentOsh, traceConfig.versionInfo) if traceConfig.jstartVersionInfo: smdAgentOsh = smdAgentBuilder.updateJstartVersionInfo( smdAgentOsh, traceConfig.jstartVersionInfo) # x) show relation between agent and # - SMD server / no enough information / # - message server of SCS OR Solution Manager, represented as agent connection endpoint # - SLD if propertiesFile and runtimeConfig: # x) report properties file as configuration document vector.add( configFileReporter.report(propertiesFile, smdAgentOsh)) # x) Report relation between agent and SLD server and SolMan # Resolve endpoint addresses # make function that will accept endpoint only resolveEndpointFn = fptools.partiallyApply( self.__resolveEndpointAddress, fptools.safeFunc(resolverByShell.resolveIpsByHostname, []), fptools._) # - SLD relation if runtimeConfig.sldEndpoint: for endpoint in resolveEndpointFn( runtimeConfig.sldEndpoint): sldHostOsh = endpointReporter.reportHostFromEndpoint( endpoint) vector.add(sldHostOsh) sldEndpointOsh = endpointReporter.reportEndpoint( endpoint, sldHostOsh) vector.add(sldEndpointOsh) # this unknown server type must be SLD server sldOsh = softwareReporter.reportUknownSoftware( sldHostOsh) vector.add(sldOsh) vector.add( linkReporter.reportUsage(sldOsh, sldEndpointOsh)) # report link between process and SLD server endpoint vector.add( linkReporter.reportClientServerRelation( processOsh, sldEndpointOsh)) # - Solution Manager relation agentConnectionEndpoint = runtimeConfig.getAgentConnecitonEndpoint( ) if agentConnectionEndpoint: for endpoint in resolveEndpointFn(agentConnectionEndpoint): hostOsh = endpointReporter.reportHostFromEndpoint( endpoint) vector.add(hostOsh) endpointOsh = endpointReporter.reportEndpoint( endpoint, hostOsh) vector.add(endpointOsh) softwareOsh = softwareReporter.reportUknownSoftware( hostOsh) vector.add(softwareOsh) vector.add( linkReporter.reportUsage(softwareOsh, endpointOsh)) # report link between process and SolMan end-point vector.add( linkReporter.reportClientServerRelation( processOsh, endpointOsh))
# Group DB security groups by name for further reporting needs securityGroupByName = _applyMapping(aws_rds.SecurityGroup.getName, securityGroups) logger.debug("Got %s security groups" % len(securityGroups)) logger.info("Get DB snapshots") # User can make snapshots of existing instances. Get information about snapshots snapshots = warnException(discoverer.getSnapshots, [], message="Failed to get DB snapshots")() logger.debug("Got %s DB snapshots" % len(snapshots)) # group snapshots by instance ID snapshotsByInstanceId = _groupBy(aws_rds.Snapshot.getInstanceId, snapshots) logger.info("RDS TOPOLOGY REPORTING") awsReporter = aws.Reporter(aws.Builder()) endpointReporter = netutils.EndpointReporter(netutils.UriEndpointBuilder()) # Report account OSH vector = ObjectStateHolderVector() accountOsh = awsReporter.reportAccount(account) vector.add(accountOsh) # more functional approach can be ... # _reportDbInstance = _partialFunc(reportDbInstance, _, awsReporter, accountOsh) # map(vector.addAll, map(_reportDbInstance, instances)) for instance in instances: dbServer = instance.getServer() # get more information about server using engine information # we get engine by its name and version for engine in engines: if (engine.getName() == instance.getEngineName()
except JException, ex: msg = ex.getMessage() logger.debugException(msg) errormessages.resolveAndReport(msg, protocol, Framework) else: msg = errormessages.makeErrorMessage(tibco.TIBCO_PROTOCOL, pattern=errormessages.ERROR_NO_CREDENTIALS) errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [ tibco.TIBCO_PROTOCOL ], msg) logger.reportErrorObject(errobj) except: exInfo = logger.prepareJythonStackTrace('Error connecting: ') errormessages.resolveAndReport(exInfo, protocol, Framework) logger.debug("--- Start reporting ---") reporter = tibco.TopologyReporter(tibco.TopologyBuilder()) endpointReporter = netutils.EndpointReporter(netutils.ServiceEndpointBuilder()) for emsTopologyItem in emsTopology: emsOsh = reporter.reportEMSServer(emsTopologyItem.getEmsServer(), hostOsh) OshvResult.add(emsOsh) jmsServer = emsTopologyItem.getJmsServer() jmsServerOsh = reporter.reportJmsServer(jmsServer, emsOsh) serviceEndPointOsh = endpointReporter.reportEndpoint( netutils.createTcpEndpoint(jmsServer.hostname, jmsServer.getPort()), hostOsh) serviceEndPointLinkOsh = reporter.reportEmsServerServiceAddressLink(emsOsh, serviceEndPointOsh) OshvResult.add(jmsServerOsh) OshvResult.add(serviceEndPointOsh) OshvResult.add(serviceEndPointLinkOsh) # Report all JMS Destinations