path: root/library/cpp/actors/dnsresolver/dnsresolver_caching.cpp

#include "dnsresolver.h" 
 
#include <library/cpp/actors/core/hfunc.h> 
#include <util/generic/intrlist.h> 
 
#include <ares.h> 
 
#include <queue> 
 
namespace NActors { 
namespace NDnsResolver { 
 
    class TCachingDnsResolver : public TActor<TCachingDnsResolver> { 
    public: 
        struct TMonCounters { 
            NMonitoring::TDynamicCounters::TCounterPtr OutgoingInFlightV4; 
            NMonitoring::TDynamicCounters::TCounterPtr OutgoingInFlightV6; 
            NMonitoring::TDynamicCounters::TCounterPtr OutgoingErrorsV4; 
            NMonitoring::TDynamicCounters::TCounterPtr OutgoingErrorsV6; 
            NMonitoring::TDynamicCounters::TCounterPtr OutgoingTotalV4; 
            NMonitoring::TDynamicCounters::TCounterPtr OutgoingTotalV6; 
 
            NMonitoring::TDynamicCounters::TCounterPtr IncomingInFlight; 
            NMonitoring::TDynamicCounters::TCounterPtr IncomingErrors; 
            NMonitoring::TDynamicCounters::TCounterPtr IncomingTotal; 
 
            NMonitoring::TDynamicCounters::TCounterPtr CacheSize; 
            NMonitoring::TDynamicCounters::TCounterPtr CacheHits; 
            NMonitoring::TDynamicCounters::TCounterPtr CacheMisses; 
 
            TMonCounters(const NMonitoring::TDynamicCounterPtr& counters) 
                : OutgoingInFlightV4(counters->GetCounter("DnsResolver/Outgoing/InFlight/V4", false)) 
                , OutgoingInFlightV6(counters->GetCounter("DnsResolver/Outgoing/InFlight/V6", false)) 
                , OutgoingErrorsV4(counters->GetCounter("DnsResolver/Outgoing/Errors/V4", true)) 
                , OutgoingErrorsV6(counters->GetCounter("DnsResolver/Outgoing/Errors/V6", true)) 
                , OutgoingTotalV4(counters->GetCounter("DnsResolver/Outgoing/Total/V4", true)) 
                , OutgoingTotalV6(counters->GetCounter("DnsResolver/Outgoing/Total/V6", true)) 
                , IncomingInFlight(counters->GetCounter("DnsResolver/Incoming/InFlight", false)) 
                , IncomingErrors(counters->GetCounter("DnsResolver/Incoming/Errors", true)) 
                , IncomingTotal(counters->GetCounter("DnsResolver/Incoming/Total", true)) 
                , CacheSize(counters->GetCounter("DnsResolver/Cache/Size", false)) 
                , CacheHits(counters->GetCounter("DnsResolver/Cache/Hits", true)) 
                , CacheMisses(counters->GetCounter("DnsResolver/Cache/Misses", true)) 
            { } 
        }; 
 
    public: 
        TCachingDnsResolver(TActorId upstream, TCachingDnsResolverOptions options) 
            : TActor(&TThis::StateWork) 
            , Upstream(upstream) 
            , Options(std::move(options)) 
            , MonCounters(Options.MonCounters ? new TMonCounters(Options.MonCounters) : nullptr) 
        { } 
 
        static constexpr EActivityType ActorActivityType() { 
            return DNS_RESOLVER; 
        } 
 
    private: 
        STRICT_STFUNC(StateWork, { 
            hFunc(TEvents::TEvPoison, Handle); 
            hFunc(TEvDns::TEvGetHostByName, Handle); 
            hFunc(TEvDns::TEvGetAddr, Handle); 
            hFunc(TEvDns::TEvGetHostByNameResult, Handle); 
            hFunc(TEvents::TEvUndelivered, Handle); 
        }); 
 
        void Handle(TEvents::TEvPoison::TPtr&) { 
            DropPending(ARES_ECANCELLED); 
            PassAway(); 
        } 
 
        void Handle(TEvDns::TEvGetHostByName::TPtr& ev) { 
            auto req = MakeHolder<TIncomingRequest>(); 
            req->Type = EIncomingRequestType::GetHostByName; 
            req->Sender = ev->Sender; 
            req->Cookie = ev->Cookie; 
            req->Name = std::move(ev->Get()->Name); 
            req->Family = ev->Get()->Family; 
            EnqueueRequest(std::move(req)); 
        } 
 
