def findTCPNextHop(Framework, hostIPs, shell, processes, connectivityEndPoints, connections, application, hostOsh):
warninglist = []
OSHVResult = ObjectStateHolderVector()
logger.debug("Start to do tcp discovery for application:", application.getName())
pids = [x.getPid() for x in application.getProcesses() if x]
logger.debug("getting pids:", pids)
endpoints_for_pids = [x for x in connectivityEndPoints if x and x.getKey() in pids]
processedendpoints = filterEndpointsByPorts(Framework, endpoints_for_pids, connections, warninglist)
results = reportProcessToPort(application.getProcesses(), processedendpoints, application.getOsh(), shell, hostIPs)
logger.debug("found %s scp for application: %s via TCP connection" % (getNumOfSCP(results), application.getName()))
OSHVResult.addAll(results)
processReporter = process.Reporter()
for processObject in processes:
processesVector = processReporter.reportProcess(hostOsh, processObject)
OSHVResult.addAll(processesVector)
return OSHVResult, getNumOfSCP(results), warninglist
def DiscoveryMain(Framework):
vector = ObjectStateHolderVector()
protocol = Framework.getDestinationAttribute('Protocol')
client = None
shell = None
try:
try:
# connect to destination
client = Framework.createClient()
# wrap client with Shell
shell = shellutils.ShellFactory().createShell(client)
except AuthenticationException, ae:
errormessages.resolveAndReport(ae.getMessage(), protocol,
Framework)
except:
exInfo = logger.prepareJythonStackTrace('')
errormessages.resolveAndReport(exInfo, protocol, Framework)
else:
language = Framework.getDestinationAttribute('language')
hostCmdbId = Framework.getDestinationAttribute('hostId')
# configure internationalization support
if language and language != 'NA':
langBund = Framework.getEnvironmentInformation().getBundle(
'langHost_Resources_By_TTY', language)
else:
langBund = Framework.getEnvironmentInformation().getBundle(
'langHost_Resources_By_TTY')
# discovery
discoverCPUs = Boolean.parseBoolean(
Framework.getParameter('discoverCPUs'))
discoverDisks = Boolean.parseBoolean(
Framework.getParameter('discoverDisks'))
discoveriSCSIInfo = Boolean.parseBoolean(
Framework.getParameter('discoveriSCSIInfo'))
discoverDrivers = Boolean.parseBoolean(
Framework.getParameter('discoverDrivers'))
discoverMemory = Boolean.parseBoolean(
Framework.getParameter('discoverMemory'))
discoverSoftware = Boolean.parseBoolean(
Framework.getParameter('discoverInstalledSoftware'))
discoverUsers = Boolean.parseBoolean(
Framework.getParameter('discoverUsers'))
discoverServices = Boolean.parseBoolean(
Framework.getParameter('discoverServices'))
discoverShares = Boolean.parseBoolean(
Framework.getParameter('discoverShares'))
discoverP2P = Boolean.parseBoolean(
Framework.getParameter('discoverP2P'))
try:
hostOsh = modeling.createOshByCmdbIdString('host', hostCmdbId)
if discoverShares:
try:
vector.addAll(_discoverSharedResources(shell, hostOsh))
except:
errorMessage = 'Failed to discover shared resources'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['share', protocol], errorMessage)
if discoverCPUs:
try:
vector.addAll(
TTY_HR_CPU_Lib.disWinOS(hostCmdbId, shell,
Framework, langBund))
except:
errorMessage = 'Failed to discover CPUs'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['cpus', protocol], errorMessage)
if discoverDisks:
try:
vector.addAll(TTY_HR_Disk_Lib.disWinOS(hostOsh, shell))
except:
errorMessage = 'Failed to discover disks'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['disks', protocol], errorMessage)
if discoverDrivers and shell.isWinOs():
try:
vector.addAll(
_discoverWindowsDeviceDriver(shell, hostOsh))
except:
errorMessage = 'Failed to discover windows device driver by powershell'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['windows device driver', protocol], errorMessage)
if discoveriSCSIInfo:
try:
vector.addAll(
TTY_HR_Disk_Lib.disWinOSiSCSIInfo(hostOsh, shell))
except:
errorMessage = 'Failed to discover iSCSI info'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['iSCSI', protocol], errorMessage)
if discoverMemory:
try:
vector.addAll(
TTY_HR_Memory_Lib.disWinOS(hostCmdbId, shell,
Framework, langBund))
except:
errorMessage = 'Failed to discover memory'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['memory', protocol], errorMessage)
processes = []
try:
processesDiscoverer = process_discoverer.DiscovererByShellOnWindows(
shell)
processes = processesDiscoverer.discoverAllProcesses()
if not processes:
raise ValueError()
except:
errorMessage = 'Failed to discover processes'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['processes', protocol], errorMessage)
if processes:
# save processes to DB
process_discoverer.saveProcessesToProbeDb(
processes, hostCmdbId, Framework)
# report processes
discoverProcesses = Boolean.parseBoolean(
Framework.getParameter('discoverProcesses'))
if discoverProcesses:
processReporter = process.Reporter()
for processObject in processes:
processVector = processReporter.reportProcess(
hostOsh, processObject)
vector.addAll(processVector)
if discoverUsers:
try:
vector.addAll(_discoverUsers(hostOsh, shell))
except:
errorMessage = 'Failed to discover users'
_logWarn(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['users', protocol], errorMessage)
cmdLineToInstalledSoftware = {}
softNameToInstSoftOSH = {}
if discoverSoftware:
try:
softwareOSHs = TTY_HR_Software_Lib.disWinOS(
hostCmdbId, shell, Framework, langBund,
softNameToInstSoftOSH)
if softwareOSHs:
vector.addAll(softwareOSHs)
except:
errorMessage = 'Failed to discover installed software'
_logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE,
['installed software', protocol],
errorMessage)
servicesByCmd = Hashtable()
if discoverServices:
try:
srvcOSHs = NTCMD_HR_REG_Service_Lib.doService(
shell, hostOsh, servicesByCmd, langBund, Framework)
vector.addAll(srvcOSHs)
except:
errorMessage = 'Failed to discover services'
_logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE,
['services', protocol], errorMessage)
connectivityEndPoints = []
try:
tcpDiscoverer = Dis_TCP.getDiscovererByShell(
client, Framework, shell)
if tcpDiscoverer is not None:
tcpDiscoverer.discoverTCP()
connectivityEndPoints = tcpDiscoverer.getProcessEndPoints(
)
except:
errorMessage = 'Failed to run TCP discovery'
_logWarn(
errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE,
['tcp', protocol], errorMessage)
appSign = applications.createApplicationSignature(
Framework, client, shell)
if processes:
appSign.setProcessesManager(
applications.ProcessesManager(processes,
connectivityEndPoints))
servicesInfo = applications.ServicesInfo(servicesByCmd)
appSign.setServicesInfo(servicesInfo)
softwareInfo = applications.InstalledSoftwareInfo(
cmdLineToInstalledSoftware, softNameToInstSoftOSH)
appSign.setInstalledSoftwareInfo(softwareInfo)
appSign.getApplicationsTopology(hostCmdbId)
if discoverP2P:
try:
p2p = process_to_process.ProcessToProcess(Framework)
p2p.getProcessesToProcess()
except:
errorMessage = 'Failed to run p2p discovery'
_logWarn(errorcodes.FAILED_RUNNING_DISCOVERY,
['p2p', protocol], errorMessage)
except JException, ex:
exInfo = ex.getMessage()
errormessages.resolveAndReport(exInfo, protocol, Framework)
except:
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
client = None
try:
client = createWmiClient(Framework)
if client:
protocol = Framework.getDestinationAttribute('Protocol')
hostId = Framework.getDestinationAttribute('hostId')
hostOsh = modeling.createOshByCmdbIdString('nt', hostId)
_, warning = discover_or_warn('fibre channel HBAs',
discover_fc_hbas,
Framework,
hostOsh,
protocol,
OSHVResult,
protocol_name=protocol)
if warning:
logger.reportWarningObject(warning)
discoverUsers = Boolean.parseBoolean(
Framework.getParameter('discoverUsers'))
if discoverUsers:
try:
wmi_dis_user_lib.executeWmiQuery(client, Framework,
OSHVResult, hostOsh)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['users', 'wmi'], 'Failed to discover users by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover users by wmi')
discoverShares = Boolean.parseBoolean(
Framework.getParameter('discoverShares'))
if discoverShares:
try:
wmi_dis_share_lib.executeWmiQuery(client, OSHVResult,
hostOsh)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['shares', 'wmi'], 'Failed to discover shares by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover shares by wmi')
discoverProcesses = Boolean.parseBoolean(
Framework.getParameter('discoverProcesses'))
processes = []
try:
processDiscoverer = process_discoverer.getDiscovererByWmi(
client)
processes = processDiscoverer.discoverAllProcesses()
if not processes:
raise ValueError()
except:
errobj = errorobject.createError(
errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['processes', 'wmi'],
'Failed to discover processes by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover processes by wmi')
if processes:
# save processes to DB
process_discoverer.saveProcessesToProbeDb(
processes, hostId, Framework)
# report processes
if discoverProcesses:
processReporter = process.Reporter()
for processObject in processes:
processesVector = processReporter.reportProcess(
hostOsh, processObject)
OSHVResult.addAll(processesVector)
discoverMemory = Boolean.parseBoolean(
Framework.getParameter('discoverMemory'))
if discoverMemory:
try:
wmi_dis_memory_lib.executeWmiQuery(client, OSHVResult,
hostOsh)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['memory', 'wmi'], 'Failed to discover memory by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover memory by wmi')
discoverDisks = Boolean.parseBoolean(
Framework.getParameter('discoverDisks'))
if discoverDisks:
try:
containerOsh = hostOsh or modeling.createHostOSH(
client.getIpAddress())
NTCMD_HR_Dis_Disk_Lib.discoverDiskByWmic(
client, OSHVResult, containerOsh)
NTCMD_HR_Dis_Disk_Lib.discoverPhysicalDiskByWmi(
client, OSHVResult, containerOsh)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['disks', 'wmi'], 'Failed to discover disks by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover disks by wmi')
discoverDrivers = Boolean.parseBoolean(
Framework.getParameter('discoverDrivers'))
if discoverDrivers:
try:
containerOsh = hostOsh or modeling.createHostOSH(
client.getIpAddress())
HR_Dis_Driver_Lib.discoverDriverByWmi(
client, OSHVResult, containerOsh)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['drivers', 'wmi'],
'Failed to discover drivers by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover drivers by wmi')
discoveriSCSIInfo = Boolean.parseBoolean(
Framework.getParameter('discoveriSCSIInfo'))
if discoveriSCSIInfo:
try:
NTCMD_HR_Dis_Disk_Lib.discoveriSCSIInfo(
client, OSHVResult, containerOsh)
except:
logger.warn(
'Failed to connect with namespace Root\Microsoft\Windows\Storage'
)
discoverCPUs = Boolean.parseBoolean(
Framework.getParameter('discoverCPUs'))
if discoverCPUs:
try:
wmi_dis_cpu_lib.executeWmiQuery(client, OSHVResult,
hostOsh)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['cpus', 'wmi'], 'Failed to discover cpus by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover cpus by wmi')
discoverServices = Boolean.parseBoolean(
Framework.getParameter('discoverServices'))
servicesByCmd = Hashtable()
if discoverServices:
try:
servOSHV = wmi_dis_service_lib.executeWmiQuery(
client, OSHVResult, servicesByCmd, hostOsh)
OSHVResult.addAll(servOSHV)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['services', 'wmi'],
'Failed to discover services by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover services by wmi')
#NOTE: software discovery had to be the last in discovery chain
discoverSoftware = Boolean.parseBoolean(
Framework.getParameter('discoverInstalledSoftware'))
softNameToInstSoftOSH = {}
if discoverSoftware:
(softNameToInstSoftOSH,
client) = __discoverInstalledSoftware(Framework, OSHVResult,
client)
if not client:
logger.warn(
"Application Signature will not be run since the client is not initialized"
)
if client:
appSign = applications.createApplicationSignature(
Framework, client)
if processes:
appSign.setProcessesManager(
applications.ProcessesManager(processes, []))
servicesInfo = applications.ServicesInfo(servicesByCmd)
appSign.setServicesInfo(servicesInfo)
softwareInfo = applications.InstalledSoftwareInfo(
None, softNameToInstSoftOSH)
appSign.setInstalledSoftwareInfo(softwareInfo)
appSign.getApplicationsTopology(hostId)
finally:
if client != None:
client.close()
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
client = None
framework = StatisticsFramework(Framework)
try:
try:
client = framework.createClient()
except:
# No need to report twice, exception msg is sufficient
# errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_NO_PROTOCOL, None, 'Connection failed')
# logger.reportErrorObject(errobj)
errMsg = 'Exception while creating %s client: %s' % (
ClientsConsts.SNMP_PROTOCOL_NAME, sys.exc_info()[1])
errormessages.resolveAndReport(str(sys.exc_info()[1]),
ClientsConsts.SNMP_PROTOCOL_NAME,
framework)
logger.debugException(errMsg)
else:
config = (flow.DiscoveryConfigBuilder(
framework).dest_data_required_params_as_str('ip_address').
dest_data_params_as_list('host_ips')).build()
ipaddress = config.ip_address
host_ips = filter(None, config.host_ips)
ips = set(host_ips)
ips.add(ipaddress)
hostId = framework.getDestinationAttribute('hostId')
hostOsh = modeling.createOshByCmdbIdString('host', hostId)
discoverUsers = Boolean.parseBoolean(
framework.getParameter('discoverUsers'))
if discoverUsers:
logger.debug('Starting to discover users')
try:
snmp_dis_user_lib.doQueryOSUsers(client, OSHVResult)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['users', 'snmp'], 'Failed to discover users by snmp')
logger.reportWarningObject(errobj)
logger.errorException('Failed to discover users by snmp')
discoverDisks = Boolean.parseBoolean(
framework.getParameter('discoverDisks'))
if discoverDisks:
logger.debug('Starting to discover disks')
try:
snmp_dis_disk_lib.doQueryDisks(client, OSHVResult)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['disks', 'snmp'], 'Failed to discover disks by snmp')
logger.reportWarningObject(errobj)
logger.errorException('Failed to discover disks by snmp')
discoverProcesses = Boolean.parseBoolean(
framework.getParameter('discoverProcesses'))
processes = []
logger.debug('Starting to discover processes')
try:
processDiscoverer = process_discoverer.getDiscovererBySnmp(
client)
processes = processDiscoverer.discoverAllProcesses()
if not processes:
raise ValueError()
except:
errobj = errorobject.createError(
errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['processes', 'snmp'],
'Failed to discover processes by snmp')
logger.reportWarningObject(errobj)
logger.errorException('Failed to discover processes by snmp')
if processes:
# save processes to DB
process_discoverer.saveProcessesToProbeDb(
processes, hostId, framework)
# report processes
if discoverProcesses:
processReporter = process.Reporter()
for processObject in processes:
processesVector = processReporter.reportProcess(
hostOsh, processObject)
OSHVResult.addAll(processesVector)
discoverServices = Boolean.parseBoolean(
framework.getParameter('discoverServices'))
if discoverServices:
logger.debug('Starting to discover services')
try:
snmp_dis_service_lib.doQuerySNMPService(client, OSHVResult)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['services', 'snmp'],
'Failed to discover services by snmp')
logger.reportWarningObject(errobj)
logger.errorException(
'Failed to discover services by snmp')
discoverSoftware = Boolean.parseBoolean(
framework.getParameter('discoverInstalledSoftware'))
if discoverSoftware:
logger.debug('Starting to discover software')
try:
snmp_dis_software_lib.doQuerySoftware(client, OSHVResult)
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['software', 'snmp'],
'Failed to discover software by snmp')
logger.reportWarningObject(errobj)
logger.errorException(
'Failed to discover software by snmp')
connectivityEndPoints = []
try:
tcpDiscoverer = Dis_TCP.TCPDisBySNMP(client,
framework,
ips=tuple(ips))
if tcpDiscoverer is not None:
tcpDiscoverer.discoverTCP()
connectivityEndPoints = tcpDiscoverer.getProcessEndPoints()
except:
errorMessage = 'Failed to run tcp discovery by snmp'
logger.debugException(errorMessage)
errobj = errorobject.createError(
errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE,
['tcp', 'snmp'], errorMessage)
logger.reportWarningObject(errobj)
if processes:
appSign = applications.createApplicationSignature(
framework, client)
appSign.setProcessesManager(
applications.ProcessesManager(processes,
connectivityEndPoints))
appSign.getApplicationsTopology(hostId)
discoverModules = Boolean.parseBoolean(
framework.getParameter('discoverModules'))
if discoverModules:
logger.debug('Begin discover snmp modules...')
try:
from snmp_model_finder import SnmpStateHolder
from snmp_model_finder import SnmpQueryHelper
from snmp_model_finder import ModelTypeMatcher
import snmp_model_discovery
snmpStateHolder = SnmpStateHolder()
cacheClient = None
# from discovery.client.snmp import SnmpClientCacheProxy
# cacheClient = SnmpClientCacheProxy(client, 'cache/'+ipaddress+'.cache')
snmpQueryHelper = SnmpQueryHelper(client)
mtm = ModelTypeMatcher(snmpStateHolder, snmpQueryHelper)
logger.debug('The target is matched:', mtm.match())
logger.debug('The type of the target is:',
snmpStateHolder.getTypes())
vector = snmp_model_discovery.discoverAll(
hostOsh, snmpStateHolder, snmpQueryHelper)
logger.debug('Discovered CI count:', vector.size())
OSHVResult.addAll(vector)
if cacheClient:
cacheClient.writeCache()
except:
errobj = errorobject.createError(
errorcodes.
FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
['modules', 'snmp'],
'Failed to discover modules by snmp')
logger.reportWarningObject(errobj)
logger.errorException('Failed to discover modules by snmp')
logger.debug('End discover snmp modules')
finally:
if client != None:
client.close()
if OSHVResult.size() == 0 and framework.getSentObjectsCount() == 0:
logger.reportWarning('SNMP: No data collected')
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 _report(ip, config, version_info, partition_groups, partitions,
pg_names_by_partition_number, buffer_pools_by_partition_nr,
tablespaces, partition_numbers_by_pg_name, mountpoint_by_container,
containers_by_tablespace_id, partition_nr_by_container,
schemas, tables, sessions, inst_name=None, svcename=None, version=None):
oshs = []
add_all_to_result = Fn(_add_vector_and_return, oshs, fptools._)
add_to_result = Fn(_add_osh_and_return, oshs, fptools._)
link_reporter = db2_topology.LinkReporter()
report_usage_link = comp(add_to_result, link_reporter.report_usage)
report_client_server_link = comp(add_to_result,
link_reporter.report_client_server)
report_dbclient_link = comp(add_to_result,
link_reporter.report_dbclient)
host_reporter = db2_host.Reporter(db2_host.Builder())
report_host = comp(add_to_result, modeling.createHostOSH, str)
process_reporter = process.Reporter()
report_process = Fn(process_reporter.report,
fptools._,
fptools._,
process.ProcessBuilder())
report_process = comp(add_all_to_result, report_process)
host_osh = modeling.createOshByCmdbIdString('node', config.host_id)
db_osh = modeling.createOshByCmdbIdString('db2_database', config.db_id)
oshs.append(host_osh)
oshs.append(db_osh)
endpoint_osh, oshs_ = _report_ipse(config, ip, svcename, host_osh, db_osh)
oshs.extend(oshs_)
db2_rs_osh, oshs_ = _report_instance(config, inst_name, version, db_osh, host_osh, endpoint_osh)
oshs.extend(oshs_)
if version_info:
if db2_rs_osh:
db2_topology.SoftwareBuilder.updateVersionDescription(db2_rs_osh,
str(version_info))
db2_topology.SoftwareBuilder.updateVersionDescription(db_osh,
str(version_info))
db2_reporter = db2_topology.Reporter()
report_dbschema = Fn(db2_reporter.reportDbSchema,
fptools._,
db_osh)
report_dbschema = comp(add_to_result, report_dbschema)
report_datafile = comp(add_all_to_result, db2_reporter.reportDatafile)
report_tablespace = comp(add_all_to_result, db2_reporter.reportTablespace)
report_table = comp(add_all_to_result, db2_reporter.reportTable)
report_partition_group = Fn(db2_reporter.reportPartitionGroup,
fptools._,
db_osh)
report_partition_group = comp(add_to_result, report_partition_group)
report_partition = comp(add_all_to_result, db2_reporter.reportPartition)
report_buffer_pool = comp(add_all_to_result,
Fn(db2_reporter.reportBufferPool,
fptools._, db_osh, fptools._,))
file_system_builder = db2_topology.FileSystemBuilder()
file_system_reporter = db2_topology.FileSystemReporter(file_system_builder)
report_file_system = comp(add_to_result, file_system_reporter.report_file_system)
pg_osh_by_pg_name = _report_pgs(partition_groups, report_partition_group)
partition_osh_by_number, node_osh_by_partition_nr = _report_partitions(partitions, db2_rs_osh, oshs, pg_names_by_partition_number, pg_osh_by_pg_name, report_partition, host_reporter)
bp_osh_by_partition_nr_and_bp_id = _report_bufferpools(buffer_pools_by_partition_nr,
partition_osh_by_number,
report_buffer_pool)
container_oshes_by_tablespace = _report_data_files(mountpoint_by_container,
containers_by_tablespace_id,
partition_nr_by_container,
tablespaces,
partition_osh_by_number,
node_osh_by_partition_nr,
report_datafile,
report_file_system)
tablespace_osh_by_tablespace = _report_tablespaces(tablespaces,
db_osh,
pg_osh_by_pg_name,
partition_numbers_by_pg_name,
bp_osh_by_partition_nr_and_bp_id,
container_oshes_by_tablespace,
report_tablespace,
report_usage_link)
schema_osh_by_name = {}
for schema in schemas:
schema_osh_by_name[schema.name] = report_dbschema(schema)
for table, tablespace, schema_name, owner in tables:
table_pdo = db2_topology.Builder.TablePdo(table.name, owner)
tablespace_osh = tablespace_osh_by_tablespace.get(tablespace)
schemaOsh = schema_osh_by_name.get(schema_name)
if schemaOsh:
report_table(table_pdo, schemaOsh, tablespaceOsh=tablespace_osh)
else:
logger.warn("Schema '%s' not found, table '%s' is not reported" %
(schema_name, table.name))
port = config.port or resolve_svcename_to_port_nr(svcename)
_report_sessions(sessions, endpoint_osh, db2_rs_osh, port, report_host, report_process, report_client_server_link, report_dbclient_link)
return oshs
def process(self, context):
r'''
@types: applications.ApplicationSignatureContext
'''
self.__shell = context.client
osh = context.application.applicationOsh
hostOsh = context.hostOsh
processes = context.application.getProcesses()
vector = context.resultsVector
layout = emc_autostart_discover.createLayout(self.__shell)
clusterVersion = None
for processFtAgent in filter(isFtAgentProcess, processes):
process = _createFixedFtAgentProcess(processFtAgent)
reporter = process_module.Reporter()
builder = process_module.ProcessBuilder()
processOsh, pVector = reporter.report(hostOsh, process, builder)
vector.addAll(pVector)
vector.add(modeling.createLinkOSH('dependency', osh, processOsh))
if not clusterVersion:
layout.initWithAgentPath(process.executablePath)
self.ftCli = emc_autostart_discover.createCli(self.__shell, layout.getBinFolder())
version = emc_autostart_discover.getVersionByFtCli(self.__shell, self.ftCli)
clusterVersion = version.fullString or version.shortString
osh.setAttribute("application_version", clusterVersion)
osh.setAttribute("application_version_number",
version.shortString)
if clusterVersion:
# discover cluster
domainName = context.application.getOsh().getAttribute("name").getStringValue()
clusterOsh = buildEMCClusterOsh(domainName, clusterVersion)
vector.add(clusterOsh)
vector.add(modeling.createLinkOSH('membership', clusterOsh, osh))
# discover group
discoverer = emc_autostart_discover.createDiscoverer(self.__shell, None, layout)
discoverer.ftCli = self.ftCli
resourceGroupsByName = discoverer.discoverResourceGroups()
# discover IP
managedIpsByName = discoverer.discoverManagedIps()
if resourceGroupsByName:
for key in resourceGroupsByName:
group = resourceGroupsByName.get(key)
resources = group.resources
if resources:
for resource in resources:
if resource.getType() == "IP":
ipName = resource.getName()
managedIp = managedIpsByName.get(ipName, None)
if managedIp:
ipAddress = managedIp.ipAddress
groupOsh = buildResourceGroupOsh(group.getName(), domainName)
vector.add(groupOsh)
vector.add(modeling.createLinkOSH('contained', clusterOsh, groupOsh))
ipOsh = modeling.createIpOSH(ipAddress)
vector.add(modeling.createLinkOSH('contained', groupOsh, ipOsh))
vector.add(ipOsh)
context.crgMap[str(ipAddress)] = groupOsh