def processApplicationComponent(self, applicationsToReport):
logger.debug("Processing application component '%s'" % self.getName())
self.createApplications()
resultsVector = ObjectStateHolderVector()
for application in self.applications:
applicationResultsVector = ObjectStateHolderVector()
try:
application.process()
self.processPluginsChain(application, applicationResultsVector)
applicationsToReport.append(application)
application.addResultsToVector(applicationResultsVector)
except applications.PluginUncheckedException, ex:
if ex.__class__ == applications.IgnoreApplicationException or ex.__class__.__name__ == "IgnoreApplicationException":
logger.warn(
"Instance of application '%s' is ignored, reason: %s" %
(self.applicationName, str(ex)))
else:
raise ex.__class__(ex)
except ApplicationSignatureException, ex:
logger.debugException(
"Exception while processing application '%s', application skipped"
% self.applicationName)
def reportDatabaseTopology(self, dsnInfo, dependentObject):
"""
:param dsnInfo: list of all DSN's for which need to report topology
:type dsnInfo: odbc.DSNInfo
:return: vector which include all osh's for created topology
:rtype: appilog.common.system.types.vectors.ObjectStateHolderVector
"""
vector = ObjectStateHolderVector()
try:
database_pdo = self.__builder.buildDatabaseServerPdo(dsnInfo)
platform = db_platform.findPlatformBySignature(dsnInfo.driver)
builder = db_builder.getBuilderByPlatform(platform)
db_reporter = db.getReporter(platform, builder)
host_descriptor = self.__builder.buildHostDescriptor(
dsnInfo.address)
host_descriptor = host_descriptor._replace(name=None)
reporter = host_topology.Reporter()
host_osh, ip_oshs, oshs = reporter.report_host(host_descriptor)
server_osh, ipseOsh, database_oshs, topology = db_reporter.reportServerWithDatabases(
database_pdo, host_osh, [dependentObject])
vector.addAll(topology)
vector.addAll(oshs)
return vector
except dns_resolver.ResolveException:
logger.reportWarning("Cannot resolve ip of node")
return ObjectStateHolderVector()
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
localHostId = Framework.getDestinationAttribute('localHostId')
remoteIds = Framework.getTriggerCIDataAsList('clusteredUcmdbIds')
localSoftwareId = Framework.getDestinationAttribute('localSoftwareId')
clusteredContainers = Framework.getTriggerCIDataAsList(
'clusteredContainer')
softwareName = Framework.getDestinationAttribute('softwareName')
className = Framework.getDestinationAttribute('className')
discProdName = Framework.getDestinationAttribute('discProdName')
productName = Framework.getDestinationAttribute('productName')
ipServiceEndpointIds = Framework.getTriggerCIDataAsList(
'ipServiceEndpointIds') or []
for remoteIndex in xrange(len(remoteIds)):
remoteId = remoteIds[remoteIndex]
clusteredContainer = None
try:
clusteredContainer = clusteredContainers[remoteIndex]
except:
logger.debug('Clustered software is related to a single CRG')
clusteredContainer = clusteredContainers[0]
if not clusteredContainer:
raise ValueError(
'Failed to detect Clustered Resource Group for Clustered Software'
)
logger.debug('Working with remote Id %s and clustered Container %s' %
(remoteId, clusteredContainer))
vector = ObjectStateHolderVector()
softwareOsh = modeling.createOshByCmdbId(className, localSoftwareId)
hostOsh = modeling.createOshByCmdbId('cluster_resource_group',
clusteredContainer)
softwareOsh.setContainer(hostOsh)
softwareOsh.setStringAttribute('name', softwareName)
if discProdName and discProdName != 'NA':
softwareOsh.setStringAttribute('discovered_product_name',
discProdName)
if productName and productName != 'NA':
softwareOsh.setStringAttribute('product_name', productName)
for ipServiceEndpointId in ipServiceEndpointIds:
logger.debug("ip service endpoint id:", ipServiceEndpointId)
if not ipServiceEndpointId:
continue
iseOsh = modeling.createOshByCmdbId('ip_service_endpoint',
ipServiceEndpointId)
iseOsh.setContainer(hostOsh)
vector.add(iseOsh)
vector.add(hostOsh)
vector.add(softwareOsh)
OSHVResult.addAll(vector)
return OSHVResult
def _discoverInstanceDetails(client, baseTopology):
r'@types: BaseSapJmxClient, str, System, osh, osh -> oshv'
system, hostname, clusterOSH, systemOsh = baseTopology
inst, servers = ServerProcessQuery().getSystemDetails(client)
if not inst.hostname and hostname:
inst = sap.Instance.replaceHostname(inst, hostname)
instanceReporter = sap_jee.InstanceReporter(sap_jee.InstanceBuilder())
# report host by resolved IPs
hostname = inst.hostname
if not hostname:
logger.warn("Failed to determine hostname for %s" % inst)
return ObjectStateHolderVector()
dnsResolver = netutils.JavaDnsResolver()
vector = ObjectStateHolderVector()
try:
ips = dnsResolver.resolveIpsByHostname(hostname)
except netutils.ResolveException:
logger.warn("Failed to resolve hostname of %s" % inst)
else:
hostReporter = sap.HostReporter(sap.HostBuilder())
hostOSH, vector = hostReporter.reportHostWithIps(*ips)
# report instance
pdo = sap_jee.InstanceBuilder.InstancePdo(inst, system)
instOsh = instanceReporter.reportInstancePdo(pdo, hostOSH)
vector.add(instOsh)
#report sap system
systemOsh.setStringAttribute('data_note', 'This SAP System link to ' + hostOSH.getAttributeValue('host_key'))
vector.add(systemOsh)
# report j2ee_cluster -membership-> sap_app_server
linkReporter = sap.LinkReporter()
vector.add(linkReporter.reportMembership(clusterOSH, instOsh))
vector.add(linkReporter.reportMembership(systemOsh, instOsh))
# report server processes
oshs = [_reportServerProcess(s, inst, instOsh) for s in servers]
each(vector.add, oshs)
# discover applications
serverToOshs = filter(comp(_isWorkerProcess, first), zip(servers, oshs))
for server, osh in serverToOshs:
id_ = server.id
appNameToOsh = Sf(discoverEjbApplications)(client, id_, osh, clusterOSH, vector)
Sf(buildWebApplications)(client, id_, osh, clusterOSH, appNameToOsh, vector)
return vector
def discoverEntityDetails(client):
snmpAgent = snmputils.SnmpAgent(None, client)
queryBuilder = snmputils.SnmpQueryBuilder(BASE_ENTITY_PHYSICAL_OBJECTS_OID)
queryBuilder.addQueryElement(2, 'description')
queryBuilder.addQueryElement(3, 'type')
queryBuilder.addQueryElement(4, 'containedIn')
queryBuilder.addQueryElement(5, 'physClass')
queryBuilder.addQueryElement(7, 'name')
queryBuilder.addQueryElement(10, 'swRev')
queryBuilder.addQueryElement(11, 'serialNumber')
queryBuilder.addQueryElement(12, 'vendor')
queryBuilder.addQueryElement(13, 'model')
try:
sysTable = snmpAgent.getSnmpData(queryBuilder)
except:
return [], ObjectStateHolderVector()
aggregated_switches = []
interfaces = []
index_to_data_map = {}
for data in sysTable:
if data.type in phys_sw_oids and (data.physClass and int(data.physClass) == 3):
aggregated_switches.append(data)
if data.physClass and int(data.physClass) == 10:
interfaces.append(data)
index_to_data_map[data.meta_data] = data
switches_oshs = []
interfaceVector = ObjectStateHolderVector()
if aggregated_switches and aggregated_switches[1:]:
logger.debug('Detected Switch aggregation.')
logger.debug('Found aggregated devices %s' % ([x.name for x in aggregated_switches[1:]]))
lookup_sw = {}
for data in aggregated_switches[1:]:
sw_osh = buildAggrBackendSwitch(data)
switches_oshs.append(sw_osh)
lookup_sw[data.meta_data] = sw_osh
for interface in interfaces:
switch_id = findRelatedSwitch(interface, index_to_data_map, lookup_sw.keys())
sw_osh = lookup_sw.get(switch_id)
if sw_osh:
interface_osh = buildSwInterface(interface, sw_osh)
interfaceVector.add(interface_osh)
return switches_oshs, interfaceVector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
protocol = Framework.getDestinationAttribute('Protocol')
try:
csvFileName = Framework.getRequiredParameterValue(PARAM_CSV_FILE)
delimiter = Framework.getRequiredParameterValue(
PARAM_CSV_FILE_DELIMITER)
if delimiter and delimiter.isdigit():
delimiter = chr(int(delimiter))
rowToStartIndex = Framework.getRequiredParameterValue(
PARAM_ROW_TO_START_INDEX)
bulkSize = Framework.getParameter(import_utils.PARAM_BULK_SIZE)
flushObjects = Framework.getParameter(import_utils.PARAM_FLUSH_OBJECTS)
fileEncoding = Framework.getParameter(import_utils.PARAM_FILE_ENCODING)
dataSource = CsvFileDataSource(csvFileName, delimiter,
int(rowToStartIndex), Framework,
fileEncoding)
dataSource.quoteSymbol = Framework.getParameter(PARAM_QUOTE_SYMBOL)
if flushObjects and (flushObjects.lower() == "true"):
import_utils.importFlushingCis(dataSource, OSHVResult, Framework,
bulkSize)
else:
import_utils.importCis(dataSource, OSHVResult, Framework)
except Exception, ex:
exInfo = ex.getMessage()
errormessages.resolveAndReport(exInfo, protocol, Framework)
def DiscoveryMain(Framework):
version = Framework.getDestinationAttribute('siebelVersion')
siebelRootDir = Framework.getDestinationAttribute('siebelInstallDir')
OSHVResult = ObjectStateHolderVector()
appServerId = Framework.getDestinationAttribute('id')
appServerOSH = modeling.createOshByCmdbIdString('siebel_app_server',
appServerId)
modeling.setAppServerType(appServerOSH)
client = None
try:
client = Framework.createClient()
discoverConfigFile(siebelRootDir, appServerOSH, client, version,
OSHVResult)
except:
errmsg = 'Connection failed: %s' % str(sys.exc_info()[1]).strip()
Framework.reportError(errmsg)
logger.debugException(errmsg)
if (client != None):
try:
client.close()
except:
pass
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute('ip_address')
credentialsId = Framework.getDestinationAttribute('credentialsId')
hostId = Framework.getDestinationAttribute('hostId')
hostOsh = ms_exchange_utils.restoreHostById(hostId)
try:
shellClient = Framework.createClient()
client = PowerShellClient(shellClient, Framework)
try:
ExchangeServer = client.executeScenario("Exchange_Server_2007_Discovery.ps1")
exchangeServerOsh = modeling.createExchangeServer(hostOsh, ipAddress, credentialsId, ExchangeServer.ExchangeSnapInVersion)
exchangeServerOsh.setAttribute('guid', normalizeGuid(ExchangeServer.Guid))
exchangeServerOsh.setAttribute('fqdn', ExchangeServer.Fqdn)
buildNumber = parseBuildNumber(ExchangeServer.AdminDisplayVersion)
if buildNumber:
exchangeServerOsh.setAttribute('build_number', buildNumber)
#exchangeServerOsh.setAttribute('application_version_number', ExchangeServer.ExchangeSnapInVersion)
versionNumber = parseExchangeVersion(ExchangeServer.AdminDisplayVersion)
if versionNumber:
exchangeServerOsh.setAttribute('application_version_number', exchange_version_mapping[versionNumber])
exchangeServerOsh.setAttribute('application_version', ExchangeServer.AdminDisplayVersion)
exchangeServerOsh.setDateAttribute('creation_date', DATE_FORMAT.parse(ExchangeServer.WhenCreated))
OSHVResult.add(exchangeServerOsh)
finally:
client.close()
except Exception, ex:
logger.debugException('')
strException = str(ex.getMessage())
errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
def report(self, container):
vector = ObjectStateHolderVector()
zone_osh = ObjectStateHolder('openstack_zone')
zone_osh.setStringAttribute('name', self.name)
zone_osh.setContainer(container)
vector.add(zone_osh)
return zone_osh, vector
def getUrl(WSDLUrl, containerOSH):
res = ObjectStateHolderVector()
urlIP = None
try:
url = URL(WSDLUrl)
hostName = url.getHost()
urlIP = netutils.getHostAddress(hostName, None)
if (not netutils.isValidIp(urlIP)) or netutils.isLocalIp(urlIP):
urlIP = None
except:
urlIP = None
urlOSH = modeling.createUrlOsh(containerOSH, WSDLUrl, 'wsdl')
urlIpOSH = None
if urlIP != None:
try:
urlIpOSH = modeling.createIpOSH(urlIP)
except:
urlIpOSH = None
res.add(urlOSH)
if urlIpOSH:
res.add(urlIpOSH)
urlToIpOSH = modeling.createLinkOSH('depend', urlOSH, urlIpOSH)
res.add(urlToIpOSH)
return res
def processWsdl(wsdl_url,
Framework,
wsdl_url_data=None,
importWsdlDocuments=1,
containerOSH=None):
ucmdbVersion = Version().getVersion(Framework)
locator = resource_locator.getProbeResourceLocator(ucmdbVersion)
webserviceFolder = 'webservice'
System.setProperty("wasp.location",
locator.contentLibPathOf(webserviceFolder))
importWsdldNames = []
importWsdldNameToData = {}
OSHVResult = ObjectStateHolderVector()
try:
result = readWSDL(wsdl_url, wsdl_url_data, importWsdlDocuments)
wsdl_url_data = result[0]
defintion = result[1]
except UnknownHostException, ex:
host = ex.getMessage()
msg = "Unknown host: %s" % host
logger.debugException("Failed reading url: '%s', reason: '%s'\n" %
(wsdl_url, msg))
errormessages.resolveAndReport(msg, ClientsConsts.HTTP_PROTOCOL_NAME,
Framework)
return OSHVResult
def osh_createOutQueueOsh(lparOsh, outQueueLists):
_vector = ObjectStateHolderVector()
str_name = 'name'
for queue in outQueueLists:
if isNotNull(queue[0]):
key = concatenate(queue[0].strip(), queue[1].strip())
outqueueOsh = ObjectStateHolder('iseries_outqueue')
outqueueOsh.setAttribute(str_name, key)
outqueueOsh.setAttribute('queue_name', queue[0].strip())
outqueueOsh.setAttribute('library_name', queue[1].strip())
outqueueOsh.setAttribute('number_of__files', int(queue[2]))
outqueueOsh.setAttribute('writer', queue[3].strip())
outqueueOsh.setAttribute('queue_status', queue[4].strip())
outqueueOsh.setContainer(lparOsh)
_vector.add(outqueueOsh)
subsystem = queue[3].strip()
if isNotNull(subsystem):
subsystemOSH = ObjectStateHolder('iseriessubsystem')
subsystemOSH.setAttribute(str_name, subsystem)
subsystemOSH.setAttribute('discovered_product_name', subsystem)
subsystemOSH.setContainer(lparOsh)
_vector.add(subsystemOSH)
memberOsh = modeling.createLinkOSH('membership', outqueueOsh,
subsystemOSH)
_vector.add(memberOsh)
return _vector
def osh_createJobOsh(lparOsh, jobsLists):
_vector = ObjectStateHolderVector()
str_name = 'name'
for job in jobsLists:
if isNotNull(job[0]):
jobOsh = ObjectStateHolder('iseries_job')
jobOsh.setAttribute(str_name, job[0].strip())
jobOsh.setAttribute('owner', job[1])
jobOsh.setAttribute('job_id', int(job[2]))
jobOsh.setAttribute('job_int_id', job[3])
jobOsh.setAttribute('job_status', job[4])
jobOsh.setAttribute('job_type', job[5])
jobOsh.setContainer(lparOsh)
_vector.add(jobOsh)
subsystem = job[6].strip()
if isNotNull(subsystem):
subsystemOSH = ObjectStateHolder('iseriessubsystem')
subsystemOSH.setAttribute(str_name, subsystem)
subsystemOSH.setAttribute('discovered_product_name', subsystem)
subsystemOSH.setContainer(lparOsh)
_vector.add(subsystemOSH)
memberOsh = modeling.createLinkOSH('membership', jobOsh,
subsystemOSH)
_vector.add(memberOsh)
return _vector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
shell = None
protocol = Framework.getDestinationAttribute('Protocol')
try:
try:
try:
hostName = Framework.getDestinationAttribute('hostname')
msMqManagerUcmdbId = Framework.getDestinationAttribute(
'msmq_id')
msMqManagerOsh = modeling.createOshByCmdbIdString(
'msmqmanager', msMqManagerUcmdbId)
client = Framework.createClient()
shell = shellutils.ShellUtils(client)
msMqDiscoverer = MsMqDiscoverer(shell, msMqManagerOsh,
hostName)
if msMqDiscoverer:
msMqDiscoverer.discover()
msMqDiscoverer.addResultsToVector(OSHVResult)
finally:
try:
shell and shell.closeClient()
except:
logger.debugException('')
logger.error('Unable to close shell')
if OSHVResult.size() == 0:
raise Exception, "Failed getting information about Microsoft Message Queue"
except JavaException, ex:
msg = ex.getMessage()
errormessages.resolveAndReport(msg, protocol, Framework)
except:
msg = logger.prepareJythonStackTrace('')
errormessages.resolveAndReport(msg, protocol, Framework)
return OSHVResult
def reportSharedResources(self, sharedResource, containerOsh):
vector = ObjectStateHolderVector()
pdo = self._builder.SharedResource(sharedResource)
osh = pdo.build(self._builder)
osh.setContainer(containerOsh)
vector.add(osh)
return vector
def disSunOS(hostId, client, Framework=None, langBund=None):
''' Discover physical memory and swap memory on SunOs
str, Shell, Framework, Properties -> oshVector
@command: /usr/sbin/prtconf
@command: swap -l
'''
myVec = ObjectStateHolderVector()
hostOsh = modeling.createOshByCmdbIdString('host', hostId)
output = None
try:
output = client.execCmd(
'/usr/sbin/prtconf',
120000) #V@@CMD_PERMISION tty protocol execution
if not output or client.getLastCmdReturnCode() != 0:
raise ValueError
except:
logger.warn("Failed getting memory size from prtconf")
else:
compiled = re.compile('Memory size: (\d+) Megabytes')
matches = compiled.findall(output)
totalMemorySizeInMegabytes = 0
for match in matches:
totalMemorySizeInMegabytes += int(match)
if totalMemorySizeInMegabytes:
memory.report(myVec, hostOsh, totalMemorySizeInMegabytes * 1024)
# > swap -l
#swapfile dev swaplo blocks free
#/dev/dsk/c1t0d0s1 32,25 16 1058288 1021616
#/swapfile - 16 7329776 7293968
try:
output = client.execAlternateCmds(
'/usr/sbin/swap -l', '/etc/swap -l',
'swap -l') #V@@CMD_PERMISION tty protocol execution
if not output or client.getLastCmdReturnCode() != 0:
raise ValueError
except:
logger.warn("Failed getting swap size from 'swap'")
else:
totalSwapSizeInMegabytes = 0
lines = output.split('\n')
for line in lines:
if line:
line = line.strip()
if re.search("swapfile\s+dev\s+swaplo\s+blocks\s+free", line):
continue
matcher = re.match(".*\d+\s+(\d+)\s+\d+$", line)
if matcher:
swapSizeInMegabytes = int(
matcher.group(1)) / 2048 # 1 block = 512 bytes
totalSwapSizeInMegabytes += swapSizeInMegabytes
if totalSwapSizeInMegabytes:
modeling.setHostSwapMemorySizeAttribute(hostOsh,
totalSwapSizeInMegabytes)
myVec.add(hostOsh)
return myVec
def disVMKernel(hostId, shell, Framework=None, langBund=None):
''' Discover physical memory on VMKernel
str, Shell, Framework, Properties -> oshVector
@raise ValueError: memory size is not a digit
@command: esxcfg-info -F xml | sed -n \'/<memory-info>/,/<\/memory-info>/p\'
'''
resVec = ObjectStateHolderVector()
hostOsh = modeling.createOshByCmdbIdString('host', hostId)
xml = shell.execCmd(
'esxcfg-info -F xml | sed -n \'/<memory-info>/,/<\/memory-info>/p\' | sed -n \'1,/<\/memory-info>/p\''
)
#Cleanup retrieved xml. Sometimes there is some debug info added
xml = xml[xml.find('<'):xml.rfind('>') + 1]
builder = SAXBuilder(0)
document = builder.build(StringReader(xml))
rootElement = document.getRootElement()
memory_values = rootElement.getChild(
'aux-source-memory-stats').getChildren('value')
for value in memory_values:
if value.getAttributeValue('name') == 'physical-memory-est.':
memorySizeInKilobytes = int(value.getText())
memory.report(resVec, hostOsh, memorySizeInKilobytes)
#TODO: Implement swap discovery for vmkernel
resVec.add(hostOsh)
return resVec
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
try:
hostId = Framework.getDestinationAttribute('hostId')
hostOsh = modeling.createOshByCmdbIdString('host_node', hostId)
snmpClient = Framework.createClient()
try:
cssDiscoverer = createCssDiscoverer(snmpClient, Framework,
OSHVResult, hostOsh)
cssDiscoverer.discoverContentRules()
cssDiscoverer.discoverServices()
finally:
snmpClient.close()
except NoCssException:
errobj = errorobject.createError(
errorcodes.CSS_NOT_FOUND_ON_TARGET_HOST, None,
'CSS was not found on target host')
logger.reportErrorObject(errobj)
except:
errorMessage = logger.prepareJythonStackTrace('')
logger.error(errorMessage)
errormessages.resolveAndReport(errorMessage, 'SNMP', Framework)
return OSHVResult
def DiscoveryMain(Framework):
resultVector = ObjectStateHolderVector()
try:
configurationReader = nnmi.ConfigurationReader(Framework)
configuration = configurationReader.getConfiguration()
connectionFactory = nnmi.ConnectionFactory(Framework)
connections = connectionFactory.getConnections()
if connections:
if len(connections) > 1:
logger.debug(
"More than one set of credentials found, the first one is used"
)
connection = connections[0]
strategy = nnmi.getDiscoveryStrategy(Framework, configuration)
strategy.discover(connection)
except nnmi.IntegrationException, ex:
msg = str(ex)
logger.error(msg)
errormessages.resolveAndReport(msg, nnmi.NNM_PROTOCOL_NAME, Framework)
def reportInstances(instances,
sys_,
sysOsh,
get_inst_creds=None,
connectionClientNr=None):
r'''@types: list[InstanceInfo], System, osh, callable, str -> dict, oshv
@type get_inst_creds: (InstanceInfo, list[_BaseIP] -> str?)
@param get_inst_creds: function to get credentials for the specified instance
'''
vector = ObjectStateHolderVector()
#resolve IP for instance host
dnsResolver = dns_resolver.SocketDnsResolver()
resolveAddressToIps = fptools.partiallyApply(_resolveInstanceAddressToIps,
fptools._, dnsResolver)
ipsOfInstances = map(resolveAddressToIps, instances)
# report instances
oshPerInstance = {}
hasIps = second
for instInfo, ips in filter(hasIps, zip(instances, ipsOfInstances)):
serverOsh, iVector = reportInstanceWithSystem(instInfo, ips, sys_,
sysOsh,
connectionClientNr)
vector.addAll(iVector)
oshPerInstance[instInfo.instance] = serverOsh
return oshPerInstance, vector
def reportVirtualTopology(self, virtualMachines, hypervisorCmdbId):
'''
list(VmComputerSystem), string -> ObjectStateHolderVector
'''
resultVector = ObjectStateHolderVector()
if not virtualMachines:
return resultVector
hypervisorOsh = self.reportHypervisorByCmdbId(hypervisorCmdbId)
resultVector.add(hypervisorOsh)
for vm in virtualMachines:
vmOsh = self.reportVirtualMachine(vm)
if vmOsh:
resultVector.add(vmOsh)
hostResourceOsh = self.reportVmHostResource(vm, vmOsh)
resultVector.add(hostResourceOsh)
runLink = self.reportRunLink(hypervisorOsh, vmOsh)
resultVector.add(runLink)
ipOsh = self.reportIpAddressOfVm(vm)
if ipOsh is not None:
resultVector.add(ipOsh)
containmentLink = self.reportContainmentLink(vmOsh, ipOsh)
resultVector.add(containmentLink)
return resultVector
def reportMqServerWithEndpoint(self, server):
r''' Make reporting of MQ server based on its IP where contains
is incomplete host built using IP address and if port specified
linked with corresponding service endpoint
@types: jms.MqServer -> ObjectStateHolderVector
@raise ValueError: JMS Server is not specified
@raise ValueError: MQ Server IP address is empty or not resolved
'''
if not server:
raise ValueError("JMS Server is not specified")
ip = server.address
if not (ip and netutils.isValidIp(ip)):
raise ValueError("MQ Server IP address is empty or not resolved")
vector = ObjectStateHolderVector()
hostOsh = modeling.createIpOSH(ip)
vector.add(hostOsh)
serverOsh = self.reportMqServer(server, hostOsh)
vector.add(serverOsh)
if server.getPort() is not None:
vector.add(
modeling.createServiceAddressOsh(
hostOsh, ip, server.getPort(),
modeling.SERVICEADDRESS_TYPE_TCP))
return vector
def createVlanOshv(vlMap, portOshMap):
vlanHostOshMap = {}
oshv = ObjectStateHolderVector()
# process VLANs
for (vlanId, vlanObj) in vlMap.items():
ports = vlanObj.ports
ports.sort()
for portId in ports:
if notNull(portOshMap) and portOshMap.has_key(portId):
vlanOsh = ObjectStateHolder('vlan')
vlanOsh.setIntegerAttribute('vlan_number', int(vlanObj.vlanId))
vlanOsh.setAttribute('vlan_aliasname', vlanObj.name)
vlanOsh.setAttribute('data_name', vlanObj.vlanId)
if vlanHostOshMap.has_key(vlanObj.vlanId):
hostOsh = vlanHostOshMap[vlanObj.vlanId]
else:
hostOsh = portOshMap[portId].getAttributeValue('root_container')
oshv.add(vlanOsh)
vlanHostOshMap[vlanObj.vlanId] = hostOsh
vlanOsh.setContainer(hostOsh)
membershipLink = modeling.createLinkOSH("member", portOshMap[portId], vlanOsh)
oshv.add(membershipLink)
return oshv
def _discoverWindowsDeviceDriver(powershell, hostOsh):
'''PowerShell, osh -> vector
@raise Exception: failed getting windows driver by WMI
'''
vector = ObjectStateHolderVector()
HR_Dis_Driver_Lib.discoverDriverByWmi(powershell, vector, hostOsh)
return vector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
logger.debug('Start nmap_osfingerprint.py')
ip = Framework.getDestinationAttribute('ip_address')
timeout = Framework.getParameter('nmap_host_timeout')
if not str(timeout).isdigit():
msg = "Timeout parameter value must be a digit"
logger.debug(msg)
errormessages.resolveAndReport(msg,
ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME,
Framework)
return OSHVResult
timeout = int(timeout) * 1000
scanKnownPortsOnly = Boolean.parseBoolean(
Framework.getParameter('scan_known_ports_only'))
portstoscan = Framework.getParameter('scan_these_ports_only')
doServiceFingerprints = Boolean.parseBoolean(
Framework.getParameter('Perform_Port_Fingerprints'))
createApp = Boolean.parseBoolean(
Framework.getParameter('Create_Application_CI'))
discoverOsName = Boolean.parseBoolean(
Framework.getParameter('discover_os_name'))
nmapLocation = Framework.getParameter('nmap_location')
#discover_UDP_Ports = int(Framework.getParameter('Discover_UDP_Ports'))
discoverUdpPorts = 0
agent_root_dir = CollectorsParameters.BASE_PROBE_MGR_DIR
agent_ext_dir = agent_root_dir + CollectorsParameters.getDiscoveryResourceFolder(
) + CollectorsParameters.FILE_SEPARATOR
tmp_file_name = agent_ext_dir + string.replace(
ip, '.', '_') + time.strftime("%H%M%S", time.gmtime(
time.time())) + 'nmap.xml'
syncNmapPortConfigFile(agent_root_dir)
logger.debug('temp file for storing nmap results: ', tmp_file_name)
try:
client = Framework.createClient(
ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME)
try:
performNmapDiscover(client, ip, tmp_file_name, timeout,
agent_ext_dir, scanKnownPortsOnly, portstoscan,
doServiceFingerprints, discoverUdpPorts,
nmapLocation)
if os.path.exists(tmp_file_name):
logger.debug('start processing the nmap results')
processNmapResult(tmp_file_name, OSHVResult, discoverOsName,
doServiceFingerprints, createApp, Framework)
else:
raise ValueError, 'Error nmap result file is missing: %s' % tmp_file_name
finally:
client.close()
File(tmp_file_name).delete()
except Exception, e:
msg = str(e.getMessage())
logger.debug(msg)
errormessages.resolveAndReport(msg,
ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME,
Framework)
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute('ip_address')
credentialsId = Framework.getDestinationAttribute('credentialsId')
hostId = Framework.getDestinationAttribute('hostId')
hostOsh = ms_exchange_utils.restoreHostById(hostId)
hostName = Framework.getDestinationAttribute('hostName')
if not hostName or hostName == 'N/A':
hostName = ms_exchange_utils.getHostNameFromWmi(Framework)
if not hostName:
errobj = errorobject.createError(errorcodes.FAILED_GETTING_INFORMATION_NO_PROTOCOL, ['host name'], 'Failed to obtain host name')
logger.reportErrorObject(errobj)
return
props = Properties()
props.put(AgentConstants.PROP_WMI_NAMESPACE, WMI_NAMESPACE)
try:
wmiClient = Framework.createClient(props)
wmiAgent = WmiAgent(wmiClient, Framework)
try:
discoverExchangeServer(wmiAgent, ipAddress, credentialsId, OSHVResult, Framework, hostOsh, hostName)
finally:
wmiClient.close()
except Exception, ex:
message = ex.getMessage()
if (re.search("Invalid\sclass", message)):
message = 'Unable to get Exchange data from WMI'
logger.debugException(message)
errormessages.resolveAndReport(message, WMI_PROTOCOL, Framework)
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
#ipAddress = Framework.getDestinationAttribute('ip_address')
#credentialsId = Framework.getDestinationAttribute('credentialsId')
hostId = Framework.getDestinationAttribute('hostId')
try:
factory = hyperv.ShellClientFactory(Framework)
shell = None
try:
shell = factory.createClient()
language = shell.getOsLanguage()
bundle = hyperv.getBundleByLanguage(language, Framework)
namespace = hyperv.ShellNamespaceLookUp().lookUp(shell)
wmiProvider = hyperv.ShellHypervAgentProvider(
shell, bundle, namespace)
hyperv.discoverHypervHost(
wmiProvider, hostId, Framework, OSHVResult,
namespace[2:]) #strip heading slashes in namespace
finally:
if shell is not None:
shell.closeClient()
except JException, ex:
exInfo = ex.getMessage()
errormessages.resolveAndReport(exInfo, NTCMD_PROTOCOL, Framework)
def createLayer2Topology(interfaceEnd1, interfaceEnd2):
OSHV = ObjectStateHolderVector()
end1Node = modeling.createCompleteHostOSH('node', str(interfaceEnd1.xHash))
end2Node = modeling.createCompleteHostOSH('node', str(interfaceEnd2.xHash))
interface1 = modeling.createInterfaceOSH(
interfaceEnd1.ifMac, end1Node, interfaceEnd1.ifDescr,
interfaceEnd1.ifIndex, interfaceEnd1.ifType,
interfaceEnd1.ifAdminStatus, interfaceEnd1.ifOperStatus,
interfaceEnd1.ifSpeed, interfaceEnd1.ifName, interfaceEnd1.ifAlias)
interface2 = modeling.createInterfaceOSH(
interfaceEnd2.ifMac, end2Node, interfaceEnd2.ifDescr,
interfaceEnd2.ifIndex, interfaceEnd2.ifType,
interfaceEnd2.ifAdminStatus, interfaceEnd2.ifOperStatus,
interfaceEnd2.ifSpeed, interfaceEnd2.ifName, interfaceEnd2.ifAlias)
layer2Osh = ObjectStateHolder('layer2_connection')
layer2Osh.setAttribute(
'layer2_connection_id',
str(hash(interfaceEnd1.ifMac + interfaceEnd2.ifMac)))
member1 = modeling.createLinkOSH('member', layer2Osh, interface1)
member2 = modeling.createLinkOSH('member', layer2Osh, interface2)
OSHV.add(end1Node)
OSHV.add(end2Node)
OSHV.add(interface1)
OSHV.add(interface2)
OSHV.add(layer2Osh)
OSHV.add(member1)
OSHV.add(member2)
return OSHV
def collectData(self,hostId,sqlServerId, discoverConfigs = 1):
self.connection.open()
oshv = ObjectStateHolderVector()
try:
oshv.add(self.getServerProperties(sqlServerId,hostId))
dbMap = self.getDatabases(sqlServerId)
#get the databases
oshv.addAll(self.sqlDataBaseProps.getDatabases(dbMap,hostId,discoverConfigs))
oshv.addAll(self.sqlDataBaseProps.getStoredProcedures(dbMap))
#get the server configuration:
logger.debug('discovering configs')
try:
oshv.add(self.sqlServerConfig.getServerConfiguration(sqlServerId))
oshv.add(self.sqlServerConfig.getServerStartup(sqlServerId))
self.sqlServerConfig.discoverPlans(oshv,sqlServerId,dbMap)
except:
logger.debugException(hostId.toString())
if self.discoveryOptions and self.discoveryOptions.discoverDbUser:
users = self.getDbUsers(sqlServerId)
Util.addFromMap(users,oshv)
else:
users = LinkedHashMap()
oshv.addAll(self.getProcesses(hostId,sqlServerId,dbMap,users))
oshv.addAll(self.clusterConfiguration.collectData(sqlServerId))
#db configuration:
oshv.addAll(self.getDbConf(dbMap,hostId,users))
logger.debug("sql db result for hostid:"+hostId.toString())
except:
logger.debugException(hostId.toString())
self.connection.close()
return oshv
def DiscoveryMain(Framework):
logger.reportWarning(
'The job is deprecated. Use "Network Connectivity Data Analyzer" instead.'
)
# netlinks = NetlinksPotentialServers(Framework)
# netlinks.discover()
return ObjectStateHolderVector()
