def _report_ascs_osh(host_name, instance_number, system):
resolver = dns_resolver.SocketDnsResolver()
ips = []
try:
ips = resolver.resolve_ips(host_name)
except netutils.ResolveException, re:
logger.warn("Failed to resolve %s" % host_name)
def reportInstances(instances,
sys_,
sysOsh,
get_inst_creds=None,
connectionClientNr=None):
r'''@types: list[InstanceInfo], System, osh, callable, str -> dict, oshv
@type get_inst_creds: (InstanceInfo, list[_BaseIP] -> str?)
@param get_inst_creds: function to get credentials for the specified instance
'''
vector = ObjectStateHolderVector()
#resolve IP for instance host
dnsResolver = dns_resolver.SocketDnsResolver()
resolveAddressToIps = fptools.partiallyApply(_resolveInstanceAddressToIps,
fptools._, dnsResolver)
ipsOfInstances = map(resolveAddressToIps, instances)
# report instances
oshPerInstance = {}
hasIps = second
for instInfo, ips in filter(hasIps, zip(instances, ipsOfInstances)):
serverOsh, iVector = reportInstanceWithSystem(instInfo, ips, sys_,
sysOsh,
connectionClientNr)
vector.addAll(iVector)
oshPerInstance[instInfo.instance] = serverOsh
return oshPerInstance, vector
def resolveFQDN(shell, ip):
'''
@deprecated: use
dns_resolver.NsLookupDnsResolver and
dns_resolver.SocketDnsResolver
Resolves fqdn of a host by ip.
NsLookup is used first and then @netutils.getHostName used on fallback
@types: ip -> str?
'''
fqdn = None
if isValidIp(ip):
dnsResolver = dns_resolver.NsLookupDnsResolver(shell)
fqdn = dnsResolver.resolve_hostnames(ip)
if not fqdn:
try:
hostnames = dns_resolver.SocketDnsResolver().resolve_hostnames(
ip)
if hostnames:
fqdn = hostnames[0]
except:
logger.warn('Failed to resolve host IP through socket')
else:
fqdn = fqdn[0]
return fqdn
def _resolveHostIps(shell, hostName):
'@types: Shell, str -> list[str]'
ips = ()
if not netutils.isValidIp(hostName):
resolver = dns_resolver.SocketDnsResolver()
try:
ips = resolver.resolve_ips(hostName)
except dns_resolver.ResolveException, re:
logger.warn("Failed to resolve: %s. %s" % (hostName, re))
def _resolve_host_ips(host, hostName, hostDnsName):
''' Resolve address to IPs
@types: str, str, str -> list[IPAddress]'''
if ip_addr.isValidIpAddress(host.ip):
return (host.ip,)
try:
address = hostDnsName or hostName
return dns_resolver.SocketDnsResolver().resolve_ips(address)
except dns_resolver.ResolveException:
return []
def _resolve_switch_ips(switch):
''' Resolve address to IPs
@types: str -> list[IPAddress]'''
address = switch.address
if ip_addr.isValidIpAddress(address):
return (ip_addr.IPAddress(address),)
try:
hostname = _get_name_only(switch.name)
return dns_resolver.SocketDnsResolver().resolve_ips(hostname)
except dns_resolver.ResolveException:
return []
def _resolveIps(hostname, hostnameToAddress):
'''
Resolve hostname using passed mapping or performing real DNS query
@types: str, dict[str, sap.Address] -> list[ip_addr._BaseIp]
'''
ips = ()
address = hostnameToAddress.get(hostname)
if address:
ips = address.ips
else:
resolver = dns_resolver.SocketDnsResolver()
try:
ips = resolver.resolve_ips(hostname)
except dns_resolver.ResolveException, e:
logger.debug("Failed to resolve %s. %s" % (hostname, str(e)))
def find_instance_with_ip(instances, ip):
found_instance = None
s_dns_resolver = dns_resolver.SocketDnsResolver()
for instance in instances:
# resolve host name first
ips = []
try:
ips = s_dns_resolver.resolve_ips(instance.host.address.hostname)
except dns_resolver.ResolveException, re:
logger.warn("Failed to resolve %s" %
instance.host.address.hostname)
if not ips:
ips = instance.host.address.ips
if str(ip) in map(str, ips):
found_instance = instance
break
def getHostNamesFromShell(ip_string, shell=None, dnsServers=None):
resolvers = []
dnsServers = dnsServers or []
try:
resolvers.append(dns_resolver.SocketDnsResolver())
if shell and dnsServers:
for dns in dnsServers:
resolvers.append(dns_resolver.NsLookupDnsResolver(shell, dns))
dnsResolver = dns_resolver.FallbackResolver(resolvers)
hostname = dnsResolver.resolve_fqdn(ip_string)
aliasList = dnsResolver.resolve_hostnames(ip_string)
if hostname and hostname != ip_string:
logger.debug("DNS Lookup: %s: %s, %s" %
(ip_string, hostname, aliasList))
return hostname, aliasList
except:
logger.warnException("Cannot get hostnames for %s" % ip_string)
return None, []
def _reportDbServer(server, datasource, systemOsh):
'@types: db.DatabaseServer, jdbc.Datasource, osh -> list[osh]'
oshs = []
hostReporter = sap.HostReporter(sap.HostBuilder())
resolver = dns_resolver.SocketDnsResolver()
ips = Sfn(resolver.resolve_ips)(server.address) or ()
if ips:
ds_reporter = jdbc.JdbcTopologyReporter(jdbc.DataSourceBuilder())
ds_osh = ds_reporter.reportDatasource(datasource, systemOsh)
oshs.append(ds_osh)
server.address = first(ips)
logger.info("Report %s" % server)
host_osh, oshs_ = hostReporter.reportHostWithIps(*ips)
oshs.extend(oshs_)
_, oshs_ = sap_db.report_db(server, host_osh, (systemOsh, ds_osh))
oshs.extend(oshs_)
else:
logger.warn("Failed to report %s. Hostname is not resolved" % server)
return oshs
def getIPsFromShell(hostname, shell=None, dnsServers=None):
if netutils.isValidIp(hostname):
return [hostname]
dnsServers = dnsServers or []
resolvers = []
names = hostname.split('.', 1)
if len(names) > 1:
dnsServers.extend(getNameServersFromShell(names[1], shell, None))
logger.debug("lookup %s using %s" % (hostname, dnsServers))
try:
resolvers.append(dns_resolver.SocketDnsResolver())
if shell and dnsServers:
for dns in dnsServers:
resolvers.append(dns_resolver.NsLookupDnsResolver(shell, dns))
dnsResolver = dns_resolver.FallbackResolver(resolvers)
ips = dnsResolver.resolve_ips(hostname)
logger.debug("DNS Lookup: %s: %s" % (hostname, ips))
return ips
except:
logger.warnException("Cannot get IPs for %s" % hostname)
return []
def resolveIpAddress(url):
ips = []
try:
match = re.findall("(https?)://([\w.]+):(\d+)/", url)
for parameters in match:
if len(parameters) >= 2:
protocol = parameters[0]
name = parameters[1]
logger.debug("resolveIpAddress-hostname:", name)
if not ip_addr.isValidIpAddress(name):
resolver = dns_resolver.SocketDnsResolver()
ips = resolver.resolve_ips(name)
else:
ips.append(IPAddress(name))
else:
msg = "wrong format of url:" + str(url)
logger.reportWarning(msg)
logger.error("wrong format of url:", url)
except:
msg = "Failed to resolve host name: " + str(url)
logger.reportWarning(msg)
logger.error(msg, str(sys.exc_info()[1]))
return ips
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)