        void Handle(TEvDns::TEvGetAddr::TPtr& ev) { 
            auto req = MakeHolder<TIncomingRequest>(); 
            req->Type = EIncomingRequestType::GetAddr; 
            req->Sender = ev->Sender; 
            req->Cookie = ev->Cookie; 
            req->Name = std::move(ev->Get()->Name); 
            req->Family = ev->Get()->Family; 
            EnqueueRequest(std::move(req)); 
        } 
 
        void Handle(TEvDns::TEvGetHostByNameResult::TPtr& ev) { 
            auto waitingIt = WaitingRequests.find(ev->Cookie); 
            Y_VERIFY(waitingIt != WaitingRequests.end(), "Unexpected reply, reqId=%" PRIu64, ev->Cookie); 
            auto waitingInfo = waitingIt->second; 
            WaitingRequests.erase(waitingIt); 
 
            switch (waitingInfo.Family) { 
                case AF_INET6: 
                    if (ev->Get()->Status) { 
                        ProcessErrorV6(waitingInfo.Position, ev->Get()->Status, std::move(ev->Get()->ErrorText)); 
                    } else { 
                        ProcessAddrsV6(waitingInfo.Position, std::move(ev->Get()->AddrsV6)); 
                    } 
                    break; 
 
                case AF_INET: 
                    if (ev->Get()->Status) { 
                        ProcessErrorV4(waitingInfo.Position, ev->Get()->Status, std::move(ev->Get()->ErrorText)); 
                    } else { 
                        ProcessAddrsV4(waitingInfo.Position, std::move(ev->Get()->AddrsV4)); 
                    } 
                    break; 
 
                default: 
                    Y_FAIL("Unexpected request family %d", waitingInfo.Family); 
            } 
        } 
 
        void Handle(TEvents::TEvUndelivered::TPtr& ev) { 
            switch (ev->Get()->SourceType) { 
                case TEvDns::TEvGetHostByName::EventType: { 
                    auto waitingIt = WaitingRequests.find(ev->Cookie); 
                    Y_VERIFY(waitingIt != WaitingRequests.end(), "Unexpected TEvUndelivered, reqId=%" PRIu64, ev->Cookie); 
                    auto waitingInfo = waitingIt->second; 
                    WaitingRequests.erase(waitingIt); 
 
                    switch (waitingInfo.Family) { 
                        case AF_INET6: 
                            ProcessErrorV6(waitingInfo.Position, ARES_ENOTINITIALIZED, "Caching dns resolver cannot deliver to the underlying resolver"); 
                            break; 
                        case AF_INET: 
                            ProcessErrorV4(waitingInfo.Position, ARES_ENOTINITIALIZED, "Caching dns resolver cannot deliver to the underlying resolver"); 
                            break; 
                        default: 
                            Y_FAIL("Unexpected request family %d", waitingInfo.Family); 
                    } 
 
                    break; 
                } 
 
                default: 
                    Y_FAIL("Unexpected TEvUndelievered, type=%" PRIu32, ev->Get()->SourceType); 
            } 
        } 
 
    private: 
        enum EIncomingRequestType { 
            GetHostByName, 
            GetAddr, 
        }; 
 
        struct TIncomingRequest : public TIntrusiveListItem<TIncomingRequest> { 
            EIncomingRequestType Type; 
            TActorId Sender; 
            ui64 Cookie; 
            TString Name; 
            int Family; 
        }; 
 
        using TIncomingRequestList = TIntrusiveListWithAutoDelete<TIncomingRequest, TDelete>; 
 
        void EnqueueRequest(THolder<TIncomingRequest> req) { 
            if (MonCounters) { 
                ++*MonCounters->IncomingTotal; 
            } 
 
            CleanupExpired(TActivationContext::Now()); 
 
            switch (req->Family) { 
                case AF_UNSPEC: 
                    if (Options.AllowIPv6) { 
                        EnqueueRequestIPv6(std::move(req)); 
                        return; 
                    } 
                    if (Options.AllowIPv4) { 
                        EnqueueRequestIPv4(std::move(req)); 
                        return; 
                    } 
                    break; 
 
                case AF_INET6: 
                    if (Options.AllowIPv6) { 
                        EnqueueRequestIPv6(std::move(req)); 
                        return; 
                    } 
                    break; 
 
                case AF_INET: 
                    if (Options.AllowIPv4) { 
                        EnqueueRequestIPv4(std::move(req)); 
                        return; 
                    } 
                    break; 
            } 
 
            ReplyWithError(std::move(req), ARES_EBADFAMILY); 
        } 
 
