intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 128 insertions, 0 deletions

diff --git a/library/cpp/actors/dnsresolver/dnsresolver.h b/library/cpp/actors/dnsresolver/dnsresolver.h
new file mode 100644
index 0000000000..88fc74df7d
--- /dev/null
+++ b/library/cpp/actors/dnsresolver/dnsresolver.h
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <library/cpp/actors/core/actor.h>
+#include <library/cpp/actors/core/events.h>
+#include <library/cpp/actors/core/event_local.h>
+#include <library/cpp/monlib/dynamic_counters/counters.h>
+#include <util/network/address.h>
+#include <variant>
+
+namespace NActors {
+namespace NDnsResolver {
+
+    struct TEvDns {
+        enum EEv {
+            EvGetHostByName = EventSpaceBegin(TEvents::ES_DNS),
+            EvGetHostByNameResult,
+            EvGetAddr,
+            EvGetAddrResult,
+        };
+
+        /**
+         * TEvGetHostByName returns the result of ares_gethostbyname
+         */
+        struct TEvGetHostByName : public TEventLocal<TEvGetHostByName, EvGetHostByName> {
+            TString Name;
+            int Family;
+
+            explicit TEvGetHostByName(TString name, int family = AF_UNSPEC)
+                : Name(std::move(name))
+                , Family(family)
+            { }
+        };
+
+        struct TEvGetHostByNameResult : public TEventLocal<TEvGetHostByNameResult, EvGetHostByNameResult> {
+            TVector<struct in_addr> AddrsV4;
+            TVector<struct in6_addr> AddrsV6;
+            TString ErrorText;
+            int Status = 0;
+        };
+
+        /**
+         * TEvGetAddr returns a single address for a given hostname
+         */
+        struct TEvGetAddr : public TEventLocal<TEvGetAddr, EvGetAddr> {
+            TString Name;
+            int Family;
+
+            explicit TEvGetAddr(TString name, int family = AF_UNSPEC)
+                : Name(std::move(name))
+                , Family(family)
+            { }
+        };
+
+        struct TEvGetAddrResult : public TEventLocal<TEvGetAddrResult, EvGetAddrResult> {
+            // N.B. "using" here doesn't work with Visual Studio compiler
+            typedef struct in6_addr TIPv6Addr;
+            typedef struct in_addr TIPv4Addr;
+
+            std::variant<std::monostate, TIPv6Addr, TIPv4Addr> Addr;
+            TString ErrorText;
+            int Status = 0;
+
+            bool IsV6() const {
+                return std::holds_alternative<TIPv6Addr>(Addr);
+            }
+
+            bool IsV4() const {
+                return std::holds_alternative<TIPv4Addr>(Addr);
+            }
+
+            const TIPv6Addr& GetAddrV6() const {
+                const TIPv6Addr* p = std::get_if<TIPv6Addr>(&Addr);
+                Y_VERIFY(p, "Result is not an ipv6 address");
+                return *p;
+            }
+
+            const TIPv4Addr& GetAddrV4() const {
+                const TIPv4Addr* p = std::get_if<TIPv4Addr>(&Addr);
+                Y_VERIFY(p, "Result is not an ipv4 address");
+                return *p;
+            }
+        };
+    };
+
+    struct TSimpleDnsResolverOptions {
+        // Initial per-server timeout, grows exponentially with each retry
+        TDuration Timeout = TDuration::Seconds(1);
+        // Number of attempts per-server
+        int Attempts = 2;
+        // Optional list of custom dns servers (ip.v4[:port], ip::v6 or [ip::v6]:port format)
+        TVector<TString> Servers;
+    };
+
+    IActor* CreateSimpleDnsResolver(TSimpleDnsResolverOptions options = TSimpleDnsResolverOptions());
+
+    struct TCachingDnsResolverOptions {
+        // Soft expire time specifies delay before name is refreshed in background
+        TDuration SoftNegativeExpireTime = TDuration::Seconds(1);
+        TDuration SoftPositiveExpireTime = TDuration::Seconds(10);
+        // Hard expire time specifies delay before the last result is forgotten
+        TDuration HardNegativeExpireTime = TDuration::Seconds(10);
+        TDuration HardPositiveExpireTime = TDuration::Hours(2);
+        // Allow these request families
+        bool AllowIPv6 = true;
+        bool AllowIPv4 = true;
+        // Optional counters
+        NMonitoring::TDynamicCounterPtr MonCounters = nullptr;
+    };
+
+    IActor* CreateCachingDnsResolver(TActorId upstream, TCachingDnsResolverOptions options = TCachingDnsResolverOptions());
+
+    struct TOnDemandDnsResolverOptions
+        : public TSimpleDnsResolverOptions
+        , public TCachingDnsResolverOptions
+    {
+    };
+
+    IActor* CreateOnDemandDnsResolver(TOnDemandDnsResolverOptions options = TOnDemandDnsResolverOptions());
+
+    /**
+     * Returns actor id of a globally registered dns resolver
+     */
+    inline TActorId MakeDnsResolverActorId() {
+        return TActorId(0, TStringBuf("dnsresolver"));
+    }
+
+} // namespace NDnsResolver
+} // namespace NActors