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 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 DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip = Framework.getDestinationAttribute('ip_address')
domain = Framework.getDestinationAttribute('ip_domain')
host_id = Framework.getDestinationAttribute('hostId')
errorsList = []
protocol = "ldap"
credential_ids = Framework.getAvailableProtocols(ip, protocol)
lastConnectedCredential = Framework.loadState()
lastConnectedCredential and credential_ids.append(lastConnectedCredential)
if not credential_ids:
msg = errormessages.makeErrorMessage('webseal', pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, ['webseal'], msg)
errorsList.append(errobj)
client = Framework.createClient()
credential_id = find_valid_credential(credential_ids, client, Framework)
if credential_id:
Framework.saveState(credential_id)
OSHVResult.addAll(reportWebSeal(host_id, credential_id))
else:
Framework.clearState()
msg = errormessages.makeErrorMessage('Shell', pattern=errormessages.ERROR_FAILED_TO_CONNECT_TO_SERVER)
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, ['webseal'], msg)
errorsList.append(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
return OSHVResult
def iterate_over_creds(main_fn, proto_name, stop_on_first=True,
is_cred_ok_fn=identity):
'''
Decorator for the DiscoveryMain function in case when connection attempts
performed over available protocols
@param main_fn: DiscoveryMain function reference
@param proto_name: protocol to connect with
@param stop_on_first: Stop on first successful discovery
@param is_cred_ok_fn: predicate to check whether credentials are suitable
Signature is (Framework, CredsManager, str -> bool)
Usage:
from fptools import paritallyApply as Fn, _ as __
@Fn(iterate_over_creds, __, ClientsConsts.SSH_PROTOCOL_NAME)
def DiscoveryMain(rich_framework, creds_manager, cred_id):
'@types: Framework, CredsManager, str -> list[osh], list[str]'
...
return oshs, warnings
'''
@wraps(main_fn)
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)
if at_least_once_discovered:
if warnings:
each(logger.reportWarning, warnings)
else:
for ex in connection_exs:
obj = _create_connection_errorobj(proto_name, ex.message)
logger.reportWarningObject(obj)
for ex in discovery_exs:
obj = _create_discovery_errorobj(proto_name, ex.message)
logger.reportErrorObject(obj)
def decorator_fn(original_fn):
@wraps(original_fn)
def wrapper(framework):
client_factories_provider = kwargs.get('client_factories_provider')
if not client_factories_provider:
client_factories_provider = default_client_factories_provider
proto_name = kwargs.get('protocol_name')
stop_on_first = kwargs.get('stop_on_first')
vector = ObjectStateHolderVector()
framework = RichFramework(framework)
if not proto_name:
proto_name = framework.get_dest_attribute('Protocol')
creds_manager = CredsManager(framework)
client_factories = client_factories_provider(framework,
creds_manager)
first_factory = take(0, 1, client_factories)
if not first_factory:
logger.reportErrorObject(_create_missed_creds_error(proto_name))
else:
connection_exs = []
discovery_exs = []
warnings = []
at_least_once_discovered = False
oshs = []
client_factories = list(itertools.chain(first_factory, client_factories))
main_fn = original_fn
for index, client_factory in enumerate(client_factories):
try:
with client_factory() as client:
args_ = (framework, client, index)
kwargs_ = {}
oshs_, warnings_ = main_fn(*args_, **kwargs_)
oshs.extend(oshs_)
warnings.extend(warnings_)
at_least_once_discovered = True
if stop_on_first:
break
except ConnectionException, ce:
logger.debugException(str(ce))
connection_exs.append(ce)
except (DiscoveryException, Exception), de:
logger.debugException(str(de))
discovery_exs.append(de)
if at_least_once_discovered:
each(logger.reportWarningObject, warnings)
else:
for ex in connection_exs:
obj = _create_connection_errorobj(proto_name, ex.message)
logger.reportWarningObject(obj)
for ex in discovery_exs:
obj = _create_discovery_errorobj(proto_name, ex.message)
logger.reportErrorObject(obj)
vector.addAll(oshs)
def decorator_fn(original_fn):
@wraps(original_fn)
def wrapper(framework):
client_factories_provider = kwargs.get('client_factories_provider')
if not client_factories_provider:
client_factories_provider = default_client_factories_provider
proto_name = kwargs.get('protocol_name')
stop_on_first = kwargs.get('stop_on_first')
vector = ObjectStateHolderVector()
framework = RichFramework(framework)
if not proto_name:
proto_name = framework.get_dest_attribute('Protocol')
creds_manager = CredsManager(framework)
client_factories = client_factories_provider(framework,
creds_manager)
first_factory = take(0, 1, client_factories)
if not first_factory:
logger.reportErrorObject(_create_missed_creds_error(proto_name))
else:
connection_exs = []
discovery_exs = []
warnings = []
at_least_once_discovered = False
oshs = []
client_factories = list(itertools.chain(first_factory, client_factories))
main_fn = original_fn
for index, client_factory in enumerate(client_factories):
try:
with client_factory() as client:
args_ = (framework, client, index)
kwargs_ = {}
oshs_, warnings_ = main_fn(*args_, **kwargs_)
oshs.extend(oshs_)
warnings.extend(warnings_)
at_least_once_discovered = True
if stop_on_first:
break
except ConnectionException, ce:
logger.debugException(str(ce))
connection_exs.append(ce)
except (DiscoveryException, Exception), de:
logger.debugException(str(de))
discovery_exs.append(de)
if at_least_once_discovered:
each(logger.reportWarningObject, warnings)
else:
for ex in connection_exs:
obj = _create_connection_errorobj(proto_name, ex.message)
logger.reportWarningObject(obj)
for ex in discovery_exs:
obj = _create_discovery_errorobj(proto_name, ex.message)
logger.reportErrorObject(obj)
vector.addAll(oshs)
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 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 DiscoveryMain(Framework):
resultVector = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute(DestinationProperty.IP_ADDRESS)
credentialsId = Framework.getDestinationAttribute(DestinationProperty.CREDENTIALS_ID)
hypervisorCmdbId = Framework.getDestinationAttribute(DestinationProperty.HYPERVISOR_CMDB_ID)
esxCmdbId = Framework.getDestinationAttribute(DestinationProperty.ESX_CMDB_ID)
esxBiosUuid = Framework.getDestinationAttribute(DestinationProperty.ESX_BIOS_UUID)
if not esxBiosUuid:
msg = "ESX BIOS UUID from trigger data is empty"
errorObject = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg)
logger.reportErrorObject(errorObject)
logger.error(msg)
return resultVector
try:
unitaryComputerSystem = discoverEsxInventory(ipAddress, credentialsId, esxBiosUuid, Framework)
inventoryResultVector = reportEsxInventory(unitaryComputerSystem, esxCmdbId)
resultVector.addAll(inventoryResultVector)
virtualMachines = discoverEsxVirtualTopology(ipAddress, credentialsId, esxBiosUuid, Framework)
if virtualMachines:
virtualResultVector = reportVirtualTopology(virtualMachines, hypervisorCmdbId)
resultVector.addAll(virtualResultVector)
except JException, ex:
msg = ex.getMessage()
msg = cim_discover.translateErrorMessage(msg)
logger.debug(msg)
errormessages.resolveAndReport(msg, cim.Protocol.DISPLAY, Framework)
def getPolicyContent(httpClient, ip, protocolId, protocolName, version):
try:
protocol = ProtocolManager.getProtocolById(protocolId)
protocol_port = protocol.getProtocolAttribute('protocol_port')
http_protocol = protocol.getProtocolAttribute('protocol')
builder = oam_policy_builder.PolicyBuilder(http_protocol, ip, protocol_port, version, httpClient)
return builder.createPolicyDoc()
except JException, e:
msg = 'URL is not accessable: ' + e.getMessage()
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg)
logger.reportErrorObject(errobj)
def DiscoveryMain(Framework):
ip = Framework.getDestinationAttribute('ip_address')
domain = Framework.getDestinationAttribute('ip_domain')
codepage = Framework.getCodePage()
shell = None
credentialId = None
OSHVResult = None
warningsList = []
errorsList = []
protocolType = PowerShell.PROTOCOL_TYPE
credentials = []
# use the latest used credentials if any
lastConnectedCredential = Framework.loadState()
lastConnectedCredential and credentials.append(lastConnectedCredential)
# and other defined for triggered IP
credentials.extend(
netutils.getAvailableProtocols(Framework, protocolType, ip, domain))
if credentials:
shell, credentialId = getShellUtils(Framework, protocolType,
credentials, ip, codepage,
warningsList, errorsList)
else:
msg = errormessages.makeErrorMessage(
protocolType, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(
errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolType], msg)
errorsList.append(errobj)
if shell:
# successfully connected, do discovery
errorsList = []
warningsList = []
Framework.saveState(credentialId)
OSHVResult = doDiscovery(Framework, shell, ip, credentialId, codepage,
protocolType, warningsList, errorsList)
else:
if not len(errorsList):
msg = errormessages.makeErrorMessage(
protocolType, pattern=errormessages.ERROR_CONNECTION_FAILED)
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED,
[protocolType], msg)
errorsList.append(errobj)
Framework.clearState()
for errobj in warningsList:
logger.reportWarningObject(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip_address = Framework.getTriggerCIDataAsList('ip_address')
ip_domain = Framework.getTriggerCIDataAsList('ip_domain')
credentialIds = Framework.getAvailableProtocols(ip_address[0], ProtocolManager.UDDI_REGISTRY)
logger.debug('Len of credentials: %s' %str(len(credentialIds)))
logger.debug('Start on Address:', ip_address[0], ', Domain:', ip_domain[0])
if credentialIds.__len__() == 0:
msg = errormessages.makeErrorMessage(ProtocolManager.UDDI_REGISTRY, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [ProtocolManager.UDDI_REGISTRY], msg)
logger.reportErrorObject(errobj)
ip_domain = Framework.getDestinationAttribute("ip_domain")
for credentialId in credentialIds:
url = Framework.getProtocolProperty(credentialId, CollectorsConstants.UDDI_PROTOCOL_ATTRIBUTE_URL, '')
if url == '':
Framework.reportError('URL attribute is not specified in the UDDI protocol')
continue
# Check the URL
try:
logger.debug("Checking availability of %s" % url)
netutils.doHttpGet(url, 20000, 'header').strip()
except:
Framework.reportWarning('Failed to connect to UDDI Registry using URL: ' + url)
logger.debugException("Cannot connect to UDDI server")
else:
properties = Properties()
properties.setProperty(CollectorsConstants.UDDI_PROTOCOL_ATTRIBUTE_URL, url)
properties.setProperty("ip_domain", ip_domain)
connected = False
version = 0
for uddiVersion in (3, 2):
if connected:
break
try:
logger.debug('Using version UDDIv%d' % uddiVersion)
properties.setProperty('uddi_version', str(uddiVersion))
logger.debug('Try to connect to UDDI Registry using url: ', url)
Framework.getAgent(AgentConstants.UDDI_AGENT, '', credentialId, properties)
logger.debug('Connected to UDDI Registry url: ', url)
connected = True
version = uddiVersion
except MissingSdkJarException, ex:
Framework.reportError('UDDI SDK jars are missed. Refer documentation for details')
logger.debugException(ex.getMessage())
break
except JException, java_exc:
Framework.reportWarning("Cannot connect to UDDI server")
logger.debugException('Failed to connect to UDDI Registry: ' + java_exc.getMessage())
except:
def createWmiClient(Framework, namespace=None):
try:
if namespace:
props = Properties()
props.setProperty(AgentConstants.PROP_WMI_NAMESPACE, namespace)
return Framework.createClient(props)
else:
return Framework.createClient()
except:
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED_NO_PROTOCOL, ["WMI"], 'Failed to connect')
logger.reportErrorObject(errobj)
logger.debugException('Failed to to connect')
def executeUpdate(self, sql): st = None try: try: st = self.conn.createStatement() return st.executeUpdate(sql) except: error = 'Failed to execute sql ' + sql logger.errorException(error) errobj = errorobject.createError(errorcodes.FAILED_TO_EXECUTE_SQL, [sql], error) logger.reportErrorObject(errobj) finally: self.closeStatement(st)
def executeUpdate(self, sql):
st = None
try:
try:
st = self.conn.createStatement()
return st.executeUpdate(sql)
except:
error = 'Failed to execute sql ' + sql
logger.errorException(error)
errobj = errorobject.createError(
errorcodes.FAILED_TO_EXECUTE_SQL, [sql], error)
logger.reportErrorObject(errobj)
finally:
self.closeStatement(st)
def clientDiscovery(Framework, ip):
(vec, errObj) = mainFunction(Framework, 1, ip)
logger.debug('OSHVector contains ', vec.size(), ' objects.')
if vec.size() == 0:
logger.debug('Failed to connect or no valid protocols defined. No Host CI will be created')
if (errObj == None or errObj.errMsg == None or errObj.errMsg.strip() == ''):
altErr = errorobject.createError(errorcodes.INTERNAL_ERROR ,None , 'Discovery failed due to internal error')
logger.reportErrorObject(altErr)
else:
logger.reportWarningObject(errObj)
else:
Framework.sendObjects(vec)
Framework.flushObjects()
return None
def wrapper(framework):
vector = ObjectStateHolderVector()
framework = RichFramework(framework)
creds_manager = CredsManager(framework)
creds = get_credentials_fn(framework, creds_manager)
if creds is None:
return vector
first_cred = take(0, 1, creds)
if not first_cred:
logger.reportErrorObject(
_create_missed_creds_error(proto_name))
else:
connection_exs = []
discovery_exs = []
warnings = []
at_least_once_discovered = False
oshs = []
creds = list(itertools.chain(first_cred, creds))
if with_dns_resolver:
local_client = framework.createClient(
LOCAL_SHELL_PROTOCOL_NAME)
local_shell = shellutils.ShellUtils(local_client)
dns_resolver = _get_dns_resolver(local_shell)
for args in starmap(
functools.partial(cred_to_client_args, creds_manager),
creds):
try:
with create_client(framework, *args) as client:
args = with_dns_resolver and (
dns_resolver, ) + args or args
oshs_, warnings_ = main_fn(client, framework,
*args)
oshs.extend(oshs_)
warnings.extend(warnings_)
at_least_once_discovered = True
if stop_on_first:
break
except ConnectionException, ce:
logger.debugException(str(ce))
connection_exs.append(ce)
except (DiscoveryException, Exception), de:
logger.debugException(str(de))
discovery_exs.append(de)
def createWmiClient(Framework, namespace=None):
try:
if namespace:
props = Properties()
props.setProperty(AgentConstants.PROP_WMI_NAMESPACE, namespace)
return Framework.createClient(props)
else:
return Framework.createClient()
except:
errobj = errorobject.createError(
errorcodes.CONNECTION_FAILED_NO_PROTOCOL, ["WMI"],
'Failed to connect')
logger.reportErrorObject(errobj)
logger.debugException('Failed to to connect')
def getProcessesToProcess(self):
if not self.shouldRun():
return
rs = None
try:
try:
self.buildProcessMap()
st = self.getPreparedStatement(ProcessToProcess.P2PSQL)
logger.debug(st)
rs = st.executeQuery()
while(rs.next()):
SrcListen = rs.getBoolean('SrcListen')
DstListen = rs.getBoolean('DstListen')
if SrcListen and (not DstListen):
self.buildTcpConnTopology(rs, 'dst', 'src')
elif DstListen and (not SrcListen):
self.buildTcpConnTopology(rs, 'src', 'dst')
else:
srcPrefered = self.isPreferedService(rs, 'src')
dstPrefered = self.isPreferedService(rs, 'dst')
if srcPrefered and (not dstPrefered):
self.buildTcpConnTopology(rs, 'dst', 'src')
elif dstPrefered and (not srcPrefered):
self.buildTcpConnTopology(rs, 'src', 'dst')
else:
# we don't known which endpoint is listening,
# so we can't set the link direction
srcip = rs.getString('srcAddr')
srcport = rs.getInt('srcPort')
dstip = rs.getString('dstAddr')
dstport = rs.getInt('dstPort')
connString = '%s:%d %s:%d' % (srcip, srcport, dstip, dstport)
logger.warn('process to process topology: '
'Listen endpoint is unknown, skipping %s' % connString)
except:
error = 'Failed to fetch processes to process communication'
logger.errorException(error)
errobj = errorobject.createError(errorcodes.PROCESS_TO_PROCESS_FAILED, None, error)
logger.reportErrorObject(errobj)
finally:
if rs:
try:
rs.close()
except:
pass
self.conn.close()
def DiscoveryMain(Framework):
# get attribute
shell = None
client = None
OSHVResult = ObjectStateHolderVector()
try:
ip = reportIpAddress(Framework, OSHVResult)
# do host connection
client, shell, warningsList, errorsList, hostOsh = host_connection.doConnection(Framework, ip, OSHVResult)
if not (client and shell):
logger.debug("host connection failed")
for errobj in warningsList:
logger.reportWarningObject(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
return OSHVResult
# do host application
runningApplications, processes, connectivityEndPoints, connections, errorsList = host_application.doApplication(
Framework, ip,
OSHVResult,
client, shell, hostOsh)
if not (runningApplications and processes and connectivityEndPoints and connections):
logger.debug("host application failed")
for errobj in errorsList:
logger.reportErrorObject(errobj)
return OSHVResult
# do next hop
next_hop.doNextHop(Framework, ip, OSHVResult, shell, runningApplications,
processes, connectivityEndPoints, connections, hostOsh)
finally:
#close connection
if shell:
try:
shell.closeClient()
except:
logger.warnException('Client was not closed properly')
# close client anyway
if client and client.close():
pass
return OSHVResult
def decorator(framework):
framework = flow.RichFramework(framework)
proto_name = clients.SAPJmxClient.SAPJMX_CLIENT_TYPE
versions = get_sap_java_client_versions()
if not filter(len, versions):
msg = 'SAP_JMX drivers are missing'
obj = flow._create_connection_errorobj(proto_name, msg)
logger.reportErrorObject(obj)
return ObjectStateHolderVector()
pairs = get_applicable_credentials(framework, P4_PORT_PATTERN)
creds = ((creds_id, port, v) for creds_id, port in pairs
for v in versions)
return iterate_over_args(main_fn, framework, creds,
proto_name, stop_on_first)
def DiscoveryMain(Framework):
vector = ObjectStateHolderVector()
(vec, warnList, errList) = WMI_Connection_Utils.mainFunction(Framework)
logger.debug('OSHVector contains ', vec.size(), ' objects.')
# just in case we couldnt do any connection
if vec.size() == 0:
for errobj in errList:
logger.reportErrorObject(errobj)
for errobj in warnList:
logger.reportWarningObject(errobj)
else:
vector.addAll(vec)
return vector
def DiscoveryMain(Framework):
ip = Framework.getDestinationAttribute('ip_address')
domain = Framework.getDestinationAttribute('ip_domain')
codepage = Framework.getCodePage()
shell = None
credentialId = None
OSHVResult = None
warningsList = []
errorsList = []
protocolType = PowerShell.PROTOCOL_TYPE
credentials = []
# use the latest used credentials if any
lastConnectedCredential = Framework.loadState()
lastConnectedCredential and credentials.append(lastConnectedCredential)
# and other defined for triggered IP
credentials.extend(netutils.getAvailableProtocols(Framework, protocolType,
ip, domain))
if credentials:
shell, credentialId = getShellUtils(Framework, protocolType,
credentials, ip, codepage,
warningsList, errorsList)
else:
msg = errormessages.makeErrorMessage(protocolType, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolType], msg)
errorsList.append(errobj)
if shell:
# successfully connected, do discovery
errorsList = []
warningsList = []
Framework.saveState(credentialId)
OSHVResult = doDiscovery(Framework, shell, ip, credentialId, codepage, protocolType, warningsList, errorsList)
else:
if not len(errorsList):
msg = errormessages.makeErrorMessage(protocolType, pattern=errormessages.ERROR_CONNECTION_FAILED)
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolType], msg)
errorsList.append(errobj)
Framework.clearState()
for errobj in warningsList:
logger.reportWarningObject(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
return OSHVResult
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 DiscoveryMain(Framework):
resultVector = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute(DestinationProperty.IP_ADDRESS)
connectionHandler = vmware_cim_discover.DefaultDiscoveryConnectionHandler(Framework, discoverConnectedEsx)
connectionDiscoverer = None
try:
connectionDiscoverer = vmware_cim_discover.ConnectionDiscoverer(Framework, connectionHandler)
except (cim_discover.MissingConfigFileException, vmware_cim_discover.RuntimeException), ex:
msg = str(ex)
errorObject = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [cim.Protocol.DISPLAY, msg], msg)
logger.reportErrorObject(errorObject)
logger.error(msg)
return resultVector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip = Framework.getDestinationAttribute('ip')
port = Framework.getDestinationAttribute('port')
scp_id = Framework.getDestinationAttribute('scp_id')
apache_id = Framework.getDestinationAttribute('apache_id')
apache_ip = Framework.getDestinationAttribute('apache_ip')
contexts = Framework.getTriggerCIDataAsList('contexts')
context_ids = Framework.getTriggerCIDataAsList('context_ids')
localShell = shellutils.ShellUtils(Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME))
protocolName = ClientsConsts.HTTP_PROTOCOL_NAME
connectionFailedMsgs = []
protocolIds = findProperProtocolIds(ip, netutils.getAvailableProtocols(Framework, protocolName, ip) or [])
if not protocolIds:
msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg)
logger.reportErrorObject(errobj)
return OSHVResult
httpClient, protocolId, version = findHttpProtocol(Framework, protocolName, protocolIds, ip, connectionFailedMsgs)
if httpClient:
apacheOsh = modeling.createOshByCmdbIdString('apache', apache_id)
# create oam running software
createOAMRunningSoftwareOsh(scp_id, ip, port, protocolId, version, apacheOsh, OSHVResult)
# get oam policy content
policy_content = getPolicyContent(httpClient, ip, protocolId, protocolName, version)
# parse oam policy, get redirect urls
authorization_policies = oam_policy_parser.parse_oam_policy(policy_content)
redirect_policies = oam_policy_parser.get_redirect_policies(authorization_policies)
# create oam dependency scp
for index in range(0, len(contexts)):
context, context_id = contexts[index], context_ids[index]
if context_id:
matched_policies = findMatchedRedirectPolicies(context, redirect_policies)
apacheScpOsh = modeling.createOshByCmdbIdString('scp', context_id)
for policy in matched_policies:
createOAMDependenyScp(localShell, apacheOsh, apacheScpOsh, policy.redirect_url, apache_ip, OSHVResult)
if not OSHVResult.size():
for msg in connectionFailedMsgs:
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED, [protocolName], msg)
logger.reportErrorObject(errobj)
return OSHVResult
def wrapper(framework):
vector = ObjectStateHolderVector()
framework = RichFramework(framework)
creds_manager = CredsManager(framework)
creds = get_credentials_fn(framework, creds_manager)
if creds is None:
return vector
first_cred = take(0, 1, creds)
if not first_cred:
logger.reportErrorObject(_create_missed_creds_error(proto_name))
else:
connection_exs = []
discovery_exs = []
warnings = []
at_least_once_discovered = False
oshs = []
creds = list(itertools.chain(first_cred, creds))
if with_dns_resolver:
local_client = framework.createClient(LOCAL_SHELL_PROTOCOL_NAME)
local_shell = shellutils.ShellUtils(local_client)
dns_resolver = _get_dns_resolver(local_shell)
for args in starmap(functools.partial(cred_to_client_args,
creds_manager),
creds):
try:
with create_client(framework, *args) as client:
args = with_dns_resolver and (dns_resolver,) + args or args
oshs_, warnings_ = main_fn(client, framework, *args)
oshs.extend(oshs_)
warnings.extend(warnings_)
at_least_once_discovered = True
if stop_on_first:
break
except ConnectionException, ce:
logger.debugException(str(ce))
connection_exs.append(ce)
except (DiscoveryException, Exception), de:
logger.debugException(str(de))
discovery_exs.append(de)
def insertEntitiesProbeDb(self, entitiesbulk): st = None try: try: sql = entitiesbulk[0].getInsertSQL() st = self.conn.prepareStatement(sql) for entity in entitiesbulk: entity.setValues(st) st.addBatch() st.executeBatch() except: error = 'Failed to add entities of type ' + str(entitiesbulk[0].getEntityType()) + ' to Probe database' logger.errorException(error) errobj = errorobject.createError(errorcodes.FAILED_ADDING_ENTITIES_TO_PROBE_DB, [str(entitiesbulk[0].getEntityType())], error) logger.reportErrorObject(errobj) finally: self.closeStatement(st)
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 DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
(vec, errObj) = NTCMD_Connection_Utils.mainFunction(Framework)
logger.debug('OSHVector contains ', vec.size(), ' objects.')
# just in case we couldn't do any connection
if vec.size() == 0:
logger.debug('Failed to connect. No Host CI will be created')
if (errObj == None or errObj.errMsg == None or errObj.errMsg.strip() == ''):
altErr = errorobject.createError(errorcodes.INTERNAL_ERROR ,None , 'Discovery failed due to internal error')
logger.reportErrorObject(altErr)
else:
logger.reportWarningObject(errObj)
else:
OSHVResult.addAll(vec)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip = Framework.getDestinationAttribute("ip_address")
ip_domain = Framework.getDestinationAttribute("ip_domain")
cmdb_id = Framework.getDestinationAttribute("cmdb_id")
protocolName = ClientsConsts.HTTP_PROTOCOL_NAME
connectionFailedMsgs = []
protocolIds = findProperProtocolIds(
ip, netutils.getAvailableProtocols(Framework, protocolName, ip, ip_domain) or []
)
if not protocolIds:
msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg)
logger.reportErrorObject(errobj)
else:
for protocolId in protocolIds:
protocol = ProtocolManager.getProtocolById(protocolId)
port = protocol.getProtocolAttribute("protocol_port")
for version in SUPPORTED_OAM_VERSION:
props = Properties()
props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, protocolId)
props.setProperty("autoAcceptCerts", "true")
props.setProperty("host", ip)
try:
httpClient = Framework.createClient(props)
httpClient.getAsString(
"http://%s:%s/oam/services/rest/%s/ssa/policyadmin/appdomain" % (ip, port, version)
)
oamOsh = modeling.createOshByCmdbId("running_software", cmdb_id)
oamOsh.setStringAttribute("credentials_id", protocolId)
oamOsh.setStringAttribute("version", version)
OSHVResult.add(oamOsh)
except SocketTimeoutException, e:
msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_TIMEOUT)
connectionFailedMsgs.append(msg)
except JException, e:
msg = "URL is not accessable: " + e.getMessage()
# logger.debugException(msg)
connectionFailedMsgs.append(msg)
finally:
def DiscoveryMain(Framework):
warningsList = []
errorsList = []
vector = ObjectStateHolderVector()
ip_address = Framework.getDestinationAttribute('ip_address')
ip_domain = Framework.getDestinationAttribute('ip_domain')
protocolName = cim.Protocol.DISPLAY
credentials = netutils.getAvailableProtocols(Framework, cim.Protocol.FULL,
ip_address, ip_domain)
credentials = smis_discoverer.getSmisCredentials(credentials, Framework)
if len(credentials) == 0:
msg = errormessages.makeErrorMessage(
protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(
errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg)
warningsList.append(errobj)
logger.debug(msg)
smisNamespaces = smis_discoverer.getSmisNamespaces(Framework)
if not smisNamespaces:
msg = errormessages.makeErrorMessage(protocolName,
"No SMI-S namespaces found")
errobj = errorobject.createError(
errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS,
[cim.Protocol.DISPLAY, msg], msg)
errorsList.append(errobj)
logger.reportErrorObject(errobj)
return vector
for credential in credentials:
testedNamespace = None
for namespaceObject in smisNamespaces:
try:
testedNamespace = cim_discover.testConnectionWithNamespace(
Framework, ip_address, credential, namespaceObject)
break
except JException, ex:
msg = ex.getMessage()
msg = cim_discover.translateErrorMessage(msg)
errormessages.resolveAndAddToObjectsCollections(
msg, protocolName, warningsList, errorsList)
except:
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
exchangeServerId = Framework.getDestinationAttribute('id')
fqdn = Framework.getDestinationAttribute('fqdn')
hostName = getHostName(Framework)
exchangeServerOsh = ms_exchange_utils.restoreExchangeServerOSH(
exchangeServerId)
props = Properties()
props.put(AgentConstants.PROP_WMI_NAMESPACE, WMI_NAMESPACE)
try:
wmiClient = Framework.createClient(props)
wmiAgent = WmiAgent(wmiClient, Framework)
try:
exchangeDiscoverer = ExchangeDiscoverer(wmiAgent,
exchangeServerOsh,
Framework, OSHVResult,
hostName)
try:
exchangeDiscoverer.doExchangeSystem(fqdn)
exchangeDiscoverer.doFolderTrees()
except:
errorMsg = 'Failed to discover folder trees and public folders'
logger.warnException(errorMsg)
errobj = errorobject.createError(
errorcodes.FAILED_DISCOVERING_RESOURCE,
['folder trees and public folders'], errorMsg)
logger.reportWarningObject(errobj)
if not exchangeDiscoverer.objectsDiscovered:
errobj = errorobject.createError(
errorcodes.MS_EXCHANGE_OBJECTS_NOT_FOUND, None,
'Microsoft Exchange objects not found in discovery')
logger.reportErrorObject(errobj)
finally:
wmiClient.close()
except:
exInfo = logger.prepareJythonStackTrace('')
errormessages.resolveAndReport(exInfo, WMI_PROTOCOL, Framework)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute('ip_address')
try:
snmpClient = Framework.createClient()
try:
a10Discoverer = createA10Discoverer(snmpClient, Framework, OSHVResult)
a10Discoverer.getTopology(ipAddress)
finally:
snmpClient.close()
except NoA10Exception:
logger.reportWarning("No A10 vThunder found on the remote machine")
except:
#TODO: use errormessages here
msg = logger.prepareFullStackTrace('')
errobj = errormessages.resolveError(msg, 'snmp')
logger.reportErrorObject(errobj)
logger.debugException('')
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
(vec, errObj) = NTCMD_Connection_Utils.mainFunction(Framework)
logger.debug('OSHVector contains ', vec.size(), ' objects.')
# just in case we couldn't do any connection
if vec.size() == 0:
logger.debug('Failed to connect. No Host CI will be created')
if (errObj == None or errObj.errMsg == None
or errObj.errMsg.strip() == ''):
altErr = errorobject.createError(
errorcodes.INTERNAL_ERROR, None,
'Discovery failed due to internal error')
logger.reportErrorObject(altErr)
else:
logger.reportWarningObject(errObj)
else:
OSHVResult.addAll(vec)
return OSHVResult
def insertEntitiesProbeDb(self, entitiesbulk):
st = None
try:
try:
sql = entitiesbulk[0].getInsertSQL()
st = self.conn.prepareStatement(sql)
for entity in entitiesbulk:
entity.setValues(st)
st.addBatch()
st.executeBatch()
except:
error = 'Failed to add entities of type ' + str(
entitiesbulk[0].getEntityType()) + ' to Probe database'
logger.errorException(error)
errobj = errorobject.createError(
errorcodes.FAILED_ADDING_ENTITIES_TO_PROBE_DB,
[str(entitiesbulk[0].getEntityType())], error)
logger.reportErrorObject(errobj)
finally:
self.closeStatement(st)
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute('ip_address')
try:
snmpClient = Framework.createClient()
try:
f5Discoverer = createF5Discoverer(snmpClient, Framework, OSHVResult)
f5Discoverer.getTopology(ipAddress)
finally:
snmpClient.close()
except NoF5Exception:
logger.reportWarning("No F5 LTM found on the remote machine")
except:
#TODO: use errormessages here
msg = logger.prepareFullStackTrace('')
errobj = errormessages.resolveError(msg, 'snmp')
logger.reportErrorObject(errobj)
logger.debugException('')
return OSHVResult
def doNextHop(Framework, hostIPs, OSHVResult, shell, runningApplications, processes, connectivityEndPoints, connections,
hostOsh):
portToDiscover = Framework.getDestinationAttribute("PORT")
signatureLoader = asm_signature_loader.SignatureLoader(Framework)
processMap = buildProcessMap(processes)
for application in runningApplications:
results, configFileScp = findConfigFileNextHop(Framework, hostIPs, shell, processMap, application,
signatureLoader)
OSHVResult.addAll(results)
nonTcpScpSet = buildSCPSet(results)
results, tcpScp, warninglist = findTCPNextHop(Framework, hostIPs, shell, processes, connectivityEndPoints,
connections, application, hostOsh)
filterSCP(results, nonTcpScpSet, hostIPs, portToDiscover)
OSHVResult.addAll(results)
if int(configFileScp) + int(tcpScp) == 0:
for warning in warninglist:
logger.reportErrorObject(warning)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
try:
checkAlteon(Framework)
snmpClient = Framework.createClient()
ipAddress = Framework.getDestinationAttribute("ip_address")
hostOsh = modeling.createHostOSH(ipAddress)
OSHVResult.add(hostOsh)
try:
snmpAgent = SnmpAgent(ALTEON_OID_BASE, snmpClient, Framework)
alteonDiscoverer = AlteonDiscoverer(snmpAgent, OSHVResult, Framework)
alteonDiscoverer.discoverAlteon(hostOsh)
finally:
snmpClient.close()
except:
logger.errorException("")
errobj = errorobject.createError(errorcodes.FAILED_TO_DISCOVER_ALTEON, None, "Failed to discover Alteon")
logger.reportErrorObject(errobj)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
try:
checkAlteon(Framework)
snmpClient = Framework.createClient()
ipAddress = Framework.getDestinationAttribute('ip_address')
hostOsh = modeling.createHostOSH(ipAddress)
OSHVResult.add(hostOsh)
try:
snmpAgent = SnmpAgent(ALTEON_OID_BASE, snmpClient, Framework);
alteonDiscoverer = AlteonDiscoverer(snmpAgent, OSHVResult, Framework)
alteonDiscoverer.discoverAlteon(hostOsh)
finally:
snmpClient.close()
except:
logger.errorException('')
errobj = errorobject.createError(errorcodes.FAILED_TO_DISCOVER_ALTEON, None, 'Failed to discover Alteon')
logger.reportErrorObject(errobj)
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip = Framework.getDestinationAttribute('ip_address')
ip_domain = Framework.getDestinationAttribute('ip_domain')
cmdb_id = Framework.getDestinationAttribute('cmdb_id')
protocolName = ClientsConsts.HTTP_PROTOCOL_NAME
connectionFailedMsgs = []
protocolIds = findProperProtocolIds(ip, netutils.getAvailableProtocols(Framework, protocolName, ip, ip_domain) or [])
if not protocolIds:
msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg)
logger.reportErrorObject(errobj)
else:
for protocolId in protocolIds:
protocol = ProtocolManager.getProtocolById(protocolId)
port = protocol.getProtocolAttribute('protocol_port')
for version in SUPPORTED_OAM_VERSION:
props = Properties()
props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID, protocolId)
props.setProperty('autoAcceptCerts', 'true')
props.setProperty('host', ip)
try:
httpClient = Framework.createClient(props)
httpClient.getAsString('http://%s:%s/oam/services/rest/%s/ssa/policyadmin/appdomain' % (ip, port, version))
oamOsh = modeling.createOshByCmdbId('running_software', cmdb_id)
oamOsh.setStringAttribute('credentials_id', protocolId)
oamOsh.setStringAttribute('version', version)
OSHVResult.add(oamOsh)
except SocketTimeoutException, e:
msg = errormessages.makeErrorMessage(protocolName, pattern=errormessages.ERROR_TIMEOUT)
connectionFailedMsgs.append(msg)
except JException, e:
msg = 'URL is not accessable: ' + e.getMessage()
# logger.debugException(msg)
connectionFailedMsgs.append(msg)
finally:
def checkNonNativeAgentInstalled(Framework):
# Set the nonnative flags
Framework.setProperty(InventoryUtils.STATE_PROPERTY_IS_MIGRATE, 'false')
InventoryUtils.resetBaseDir(Framework)
AgentUtils.setUpgradingNativeAgent(Framework, 'true')
# Ensure we're disconnected
InventoryUtils.releaseConnection(Framework)
Framework.setProperty(AgentUtils.DOWNLOAD_MIGRATE_LOG_FILE,
AgentUtils.DOWNLOAD_MIGRATE_LOG_FILE)
# For now - the usual check
logger.debug(
'Going to check whether non-native agent already installed or not')
warningsList = []
errorsList = []
agent = AgentUtils.agentConnect(
Framework,
AgentUtils.getUdAgentProtocolForMigration(Framework).getIdAsString(),
warningsList, errorsList)
if not agent:
for errobj in warningsList:
logger.reportWarningObject(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
Framework.reportError(
inventoryerrorcodes.INVENTORY_DISCOVERY_ENSURE_CONNECTED_FAILED,
['Could not connect to the remote agent'])
Framework.setStepExecutionStatus(WorkflowStepStatus.FAILURE)
else:
logger.debug('Connected to agent!!!!')
Framework.setProperty(AgentUtils.DOWNLOAD_MIGRATE_LOG_FILE, '')
InventoryUtils.setConnectedClientIdentifier(Framework, agent)
agent.close()
Framework.setStepExecutionStatus(WorkflowStepStatus.SUCCESS)
def DiscoveryMain(Framework):
resultVector = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute(DestinationProperty.IP_ADDRESS)
if not ipAddress:
msg = errormessages.makeErrorMessage(na.Protocol.DISPLAY, message="Invalid IP address")
errorObject = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [na.Protocol.DISPLAY, msg], msg)
logger.reportErrorObject(errorObject)
return resultVector
credentialsId = Framework.getParameter(DestinationProperty.CREDENTIALS_ID)
if not credentialsId:
msg = errormessages.makeErrorMessage(na.Protocol.DISPLAY, pattern=errormessages.ERROR_NO_CREDENTIALS)
errorObject = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [na.Protocol.DISPLAY], msg)
logger.reportErrorObject(errorObject)
return resultVector
queryTopologyPerDevice = _getBooleanParameter(JobParameter.QUERY_TOPOLOGY_PER_DEVICE, Framework, False)
discovererClass = na_discover.SingleRequestsNaDiscoverer
if queryTopologyPerDevice:
discovererClass = na_discover.NaDiscovererPerDevice
reportDeviceConfigs = _getBooleanParameter(JobParameter.REPORT_DEVICE_CONFIGS, Framework, False)
logger.debug('reportDeviceConfigs: ', reportDeviceConfigs)
reportDeviceModules = _getBooleanParameter(JobParameter.REPORT_DEVICE_MODULES, Framework, False)
logger.debug('reportDeviceModules:', reportDeviceModules)
client = None
try:
try:
client = na_discover.createJavaClient(Framework, ipAddress, credentialsId)
logger.debug("Topology is discovered by '%s'" % discovererClass.__name__)
discoverer = discovererClass(client, ipAddress, Framework)
discoverer.setDevicePageSize(500)
discoverer.setReportDeviceConfigs(reportDeviceConfigs)
discoverer.setReportDeviceModules(reportDeviceModules)
discoverResult = discoverer.discover()
if discoverResult:
devicesById, connectivitiesByDeviceId = discoverResult
reporter = na.NaReporter(Framework)
reporter.setBulkThreshold(10000)
reporter.setReportDeviceConfigs(reportDeviceConfigs)
reporter.setReportDeviceModules(reportDeviceModules)
reporter.report(devicesById, connectivitiesByDeviceId)
finally:
client and client.close()
except MissingSdkJarException, ex:
msg = errormessages.makeErrorMessage(na.Protocol.DISPLAY, message="Not all jar dependencies are found in class path")
errorObject = errorobject.createError(errorcodes.MISSING_JARS_ERROR, [na.Protocol.DISPLAY, msg], msg)
logger.reportErrorObject(errorObject)
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()
ipAddress = Framework.getDestinationAttribute(
DestinationProperty.IP_ADDRESS)
connectionHandler = vmware_cim_discover.DefaultDiscoveryConnectionHandler(
Framework, discoverConnectedEsx)
connectionDiscoverer = None
try:
connectionDiscoverer = vmware_cim_discover.ConnectionDiscoverer(
Framework, connectionHandler)
except (cim_discover.MissingConfigFileException,
vmware_cim_discover.RuntimeException), ex:
msg = str(ex)
errorObject = errorobject.createError(
errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS,
[cim.Protocol.DISPLAY, msg], msg)
logger.reportErrorObject(errorObject)
logger.error(msg)
return resultVector
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ipAddress = Framework.getDestinationAttribute('ip_address')
try:
snmpClient = Framework.createClient()
snmpAgent = SnmpAgent(CISCO_ACE_OID_BASE, snmpClient, Framework)
try:
cisco_Discoverer = Cisco_Discoverer(snmpAgent, OSHVResult,
Framework)
cisco_Discoverer.getTopology(ipAddress)
finally:
snmpClient.close()
except NO_CISCO_ACE_Exception:
logger.reportWarning("No Cisco ACE found on the remote machine")
except:
#TODO: use errormessages here
msg = logger.prepareFullStackTrace('')
errobj = errormessages.resolveError(msg, 'snmp')
logger.reportErrorObject(errobj)
logger.debugException('')
return OSHVResult
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip = Framework.getDestinationAttribute('ip_address')
domain = Framework.getDestinationAttribute('ip_domain')
host_id = Framework.getDestinationAttribute('hostId')
errorsList = []
protocol = "ldap"
credential_ids = Framework.getAvailableProtocols(ip, protocol)
lastConnectedCredential = Framework.loadState()
lastConnectedCredential and credential_ids.append(lastConnectedCredential)
if not credential_ids:
msg = errormessages.makeErrorMessage(
'webseal', pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(
errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, ['webseal'], msg)
errorsList.append(errobj)
client = Framework.createClient()
credential_id = find_valid_credential(credential_ids, client, Framework)
if credential_id:
Framework.saveState(credential_id)
OSHVResult.addAll(reportWebSeal(host_id, credential_id))
else:
Framework.clearState()
msg = errormessages.makeErrorMessage(
'Shell', pattern=errormessages.ERROR_FAILED_TO_CONNECT_TO_SERVER)
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED,
['webseal'], msg)
errorsList.append(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
return OSHVResult
def __discoverInstalledSoftware(Framework, OSHVResult, client):
discoverSoftwareOld = Boolean.parseBoolean(Framework.getParameter('discoverInstalledSoftwareByOldMechanism'))
softNameToInstSoftOSH = {}
try:
if discoverSoftwareOld:
#we close client here since in the software discovery we had to open another client
#since we changing namespace and reference registry instead of wmi
logger.debug('The software is discovered using old mechanism. This mechanism is very non-efficient and thus discovery might take time.')
client.close()
client = None
wmi_dis_software_lib.mainFunction(Framework, OSHVResult, softNameToInstSoftOSH)
#reopen general WMI client since it will be used in Plug-ins
logger.debug("Reopening WMI client")
client = createWmiClient(Framework)
else:
wmi_dis_software_lib.mainFunctionWithWbem(Framework, client, OSHVResult, softNameToInstSoftOSH)
except:
errobj = errorobject.createError(errorcodes.FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE, ['software', 'wmi'], 'Failed to discover software by wmi')
logger.reportErrorObject(errobj)
logger.errorException('Failed to discover software by wmi')
return (softNameToInstSoftOSH, client)
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ip = Framework.getDestinationAttribute('ip_address')
credential_id = Framework.getDestinationAttribute('credential_id')
version = Framework.getDestinationAttribute('version')
cmdb_id = Framework.getDestinationAttribute('cmdb_id')
protocol = ProtocolManager.getProtocolById(credential_id)
host = protocol.getProtocolAttribute('host')
port = protocol.getProtocolAttribute('protocol_port')
protocolName = ClientsConsts.HTTP_PROTOCOL_NAME
if (host and ip != host) or not port:
msg = errormessages.makeErrorMessage(
protocolName,
'Invalid ip address or missing port in HTTP credential',
pattern=errormessages.ERROR_OPERATION_FAILED)
errobj = errorobject.createError(errorcodes.OPERATION_FAILED,
[protocolName], msg)
logger.reportErrorObject(errobj)
else:
props = Properties()
props.setProperty(CollectorsConstants.ATTR_CREDENTIALS_ID,
credential_id)
props.setProperty('autoAcceptCerts', 'true')
props.setProperty('host', ip)
try:
httpClient = Framework.createClient(props)
builder = PolicyBuilder(ip, port, version, httpClient)
doc = builder.createPolicyDoc()
oamServerOSH = modeling.createOshByCmdbIdString(
'running_software', cmdb_id)
policyOSH = modeling.createConfigurationDocumentOSH(
'policy.xml', '', doc, oamServerOSH)
linkOSH = modeling.createLinkOSH('composition', oamServerOSH,
policyOSH)
OSHVResult.add(oamServerOSH)
OSHVResult.add(policyOSH)
OSHVResult.add(linkOSH)
except UnauthorizedException, e:
msg = 'Failed to authenticate: ' + e.getMessage()
errobj = errorobject.createError(
errorcodes.INVALID_USERNAME_PASSWORD, [protocolName], msg)
logger.reportErrorObject(errobj)
except JException, e:
msg = 'URL is not accessable: ' + e.getMessage()
errobj = errorobject.createError(errorcodes.CONNECTION_FAILED,
[protocolName], msg)
logger.reportErrorObject(errobj)
def checkAgentInstalled(Framework, ignoreError=False):
# Ensure we're disconnected
InventoryUtils.releaseConnection(Framework)
Framework.setProperty(AgentUtils.DOWNLOAD_INSTALL_LOG_FILE, AgentUtils.DOWNLOAD_INSTALL_LOG_FILE)
if Framework.getProperty(FIRST_TRY_INSTALL_AGENT) is None:
# we don't want immediately check whether agent installed or not, since for sure it is not. go to parking
# to let others to install
logger.debug('UD agent install command just run, will check after parking')
Framework.setProperty(FIRST_TRY_INSTALL_AGENT, FIRST_TRY_INSTALL_AGENT)
Framework.setStepExecutionStatus(WorkflowStepStatus.FAILURE)
return
else:
logger.debug('Going to check whether agent already installed or not')
# errorCode = AgentUtils.getInstallErrorCode(Framework)
# if not errorCode.isSuccess():
# logger.debug('Failed to install agent.')
# Framework.reportError(inventoryerrorcodes.INVENTORY_DISCOVERY_FAILED_AGENT_INSTALL, None)
# Framework.setStepExecutionStatus(WorkflowStepStatus.FATAL_FAILURE)
# return
warningsList = []
errorsList = []
# When we migrate ddmi to uda, we already know what cred_id to use
ddmiMigrationCredId = AgentUtils.getUdAgentProtocolForMigration(Framework)
if ddmiMigrationCredId:
conToUse = ddmiMigrationCredId.getIdAsString()
else:
conToUse = None
agent = AgentUtils.agentConnect(Framework, conToUse, warningsList, errorsList)
if not agent:
if not ignoreError:
for errobj in warningsList:
logger.reportWarningObject(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
Framework.reportError(inventoryerrorcodes.INVENTORY_DISCOVERY_ENSURE_CONNECTED_FAILED, ['Could not connect to the remote agent'])
Framework.setStepExecutionStatus(WorkflowStepStatus.FAILURE)
else:
try:
logger.debug('Connected to agent!!!!')
# Check whether the agent is native
agentsConfigFile = Framework.getConfigFile(CollectorsConstants.AGENTSSBYPLATFORM_FILE_NAME)
platform = Framework.getProperty(InventoryUtils.STATE_PROPERTY_PLATFORM)
architecture = Framework.getProperty(InventoryUtils.STATE_PROPERTY_ARCHITECTURE)
agentPlatformConfig = agentsConfigFile.getPlatformConfiguration(platform, architecture)
isNativeCmd = agentPlatformConfig.getIsNativeCmd()
logger.debug('Native command is [' + str(isNativeCmd) + ']')
if isNativeCmd and len(isNativeCmd) > 0:
isNativeCmd = InventoryUtils.handleBaseDirPath(Framework, isNativeCmd)
isNative = agent.executeCmd(isNativeCmd)
if isNative != 'true':
logger.debug('Could not verify whether the remote agent is native')
Framework.reportError(inventoryerrorcodes.INVENTORY_DISCOVERY_ENSURE_CONNECTED_FAILED,
['Remote agent doesnt appear to be natively installed'])
Framework.setStepExecutionStatus(WorkflowStepStatus.FAILURE)
return
# Reporting agent osh to framework
Framework.setProperty(AgentUtils.DOWNLOAD_INSTALL_LOG_FILE, '')
Framework.setProperty(InventoryUtils.STATE_PROPERTY_AGENT_INSTALLED, InventoryUtils.STATE_PROPERTY_AGENT_INSTALLED)
AgentUtils.saveGlobalState(agent, Framework)
OSHVResult = ObjectStateHolderVector()
ip = Framework.getProperty(InventoryUtils.STATE_PROPERTY_CONNECTED_SHELL_IP)
hostOsh = modeling.createHostOSH(ip)
uduid = InventoryUtils.getUduid(agent)
hostOsh.setStringAttribute(InventoryUtils.ATTR_UD_UNIQUE_ID, uduid)
agentOsh = AgentUtils.createAgentOsh(agent, Framework)
agentOsh.setContainer(hostOsh)
OSHVResult.add(hostOsh)
OSHVResult.add(agentOsh)
Framework.sendObjects(OSHVResult)
Framework.flushObjects()
Framework.setStepExecutionStatus(WorkflowStepStatus.SUCCESS)
finally:
if agent:
agent.close()
def DiscoveryMain(Framework):
OSHVResult = ObjectStateHolderVector()
ms_domain_name = Framework.getDestinationAttribute('ms_domain_name')
if not ms_domain_name:
ms_domain_name = 'NULL'
try:
netUtil = MsNetworkUtil()
hostsOutput = netUtil.doNetServerEnum('NULL', SV_TYPE_SERVER,
ms_domain_name)
if hostsOutput != None:
discoverUnknownIPs = 1
try:
strDiscoverUnknownIPs = Framework.getParameter(
'discoverUnknownIPs')
discoverUnknownIPs = Boolean.parseBoolean(
strDiscoverUnknownIPs)
except:
pass
oshMsDomain = ObjectStateHolder('msdomain')
oshMsDomain.setStringAttribute('data_name', ms_domain_name)
alreadyDiscoveredIps = HashMap()
for hostInfo in hostsOutput:
hostType = Long(hostInfo[1]).longValue()
hostName = (str(hostInfo[0])).lower()
try:
ip = InetAddress.getByName(hostInfo[0]).getHostAddress()
if netutils.isLocalIp(ip):
continue
cachedHostName = alreadyDiscoveredIps.get(ip)
if cachedHostName != None:
logger.debug(
'IP ', ip,
' already reported for host ' + cachedHostName,
' current host ', hostName, ' - skipping')
continue
else:
logger.debug('Discovered IP ' + ip + ' for host ' +
hostName)
alreadyDiscoveredIps.put(ip, hostName)
ipDomain = DomainScopeManager.getDomainByIp(ip)
if not discoverUnknownIPs and ipDomain == 'unknown':
logger.debug(
'ip: ' + ip +
' is out of probe range and will be excluded')
continue
if SV_TYPE_CLUSTER_NT & hostType:
logger.debug(
'Not reporting the entry %s because it is a Cluster'
% hostName)
continue
hostOsType = 'nt'
if SV_TYPE_SERVER_UNIX & hostType:
hostOsType = 'unix'
oshHost = modeling.createHostOSH(ip, hostOsType)
oshHost.setStringAttribute("host_hostname", hostName)
OSHVResult.add(oshHost)
link = modeling.createLinkOSH('member', oshMsDomain,
oshHost)
OSHVResult.add(link)
ipOSH = modeling.createIpOSH(ip)
OSHVResult.add(ipOSH)
contained = modeling.createLinkOSH('contained', oshHost,
ipOSH)
OSHVResult.add(contained)
except:
errorMsg = str(sys.exc_info()[1]).strip()
logger.warn('Failed to resolve host ', hostInfo[0], ' : ',
errorMsg)
else:
message = 'Failed to discover hosts on MS Domain'
logger.warn(message)
logger.reportWarning(message)
except:
errorMsg = str(sys.exc_info()[1]).strip()
logger.errorException('Failed to discovery MS Domains')
errorMessage = errormessages.makeErrorMessage(
"msdomain", errorMsg,
errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS)
errobj = errorobject.createError(
errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST,
["msdomain", errorMsg], errorMessage)
logger.reportErrorObject(errobj)
return OSHVResult
def discover_private(self):
ports = self.servicesPorts(0)
query = 'select ipaddress, port, Protocol from Port_Process '
if (ports != None) and (len(ports) > 0):
query = query + ' where listen and port IN (' + ports + ')'
logger.debug('ListenPorts,sql:', query)
conn = self.Framework.getProbeDatabaseConnection('TCPDISCOVERY')
st = None
result = None
try:
try:
if logger.isDebugEnabled():
logger.debug(query)
st = conn.createStatement()
result = st.executeQuery(query)
dataFound = 0
while result.next():
dataFound = 1
address = result.getString('ipaddress');
port = result.getInt('port');
prot = result.getInt('Protocol');
if not self.shouldInclude(address, 1):
if logger.isDebugEnabled():
logger.debug("ignoring ip out of scope: " + address)
continue
ipOSH = modeling.createIpOSH(address)
self.Framework.sendObject(ipOSH)
hostOSH = modeling.createHostOSH(address)
portName = self.knownPortsConfigFile.getPortName(prot, port)
if portName == None:
portName = str(port)
portType = modeling.SERVICEADDRESS_TYPE_TCP
if prot == modeling.UDP_PROTOCOL:
portType = modeling.SERVICEADDRESS_TYPE_UDP
serverPortOSH = modeling.createServiceAddressOsh(hostOSH, address, port, portType, portName)
containedLinkOSH = modeling.createLinkOSH('contained', hostOSH, ipOSH)
self.Framework.sendObject(hostOSH)
self.Framework.sendObject(serverPortOSH)
self.Framework.sendObject(containedLinkOSH)
if not dataFound:
self.Framework.reportWarning("No data to process, please check if Host Resources jobs had already run")
except:
msg = sys.exc_info()[1]
exInfo = '%s' % msg
if exInfo.find('ResultSet closed') != -1:
error = 'Connection to probe database closed'
details = str("Please increase job execution max time and/or configure parameter 'appilog.agent.netflow.heldTimeoutConnection' in DiscoveryProbe.properties file")
errobj = errorobject.createError(errorcodes.INTERNAL_ERROR_WITH_PROTOCOL_DETAILS, [error, details], error + details)
logger.reportErrorObject(errobj)
else:
errobj = errorobject.createError(errorcodes.FAILED_TO_EXECUTE_SQL, [exInfo], exInfo)
logger.reportErrorObject(errobj)
finally:
if result != None:
try:
result.close
except:
pass
conn.close(st)
conn.close()
errormessages.resolveAndAddToObjectsCollections(
trace, protocolName, warningsList, errorsList)
if testedNamespace is not None:
hostOsh = modeling.createHostOSH(ip_address)
smisOsh = cim.createCimOsh(ip_address, hostOsh, credential,
smis.CimCategory.SMIS)
smisOsh.setStringAttribute('application_category', 'Storage')
vector.add(hostOsh)
vector.add(smisOsh)
warningsList = []
errorsList = []
break
if vector.size() <= 0:
Framework.clearState()
if (len(warningsList) == 0) and (len(errorsList) == 0):
msg = errormessages.makeErrorMessage(
protocolName, pattern=errormessages.ERROR_GENERIC)
logger.debug(msg)
errobj = errorobject.createError(
errorcodes.INTERNAL_ERROR_WITH_PROTOCOL, [protocolName], msg)
errorsList.append(errobj)
if errorsList:
for errorObj in errorsList:
logger.reportErrorObject(errorObj)
if warningsList:
for warnObj in warningsList:
logger.reportErrorObject(warnObj)
return vector
logger.debugException(str(e))
warning = errorobject.createError(
errorcodes.INTERNAL_ERROR, None,
"%s failed" % discovery.description)
discoveryWarnings.append(warning)
# === Error cases handling ===
# Discovery finished and we have to show reasons in the UI:
#
# * No credentials found for _aws_ protocol
if not credentials:
msg = errormessages.makeErrorMessage(
protocolName, pattern=errormessages.ERROR_NO_CREDENTIALS)
errobj = errorobject.createError(
errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [protocolName], msg)
logger.reportErrorObject(errobj)
# * Among enabled flows no successful discovery
elif not oneDiscoveryHappened:
errobj = errorobject.createError(errorcodes.FAILED_RUNNING_DISCOVERY,
['Amazon Cloud'],
'Failed to make discovery')
logger.reportErrorObject(errobj)
# * Other, like connection troubles or failed discovery
map(logger.reportErrorObject, discoveryErrors)
map(logger.reportWarningObject, discoveryWarnings)
return ObjectStateHolderVector()
# Discovery details
# -----------------
def reportErrors(warningsList, errorsList):
for errobj in warningsList:
logger.reportWarningObject(errobj)
for errobj in errorsList:
logger.reportErrorObject(errobj)
return