        void EnqueueRequestIPv6(THolder<TIncomingRequest> req) { 
            auto now = TActivationContext::Now(); 
 
            auto& fullState = NameToState[req->Name]; 
            if (MonCounters) { 
                *MonCounters->CacheSize = NameToState.size(); 
            } 
 
            auto& state = fullState.StateIPv6; 
            EnsureRequest(state, req->Name, AF_INET6, now); 
 
            if (state.IsHardExpired(now)) { 
                Y_VERIFY(state.Waiting); 
                if (MonCounters) { 
                    ++*MonCounters->CacheMisses; 
                } 
                // We need to wait for ipv6 reply, schedule ipv4 request in parallel if needed 
                if (Options.AllowIPv4) { 
                    EnsureRequest(fullState.StateIPv4, req->Name, AF_INET, now); 
                } 
                state.WaitingRequests.PushBack(req.Release()); 
                return; 
            } 
 
            // We want to retry AF_UNSPEC with IPv4 in some cases 
            if (req->Family == AF_UNSPEC && Options.AllowIPv4 && state.RetryUnspec()) { 
                EnqueueRequestIPv4(std::move(req)); 
                return; 
            } 
 
            if (MonCounters) { 
                ++*MonCounters->CacheHits; 
            } 
 
            if (state.Status != 0) { 
                ReplyWithError(std::move(req), state.Status, state.ErrorText); 
            } else { 
                ReplyWithAddrs(std::move(req), fullState.AddrsIPv6); 
            } 
        } 
 
        void EnqueueRequestIPv4(THolder<TIncomingRequest> req, bool isCacheMiss = false) { 
            auto now = TActivationContext::Now(); 
 
            auto& fullState = NameToState[req->Name]; 
            if (MonCounters) { 
                *MonCounters->CacheSize = NameToState.size(); 
            } 
 
            auto& state = fullState.StateIPv4; 
            EnsureRequest(state, req->Name, AF_INET, now); 
 
            if (state.IsHardExpired(now)) { 
                Y_VERIFY(state.Waiting); 
                if (MonCounters && !isCacheMiss) { 
                    ++*MonCounters->CacheMisses; 
                } 
                state.WaitingRequests.PushBack(req.Release()); 
                return; 
            } 
 
            if (MonCounters && !isCacheMiss) { 
                ++*MonCounters->CacheHits; 
            } 
 
            if (state.Status != 0) { 
                ReplyWithError(std::move(req), state.Status, state.ErrorText); 
            } else { 
                ReplyWithAddrs(std::move(req), fullState.AddrsIPv4); 
            } 
        } 
 
    private: 
        struct TFamilyState { 
            TIncomingRequestList WaitingRequests; 
            TInstant SoftDeadline; 
            TInstant HardDeadline; 
            TInstant NextSoftDeadline; 
            TInstant NextHardDeadline; 
            TString ErrorText; 
            int Status = -1; // never requested before 
            bool InSoftHeap = false; 
            bool InHardHeap = false; 
            bool Waiting = false; 
 
            bool Needed() const { 
                return InSoftHeap || InHardHeap || Waiting; 
            } 
 
            bool RetryUnspec() const { 
                return ( 
                    Status == ARES_ENODATA || 
                    Status == ARES_EBADRESP || 
                    Status == ARES_ETIMEOUT); 
            } 
 
            bool ServerReplied() const { 
                return ServerReplied(Status); 
            } 
 
            bool IsSoftExpired(TInstant now) const { 
                return !InSoftHeap || NextSoftDeadline < now; 
            } 
 
            bool IsHardExpired(TInstant now) const { 
                return !InHardHeap || NextHardDeadline < now; 
            } 
 
            static bool ServerReplied(int status) { 
                return ( 
                    status == ARES_SUCCESS || 
                    status == ARES_ENODATA || 
                    status == ARES_ENOTFOUND); 
            } 
        }; 
 
        struct TState { 
            TFamilyState StateIPv6; 
            TFamilyState StateIPv4; 
            TVector<struct in6_addr> AddrsIPv6; 
            TVector<struct in_addr> AddrsIPv4; 
 
            bool Needed() const { 
                return StateIPv6.Needed() || StateIPv4.Needed(); 
            } 
        }; 
 
