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)