Better naming. [#CLICKHOUSE-3645]

dbms/src/Client/Connection.cpp

@@ -17,7 +17,7 @@
 #include <Common/Exception.h>
 #include <Common/NetException.h>
 #include <Common/CurrentMetrics.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Interpreters/ClientInfo.h>
 
 #include <Common/config.h>
@@ -68,7 +68,7 @@ void Connection::connect()
             socket = std::make_unique<Poco::Net::StreamSocket>();
         }
 
-        current_resolved_address = DNSCache::instance().resolveAddress(host, port);
+        current_resolved_address = DNSResolver::instance().resolveAddress(host, port);
 
         socket->connect(current_resolved_address, timeouts.connection_timeout);
         socket->setReceiveTimeout(timeouts.receive_timeout);
@@ -471,7 +471,7 @@ Poco::Net::SocketAddress Connection::getResolvedAddress() const
     if (connected)
         return current_resolved_address;
 
-    return DNSCache::instance().resolveAddress(host, port);
+    return DNSResolver::instance().resolveAddress(host, port);
 }
 
 

dbms/src/Common/DNSCache.cpp → dbms/src/Common/DNSResolver.cpp

-#include "DNSCache.h"
+#include "DNSResolver.h"
 #include <Common/SimpleCache.h>
 #include <Common/Exception.h>
 #include <Core/Types.h>
@@ -75,47 +75,47 @@ static Poco::Net::IPAddress resolveIPAddressImpl(const std::string & host)
 }
 
 
-struct DNSCache::Impl
+struct DNSResolver::Impl
 {
     SimpleCache<decltype(resolveIPAddressImpl), &resolveIPAddressImpl> cache_host;
 
     /// If disabled, will not make cache lookups, will resolve addresses manually on each call
-    std::atomic<bool> is_disabled{false};
+    std::atomic<bool> disable_cache{false};
 };
 
 
-DNSCache::DNSCache() : impl(std::make_unique<DNSCache::Impl>()) {}
+DNSResolver::DNSResolver() : impl(std::make_unique<DNSResolver::Impl>()) {}
 
-Poco::Net::IPAddress DNSCache::resolveHost(const std::string & host)
+Poco::Net::IPAddress DNSResolver::resolveHost(const std::string & host)
 {
-    return !impl->is_disabled ? impl->cache_host(host) : resolveIPAddressImpl(host);
+    return !impl->disable_cache ? impl->cache_host(host) : resolveIPAddressImpl(host);
 }
 
-Poco::Net::SocketAddress DNSCache::resolveAddress(const std::string & host_and_port)
+Poco::Net::SocketAddress DNSResolver::resolveAddress(const std::string & host_and_port)
 {
     String host;
     UInt16 port;
     splitHostAndPort(host_and_port, host, port);
 
-    return !impl->is_disabled ? Poco::Net::SocketAddress(impl->cache_host(host), port) : Poco::Net::SocketAddress(host_and_port);
+    return !impl->disable_cache ? Poco::Net::SocketAddress(impl->cache_host(host), port) : Poco::Net::SocketAddress(host_and_port);
 }
 
-Poco::Net::SocketAddress DNSCache::resolveAddress(const std::string & host, UInt16 port)
+Poco::Net::SocketAddress DNSResolver::resolveAddress(const std::string & host, UInt16 port)
 {
-    return !impl->is_disabled ?  Poco::Net::SocketAddress(impl->cache_host(host), port) : Poco::Net::SocketAddress(host, port);
+    return !impl->disable_cache ?  Poco::Net::SocketAddress(impl->cache_host(host), port) : Poco::Net::SocketAddress(host, port);
 }
 
-void DNSCache::drop()
+void DNSResolver::dropCache()
 {
     impl->cache_host.drop();
 }
 
-void DNSCache::setDisableFlag(bool is_disabled)
+void DNSResolver::setDisableCacheFlag(bool is_disabled)
 {
-    impl->is_disabled = is_disabled;
+    impl->disable_cache = is_disabled;
 }
 