        using TNameToState = THashMap<TString, TState>; 
 
        template<const TFamilyState TState::* StateToFamily, 
                 const TInstant TFamilyState::* FamilyToDeadline> 
        struct THeapCompare { 
            // returns true when b < a 
            bool operator()(TNameToState::iterator a, TNameToState::iterator b) const { 
                const TState& aState = a->second; 
                const TState& bState = b->second; 
                const TFamilyState& aFamily = aState.*StateToFamily; 
                const TFamilyState& bFamily = bState.*StateToFamily; 
                const TInstant& aDeadline = aFamily.*FamilyToDeadline; 
                const TInstant& bDeadline = bFamily.*FamilyToDeadline; 
                return bDeadline < aDeadline; 
            } 
        }; 
 
        template<const TFamilyState TState::* StateToFamily, 
                 const TInstant TFamilyState::* FamilyToDeadline> 
        using TStateHeap = std::priority_queue< 
                TNameToState::iterator, 
                std::vector<TNameToState::iterator>, 
                THeapCompare<StateToFamily, FamilyToDeadline> 
        >; 
 
        struct TWaitingInfo { 
            TNameToState::iterator Position; 
            int Family; 
        }; 
 
    private: 
        void EnsureRequest(TFamilyState& state, const TString& name, int family, TInstant now) { 
            if (state.Waiting) { 
                return; // request is already pending 
            } 
 
            if (!state.IsSoftExpired(now) && !state.IsHardExpired(now)) { 
                return; // response is not expired yet 
            } 
 
            if (MonCounters) { 
                switch (family) { 
                    case AF_INET6: 
                        ++*MonCounters->OutgoingInFlightV6; 
                        ++*MonCounters->OutgoingTotalV6; 
                        break; 
                    case AF_INET: 
                        ++*MonCounters->OutgoingInFlightV4; 
                        ++*MonCounters->OutgoingTotalV4; 
                        break; 
                } 
            } 
 
            ui64 reqId = ++LastRequestId; 
            auto& req = WaitingRequests[reqId]; 
            req.Position = NameToState.find(name); 
            req.Family = family; 
            Y_VERIFY(req.Position != NameToState.end()); 
 
            Send(Upstream, new TEvDns::TEvGetHostByName(name, family), IEventHandle::FlagTrackDelivery, reqId); 
            state.Waiting = true; 
        } 
 
        template<TFamilyState TState::* StateToFamily, 
                 TInstant TFamilyState::* FamilyToDeadline, 
                 TInstant TFamilyState::* FamilyToNextDeadline, 
                 bool TFamilyState::* FamilyToFlag, 
                 class THeap> 
        void PushToHeap(THeap& heap, TNameToState::iterator it, TInstant newDeadline) { 
            auto& family = it->second.*StateToFamily; 
            TInstant& deadline = family.*FamilyToDeadline; 
            TInstant& nextDeadline = family.*FamilyToNextDeadline; 
            bool& flag = family.*FamilyToFlag; 
            nextDeadline = newDeadline; 
            if (!flag) { 
                deadline = newDeadline; 
                heap.push(it); 
                flag = true; 
            } 
        } 
 
        void PushSoftV6(TNameToState::iterator it, TInstant newDeadline) { 
            PushToHeap<&TState::StateIPv6, &TFamilyState::SoftDeadline, &TFamilyState::NextSoftDeadline, &TFamilyState::InSoftHeap>(SoftHeapIPv6, it, newDeadline); 
        } 
 
        void PushHardV6(TNameToState::iterator it, TInstant newDeadline) { 
            PushToHeap<&TState::StateIPv6, &TFamilyState::HardDeadline, &TFamilyState::NextHardDeadline, &TFamilyState::InHardHeap>(HardHeapIPv6, it, newDeadline); 
        } 
 
        void PushSoftV4(TNameToState::iterator it, TInstant newDeadline) { 
            PushToHeap<&TState::StateIPv4, &TFamilyState::SoftDeadline, &TFamilyState::NextSoftDeadline, &TFamilyState::InSoftHeap>(SoftHeapIPv4, it, newDeadline); 
        } 
 
        void PushHardV4(TNameToState::iterator it, TInstant newDeadline) { 
            PushToHeap<&TState::StateIPv4, &TFamilyState::HardDeadline, &TFamilyState::NextHardDeadline, &TFamilyState::InHardHeap>(HardHeapIPv4, it, newDeadline); 
        } 
 
