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
