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 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 _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 __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 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 _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_partition_id_to_pg_names(items):
return keep(fptools.safeFunc(_parse_partition_id_to_pg_name), 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_containers(items):
return keep(fptools.safeFunc(_parse_container), items)
def _parse_tables(items):
return keep(fptools.safeFunc(_parse_table), items)
def _parse_buffer_pools(items):
return keep(fptools.safeFunc(_parse_buffer_pool), 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_remote_databases(pairs):
return keep(fptools.safeFunc(_parse_remote_database), pairs)
def _parse_partitions(items):
return keep(fptools.safeFunc(_parse_partition), items)
def _parse_databases(databases):
return keep(fptools.safeFunc(_parse_database), databases)
def _parse_buffer_pools(items):
return keep(fptools.safeFunc(_parse_buffer_pool), 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)
def _parse_partitions(items):
return keep(fptools.safeFunc(_parse_partition), items)