        void ProcessErrorV6(TNameToState::iterator it, int status, TString errorText) { 
            auto now = TActivationContext::Now(); 
            if (MonCounters) { 
                --*MonCounters->OutgoingInFlightV6; 
                ++*MonCounters->OutgoingErrorsV6; 
            } 
 
            auto& state = it->second.StateIPv6; 
            Y_VERIFY(state.Waiting, "Got error for a state we are not waiting"); 
            state.Waiting = false; 
 
            // When we have a cached positive reply, don't overwrite it with spurious errors 
            const bool serverReplied = TFamilyState::ServerReplied(status); 
            if (!serverReplied && state.ServerReplied() && !state.IsHardExpired(now)) { 
                PushSoftV6(it, now + Options.SoftNegativeExpireTime); 
                if (state.Status == ARES_SUCCESS) { 
                    SendAddrsV6(it); 
                } else { 
                    SendErrorsV6(it, now); 
                } 
                return; 
            } 
 
            state.Status = status; 
            state.ErrorText = std::move(errorText); 
            PushSoftV6(it, now + Options.SoftNegativeExpireTime); 
            if (serverReplied) { 
                // Server actually replied, so keep it cached for longer 
                PushHardV6(it, now + Options.HardPositiveExpireTime); 
            } else { 
                PushHardV6(it, now + Options.HardNegativeExpireTime); 
            } 
 
            SendErrorsV6(it, now); 
        } 
 
        void SendErrorsV6(TNameToState::iterator it, TInstant now) { 
            bool cleaned = false; 
            auto& state = it->second.StateIPv6; 
            while (state.WaitingRequests) { 
                THolder<TIncomingRequest> req(state.WaitingRequests.PopFront()); 
                if (req->Family == AF_UNSPEC && Options.AllowIPv4 && state.RetryUnspec()) { 
                    if (!cleaned) { 
                        CleanupExpired(now); 
                        cleaned = true; 
                    } 
                    EnqueueRequestIPv4(std::move(req), /* isCacheMiss */ true); 
                } else { 
                    ReplyWithError(std::move(req), state.Status, state.ErrorText); 
                } 
            } 
        } 
 
        void ProcessErrorV4(TNameToState::iterator it, int status, TString errorText) { 
            auto now = TActivationContext::Now(); 
            if (MonCounters) { 
                --*MonCounters->OutgoingInFlightV4; 
                ++*MonCounters->OutgoingErrorsV4; 
            } 
 
            auto& state = it->second.StateIPv4; 
            Y_VERIFY(state.Waiting, "Got error for a state we are not waiting"); 
            state.Waiting = false; 
 
            // When we have a cached positive reply, don't overwrite it with spurious errors 
            const bool serverReplied = TFamilyState::ServerReplied(status); 
            if (!serverReplied && state.ServerReplied() && !state.IsHardExpired(now)) { 
                PushSoftV4(it, now + Options.SoftNegativeExpireTime); 
                if (state.Status == ARES_SUCCESS) { 
                    SendAddrsV4(it); 
                } else { 
                    SendErrorsV4(it); 
                } 
                return; 
            } 
 
            state.Status = status; 
            state.ErrorText = std::move(errorText); 
            PushSoftV4(it, now + Options.SoftNegativeExpireTime); 
            if (serverReplied) { 
                // Server actually replied, so keep it cached for longer 
                PushHardV4(it, now + Options.HardPositiveExpireTime); 
            } else { 
                PushHardV4(it, now + Options.HardNegativeExpireTime); 
            } 
 
            SendErrorsV4(it); 
        } 
 
        void SendErrorsV4(TNameToState::iterator it) { 
            auto& state = it->second.StateIPv4; 
            while (state.WaitingRequests) { 
                THolder<TIncomingRequest> req(state.WaitingRequests.PopFront()); 
                ReplyWithError(std::move(req), state.Status, state.ErrorText); 
            } 
        } 
 
