def _logWarn(errorCode, params, errorMessage):
'int, list(str), str -> None'
if not (modeling.CmdbClassModel().version() >= 9.0):
errorMessage = errormessages.makeErrorMessage(params[1].upper(), params[0], errormessages.ERROR_DISCOVERY_BY_PROTOCOL)
logger.debugException(errorMessage)
errobj = errorobject.createError(errorCode, params, errorMessage)
logger.reportWarningObject(errobj)
def decorator(framework):
vector = ObjectStateHolderVector()
framework = RichFramework(framework)
creds_manager = CredsManager(framework)
creds = creds_manager.get_creds_for_destination(proto_name)
creds = filter(Fn(is_cred_ok_fn, framework, creds_manager, __), creds)
if not creds:
logger.reportErrorObject(_create_missed_creds_error(proto_name))
else:
connection_exs = []
discovery_exs = []
warnings = []
at_least_once_discovered = False
for cred_id in creds:
try:
oshs, warnings = main_fn(framework, creds_manager, cred_id)
vector.addAll(oshs)
at_least_once_discovered = True
if stop_on_first:
break
except ConnectionException, ce:
logger.debugException(str(ce))
connection_exs.append(ce)
except (DiscoveryException, Exception, JException), de:
logger.debugException(str(de))
discovery_exs.append(de)
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):
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):
credentialsId = Framework.getDestinationAttribute('credentialsId')
OSHVResult = ObjectStateHolderVector()
matchers = SiebelAgent.SIEBEL_DEFAULT_ENTERPRISE_MATCHERS
ip = Framework.getDestinationAttribute('ip_address')
port = Framework.getDestinationAttribute('port')
if port == 'NA':
port = None
try:
client = None
try:
client = siebel_common.createClient(Framework, ip, matchers, credentialsId, port)
username = client.getUserName()
enterprise = client.getEnterprise()
siteOSH = ObjectStateHolder('siebel_site')
siteOSH.setAttribute('data_name', enterprise)
siteOSH.setAttribute('gateway_address', ip)
modeling.setAppSystemVendor(siteOSH)
start_srvrmgr_discovery(client, ip, username, enterprise, siteOSH, Framework, OSHVResult)
finally:
if client is not None:
client.close()
except Exception, ex:
strException = str(ex.getMessage())
errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
logger.debugException('')
def discoverPhysicalVolumes(wmiProvider, OSHVec, hostOSH):
queryBuilder = wmiProvider.getBuilder("MSFT_Disk")
queryBuilder.addWmiObjectProperties("ObjectId", "Path", "FriendlyName", "SerialNumber", "Number", "Size")
wmicAgent = wmiProvider.getAgent()
idToOshMap = {}
numberToOshMap = {}
try:
phyVolumes = wmicAgent.getWmiData(queryBuilder)
except:
logger.debugException("Failed getting partition to volume map via wmi")
return idToOshMap
for volume in phyVolumes:
id = volume.ObjectId and volume.ObjectId.strip() or ""
id = id.replace("&", "&")
name = volume.Path and volume.Path.strip() or ""
name = name.replace("&", "&")
description = volume.FriendlyName
serialNumber = volume.SerialNumber
number = volume.Number
size = volume.Size
phyVolumeOsh = ObjectStateHolder("physicalvolume")
phyVolumeOsh.setStringAttribute("name", name)
phyVolumeOsh.setStringAttribute("description", description)
phyVolumeOsh.setStringAttribute("serial_number", serialNumber)
phyVolumeOsh.setStringAttribute("volume_id", id)
phyVolumeOsh.setDoubleAttribute("volume_size", _bytesToMB(size))
phyVolumeOsh.setContainer(hostOSH)
OSHVec.add(phyVolumeOsh)
idToOshMap[id] = phyVolumeOsh
numberToOshMap[number] = phyVolumeOsh
return idToOshMap, numberToOshMap
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
shell = None
protocol = Framework.getDestinationAttribute("Protocol")
switchId = Framework.getDestinationAttribute("hostId")
print "Switch id %s" % switchId
errorMessage = None
try:
client = Framework.createClient()
try:
shellFactory = shellutils.ShellFactory()
shell = shellFactory.createShell(client)
switchOsh = modeling.createOshByCmdbId("switch", switchId)
discoverer = NexusDiscoverer(Framework, shell, "", "", "", "")
discoverer.discoverInterfacesAndIps()
interfaces_dict = discoverer.hostDataObject.interfaces
ports_map = parsePorts(interfaces_dict.values())
vlan_discoverer = layer2_shell_discoverer.VlanDiscoverer(shell)
vlans = vlan_discoverer.discoverVlans()
layer2_discoverer = layer2_shell_discoverer.Layer2Discoverer(shell)
remote_peers_map = layer2_discoverer.discover()
OSHVResult.addAll(layer2.reportTopology(switchOsh, interfaces_dict, vlans, remote_peers_map, ports_map))
finally:
try:
shell and shell.closeClient()
except:
logger.debugException("")
logger.error("Unable to close shell")
except JException, ex:
errorMessage = ex.getMessage()
def discover(self, firstSuccessful=1):
for ip, contextsByCredentialsMap in self.contextsMap.items():
logger.debug("Connecting by IP %s" % ip)
for contextList in contextsByCredentialsMap.values():
for context in contextList:
try:
client = self._connectByContext(context)
try:
context.client = client
self.connectionHandler.onConnection(context)
if firstSuccessful:
return
finally:
if client:
client.close()
except JException, ex:
msg = ex.getMessage()
logger.debug(msg)
errormessages.resolveAndAddToCollections(msg, VcloudProtocol.DISPLAY, context.warnings, context.errors)
self.connectionHandler.onFailure(context)
except Exception, ex:
msg = str(ex)
logger.debugException(msg)
errormessages.resolveAndAddToCollections(msg, VcloudProtocol.DISPLAY, context.warnings, context.errors)
self.connectionHandler.onFailure(context)
def mapProcessToPortsInSpecialWay(self):
'''Mapping processes to open ports by pfiles'''
invalidIpsMessage = ''
errMsg = ''
status = TCPDiscovery.OK
try:
# this command run only on sh, ksh and bash. csh and tcsh are not supported yet
marker = '_%s_' % int(time.time())
cmdLine = 'for i in `ps -e|awk \'{if($4 != "<defunct>") if($1 != "PID") print $1}\'`; do echo %s$i; nice pfiles $i 2>&1|awk "/S_IFSOCK|SOCK_STREAM|SOCK_DGRAM|port/ { print }"; done' % marker
result = self.shUtils.execCmd(cmdLine, self.shUtils.getDefaultCommandTimeout() * 40)#@@CMD_PERMISION shell protocol execution
procsToPorts = result.split(marker)
for procToPort in procsToPorts:
mappings = TCPDisBySunOSShell._parseProcessPorts(procToPort)
for mapping in mappings:
ip, port, pid, listen, prot = mapping
self._addTcpData(str(ip), port, pid, listen, prot)
except TimeoutException:
errMsg = 'Failed to map processes to ports by pfiles - timeout, try to increase command timeout parameter'
logger.debugException(errMsg)
self.Framework.reportWarning(errMsg)
except:
errMsg = 'Failed to map processes to ports by pfiles:see communication log'
logger.debugException(errMsg)
self.Framework.reportError(errMsg)
status = TCPDiscovery.ERROR
if len(invalidIpsMessage) > 0:
wrnMsg = 'There are invalid ips found while paring port by pfiles, check communication log'
self.Framework.reportWarning(wrnMsg)
logger.debug(wrnMsg + '\n' + invalidIpsMessage)
return status
def iterate_over_args(main_fn, framework, cred_args, proto_name, stop_on_first):
'''
@param cred_args: parameters you decided to iterate over
'''
vector = ObjectStateHolderVector()
framework = flow.RichFramework(framework)
creds_manager = flow.CredsManager(framework)
# as cred_args possibly generator or iterator, realize only first
first_ = first(cred_args)
if first_ is None:
logger.reportErrorObject(flow._create_missed_creds_error(proto_name))
else:
# restore cred_args
cred_args = chain((first_,), cred_args)
connection_exs = []
discovery_exs = []
warnings = []
at_least_once_discovered = False
for args in cred_args:
try:
oshs, warnings_ = main_fn(framework, creds_manager, *args)
warnings.extend(warnings_ or ())
vector.addAll(oshs)
at_least_once_discovered = True
if stop_on_first:
break
except flow.ConnectionException, ce:
logger.debugException(str(ce))
connection_exs.append(ce)
except (flow.DiscoveryException, Exception, JException), de:
logger.debugException(str(de))
discovery_exs.append(de)
def discoverDnsZoneTopologies(dnsDiscoverer, zoneList, protocolName):
r'''DnsDiscoverer, seq[str], str -> seq[_ZoneTopology]
@note: make error reporting to the UI
'''
topologies = []
try:
zoneList = zoneList and map(dns.Zone, zoneList)
zones = zoneList or dnsDiscoverer.listZones()
isError = 0
for zone in zones:
if (dns.isLocalhostZone(zone)
or dns.isReverseZone(zone)
or dns.isRootZone(zone)):
continue
topology = ZoneTopology(zone)
try:
logger.debug('transfer zone: %s' % zone)
types = (RecordType.A, # IPv4 address
RecordType.CNAME, # Alias
RecordType.AAAA) # IPv6 address
records = dnsDiscoverer.transferZone(zone, *types)
topology.records.extend(records)
except dns.DiscoveryException, dde:
logger.warn('Failed to transfer zone "%s"' % zone)
logger.debugException(str(dde))
isError = 1
else:
topologies.append(topology)
if isError:
errCode = errorcodes.FAILED_TRANSFER_DNS_ZONE
message = "Failed to transfer zone records for one or more zones"
errobj = errorobject.createError(errCode, [protocolName], message)
logger.reportWarningObject(errobj)
def mapProcessToPortsInSpecialWay(self):
invalidIpsMessage = ''
errMsg = ''
status = TCPDiscovery.OK
try:
socket_descriptors = get_socket_descriptors_by_pfiles(self.shUtils)
for pid, socket_descriptor in socket_descriptors:
local_ip, local_port, is_listen, protocol_type, _, _ = socket_descriptor
local_ip = local_ip and sanitizeIps(local_ip)
if local_ip and (not ip_addr.isValidIpAddress(local_ip)):
local_ip = netutils.resolveIP(self.shUtils, local_ip)
if local_ip and (ip_addr.isValidIpAddress(local_ip)):
self._addTcpData(local_ip, local_port, pid, is_listen, protocol_type)
else:
invalidIpsMessage = invalidIpsMessage + 'On parsing ports by pfiles invalid ip:<%s>\n' % local_ip
except TimeoutException:
errMsg = 'Failed to map processes to ports by pfiles - timeout, try to increase command timeout parameter'
logger.debugException(errMsg)
self.Framework.reportWarning(errMsg)
except:
errMsg = 'Failed to map processes to ports by pfiles:see communication log'
logger.debugException(errMsg)
self.Framework.reportError(errMsg)
status = TCPDiscovery.ERROR
if len(invalidIpsMessage) > 0:
wrnMsg = 'There are invalid ips found while paring port by pfiles, check communication log'
self.Framework.reportWarning(wrnMsg)
logger.debug(wrnMsg + '\n' + invalidIpsMessage)
return status
def getEth(self, managedSystemName):
try:
output = self.executeCommand('lshwres -r virtualio --rsubtype eth --level lpar -m \'' + managedSystemName + '\'')
return self.getEntiesAsList(output, self._parseEth)
except:
logger.debug('Failed to discover eth information.')
logger.debugException('')
def discoverSharedResourcesByWmic(client, hostOsh, oshVector):
queryBuilder = wmiutils.WmicQueryBuilder('share')
queryBuilder.addWmiObjectProperties('description', 'name', 'path')
queryBuilder.addWhereClause("Path <> ''")
wmicAgent = wmiutils.WmicAgent(client)
shareItems = []
try:
shareItems = wmicAgent.getWmiData(queryBuilder)
except:
logger.debugException('Failed getting shares information via wmic' )
return 0
collection = {}
for shareItem in shareItems:
shareName = shareItem.name
shareDescription = shareItem.description
sharePath = shareItem.path
instance = SharedResource.Instance(shareName, shareDescription)
element = collection.get(sharePath)
if element is None:
element = SharedResource(sharePath)
element.addInstance(instance)
collection[sharePath] = element
for [path, resource] in collection.items():
createSharedResourceOsh(resource, hostOsh, oshVector)
return 1
def _getLparProfiles(self, managedSystemName, lparFilter):
try:
output = self.executeCommand('lssyscfg -r prof -m \'' + managedSystemName + '\'' + ' --filter '+ lparFilter)
return self.getEntriesAsDict(output, self._parseLparProfile)
except:
logger.debug('Failed to discover LPar Profile')
logger.debugException('')
def _getLpars(self, managedSystemName):
try:
output = self.executeCommand('lssyscfg -r lpar -m \'' + managedSystemName + '\'')
return self.getEntriesAsDict(output, self._parseLpar)
except:
logger.debug('Failed to get LPar information.')
logger.debugException('')
def discoverExchangeServers(self):
#@return list of ExchangeServer Do
hostname = self._getHostNameByHostname()
try:
dagList = self._getClusteredConfiguration()
except:
dagList = []
logger.debug('The exchange configuration is not a clustered one.')
logger.debugException('')
mdbList = []
try:
mdbList = self._getMailboxDatabaseConfiguration()
ipResolver = dns_resolver.NsLookupDnsResolver(self._shell)
for mdb in mdbList:
if mdb.servers:
for serverInfo in mdb.servers:
try:
serverInfo.ips = ipResolver.resolve_ips(serverInfo.name)
except:
logger.debug('Failed to resolve ip for server %s ' % serverInfo.name)
except:
logger.debug('Failed to discover Mailbox Database configuration.')
logger.debugException('')
exchangeServers = self._getExchangeServers(hostname, hostname)
if exchangeServers:
for exchangeServer in exchangeServers:
exchangeServer.dagList = dagList
exchangeServer.mdbList = mdbList
return exchangeServers
def discoveriSCSISessionToDiskMap(wmiProvider):
queryBuilder = wmiProvider.getBuilder("MSFT_iSCSISessionToDisk")
queryBuilder.addWmiObjectProperties("Disk", "iSCSISession")
wmicAgent = wmiProvider.getAgent()
associations = []
map = {}
try:
associations = wmicAgent.getWmiData(queryBuilder)
except:
logger.debugException("Failed getting session to disk map via wmic")
return map
for association in associations:
disk = association.Disk and association.Disk.strip() or ""
disk = disk.split("=")[1].strip('"')
if disk.find("\\\\\\\\") == 0:
disk = disk.replace("\\\\", "\\")
disk = disk.replace("&", "&")
session = association.iSCSISession
session = session.split("=")[1].strip('"')
disks = map.get(session) or []
disks.append(disk)
map[session] = disks
return map
def doDiscovery(Framework, shell, ip, credentialId, codepage, shellName, warningsList, errorsList, uduid = None):
vector = ObjectStateHolderVector()
try:
try:
languageName = shell.osLanguage.bundlePostfix
langBund = Framework.getEnvironmentInformation().getBundle('langNetwork', languageName)
remoteHostnames = dns_resolver.NsLookupDnsResolver(shell).resolve_hostnames(ip)
remoteHostFqdn = None
if remoteHostnames:
remoteHostFqdn = remoteHostnames[0]
shellObj = createShellObj(shell, ip, langBund, languageName, codepage, remoteHostFqdn)
try:
vector.addAll(discover(shell, shellObj, ip, langBund, Framework, uduid))
finally:
# create shell OSH if connection established
if shellObj and not vector.size():
hostOsh = modeling.createHostOSH(ip)
shellObj.setContainer(hostOsh)
vector.add(shellObj)
except Exception, ex:
strException = ex.getMessage()
errormessages.resolveAndAddToObjectsCollections(strException, shellName, warningsList, errorsList)
except:
msg = str(sys.exc_info()[1])
logger.debugException('')
errormessages.resolveAndAddToObjectsCollections(msg, shellName, warningsList, errorsList)
def discoverPhysicalDiskByWmi(shell, OSHVec, hostOSH):
wmiProvider = wmiutils.getWmiProvider(shell)
queryBuilder = wmiProvider.getBuilder("Win32_DiskDrive")
queryBuilder.addWmiObjectProperties("DeviceID", "SerialNumber", "Size")
wmiAgent = wmiProvider.getAgent()
diskDevices = []
try:
diskDevices = wmiAgent.getWmiData(queryBuilder)
except:
logger.debugException("Failed getting physical disk via wmi")
for diskDevice in diskDevices:
diskOsh = ObjectStateHolder("disk_device")
diskName = diskDevice.DeviceID and diskDevice.DeviceID.strip() or None
if diskName:
diskOsh.setStringAttribute("name", diskName.upper())
else:
continue
diskSerialNumber = diskDevice.SerialNumber and diskDevice.SerialNumber.strip() or None
if diskSerialNumber:
diskOsh.setStringAttribute("serial_number", diskSerialNumber)
diskOsh.setStringAttribute("disk_type", "fixed_disk")
diskSize = diskDevice.Size and diskDevice.Size.strip() or None
# Byte to MB
if diskSize:
diskSize = int(diskSize) / 0x100000
diskOsh.setIntegerAttribute("disk_size", diskSize)
diskOsh.setContainer(hostOSH)
OSHVec.add(diskOsh)
def DiscoveryMain(Framework):
shell = None
try:
try:
protocolName = __getProtocolName(Framework)
discoverSharePointUrls = Boolean.parseBoolean(Framework.getParameter('discoverSharePointUrls'))
reportIntermediateWebService = Framework.getParameter('reportIntermediateWebService')
if reportIntermediateWebService:
reportIntermediateWebService = Boolean.parseBoolean(reportIntermediateWebService)
else:
#set default value
reportIntermediateWebService = 1
relativeCommandTimeoutMultiplier = Framework.getParameter('relativeCommandTimeoutMultiplier')
relativeCommandTimeoutMultiplier = int(relativeCommandTimeoutMultiplier)
client = Framework.createClient()
shell = ShellFactory().createShell(client)
logger.debug('getting SharePoint discoverer for protocol %s' % protocolName)
discoverer = sharepoint_win_shell.getDiscoverer(shell, protocolName, relativeCommandTimeoutMultiplier)
logger.debug('got discoverer')
resources = _discoverSharePoint(discoverer)
resources.build()
return resources.report(discoverSharePointUrls, reportIntermediateWebService)
except SharePointException:
logger.reportError()
logger.debugException('')
except JavaException, ex:
strException = ex.getMessage()
errormessages.resolveAndReport(strException, protocolName, Framework)
except:
strException = logger.prepareJythonStackTrace('')
errormessages.resolveAndReport(strException, protocolName, Framework)
def handleWSDL(HOST_IP, MANAGER_PORT, wsdlDirRes, wsdlDir, appList, shellUtils, OSHVResult):
lines = wsdlDirRes.split('\n')
for line in lines:
m = re.search('application-deployments[\\\\/](\w+)[\\\\/](\w+)[\\\\/]server-wsdl',line)
if m != None:
appName = m.group(1)
wsdlName = m.group(2)+'.wsdl'
wsdlFullPAth = '%s/%s/%s/server-wsdl/' % (wsdlDir, m.group(1), m.group(2))
appOSH = appList[appName]
fileWsdlContent = None
try:
fileWsdlContent = shellUtils.safecat(wsdlFullPAth + wsdlName)
if fileWsdlContent:
tg = '<service name="(\w+)">.*oracle.scheme.host.port.and.context\}.(\w+)'
compiled = re.compile(tg,re.S)
matches = compiled.findall(fileWsdlContent.strip())
for match in matches:
wsdlUrl = 'http://' + HOST_IP + ':' + MANAGER_PORT + '/integration/services/' + match[0] + '/' + match[1] + '?WSDL'
res = getUrl(wsdlUrl, appOSH)
OSHVResult.addAll(res)
except:
logger.debugException('Error reading file: %s' % (wsdlFullPAth + wsdlName))
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 ensureScannerExist(scannerPlatformConfig, Framework):
logger.debug('Ensure Scanner Exist')
#copying local scanner executable and config file to the remove machine
BASEDIR = Framework.getProperty(InventoryUtils.STATE_PROPERTY_RESOLVED_BASEDIR)
#scanner local executable file
scannerExecutable = scannerPlatformConfig.getScannerExecutable()
logger.debug('Scanner executable to be used:', scannerExecutable)
#scanner remote executable file
scannerRemoteExecutable = scannerPlatformConfig.getScannerRemoteExecutableName()
#local location of scanner and config file
scannerExecutableLocalPath = CollectorsParameters.PROBE_MGR_RESOURCES_DIR + 'ud_scanners' + str(File.separator) + scannerExecutable
logger.debug('Scanner executable local path:', scannerExecutableLocalPath)
if not checkResourceExists(Framework, scannerExecutableLocalPath):
return 0
scannerExecutableRemotePath = BASEDIR + scannerRemoteExecutable
logger.debug('Copy local ', scannerExecutableLocalPath, " to remote ", scannerExecutableRemotePath)
client = Framework.getConnectedClient()
try:
client.uploadFile(scannerExecutableLocalPath, scannerExecutableRemotePath, 0)
Framework.setProperty(InventoryUtils.SCANNER_EXECUTABLE_REMOTE_PATH, scannerExecutableRemotePath)
except:
errorMessage = str(sys.exc_info()[1])
logger.debugException('Error happened when uploading scanner:' + errorMessage)
Framework.setStepExecutionStatus(WorkflowStepStatus.FAILURE)
return 0
return 1
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 _get_initialized_execute_fn(client, run_timeout):
try:
return ovm_cli.initialize_env_with_xml_as_output(client, run_timeout)
except Exception:
msg = "Failed to initialize OVM CLI"
logger.debugException(msg)
raise ovm_flow.DiscoveryException(msg)
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
logger.info('Starting HACMP Applications')
hostIP = Framework.getDestinationAttribute('ip_address')
logger.debug ('Host IP: ',hostIP)
cluster = Framework.getDestinationAttribute('cluster')
hostOS = Framework.getDestinationAttribute('host_os')
hostOS = hostOS or 'NA'
protocolName = Framework.getDestinationAttribute('Protocol')
hostId = Framework.getDestinationAttribute('hostId')
## Get Parameter Section
cldisp_command = Framework.getParameter('cldisp_command') or 'cldisp'
cllsif_command = Framework.getParameter('cllsif_command') or 'cllsif'
try:
client = Framework.createClient()
shell = ShellUtils(client)
# If we get good client connection , run the client commands to get the Application information for the cluster
HostOSH = modeling.createOshByCmdbIdString('host', hostId)
ClusterOSH = getclusterOSH(cluster)
appDictionary = getapplicationInfo(shell, cldisp_command, Framework)
resourceDictionary = getresourceinfo(shell, cllsif_command)
OSHVResult.addAll(createserviceapplicationOSH (shell, appDictionary, resourceDictionary, HostOSH, ClusterOSH, Framework))
client.close()
except JavaException, ex:
strException = ex.getMessage()
logger.debugException('')
errormessages.resolveAndReport(strException, protocolName, Framework)
def getOracleServerNameByInstance(self):
try:
resultHost = self._client.executeQuery("select HOST_NAME from V$INSTANCE where upper(INSTANCE_NAME) = '%s'" % self._client.getSid().upper())
while resultHost.next():
return resultHost.getString(1)
except:
logger.debugException('')
def getOracleServerName(self):
try:
host_name_result = self._client.executeQuery("select UTL_INADDR.get_host_name(UTL_INADDR.get_host_address) from dual")
while host_name_result.next():
return host_name_result.getString(1)
except:
logger.debugException('')
def getServices(dbClient):
services = []
logger.debug('Query services for protocol type:', DbTypes.Oracle)
try:
res = dbClient.executeQuery("SELECT NAME, PDB from V$SERVICES WHERE NETWORK_NAME IS NOT NULL")
while res.next():
name = res.getString(1)
pdb = res.getString(2).strip() != '' and res.getString(2) != 'CDB$ROOT'
service = db.OracleServiceName(name)
service.setPdb(pdb)
services.append(service)
res.close()
except:
logger.debugException('')
try:
res = dbClient.executeQuery("SELECT NAME from V$SERVICES WHERE NETWORK_NAME IS NOT NULL")
while res.next():
name = res.getString(1)
service = db.OracleServiceName(name)
services.append(service)
res.close()
except:
logger.debugException('')
return services
def DiscoveryMain(Framework):
ip = Framework.getDestinationAttribute("ip") or None
port = Framework.getDestinationAttribute("https_port") or None
hostCmdbId = Framework.getDestinationAttribute("host_id") or None
oshvector = ObjectStateHolderVector()
hostOsh = modeling.createOshByCmdbIdString('node', hostCmdbId.strip())
if not (hostOsh and ip and port):
logger.error("Incorrect input data: %s" % hostCmdbId.strip())
logger.reportError("Incorrect input data")
return oshvector
localShell = shellutils.ShellUtils(Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME))
dnsResolver = dns_resolver.FallbackResolver([dns_resolver.SocketDnsResolver(),
dns_resolver.NsLookupDnsResolver(localShell)])
hosts = dnsResolver.resolve_hostnames(ip)
logger.debug("Host names to check: %s" % hosts)
errors = []
discoverResult = {}
for hostname in hosts:
try:
logger.info("Getting certificate from %s:%s" % (hostname, port))
certificates = ssl_cert_discoverer.openSslSession(hostname, port, ssl_cert_discoverer.discoverCertificates)
if certificates:
logger.info("Got %s certificates" % len(certificates))
discoverResult[hostname] = certificates
else:
logger.warn("There are no any certificates on the %s:%s" % (hostname, port))
logger.reportError("There are no any certificates on the target host")
except JException,ex:
logger.debugException(ex.getMessage())
errors.append(ex.getMessage())
except Exception, ex:
logger.debugException(ex.message)
errors.append(ex.message)
def _simConnect(credId, ip, Framework):
# Make sure the SIM JAR file is in place and loadable
try:
from com.hp.mx.soap.v5_1.client import MxpiMain5_1SoapBindingStub
import VerifyAllHostnameVerifier
except Throwable:
message = "SIM SDK jar is missed. Refer documentation for details"
logger.debugException(message)
return Result(False, message)
soapPort = Framework.getProtocolProperty(credId, PROTOCOL_ATTRIBUTE_PORT)
soapProtocol = Framework.getProtocolProperty(credId,
'simprotocol_protocol')
username = Framework.getProtocolProperty(credId,
PROTOCOL_ATTRIBUTE_USERNAME)
password = Framework.getProtocolProperty(credId,
PROTOCOL_ATTRIBUTE_PASSWORD)
localMxpiMain, simLogonToken = None, None
try:
localMxpiMain = _initializeMXPI(ip, soapPort,
soapProtocol,
MxpiMain5_1SoapBindingStub,
VerifyAllHostnameVerifier)
if localMxpiMain:
simLogonToken = localMxpiMain.logon(username, password)
if simLogonToken:
return Result(True)
else:
raise Exception('Log-on failed')
else:
raise Exception('MXPI initialization failed')
finally:
## Log off if log on is successful
if localMxpiMain and simLogonToken:
localMxpiMain.logoff(simLogonToken)
def discoverPoolMembers(self, nameToPool):
queryBuilder = SnmpQueryBuilder('5.3.2.1')
queryBuilder.addQueryElement(1, 'poolName')
queryBuilder.addQueryElement(2, 'addressType')
queryBuilder.addQueryElement(3, 'address', 'hexa')
queryBuilder.addQueryElement(4, 'port')
poolMembers = self.snmpAgent.getSnmpData(queryBuilder)
for poolMember in poolMembers:
ipAddress = self.convertToIp(poolMember.address)
hostOsh = modeling.createHostOSH(ipAddress, 'host')
serviceAddressOsh = modeling.createServiceAddressOsh(hostOsh, ipAddress,
poolMember.port, modeling.SERVICEADDRESS_TYPE_TCP)
try:
#TODO: consider about avoiding try-except here
self.add(modeling.createLinkOSH('member', nameToPool[poolMember.poolName], serviceAddressOsh))
self.add(hostOsh)
self.add(serviceAddressOsh)
except:
errorMsg = 'Failed to link %s member with pool %s' % (ipAddress, poolMember.poolName)
errobj = errorobject.createError(errorcodes.FAILED_LINKING_ELEMENTS, ['%s member' % ipAddress, 'pool %s' % poolMember.poolName], errorMsg)
#TODO: Change log level to debug
logger.debugException('errorMsg')
logger.reportWarningObject(errobj)
def resolveClusterNameByShell(self, instance_name):
try:
regUtil = RegistryShellUtil(self.__client)
instName = regUtil.doQuery(self.HKLM + self.SQL_SERVER_REG_KEY +
self.SQL_SERVER_REG_INSTANCES_SUFIX)
lines = instName.strip().split('\n')
tokens = lines[0].split('REG_SZ')
instName = tokens[1].strip()
for line in lines:
tokens = line.split('REG_SZ')
if instance_name == tokens[0].strip():
instName = tokens[1].strip()
clusterVal = regUtil.doQuery(self.HKLM + self.SQL_SERVER_REG_KEY +
'\\' + instName + self.CLUSTER)
lines = clusterVal.strip().split('\n')
for line in lines:
if line.find('ClusterName') > -1:
tokens = line.split('REG_SZ')
clusterVal = tokens[1].strip()
return clusterVal
except:
logger.debugException(
'Failed getting cluster name. Assume single host installation')
def _discoverBasedOnProfilesUnsafe(sapUtils, oshPerInstance, system, systemOsh, discoverSapProfiles):
'@types: SapUtils, dict[Instance, osh], System, osh, bool -> oshv'
r = discoverTopologyBasedOnProfiles(sapUtils, system.getName(), systemOsh)
pfNameToOsh, defaultPf, otherPfs = r
pfSetByInstName = _groupPfsIniByInstanceName(otherPfs)
instOshs = oshPerInstance.itervalues()
vector = ObjectStateHolderVector()
if discoverSapProfiles:
vector.addAll(pfNameToOsh.values())
vector.addAll(_reportInstPfLinks(instOshs, pfNameToOsh, system))
defaultPfDoc = None
if defaultPf:
defaultPfDoc = IniParser.parseIniDoc(second(defaultPf))
try:
logger.info("Trying to discover ASCS")
vector.addAll(_discoverAscsInPf(defaultPfDoc, system, systemOsh, oshPerInstance))
except SapSystemInconsistentDataException, e:
logger.debugException('')
raise e
except:
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute('ip_address')
credentialsId = Framework.getDestinationAttribute('credentialsId')
hostId = Framework.getDestinationAttribute('hostId')
hostOsh = modeling.createOshByCmdbIdString('host', hostId)
PROTOCOL_NAME = 'PowerShell'
try:
client = Framework.createClient()
shell = shellutils.ShellUtils(client)
discoverer = None
try:
for discovererClass in [
msexchange_win_shell.Exchange2007Discoverer,
msexchange_win_shell.Exchange2010Discoverer
]:
try:
discoverer = discovererClass(shell)
exchangeServers = discoverer.discover()
for exchangeServer in exchangeServers:
topoBuilder = msexchange.TopologyBuilder(
exchangeServer, hostOsh, ipAddress, credentialsId)
OSHVResult.addAll(topoBuilder.build())
break
except msexchange_win_shell.AddSnapInException:
logger.warn('Failed to import Snap-In.')
discoverer = None
if not discoverer:
raise Exception(
"Failed to discover MS-Exchange. See Logs for details.")
finally:
shell.closeClient()
except JavaException, ex:
logger.debugException('')
strException = str(ex.getMessage())
errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
def _uddiRegistryConnect(credId, ip, Framework):
r'''@types: str, str, Framework -> Result
@raise java.lang.Exception on connection failure
'''
protocol = ProtocolManager.getProtocolById(credId)
url = protocol.getProtocolAttribute(UDDI_PROTOCOL_ATTRIBUTE_URL)
props = java.util.Properties()
props.setProperty(UDDI_PROTOCOL_ATTRIBUTE_URL, url)
props.setProperty("ip_domain", ip)
uddiAgent = None
for uddiVersion in (3, 2):
try:
props.setProperty('uddi_version', str(uddiVersion))
uddiAgent = Framework.getAgent(AgentConstants.UDDI_AGENT, '',
credId, props)
return Result(True)
except MissingSdkJarException, ex:
logger.debugException(ex.getMessage())
return Result(
False,
"UDDI SDK jars are missed. Refer documentation for details")
finally:
class BaseDiscoveryConnectionHandler(ConnectionHandler):
def __init__(self, framework):
ConnectionHandler.__init__(self)
self.framework = framework
self.connected = 0
self.connectionErrors = []
self.connectionWarnings = []
self.vcloudDiscoverer = None
self.vcloudReporter = None
def setDiscoverer(self, discoverer):
self.vcloudDiscoverer = discoverer
def setReporter(self, reporter):
self.vcloudReporter = reporter
def onConnection(self, context):
if self.vcloudDiscoverer is None:
raise ValueError("discoverer is not set")
if self.vcloudReporter is None: raise ValueError("reporter is not set")
self.connected = 1
try:
cloud = self.vcloudDiscoverer.discover(context)
vector = self.vcloudReporter.report(cloud)
#logger.debug(vector.toXmlString())
self.framework.sendObjects(vector)
self.framework.flushObjects()
except JException, ex:
msg = ex.getMessage()
logger.debugException("")
errormessages.resolveAndReport(msg, VcloudProtocol.DISPLAY,
self.framework)
except Exception, ex:
msg = str(ex)
logger.debugException("")
errormessages.resolveAndReport(msg, VcloudProtocol.DISPLAY,
self.framework)
def DiscoveryMain(Framework):
vector = ObjectStateHolderVector()
codePage = Framework.getCodePage()
props = Properties()
props.setProperty(BaseAgent.ENCODING, codePage)
shell = None
try:
client = Framework.createClient(props)
shell = shellutils.ShellFactory().createShell(client)
dnsResolver = dns_resolver.NsLookupDnsResolver(shell)
language = shell.osLanguage
logger.debug("Using '%s' language bundle" % language.bundlePostfix)
bundle = shellutils.getLanguageBundle('langMsCluster', language,
Framework)
clusterCmd = ms_cluster_discoverer.createClusterCmd(shell, bundle)
if clusterCmd.isUsingCmd():
bundle = clusterCmd.detectLangBandle(Framework)
clusterCmd.setBundle(bundle)
vector.addAll(_discoverTopology(clusterCmd, bundle, dnsResolver))
except NoInstanceFound:
errobj = errorobject.createError(
errorcodes.MS_CLUSTER_INSTANCES_NOT_FOUND, None,
'MS cluster instances not found in discovery')
logger.reportWarningObject(errobj)
except:
msg = str(sys.exc_info()[1])
logger.debugException(msg)
if (msg.lower().find('timeout') > -1):
errobj = errorobject.createError(
errorcodes.CONNECTION_TIMEOUT_NO_PROTOCOL, None,
'Connection timed out - reactivate with larger timeout value')
logger.reportErrorObject(errobj)
logger.debugException('Connection timed out')
else:
errobj = errormessages.resolveError(msg, 'ntcmd')
logger.reportErrorObject(errobj)
logger.errorException(msg)
try:
shell and shell.closeClient()
except:
logger.debugException()
logger.error("Unable to close shell")
return vector
def iterate_over_args(main_fn, framework, cred_args, proto_name, stop_on_first):
'''
@param cred_args: parameters you decided to iterate over
'''
vector = ObjectStateHolderVector()
framework = flow.RichFramework(framework)
creds_manager = flow.CredsManager(framework)
# as cred_args possibly generator or iterator, realize only first
first_ = first(cred_args)
if first_ is None:
logger.reportErrorObject(flow._create_missed_creds_error(proto_name))
else:
# restore cred_args
cred_args = chain((first_,), cred_args)
connection_exs = []
discovery_exs = []
java_exs = []
warnings = []
at_least_once_discovered = False
for args in cred_args:
try:
oshs, warnings_ = main_fn(framework, creds_manager, *args)
warnings.extend(warnings_ or ())
vector.addAll(oshs)
at_least_once_discovered = True
if stop_on_first:
break
except flow.ConnectionException, ce:
logger.debugException('%s' % ce)
connection_exs.append(ce)
except (flow.DiscoveryException, Exception), de:
logger.debugException('%s' % de)
discovery_exs.append(de)
except JException, je:
logger.debugException('%s' % je)
java_exs.append(je)
def discoverDiskByWmic(shell, OSHVec, hostOSH):
wmiProvider = wmiutils.getWmiProvider(shell)
queryBuilder = wmiProvider.getBuilder('Win32_LogicalDisk')
queryBuilder.usePathCommand(1)
queryBuilder.addWmiObjectProperties(
'DeviceID',
'DriveType',
'FreeSpace',
'ProviderName',
'Size',
'FileSystem',
)
queryBuilder.addWhereClause('DriveType=3')
wmicAgent = wmiProvider.getAgent()
diskItems = []
try:
diskItems = wmicAgent.getWmiData(queryBuilder)
except:
logger.debugException('Failed getting disks information via wmic')
return 0
for diskItem in diskItems:
#size in MB
diskSize = diskItem.Size and diskItem.Size.strip() or None
if diskSize:
diskSize = _bytesToMB(diskSize)
diskFreeSize = diskItem.FreeSpace and diskItem.FreeSpace.strip(
) or None
if diskFreeSize:
diskFreeSize = _bytesToMB(diskFreeSize)
diskUsedSize = None
if diskFreeSize is not None and diskFreeSize is not None:
diskUsedSize = diskSize - diskFreeSize
diskName = diskItem.DeviceID and diskItem.DeviceID.strip() or None
if diskName:
diskName = re.sub(':$', '', diskName)
# if provderName is set - this is a remote disk
diskProviderName = diskItem.ProviderName and diskItem.ProviderName.strip(
) or diskName
diskType = diskItem.DriveType and int(
diskItem.DriveType.strip()) or None
logger.debug('found disk: %s, sizeInMB=%s, freespace=%s, type=%s' %
(diskName, diskSize, diskFreeSize, diskType))
diskType = diskType and modeling.STORAGE_ID_TO_STORAGE_TYPE.get(
diskType) or modeling.OTHER_STORAGE_TYPE
diskOsh = modeling.createDiskOSH(hostOSH,
diskName,
diskType,
size=diskSize,
name=diskProviderName,
usedSize=diskUsedSize)
OSHVec.add(diskOsh)
return 1
def getPushProperties():
pushProperties = HashMap()
pushPropertiesFileStr = "%s%s%s" % (adapterConfigBaseDir, FILE_SEPARATOR,
PUSH_PROPERTIES_FILE)
properties = Properties()
debugMode = 0
sortCSVFields = ""
smartUpdateIgnoreFields = ""
testConnNameSpace = "BMC.CORE"
testConnClass = "BMC_ComputerSystem"
try:
logger.debug("Checking push properties file for debugMode [%s]" %
pushPropertiesFileStr)
fileInputStream = FileInputStream(pushPropertiesFileStr)
properties.load(fileInputStream)
# Property: debugMode
try:
debugModeStr = properties.getProperty("debugMode")
if isNoneOrEmpty(debugModeStr) or string.lower(
string.strip(debugModeStr)) == 'false':
debugMode = 0
elif string.lower(string.strip(debugModeStr)) == 'true':
debugMode = 1
except:
logger.debugException(
"Unable to read debugMode property from push.properties")
if debugMode:
logger.debug(
"Debug mode = TRUE. XML data pushed to Remedy/Atrium will be persisted in the directory: %s"
% adapterResBaseDir)
else:
logger.debug("Debug mode = FALSE")
# Property: smartUpdateIgnoreFields
try:
smartUpdateIgnoreFields = properties.getProperty(
"smartUpdateIgnoreFields")
except:
logger.debugException(
"Unable to read smartUpdateIgnoreFields property from push.properties"
)
# Property: sortCSVFields
try:
sortCSVFields = properties.getProperty("sortCSVFields")
except:
logger.debugException(
"Unable to read sortCSVFields property from push.properties")
# Property: testConnNameSpace
try:
testConnNameSpace = properties.getProperty("testConnNameSpace")
except:
logger.debugException(
"Unable to read testConnNameSpace property from push.properties"
)
# Property: testConnClass
try:
testConnClass = properties.getProperty("testConnClass")
except:
logger.debugException(
"Unable to read testConnClass property from push.properties")
fileInputStream.close()
except:
logger.debugException("Unable to process %s file." %
PUSH_PROPERTIES_FILE)
return debugMode, smartUpdateIgnoreFields, sortCSVFields, testConnNameSpace, testConnClass
listenedFull = hostDnsName + ':' + hostPrimaryIP + '@' + listenedIPs
listenerName = listenerConf.getListenerName()
listenerVersion = listenerConf.getVersion()
listenerOSH = createListenerOSH(hostOSH, listenedFull, listenerName, listenerVersion)
if listenerOSH:
OSHVResult.add(listenerOSH)
else:
Framework.reportWarning('Failed to create listener OSH. Either host name or listened ips are not defined.')
except:
logger.debugException('')
Framework.reportWarning('Failed to discover one or more listeners parameters.')
finally:
try:
shell and shell.closeClient()
except:
logger.debugException('')
logger.error('Unable to close shell')
except JException, ex:
errorMessage = ex.getMessage()
except:
errorObject = sys.exc_info()[1]
if errorObject:
errorMessage = str(errorObject)
else:
errorMessage = logger.prepareFullStackTrace('')
if errorMessage:
logger.debugException(errorMessage)
errormessages.resolveAndReport(errorMessage, protocol, Framework)
return OSHVResult
def discoverProcessesByWmic(client,
OSHVResult,
hostID,
Framework,
pid2Process=None):
''' Discover system processes, report them and save in probe DB.
Shell, oshVector, str, Framework, map[str, str] -> bool
@command: wmic process get commandLine, creationdate, executablepath, name, processId
'''
wmiProvider = wmiutils.getWmiProvider(client)
queryBuilder = wmiProvider.getBuilder('Win32_Process')
queryBuilder.usePathCommand(1)
#queryBuilder = wmiutils.WmicQueryBuilder('process')
queryBuilder.addWmiObjectProperties('name', 'processId', 'commandLine',
'executablepath', 'creationdate')
wmicAgent = wmiProvider.getAgent()
processItems = []
try:
processItems = wmicAgent.getWmiData(queryBuilder)
except:
logger.debugException('Failed getting processes information via wmic')
return 0
pdu = None
try:
pdu = processdbutils.ProcessDbUtils(Framework)
processList = []
hostOSH = None
count = 0
for processItem in processItems:
if not processItem.name:
continue
processName = processItem.name
processNameLower = processName.lower()
processPid = processItem.processId
if processPid == '-1' or not processPid.isnumeric():
logger.debug(
"Process '%s' is system process or has non numeric pid" %
processName)
continue
processExecutablePath = processItem.executablepath
processCommandLine = processItem.commandLine
processStartupTimeString = processItem.creationdate
processStartupTime = None
if processStartupTimeString:
try:
startupDate = modeling.getDateFromUtcString(
processStartupTimeString)
processStartupTime = startupDate.getTime()
except:
errobj = errorobject.createError(
errorcodes.PROCESS_STARTUP_TIME_ATTR_NOT_SET,
['NTCMD', processStartupTimeString],
"%s: Process startup time attribute is not set due to error while parsing date string '%s'"
% ('NTCMD', processStartupTimeString))
logger.reportWarningObject(errobj)
# check whether process name is included in command line
# Obtain first token containing process from the CMD line
matchObj = re.match('(:?["\'](.*?)["\']|(.*?)\s)',
processCommandLine)
if matchObj and matchObj.groups():
firstCmdToken = matchObj.group(1).strip()
else:
firstCmdToken = processCommandLine.strip()
#remove quotes
firstCmdToken = re.sub('[\'"]', '', firstCmdToken).lower()
#token has to end with process name
if not firstCmdToken.endswith(processNameLower):
extStartPos = processNameLower.rfind('.')
if extStartPos != -1:
pnameNoExt = processNameLower[0:extStartPos]
if not firstCmdToken.endswith(pnameNoExt):
processCommandLine = '%s %s' % (processName,
processCommandLine)
processArgs = None
argsMatch = re.match('("[^"]+"|[^"]\S+)\s+(.+)$',
processCommandLine)
if argsMatch:
processArgs = argsMatch.group(2)
pdu.addProcess(hostID, processName, processPid, processCommandLine,
processExecutablePath, processArgs, None,
processStartupTime)
if processPid in processList:
logger.debug("Process: '%s' already reported" % processName)
continue
count += 1
processList.append(processPid)
if OSHVResult is not None:
if hostOSH == None:
hostOSH = modeling.createOshByCmdbIdString('host', hostID)
processOsh = modeling.createProcessOSH(
processName, hostOSH, processCommandLine, processPid,
processExecutablePath, None, None, processStartupTime)
OSHVResult.add(processOsh)
pdu.flushHostProcesses(hostID)
if pid2Process is not None:
pid2Process.putAll(pdu.getProcessCmdMap())
finally:
if pdu != None:
pdu.close()
return 1
def _parseCdpLayer2Output(self, output):
results = {}
if output:
blocks = re.split('----------------------------------------',
output)
for block in blocks:
if not re.search('Device ID', block):
continue
m = re.search('System Name:\s+([\w\-\.\/]+)', block)
system_name = m and m.group(1)
if not system_name:
continue
m = re.search('Interface:\s+([\w\-\.\/]+),', block)
local_interface_name = m and m.group(1)
if not local_interface_name:
continue
remote_ips = []
elems = re.findall('IPv[46] Address:(.+)\r?\n?Platform', block,
re.DOTALL)
if m:
for elem in elems:
remote_ips = [
ip_addr.IPAddress(raw_ip.strip())
for raw_ip in elem.split(',')
if ip_addr.isValidIpAddress(raw_ip.strip())
]
m = re.search('Platform:\s+([\w\-\.]+),', block)
platform = m and m.group(1)
# '''
# Capability Codes: R - Router, T - Trans-Bridge, B - Source-Route-Bridge
# S - Switch, H - Host, I - IGMP, r - Repeater,
# V - VoIP-Phone, D - Remotely-Managed-Device,
# s - Supports-STP-Dispute
# '''
m = re.search('Capabilities:\s+([\w\-\.]+)', block)
type = m and m.group(1)
mac = None
iface_name = None
m = re.search(
'Port\s+ID\s+\(outgoing\s+port\):\s+([\w\-\.\:\/]+)',
block) #can be interface name, interface mac.
if not m:
continue
if netutils.isValidMac(m.group(1)):
mac = netutils.parseMac(m.group(1))
else:
iface_name = m.group(1)
m = re.search('Version:(.+)Advertisement', block, re.DOTALL)
description = m and m.group(1).strip()
try:
remote_list = results.get(local_interface_name, [])
remote_list.append(
layer2.RemotePeer(system_name, iface_name, mac,
remote_ips, platform, type,
description))
results[local_interface_name] = remote_list
except:
logger.debugException('')
return results
def DiscoveryMain(Framework):
ipAddress = Framework.getDestinationAttribute('ip_address')
discoveredPorts = Framework.getParameter('ports') or None
useNMap = Framework.getParameter('useNMap') == 'true'
nmapPath = Framework.getParameter('nmapPath') or None
scanUDP = Framework.getParameter('scanUDP') == 'true'
UDPports = Framework.getParameter('UDPports') or None
UDPports = UDPports and UDPports.strip()
connectTimeOut = int(Framework.getParameter('connectTimeOut'))
#if we need to check host's reachability:
if Framework.getParameter('checkIfIpIsReachable').lower() == 'true':
if not netutils.pingIp(Framework, ipAddress,
Framework.getParameter('pingTimeOut')):
logger.debug('Could not connect to ', ipAddress, ' by ping')
msg = 'Target host is not reachable'
warningObject = errorobject.createError(
errorcodes.CONNECTION_FAILED_NO_PROTOCOL_WITH_DETAILS,
['', msg], msg)
logger.reportWarningObject(warningObject)
return
OSHVResult = ObjectStateHolderVector()
hostOsh = modeling.createHostOSH(ipAddress)
OSHVResult.add(hostOsh)
cfgFile = Framework.getConfigFile(
CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME)
onlyKnownPorts = Framework.getParameter('checkOnlyKnownPorts')
onlyKnownPorts = (onlyKnownPorts and onlyKnownPorts.lower() == 'true')
portsList = getPorts(discoveredPorts and discoveredPorts.strip(),
PortType.TCP, cfgFile, onlyKnownPorts)
if scanUDP:
if onlyKnownPorts and not UDPports:
UDPports = '*'
portsList.extend(
getPorts(UDPports, PortType.UDP, cfgFile, onlyKnownPorts))
portsToDiscover = filter(lambda port: port.isDiscover, portsList)
isConnectedPortFound = False
useFallback = False
if useNMap:
# Nmap flow supports udp and tcp ports
client = Framework.createClient(
ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME)
try:
shell = shellutils.ShellFactory().createShell(client)
fs = file_system.createFileSystem(shell)
try:
if nmapPath and fs.isDirectory(nmapPath):
path_tool = NtPath()
nmapPath = path_tool.join(nmapPath,
nmap.NMAP_EXECUTABLES[1])
except PathNotFoundException:
logger.warn("Specified directory \"%s\" is not exists." %
nmapPath)
if nmapPath and not nmap.NmapPathValidator.get(fs).validate(
nmapPath):
logger.warn(
"Specified Nmap path \"%s\" is not exists. Trying the system path..."
% nmapPath)
nmapPath = None
nmapDiscover = nmap.getByShell(shell, nmapPath)
nmapVersion = nmapDiscover.getVersion()
if not nmapVersion:
raise Exception('Cannot get nmap version')
logger.debug("Found nmap %s" % nmapVersion)
nmapVersion = float(nmapVersion)
if nmapVersion < 5.21:
raise Exception("Not supported version of nmap found.")
tcpPorts = [
port.getPortNumber() for port in portsToDiscover
if port and port.getProtocolName() == 'tcp'
and port.isIpInRange(ipAddress)
]
udpPorts = [
port.getPortNumber() for port in portsToDiscover
if port and port.getProtocolName() == 'udp'
and port.isIpInRange(ipAddress)
]
discoveredPorts = nmapDiscover.doPortScan(ipAddress, tcpPorts,
udpPorts)
portsNameByPortInfo = {}
for port in portsToDiscover:
port_names = portsNameByPortInfo.setdefault(
(port.getProtocol(), port.getPortNumber()), [])
port_names.append(port.portName)
if discoveredPorts:
isConnectedPortFound = True
for port_info in discoveredPorts:
port_names = portsNameByPortInfo.get(port_info, [])
OSHVResult.addAll(
reportPort(hostOsh, ipAddress, port_names, *port_info))
except:
logger.debugException(
"Nmap executing failed. Try to use default behavior...")
logger.reportWarning("Nmap executing failed")
useFallback = True
if useFallback or not useNMap:
# Old flow supports only TCP ports
for port in portsToDiscover:
if port.isIpInRange(ipAddress):
if port.getProtocol() == PortType.UDP.getProtocol():
logger.warn(
"UDP port scan is not supporting by default behavior. Skipping..."
)
elif port.getProtocol() == PortType.TCP.getProtocol() and (
netutils.checkTcpConnectivity(
ipAddress, port.getPortNumber(), connectTimeOut)):
OSHVResult.addAll(
reportPort(hostOsh, ipAddress, [port.portName],
port.getProtocol(), port.getPortNumber()))
#we found one connected port -> we need to add hostOsh to OSHVResult
isConnectedPortFound = True
#in case we didn't find any port, return nothing
if not isConnectedPortFound:
OSHVResult.clear()
msg = 'None of specified ports were discovered on destination host'
warningObject = errorobject.createError(
errorcodes.CONNECTION_FAILED_NO_PROTOCOL_WITH_DETAILS, ['', msg],
msg)
logger.reportWarningObject(warningObject)
return OSHVResult
daoService = None
try:
try:
client = Framework.createClient(credentialsId, envBuilder.build())
logger.debug("Connected to AD")
configurationNamingContext = getConfigurationNamingContext(client)
domainSuffix = getDomainSuffix(configurationNamingContext)
if not configurationNamingContext:
raise ValueError, "Failed fetching configuration naming context from Active Directory"
msmqDiscoverer = MsMqDiscoverer(client, Framework, ipAddress, domainSuffix)
msmqDiscoverer.discover()
msmqDiscoverer.addResultsToVector(OSHVResult)
finally:
if client is not None:
try:
client.close()
except:
logger.warn("Failed to close client")
if OSHVResult.size() == 0:
raise Exception, "Failed getting information about Microsoft Message Queue"
except JException, ex:
msg = ex.getMessage()
logger.debugException('Unexpected LDAP Exception: ')
errormessages.resolveAndReport(msg, LDAP_PROTOCOL_NAME, Framework)
except:
msg = str(sys.exc_info()[1]).strip()
logger.debugException('Unexpected LDAP Exception: ')
errormessages.resolveAndReport(msg, LDAP_PROTOCOL_NAME, Framework)
return OSHVResult
def __parseVersionByConfigFiles(self, tomcatHomeDir):
if not tomcatHomeDir:
return None
try:
if self.separator == '\\':
cmd = 'type "' + tomcatHomeDir + 'webapps' + self.separator + 'ROOT' + self.separator + 'RELEASE-NOTES.txt"'
else:
cmd = 'cat ' + tomcatHomeDir + 'webapps' + self.separator + 'ROOT' + self.separator + 'RELEASE-NOTES.txt'
buff = self.__client.execCmd(cmd)
if buff is not None:
match = re.search('Apache Tomcat Version ([\.\d]+)', buff)
if match is not None:
return str(match.group(1)).strip()
except:
logger.debugException(
'Failed to resolve version from RELEASE-NOTES.txt')
try:
if self.separator == '\\':
cmd = 'type "' + tomcatHomeDir + 'RELEASE-NOTES"'
else:
cmd = 'cat ' + tomcatHomeDir + 'RELEASE-NOTES'
buff = self.__client.execCmd(cmd)
if buff is not None:
match = re.search(
'Apache Tomcat Version ([\.\d]+)', buff) or re.search(
'\* Tomcat ([\.\d]+)', buff)
if match is not None:
return str(match.group(1)).strip()
except:
logger.debugException(
'Failed to resolve version from RELEASE-NOTES')
try:
if self.separator == '\\':
cmd = 'type "' + tomcatHomeDir + 'RUNNING.txt"'
else:
cmd = 'cat ' + tomcatHomeDir + 'RUNNING.txt'
buff = self.__client.execCmd(cmd)
if buff is not None:
match = re.search('Running The Tomcat ([\.\d]+)', buff)
if match is not None:
return str(match.group(1)).strip()
except:
logger.debugException('Failed to resolve version from RUNNING.txt')
try:
if self.separator == '\\':
cmd = '"' + tomcatHomeDir + 'bin\\version.bat"'
else:
cmd = tomcatHomeDir + 'bin/version.sh'
buff = self.__client.execCmd(cmd)
if buff is not None:
match = re.search('Server version: Apache Tomcat/([\.\d]+)',
buff)
if match is not None:
return str(match.group(1)).strip()
except:
logger.debugException('Failed to resolve version from ')
return None
def parseOpmnXml(opmnXML, HOST_IP, ORACLE_HOME, MANAGER_PORT, shellUtils, OSHVResult, Framework):
builder = SAXBuilder(0)
doc = builder.build(StringReader(opmnXML))
root = doc.getRootElement()
ucmdbVersion = modeling.CmdbClassModel().version()
processManager = root.getChildren()
processManagerIterator = processManager.iterator()
while processManagerIterator.hasNext():
currProcessManager = processManagerIterator.next()
currElementName = currProcessManager.getName()
if currElementName == 'process-manager':
iasInstance = currProcessManager.getChildren()
iasInstanceIterator = iasInstance.iterator()
while iasInstanceIterator.hasNext():
currIasInstance = iasInstanceIterator.next()
if currIasInstance.getName() == 'ias-instance':
OracleApplicationServerName = currIasInstance.getAttributeValue('name') or currIasInstance.getAttributeValue('id') or 'Default Server'
discoveredHost = modeling.createHostOSH(HOST_IP)
# Create Oracle IAS
oracleIASOSH = modeling.createJ2EEServer('oracleias', HOST_IP, int(MANAGER_PORT), discoveredHost, OracleApplicationServerName)
OSHVResult.add(oracleIASOSH)
iasComponent = currIasInstance.getChildren()
iasComponentIterator = iasComponent.iterator()
while iasComponentIterator.hasNext():
currIasComponent = iasComponentIterator.next()
if 'ias-component' == currIasComponent.getName():
groupName = currIasComponent.getAttributeValue('id')
# Create OC4J Group
oc4jGroupOSH = ObjectStateHolder('oc4jgroup')
oc4jGroupOSH.setContainer(oracleIASOSH)
oc4jGroupOSH.setAttribute('data_name', groupName)
OSHVResult.add(oc4jGroupOSH)
#'process-type'
processType = currIasComponent.getChildren()
processTypeIterator = processType.iterator()
while processTypeIterator.hasNext():
currProcessType = processTypeIterator.next()
oc4jName = currProcessType.getAttributeValue('id')
moduleId = currProcessType.getAttributeValue('module-id')
if 'OC4J' == moduleId:
oc4jOSH = ObjectStateHolder('oc4j')
oc4jOSH.setContainer(oc4jGroupOSH)
oc4jOSH.setAttribute('data_name', oc4jName)
OSHVResult.add(oc4jOSH)
try:
serverXML = shellUtils.safecat('%s/j2ee/%s/config/server.xml' % (ORACLE_HOME, oc4jName))
tg = '<application name="(\w+)"'
compiled = re.compile(tg,re.S)
matches = compiled.findall(serverXML)
appList = {}
for match in matches:
if ucmdbVersion < 9:
applicationOSH = modeling.createApplicationOSH('application', match, oc4jOSH)
else:
applicationOSH = ObjectStateHolder('oc4j_app')
applicationOSH.setAttribute('data_name',match)
applicationOSH.setContainer(oc4jOSH)
#
OSHVResult.add(applicationOSH)
appList[match] = applicationOSH
except:
logger.debugException()
logger.warn('Failed to get server.xml')
# Check if it holds web service
wsdlDir = shellUtils.rebuildPath('%s/j2ee/%s/application-deployments/' % (ORACLE_HOME, OracleApplicationServerName))
fileMon = file_mon_utils.FileMonitor(Framework, shellUtils, OSHVResult, None, None)
files = fileMon.getFilesInPath(wsdlDir, '*.wsdl')
if (files == []):
wsdlDir = shellUtils.rebuildPath('%s/j2ee/%s/application-deployments/' % (ORACLE_HOME, oc4jName))
logger.info('Pi Debug - parseOpmnXml() - trying with wsdlDir = %s' % wsdlDir)
files = fileMon.getFilesInPath(wsdlDir, '*.wsdl')
wsdlDirRes = '\n'.join(files)
if wsdlDirRes.find('File Not Found') != -1:
# NO WSDL
continue
else:
# WSDL
handleWSDL(HOST_IP, MANAGER_PORT, wsdlDirRes, wsdlDir, appList, shellUtils, OSHVResult)
OSHVResult = ObjectStateHolderVector()
#ipAddress = Framework.getDestinationAttribute('ip_address')
#credentialsId = Framework.getDestinationAttribute('credentialsId')
hostId = Framework.getDestinationAttribute('hostId')
language = getLanguage(Framework)
bundle = hyperv.getBundleByLanguage(language, Framework)
try:
namespace = hyperv.WmiNamespaceLookUp(Framework).lookUp()
factory = hyperv.WmiClientFactory(Framework, namespace)
client = factory.createClient()
wmiProvider = hyperv.WmiHypervAgentProvider(client, bundle)
try:
hyperv.discoverHypervHost(wmiProvider, hostId, Framework, OSHVResult, namespace)
finally:
client.close()
except JException, ex:
exInfo = ex.getMessage()
errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework)
except Exception, ex:
logger.debugException('')
exInfo = str(ex)
errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework)
return OSHVResult
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)
except JException, ex:
msg = ex.getMessage() or ''
logger.debugException(msg)
match = re.match('.*\(404\)\/NmsSdkService/(.*)', msg, re.I)
if match:
logger.debug("Service %s is not accessible" % match.group(1))
else:
logger.error(msg)
errormessages.resolveAndReport(msg, nnmi.NNM_PROTOCOL_NAME, Framework)
except:
logger.errorException("")
msg = logger.prepareFullStackTrace("")
errormessages.resolveAndReport(msg, nnmi.NNM_PROTOCOL_NAME, Framework)
return resultVector
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 get_fc_hbas(self, shell):
result = defaultdict(list)
executor = command.cmdlet.executeCommand(shell)
esxcli = find_esxcli_impl(executor)()
esxcli = esxcli.formatter('csv')
esxcli_exec = command.get_exec_fn(esxcli, executor)
storage = EsxcliStorageNamespace(esxcli)
software = EsxcliSoftwareNamespace(esxcli)
scsi_path_by_adapter_identifier = fptools.groupby(methodcaller('get', 'AdapterIdentifier'), esxcli_exec(storage.core.path.list()))
adapters = esxcli_exec(storage.core.adapter.list())
grouped_adapters = dict((adapter.get('HBAName'), adapter)
for adapter in adapters)
grouped = defaultdict(list)
for descriptor in esxcli_exec(storage.san.fc.list()):
grouped[(descriptor.get('Adapter'),
descriptor.get('NodeName'))].append(descriptor)
get_vendor = Sfn(self.get_vendor)
get_fchba_descriptor = Sfn(self._get_fchba_descriptor)
for key, descriptors in grouped.iteritems():
try:
vmhba, nodewwn = key
nodewwn = wwn.parse_from_str(nodewwn)
name = vmhba
id_ = vmhba
adapter_descriptor = grouped_adapters.get(vmhba)
driverversion = None
vendor = get_vendor(vmhba, executor)
model = None
fwversion = None
serialnum = None
if adapter_descriptor:
id_ = adapter_descriptor.get('UID')
driver = adapter_descriptor.get('Driver')
vib_descriptor = esxcli_exec(software.vib.get(vibname=driver))
driverversion = vib_descriptor.get('Version')
fchabdescriptor = get_fchba_descriptor(driver, vmhba, executor)
if fchabdescriptor:
model = fchabdescriptor.model
fwversion = fchabdescriptor.firmwareversion
serialnum = fchabdescriptor.serialnumber
driverversion = fchabdescriptor.driverversion
fchba = fc_hba_model.FcHba(id_, name,
wwn=nodewwn,
vendor=vendor, model=model,
serial_number=serialnum,
driver_version=driverversion,
firmware_version=fwversion)
ports = []
for fcdescriptor in descriptors:
try:
portwwn = fcdescriptor.get('PortName')
porttype = fcdescriptor.get('PortType')
portwwn = wwn.parse_from_str(portwwn)
portid = fcdescriptor.get('PortID')
port_speed = _parse_port_speed(fcdescriptor.get('Speed'))
portid = Sfn(int)(portid, 16)
adapter_identifier = self._compose_adapter_identifier(nodewwn, portwwn)
scsi_paths = scsi_path_by_adapter_identifier.get(adapter_identifier)
target_fcdescriptors = self._create_target_fchba_details(scsi_paths)
ports.append((fc_hba_model.FcPort(portid, portwwn,
porttype, None, port_speed),
target_fcdescriptors))
except (command.ExecuteException, TypeError, ValueError), ex:
logger.debugException('Failed to create fcport data object')
result[fchba].extend(ports)
except (command.ExecuteException, TypeError, ValueError), ex:
logger.debugException('Failed to create fchba data object')
while resultSet.next():
componentType = resultSet.getString("COMP_TYPE")
try:
release = resultSet.getString("RELEASE")
components.append(
sap.SoftwareComponent(
resultSet.getString("COMPONENT"),
componentType,
versionInfo=(release and sap.VersionInfo(
release,
patchLevel=resultSet.getString("EXTRELEASE"))
or None)))
except sap.SoftwareComponent.TypeIsNotRecognized, ex:
logger.warn("%s: %s" % (str(ex), componentType))
except:
logger.debugException("Failed to process component")
return components
@staticmethod
def isEnglishCmpDescription(d):
return sap.isSetToEnglishLanguage(d.language)
def discoverComponents(self):
r''' Collect all data from different queries about available software
components
@types: -> list[sap.SoftwareComponent]'''
componentDescriptions = self.getComponentLocalizedDescriptions()
# may exist several localized descriptions per component
descrsByName = fptools.groupby(
self.ComponentLocalizedDescription.getName, componentDescriptions)
components = []
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)
except:
exInfo = str(sys.exc_info()[1]).strip()
logger.debugException(message)
errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework)
return OSHVResult
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
except JException, ex:
msg = ex.getMessage()
logger.debugException("Failed reading url: '%s', reason: '%s'\n" %
(wsdl_url, msg))
msg = removeIp(msg, ' to ')
errormessages.resolveAndReport(msg, ClientsConsts.HTTP_PROTOCOL_NAME,
Framework)
return OSHVResult
except Exception, ex:
msg = logger.prepareJythonStackTrace('')
logger.debugException("Failed reading url: '%s'\n" % wsdl_url)
errormessages.resolveAndReport(msg, ClientsConsts.HTTP_PROTOCOL_NAME,
Framework)
return OSHVResult
if importWsdlDocuments == 1:
getAllImportWsdlsNames(defintion, importWsdldNames)
for importWsdldName in importWsdldNames:
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
SYSNAME = Framework.getDestinationAttribute('system_name')
GET_TX_ACTIVE = Framework.getParameter('getActiveTransactions') == 'true'
GET_TX_CHANGE = Framework.getParameter('getTransChanges') == 'true'
GET_TX_ALL = Framework.getParameter('getAllTransactions') == 'true'
report_app_components = Framework.getParameter(
'getAppComponents') == 'true'
properties = Properties()
instance_number = Framework.getDestinationAttribute('instance_nr')
ip_address = Framework.getDestinationAttribute('ip_address')
connection_client = Framework.getDestinationAttribute('connection_client')
logger.debug('Connecting to a SAP system number:', str(instance_number))
properties.setProperty(Protocol.SAP_PROTOCOL_ATTRIBUTE_SYSNUMBER,
instance_number)
if (connection_client is not None) and (connection_client != 'NA'):
logger.debug('Connecting to a SAP system with client:',
str(connection_client))
properties.setProperty(Protocol.SAP_PROTOCOL_ATTRIBUTE_CLIENT,
connection_client)
if GET_TX_CHANGE:
# get transaction change only parameters
FROM_DATE = Framework.getParameter('transChangesFromDate')
FROM_TIME = Framework.getParameter('transChangesFromTime')
TO_DATE = Framework.getParameter('transChangesToDate')
TO_TIME = Framework.getParameter('transChangesToTime')
INTERVAL = Framework.getParameter('transChangesDaysInterval')
if logger.isDebugEnabled():
logger.debug('FROM_DATE = ', FROM_DATE)
logger.debug('FROM_TIME = ', FROM_TIME)
logger.debug('TO_DATE = ', TO_DATE)
logger.debug('TO_TIME = ', TO_TIME)
properties.setProperty(SAPQueryClient.PARAM_FROM_DATE, FROM_DATE)
properties.setProperty(SAPQueryClient.PARAM_FROM_TIME, FROM_TIME)
properties.setProperty(SAPQueryClient.PARAM_TO_DATE, TO_DATE)
properties.setProperty(SAPQueryClient.PARAM_TO_TIME, TO_TIME)
if ((INTERVAL != None) and (INTERVAL != '0') and (INTERVAL != '')):
properties.setProperty(SAPQueryClient.PARAM_INTERVAL, INTERVAL)
loadOnInit = 0
if GET_TX_ACTIVE:
properties.setProperty(SAPQueryClient.PARAM_FLAG_GET_USERS, 'false')
loadOnInit = 1
errormsg = ''
client = None
try:
try:
# create SAP client
client = Framework.createClient(properties)
sapUtils = sapappsutils.SapAppsUtils(client, loadOnInit,
saputils.SapUtils.NO_LOAD)
except (NoClassDefFoundError, MissingJarsException,
ExceptionInInitializerError):
errormsg = 'SAP drivers are missing'
logger.debugException(errormsg)
except:
errormsg = 'Connection failed'
logger.debugException(errormsg)
else:
systemOsh, oshs = sap_abap.report_system(SYSNAME, instance_number,
ip_address)
OSHVResult.addAll(oshs)
# Check if we need to collect all the application component.
# (we can discover up to 60000 CIs per System - don't discover if it is not needed)
if not report_app_components:
logger.debug('Not sending application components to server')
# build the application hierarchy even if not all of it is sent to the server
mapDevcToOSH = None
if GET_TX_CHANGE or GET_TX_ALL or GET_TX_ACTIVE or report_app_components:
mapDevcToOSH, oshs = buildAppHierarchy(sapUtils, systemOsh,
report_app_components)
OSHVResult.addAll(oshs)
# Check if we need to collect the changed transactions
if GET_TX_CHANGE:
try:
logger.debug('Getting transaction change...')
transactionChange(sapUtils, mapDevcToOSH, systemOsh,
SYSNAME, OSHVResult)
except NoSuchChangeException:
Framework.reportWarning(
'No changes found in the given time range')
except:
logger.errorException(
'Failed retrieving transactions change')
Framework.reportError(
'Failed retrieving transactions change')
# Check if we need to collect all the transactions
if GET_TX_ALL:
try:
logger.debug('Getting all transactions...')
transactions(sapUtils, mapDevcToOSH, systemOsh, SYSNAME,
OSHVResult)
except:
logger.errorException('Failed to get transactions')
Framework.reportWarning('Failed to get transactions')
# Check if we need to collect the active transactions
if GET_TX_ACTIVE:
try:
logger.debug('Getting active transactions...')
activeTransactions(sapUtils, mapDevcToOSH, systemOsh,
SYSNAME, OSHVResult)
except:
logger.errorException(
'Failed retrieving active transactions')
Framework.reportError(
'Failed retrieving active transactions')
finally:
if client is not None:
client.close()
if errormsg:
Framework.reportError(errormsg)
return OSHVResult
def discoverEsxLicensing(topology, module, client, framework):
try:
licensingDiscoverer = module.getLicensingDiscoverer(client, framework)
if licensingDiscoverer:
licensingDiscoverer.discoverEsx(topology)
except NotSupportedException:
msg = "Licensing information discovery is not supported by server with current protocol"
framework.reportWarning(msg)
except NoPermissionException, ex:
priviledgeId = ex.getMessage()
msg = "User does not have required '%s' permission, licensing information won't be reported" % priviledgeId
framework.reportWarning(msg)
except:
framework.reportWarning("Failed to discover licensing information")
logger.debugException()
def discoverVirtualCenterLicensing(topology, module, client, framework):
try:
licensingDiscoverer = module.getLicensingDiscoverer(client, framework)
if licensingDiscoverer:
licensingDiscoverer.discoverVirtualCenter(topology)
except NotSupportedException:
msg = "Licensing information discovery is not supported by server with current protocol"
framework.reportWarning(msg)
except NoPermissionException, ex:
priviledgeId = ex.getMessage()
msg = "User does not have required '%s' permission, licensing information won't be reported" % priviledgeId
framework.reportWarning(msg)
except:
framework.reportWarning("Failed to discover licensing information")
str(e))
else:
warning = errorobject.createError(errorcodes.CONNECTION_FAILED,
[protocolName], msg)
discoveryWarnings.append(warning)
else:
try:
# Build and report discovered account for further usage
discoverer = IamDiscoverer(aimService)
account = aws.Account(discoverer.getAccountId(aimService))
accountOsh = aws.Reporter(aws.Builder()).reportAccount(account)
framework.sendObject(accountOsh)
except Exception:
# As account is a application system failed discovery of such
# cannot be continued we try other credentials
logger.debugException("Failed to create account")
warning = errorobject.createError(
errorcodes.FAILED_GETTING_INFORMATION, [protocolName],
'Failed to get information about Amazon account')
discoveryWarnings.append(warning)
# Every fail has to be remembered for reporting to the UI
else:
# Now we have account time to use it in discovery
for connection in CONNECTIONS:
# Apply filtering mechanism to find out what discoveries
# are enabled
discoveries = filter(isEnabledDiscovery,
connection.discoveries)
# Possible none of them are enabled so we have to check this
# case too
if discoveries:
def doHPCmd(client,
ntcmd_obj,
ip_address,
langBund,
Framework,
host_cmdbid=None,
host_key=None,
host_macs=None,
uduid=None,
nat_ip=None):
'Shell, osh, str, Properties, Framework, .. -> oshVector'
resultVector = ObjectStateHolderVector()
ipAddress = ip_addr.IPAddress(ip_address)
wmiProvider = wmiutils.WmicProvider(client)
hostDiscoverer = WmiHostDiscoverer(wmiProvider)
hostDo = hostDiscoverer.discover()
hostDiscoverer = HostDiscovererByShell(client, langBund, Framework, hostDo)
hostDiscoverer.discover()
hostDo = hostDiscoverer.getResults()
wmiDnsServersDiscoverer = WmiDnsServersDiscoverer(wmiProvider, ipAddress)
wmiDnsServersDiscoverer.discover()
dnsServersIpList = wmiDnsServersDiscoverer.getResults()
if not dnsServersIpList:
dnsServersDiscoverer = DnsServersDiscoverer(client, ipAddress,
langBund, Framework)
dnsServersDiscoverer.discover()
dnsServersIpList = dnsServersDiscoverer.getResults()
winsWmiServersDiscoverer = WmiWinsServersDiscoverer(wmiProvider, ipAddress)
winsWmiServersDiscoverer.discover()
winsServersIpList = winsWmiServersDiscoverer.getResults()
if not winsServersIpList:
winsServerDiscoverer = WinsServerDicoverer(client, ipAddress, langBund,
Framework)
winsServerDiscoverer.discover()
winsServersIpList = winsServerDiscoverer.getResults()
dhcpWmiServersDiscoverer = WmiDhcpServersDiscoverer(wmiProvider, ipAddress)
dhcpWmiServersDiscoverer.discover()
dhcpServersIpList = dhcpWmiServersDiscoverer.getResults()
if not dhcpServersIpList:
dhcpServerDiscoverer = DhcpServerDiscoverer(client, ipAddress,
langBund, Framework)
dhcpServerDiscoverer.discover()
dhcpServersIpList = dhcpServerDiscoverer.getResults()
interfaceDiscoverer = WmiInterfaceDiscoverer(wmiProvider, ipAddress)
try:
interfaceDiscoverer.discover()
logger.debug('Interfaces successfully discovered via wmic.')
try:
shellIfaceDiscoverer = IpConfigInterfaceDiscoverer(
client, ipAddress, Framework, langBund)
shellIfaceDiscoverer.discover()
ifaces = shellIfaceDiscoverer.getResults()
interfaceDiscoverer.interfacesList.extend(ifaces)
except:
logger.debugException('')
except:
msg = logger.prepareFullStackTrace('')
logger.debugException(msg)
logger.warn(
'Failed getting interfaces information via wmic. Falling back to ipconfig.'
)
interfaceDiscoverer = IpConfigInterfaceDiscoverer(
client, ipAddress, Framework, langBund)
interfaceDiscoverer.discover()
hostDo.ipIsVirtual = interfaceDiscoverer.isIpVirtual()
hostDo.ipIsNATed = interfaceDiscoverer.isIpNATed(nat_ip)
interfacesList = interfaceDiscoverer.getResults()
ucmdbversion = modeling.CmdbClassModel().version()
topoBuilder = TopologyBuilder(interfacesList, hostDo, ipAddress, ntcmd_obj,
dnsServersIpList, dhcpServersIpList,
winsServersIpList, host_cmdbid, host_key,
host_macs, ucmdbversion)
topoBuilder.build()
# access built host OSH to update UD UID attribute
if topoBuilder.hostOsh and uduid:
_updateHostUniversalDiscoveryUid(topoBuilder.hostOsh, uduid)
topoBuilder.addResultsToVector(resultVector)
return resultVector
