def _reportSystems(servedSystems, processOsh, shell, connectionIp, applicationOsh=None): resolveEndpoint = _getEndpResolveFn(shell, connectionIp) vector = ObjectStateHolderVector() softwareBuilder = sap.SoftwareBuilder() softwareReporter = sap.SoftwareReporter(softwareBuilder) linkR = sap.LinkReporter() #x) report details of served systems and relation with web-dispatcher for servedSystem in servedSystems: # report endpoints of external servers endpoints = servedSystem.getExternalServersEndpoints() endpoints = flatten(keep(resolveEndpoint, endpoints)) results = (_reportServerEndp(e, processOsh, applicationOsh) for e in endpoints) vector.addAll(map(third, results)) # report message server endpoint (metadata-source) # and application servers of served system sources = servedSystem.getMetadataSources() msgSources, sources = partition(isMessageServerSource, sources) logger.debug("Report %s msg sources" % len(msgSources)) logger.debug("Report %s other sources" % len(sources)) # process message server, report message server endpoints = keep(sap_webdisp.HasEndpoint.getEndpoint, msgSources) msgBuilder = sap.MessageServerBuilder() msgReporter = sap.CentralComponentReporter(msgBuilder) for e in flatten(keep(resolveEndpoint, endpoints)): e = netutils.createTcpEndpoint(e.getAddress(), e.getPort()) endpOsh, hostOsh, eVector = _reportServerEndp(e, processOsh) vector.addAll(eVector) msgOsh = msgReporter.reportAnonymous(hostOsh) vector.add(msgOsh) vector.add(linkR.reportUsage(msgOsh, endpOsh)) # process non message server sources sources = ifilter(isSourceWithEndpoint, sources) endpoints = keep(sap_webdisp.HasEndpoint.getEndpoint, sources) endpoints.extend(servedSystem.getApplicationServersEndpoints()) endpoints = flatten(keep(resolveEndpoint, endpoints)) for result in (_reportServerEndp(e, processOsh) for e in endpoints): endpOsh, hostOsh, eVector = result vector.addAll(eVector) appServerOsh = softwareReporter.reportUknownSoftware(hostOsh) vector.add(appServerOsh) vector.add(linkR.reportUsage(appServerOsh, endpOsh)) return vector
def parse(self, configParser): r'@types: ConfigParser.ConfigParser -> list[RfcConfiguration]' if not configParser: raise ValueError("ConfigParser is not specified") parseConnectionSection = Sfn(Fn(self.__parseSection, __, configParser)) sessions = configParser.sections() sessions = ifilter(self.__isTrexRfcConnectionConfigSection, sessions) return keep(parseConnectionSection, sessions)
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 __getSystemComponent(self, queriedJ2eeType, serviceClass): r'@types: str, T -> list[T]' parse = fptools.partiallyApply(self.__parseSystemComponent, fptools._, serviceClass) attributes = ("DisplayName", "ProviderName", "MinorVersion", "MicroVersion", "Description", "MajorVersion", "Name", "Jars") pattern = '*:*,j2eeType=%s' % queriedJ2eeType items = self._getClient().getMbeansByNamePattern(pattern, attributes) return keep(fptools.safeFunc(parse), items)
def _parseMsHttpPortConfigs(doc, number=None, hostname=None): r''' Get message server port configurations of format PROT=HTTP,PORT=81$$ @types: IniDocument, str?, str? -> list[Endpoint] @param number: Instance number, where port declared @param hostname: Instance hostname, where port declared @return: list of port declarations in the order they are marked with corresponding index ''' portValues = doc.findIndexedValues('ms/server_port') fn = InstanceProfileParser._parsePortDeclarationToEndpoint portToEndpointFn = partiallyApply(fn, __, number, hostname) return keep(portToEndpointFn, portValues)
def process(self, context): self.shell = context.client appOsh = context.application.applicationOsh process = first(keep(context.application.getProcess, self.PROCESSES)) binPath = process.executablePath logger.debug('Got process %s' % process) logger.debug('Process path is %s' % process.executablePath) self._discoverVersionInfo(process, appOsh) processes = context.application.getProcesses() configurations = (self._discoverConfiguration(p, binPath, appOsh) for p in processes) oshs = first(ifilter(bool, configurations)) oshs and context.resultsVector.addAll(oshs)
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 process(self, context): shell = context.client fs = file_system.createFileSystem(shell) path_util = file_system.getPath(fs) application = context.application osh = application.getOsh() process = application.getMainProcesses()[0] cmd_line = process.commandLine jvm_cmd_line_descriptor = jee.JvmCommandLineDescriptor(cmd_line) cmd_line_elements = jvm_cmd_line_descriptor.parseElements() java_options = filter(self.__is_java_option, cmd_line_elements) parse_fn = partiallyApply(self.parse_server_name, fptools._, path_util) server_name = first(keep(parse_fn, java_options)) logger.debug('server name: %s' % server_name) if server_name is not None: osh.setAttribute('j2eeserver_servername', server_name) #TODO: replace to jee.ServerTopologyBuilder._composeFullName osh.setAttribute('j2eeserver_fullname', server_name) modeling.setAppServerType(osh)
def _parseInstanceInfo(self, item): r'@types: Properties -> InstanceInfo' hostname = item.get('Host') if not hostname: raise ValueError("Address is not specified") ports = keep(item.get, self.ENDPOINT_NAMES) endpoints = [netutils.createTcpEndpoint(hostname, p) for p in ports] state = self._parseInstanceState(item.get('State')) instName = item.get('Caption') fullName = item.get('Name') _inst = sap_discoverer.parseInstanceFromName(instName) instName = _inst.name if fullName: details = sap_discoverer.parseSystemAndInstanceDetails(fullName) _, hostname, nr = details else: nr = _inst.number instanceWithHostname = sap.Instance(instName, nr, hostname=hostname) return self.InstanceInfo(instanceWithHostname, endpoints, state=state)
def discoverAllInstancesByNamesOnly(client): r''' Can be only applied for discovery by JMX due to deserialization limitatations of WebServices client @types: BaseSapJmxClient, DiscoveryConfig -> tuple[oshv, tuple[str]]''' discoverer = sap_jee_discoverer.ClusterDiscoverer(client) cluster, instanceNames = discoverer.getClusterDetails() parseInst = Sf(_createAnonymousInstFromFullName) insts = keep(parseInst, instanceNames) system = sap.System(cluster.getName()) systemOsh, clusterOsh, vector = _reportSapSystem(system) ipsPerInst = zip(map(_resolveInstHostname, insts), insts) resolved, notResolved = partition(first, ipsPerInst) warnings = () if notResolved: warnings = ("Some instances are not reported " "due to unresolved address",) vectors = (third(reportInst(i, system, systemOsh, clusterOsh, ips)) for ips, i in resolved) each(vector.addAll, vectors) return vector, warnings
def _parse_remote_databases(pairs): return keep(fptools.safeFunc(_parse_remote_database), pairs)
def _parse_partition_id_to_pg_names(items): return keep(fptools.safeFunc(_parse_partition_id_to_pg_name), items)
def _parse_tables(items): return keep(fptools.safeFunc(_parse_table), items)
def _parse_containers(items): return keep(fptools.safeFunc(_parse_container), items)
def _parse_schemas(items): return keep(_parse_schema, items)
def _parse_partition_groups(items): return keep(fptools.safeFunc(_parse_partition_group), items)
def _parse_buffer_pools(items): return keep(fptools.safeFunc(_parse_buffer_pool), items)
def _parse_partitions(items): return keep(fptools.safeFunc(_parse_partition), items)
def _parse_databases(databases): return keep(fptools.safeFunc(_parse_database), databases)
def _parseClusterInfo(self, item): r'@types: Provider._ResultItem -> ClusterInfo' cluster = self._parseCluster(item) infoList = item.get('AllInstanceInfos') instances = keep(fptools.safeFunc(self._parseInstanceInfo), infoList) return self.ClusterInfo(cluster, instances)