        void ProcessAddrsV6(TNameToState::iterator it, TVector<struct in6_addr> addrs) { 
            if (Y_UNLIKELY(addrs.empty())) { 
                // Probably unnecessary: we don't want to deal with empty address lists 
                return ProcessErrorV6(it, ARES_ENODATA, ares_strerror(ARES_ENODATA)); 
            } 
 
            auto now = TActivationContext::Now(); 
            if (MonCounters) { 
                --*MonCounters->OutgoingInFlightV6; 
            } 
 
            auto& state = it->second.StateIPv6; 
            Y_VERIFY(state.Waiting, "Got reply for a state we are not waiting"); 
            state.Waiting = false; 
 
            state.Status = ARES_SUCCESS; 
            it->second.AddrsIPv6 = std::move(addrs); 
            PushSoftV6(it, now + Options.SoftPositiveExpireTime); 
            PushHardV6(it, now + Options.HardPositiveExpireTime); 
 
            SendAddrsV6(it); 
        } 
 
        void SendAddrsV6(TNameToState::iterator it) { 
            auto& state = it->second.StateIPv6; 
            while (state.WaitingRequests) { 
                THolder<TIncomingRequest> req(state.WaitingRequests.PopFront()); 
                ReplyWithAddrs(std::move(req), it->second.AddrsIPv6); 
            } 
        } 
 
        void ProcessAddrsV4(TNameToState::iterator it, TVector<struct in_addr> addrs) { 
            if (Y_UNLIKELY(addrs.empty())) { 
                // Probably unnecessary: we don't want to deal with empty address lists 
                return ProcessErrorV4(it, ARES_ENODATA, ares_strerror(ARES_ENODATA)); 
            } 
 
            auto now = TActivationContext::Now(); 
            if (MonCounters) { 
                --*MonCounters->OutgoingInFlightV4; 
            } 
 
            auto& state = it->second.StateIPv4; 
            Y_VERIFY(state.Waiting, "Got reply for a state we are not waiting"); 
            state.Waiting = false; 
 
            state.Status = ARES_SUCCESS; 
            it->second.AddrsIPv4 = std::move(addrs); 
            PushSoftV4(it, now + Options.SoftPositiveExpireTime); 
            PushHardV4(it, now + Options.HardPositiveExpireTime); 
 
            SendAddrsV4(it); 
        } 
 
        void SendAddrsV4(TNameToState::iterator it) { 
            auto& state = it->second.StateIPv4; 
            while (state.WaitingRequests) { 
                THolder<TIncomingRequest> req(state.WaitingRequests.PopFront()); 
                ReplyWithAddrs(std::move(req), it->second.AddrsIPv4); 
            } 
        } 
 
    private: 
        template<TFamilyState TState::*StateToFamily, 
                 TInstant TFamilyState::* FamilyToDeadline, 
                 TInstant TFamilyState::* FamilyToNextDeadline, 
                 bool TFamilyState::* FamilyToFlag> 
        void DoCleanupExpired(TStateHeap<StateToFamily, FamilyToDeadline>& heap, TInstant now) { 
            while (!heap.empty()) { 
                auto it = heap.top(); 
                auto& family = it->second.*StateToFamily; 
                TInstant& deadline = family.*FamilyToDeadline; 
                if (now <= deadline) { 
                    break; 
                } 
 
                bool& flag = family.*FamilyToFlag; 
                Y_VERIFY(flag); 
                heap.pop(); 
                flag = false; 
 
                TInstant& nextDeadline = family.*FamilyToNextDeadline; 
                if (now < nextDeadline) { 
                    deadline = nextDeadline; 
                    heap.push(it); 
                    flag = true; 
                    continue; 
                } 
 
                // Remove unnecessary items 
                if (!it->second.Needed()) { 
                    NameToState.erase(it); 
                    if (MonCounters) { 
                        *MonCounters->CacheSize = NameToState.size(); 
                    } 
                } 
            } 
        } 
 
        void CleanupExpired(TInstant now) { 
            DoCleanupExpired<&TState::StateIPv6, &TFamilyState::SoftDeadline, &TFamilyState::NextSoftDeadline, &TFamilyState::InSoftHeap>(SoftHeapIPv6, now); 
            DoCleanupExpired<&TState::StateIPv6, &TFamilyState::HardDeadline, &TFamilyState::NextHardDeadline, &TFamilyState::InHardHeap>(HardHeapIPv6, now); 
            DoCleanupExpired<&TState::StateIPv4, &TFamilyState::SoftDeadline, &TFamilyState::NextSoftDeadline, &TFamilyState::InSoftHeap>(SoftHeapIPv4, now); 
            DoCleanupExpired<&TState::StateIPv4, &TFamilyState::HardDeadline, &TFamilyState::NextHardDeadline, &TFamilyState::InHardHeap>(HardHeapIPv4, now); 
        } 
 