-DNSCache::~DNSCache() = default;
+DNSResolver::~DNSResolver() = default;
 
 
 }

dbms/src/Common/DNSCache.h → dbms/src/Common/DNSResolver.h

@@ -9,13 +9,13 @@
 namespace DB
 {
 
-/// A singleton implementing global and permanent DNS cache
-/// It could be updated only manually via drop() method
-class DNSCache : public ext::singleton<DNSCache>
+/// A singleton implementing DNS names resolving with optional permanent DNS cache
+/// The cache could be updated only manually via drop() method
+class DNSResolver : public ext::singleton<DNSResolver>
 {
 public:
 
-    DNSCache(const DNSCache &) = delete;
+    DNSResolver(const DNSResolver &) = delete;
 
     /// Accepts host names like 'example.com' or '127.0.0.1' or '::1' and resolve its IP
     Poco::Net::IPAddress resolveHost(const std::string & host);
@@ -26,18 +26,18 @@ public:
     Poco::Net::SocketAddress resolveAddress(const std::string & host, UInt16 port);
 
     /// Disables caching
-    void setDisableFlag(bool is_disabled = true);
+    void setDisableCacheFlag(bool is_disabled = true);
 
     /// Drops all caches
-    void drop();
+    void dropCache();
 
-    ~DNSCache();
+    ~DNSResolver();
 
 protected:
 
-    DNSCache();
+    DNSResolver();
 
-    friend class ext::singleton<DNSCache>;
+    friend class ext::singleton<DNSResolver>;
 
     struct Impl;
     std::unique_ptr<Impl> impl;

dbms/src/IO/ReadWriteBufferFromHTTP.cpp

@@ -4,7 +4,7 @@
 #include <Common/config.h>
 #include <Core/Types.h>
 #include <IO/ReadBufferFromIStream.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Poco/Net/HTTPRequest.h>
 #include <Poco/Net/HTTPResponse.h>
 #include <Poco/Version.h>
@@ -43,7 +43,7 @@ ReadWriteBufferFromHTTP::ReadWriteBufferFromHTTP(const Poco::URI & uri,
                new Poco::Net::HTTPClientSession)
 }
 {
-    session->setHost(DNSCache::instance().resolveHost(uri.getHost()).toString());
+    session->setHost(DNSResolver::instance().resolveHost(uri.getHost()).toString());
     session->setPort(uri.getPort());
 
 #if POCO_CLICKHOUSE_PATCH || POCO_VERSION >= 0x02000000

dbms/src/Interpreters/Cluster.cpp

 #include <Interpreters/Cluster.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Common/escapeForFileName.h>
 #include <Common/isLocalAddress.h>
 #include <Common/SimpleCache.h>
@@ -47,7 +47,7 @@ inline bool isLocal(const Cluster::Address & address, const Poco::Net::SocketAdd
 
 Poco::Net::SocketAddress resolveSocketAddress(const String & host, UInt16 port)
 {
-    return Poco::Net::SocketAddress(DNSCache::instance().resolveHost(host), port);
+    return Poco::Net::SocketAddress(DNSResolver::instance().resolveHost(host), port);
 }
 
 }

dbms/src/Interpreters/Context.cpp

@@ -39,7 +39,7 @@
 #include <Interpreters/QueryLog.h>
 #include <Interpreters/PartLog.h>
 #include <Interpreters/Context.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <IO/ReadBufferFromFile.h>
 #include <IO/UncompressedCache.h>
 #include <Parsers/ASTCreateQuery.h>

dbms/src/Interpreters/DDLWorker.cpp

@@ -16,7 +16,7 @@
 
 #include <Interpreters/executeQuery.h>
 #include <Interpreters/Cluster.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Common/Macros.h>
 
 #include <Common/getFQDNOrHostName.h>
@@ -94,7 +94,7 @@ struct HostID
     {
         try
         {
-            return DB::isLocalAddress(DNSCache::instance().resolveAddress(host_name, port), clickhouse_port);
+            return DB::isLocalAddress(DNSResolver::instance().resolveAddress(host_name, port), clickhouse_port);
         }
         catch (const Poco::Net::NetException & e)
         {

dbms/src/Interpreters/DNSCacheUpdater.cpp

 #include "DNSCacheUpdater.h"
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Interpreters/Context.h>
 #include <Storages/MergeTree/BackgroundProcessingPool.h>
 #include <Common/ProfileEvents.h>
@@ -43,7 +43,7 @@ bool DNSCacheUpdater::run()
         {
             LOG_INFO(&Poco::Logger::get("DNSCacheUpdater"), "Updating DNS cache");
 
-            DNSCache::instance().drop();
+            DNSResolver::instance().dropCache();
             context.reloadClusterConfig();
 
             last_num_network_erros = num_current_network_exceptions;

dbms/src/Interpreters/InterpreterSystemQuery.cpp

 #include <Interpreters/InterpreterSystemQuery.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExternalDictionaries.h>
 #include <Interpreters/EmbeddedDictionaries.h>
@@ -78,7 +78,7 @@ BlockIO InterpreterSystemQuery::execute()
                 throwFromErrno("System call kill(0, SIGKILL) failed", ErrorCodes::CANNOT_KILL);
             break;
         case Type::DROP_DNS_CACHE:
-            DNSCache::instance().drop();
+            DNSResolver::instance().dropCache();
             /// Reinitialize clusters to update their resolved_addresses
             system_context.reloadClusterConfig();
             break;

dbms/src/Server/ClusterCopier.cpp

@@ -29,7 +29,7 @@
 #include <Common/typeid_cast.h>
 #include <Common/ClickHouseRevision.h>
 #include <Common/formatReadable.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Common/escapeForFileName.h>
 #include <Client/Connection.h>
 #include <Interpreters/Context.h>
@@ -612,7 +612,7 @@ static ShardPriority getReplicasPriority(const Cluster::Addresses & replicas, co
     res.is_remote = 1;
     for (auto & replica : replicas)
     {
-        if (isLocalAddress(DNSCache::instance().resolveHost(replica.host_name)))
+        if (isLocalAddress(DNSResolver::instance().resolveHost(replica.host_name)))
         {
             res.is_remote = 0;
             break;

dbms/src/Server/Server.cpp

@@ -11,7 +11,7 @@
 #include <common/ErrorHandlers.h>
 #include <common/getMemoryAmount.h>
 #include <Common/ClickHouseRevision.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/Macros.h>
 #include <Common/StringUtils/StringUtils.h>
@@ -330,7 +330,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
     if (config().has("disable_internal_dns_cache") && config().getInt("disable_internal_dns_cache"))
     {
         /// Disable DNS caching at all
-        DNSCache::instance().setDisableFlag();
+        DNSResolver::instance().setDisableCacheFlag();
     }
     else
     {

dbms/src/Storages/System/StorageSystemClusters.cpp

@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataStreams/OneBlockInputStream.h>
-#include <Common/DNSCache.h>
+#include <Common/DNSResolver.h>
 #include <Interpreters/Context.h>
 
 namespace DB
@@ -52,7 +52,7 @@ BlockInputStreams StorageSystemClusters::read(
         res_columns[i++]->insert(static_cast<UInt64>(shard_info.weight));
         res_columns[i++]->insert(static_cast<UInt64>(address.replica_num));
         res_columns[i++]->insert(address.host_name);
-        res_columns[i++]->insert(DNSCache::instance().resolveHost(address.host_name).toString());
+        res_columns[i++]->insert(DNSResolver::instance().resolveHost(address.host_name).toString());
         res_columns[i++]->insert(static_cast<UInt64>(address.port));
         res_columns[i++]->insert(static_cast<UInt64>(shard_info.isLocal()));
         res_columns[i++]->insert(address.user);