        template<class TEvent> 
        void SendError(TActorId replyTo, ui64 cookie, int status, const TString& errorText) { 
            auto reply = MakeHolder<TEvent>(); 
            reply->Status = status; 
            reply->ErrorText = errorText; 
            this->Send(replyTo, reply.Release(), 0, cookie); 
        } 
 
        void ReplyWithError(THolder<TIncomingRequest> req, int status, const TString& errorText) { 
            if (MonCounters) { 
                ++*MonCounters->IncomingErrors; 
            } 
            switch (req->Type) { 
                case EIncomingRequestType::GetHostByName: { 
                    SendError<TEvDns::TEvGetHostByNameResult>(req->Sender, req->Cookie, status, errorText); 
                    break; 
                } 
                case EIncomingRequestType::GetAddr: { 
                    SendError<TEvDns::TEvGetAddrResult>(req->Sender, req->Cookie, status, errorText); 
                    break; 
                } 
            } 
        } 
 
        void ReplyWithAddrs(THolder<TIncomingRequest> req, const TVector<struct in6_addr>& addrs) { 
            switch (req->Type) { 
                case EIncomingRequestType::GetHostByName: { 
                    auto reply = MakeHolder<TEvDns::TEvGetHostByNameResult>(); 
                    reply->AddrsV6 = addrs; 
                    Send(req->Sender, reply.Release(), 0, req->Cookie); 
                    break; 
                } 
                case EIncomingRequestType::GetAddr: { 
                    Y_VERIFY(!addrs.empty()); 
                    auto reply = MakeHolder<TEvDns::TEvGetAddrResult>(); 
                    reply->Addr = addrs.front(); 
                    Send(req->Sender, reply.Release(), 0, req->Cookie); 
                    break; 
                } 
            } 
        } 
 
        void ReplyWithAddrs(THolder<TIncomingRequest> req, const TVector<struct in_addr>& addrs) { 
            switch (req->Type) { 
                case EIncomingRequestType::GetHostByName: { 
                    auto reply = MakeHolder<TEvDns::TEvGetHostByNameResult>(); 
                    reply->AddrsV4 = addrs; 
                    Send(req->Sender, reply.Release(), 0, req->Cookie); 
                    break; 
                } 
                case EIncomingRequestType::GetAddr: { 
                    Y_VERIFY(!addrs.empty()); 
                    auto reply = MakeHolder<TEvDns::TEvGetAddrResult>(); 
                    reply->Addr = addrs.front(); 
                    Send(req->Sender, reply.Release(), 0, req->Cookie); 
                    break; 
                } 
            } 
        } 
 
        void ReplyWithError(THolder<TIncomingRequest> req, int status) { 
            ReplyWithError(std::move(req), status, ares_strerror(status)); 
        } 
 
        void DropPending(TIncomingRequestList& list, int status, const TString& errorText) { 
            while (list) { 
                THolder<TIncomingRequest> req(list.PopFront()); 
                ReplyWithError(std::move(req), status, errorText); 
            } 
        } 
 
        void DropPending(int status, const TString& errorText) { 
            for (auto& [name, state] : NameToState) { 
                DropPending(state.StateIPv6.WaitingRequests, status, errorText); 
                DropPending(state.StateIPv4.WaitingRequests, status, errorText); 
            } 
        } 
 
        void DropPending(int status) { 
            DropPending(status, ares_strerror(status)); 
        } 
 
    private: 
        const TActorId Upstream; 
        const TCachingDnsResolverOptions Options; 
        const THolder<TMonCounters> MonCounters; 
 
        TNameToState NameToState; 
        TStateHeap<&TState::StateIPv6, &TFamilyState::SoftDeadline> SoftHeapIPv6; 
        TStateHeap<&TState::StateIPv6, &TFamilyState::HardDeadline> HardHeapIPv6; 
        TStateHeap<&TState::StateIPv4, &TFamilyState::SoftDeadline> SoftHeapIPv4; 
        TStateHeap<&TState::StateIPv4, &TFamilyState::HardDeadline> HardHeapIPv4; 
 
        THashMap<ui64, TWaitingInfo> WaitingRequests; 
        ui64 LastRequestId = 0; 
    }; 
 
    IActor* CreateCachingDnsResolver(TActorId upstream, TCachingDnsResolverOptions options) { 
        return new TCachingDnsResolver(upstream, std::move(options)); 
    } 
 
} // namespace NDnsResolver 
} // namespace NActors