Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 72a646c2 authored by chenbruce's avatar chenbruce
Browse files

Rename definitions and funtions of stats. 

StatsRecords only include informations of dns servers. When adding the
information of Mdns statistics, we have to modifiy the names of server's
definitions and funtions to include mdns in stats files.

Bug: 140857615
Test: cd packages/modules/DnsResolver && atest
Change-Id: I38befe452d5d37b4172ee5dd16822083a08e4c88
parent b29545b9

DnsStats.cpp

+21 −21
Original line number Diff line number Diff line
@@ -59,10 +59,10 @@ std::string rcodeToName(int rcode) { 
    // clang-format on

}



bool ensureNoInvalidIp(const std::vector<IPSockAddr>& servers) {

    for (const auto& server : servers) {

        if (server.ip() == INVALID_IPADDRESS || server.port() == 0) {

            LOG(WARNING) << "Invalid server: " << server;

bool ensureNoInvalidIp(const std::vector<IPSockAddr>& addrs) {

    for (const auto& addr : addrs) {

        if (addr.ip() == INVALID_IPADDRESS || addr.port() == 0) {

            LOG(WARNING) << "Invalid addr: " << addr;

            return false;

        }

    }
@@ -73,8 +73,8 @@ bool ensureNoInvalidIp(const std::vector<IPSockAddr>& servers) { 


// The comparison ignores the last update time.

bool StatsData::operator==(const StatsData& o) const {

    return std::tie(serverSockAddr, total, rcodeCounts, latencyUs) ==

           std::tie(o.serverSockAddr, o.total, o.rcodeCounts, o.latencyUs);

    return std::tie(sockAddr, total, rcodeCounts, latencyUs) ==

           std::tie(o.sockAddr, o.total, o.rcodeCounts, o.latencyUs);

}



int StatsData::averageLatencyMs() const {
@@ -82,7 +82,7 @@ int StatsData::averageLatencyMs() const { 
}



std::string StatsData::toString() const {

    if (total == 0) return StringPrintf("%s <no data>", serverSockAddr.ip().toString().c_str());

    if (total == 0) return StringPrintf("%s <no data>", sockAddr.ip().toString().c_str());



    const auto now = std::chrono::steady_clock::now();

    const int lastUpdateSec = duration_cast<seconds>(now - lastUpdate).count();
@@ -92,7 +92,7 @@ std::string StatsData::toString() const { 
            buf += StringPrintf("%s:%d ", rcodeToName(rcode).c_str(), counts);

        }

    }

    return StringPrintf("%s (%d, %dms, [%s], %ds)", serverSockAddr.ip().toString().c_str(), total,

    return StringPrintf("%s (%d, %dms, [%s], %ds)", sockAddr.ip().toString().c_str(), total,

                        averageLatencyMs(), buf.c_str(), lastUpdateSec);

}
@@ -171,20 +171,20 @@ void StatsRecords::incrementSkippedCount() { 
    mSkippedCount = std::min(mSkippedCount + 1, kMaxQuality);

}



bool DnsStats::setServers(const std::vector<netdutils::IPSockAddr>& servers, Protocol protocol) {

    if (!ensureNoInvalidIp(servers)) return false;

bool DnsStats::setAddrs(const std::vector<netdutils::IPSockAddr>& addrs, Protocol protocol) {

    if (!ensureNoInvalidIp(addrs)) return false;



    ServerStatsMap& statsMap = mStats[protocol];

    for (const auto& server : servers) {

        statsMap.try_emplace(server, StatsRecords(server, kLogSize));

    StatsMap& statsMap = mStats[protocol];

    for (const auto& addr : addrs) {

        statsMap.try_emplace(addr, StatsRecords(addr, kLogSize));

    }



    // Clean up the map to eliminate the nodes not belonging to the given list of servers.

    const auto cleanup = [&](ServerStatsMap* statsMap) {

        ServerStatsMap tmp;

        for (const auto& server : servers) {

            if (statsMap->find(server) != statsMap->end()) {

                tmp.insert(statsMap->extract(server));

    const auto cleanup = [&](StatsMap* statsMap) {

        StatsMap tmp;

        for (const auto& addr : addrs) {

            if (statsMap->find(addr) != statsMap->end()) {

                tmp.insert(statsMap->extract(addr));

            }

        }

        statsMap->swap(tmp);
@@ -199,8 +199,8 @@ bool DnsStats::addStats(const IPSockAddr& ipSockAddr, const DnsQueryEvent& recor 
    if (ipSockAddr.ip() == INVALID_IPADDRESS) return false;



    bool added = false;

    for (auto& [serverSockAddr, statsRecords] : mStats[record.protocol()]) {

        if (serverSockAddr == ipSockAddr) {

    for (auto& [sockAddr, statsRecords] : mStats[record.protocol()]) {

        if (sockAddr == ipSockAddr) {

            const StatsRecords::Record rec = {

                    .rcode = record.rcode(),

                    .linux_errno = record.linux_errno(),
@@ -265,7 +265,7 @@ std::vector<StatsData> DnsStats::getStats(Protocol protocol) const { 
}



void DnsStats::dump(DumpWriter& dw) {

    const auto dumpStatsMap = [&](ServerStatsMap& statsMap) {

    const auto dumpStatsMap = [&](StatsMap& statsMap) {

        ScopedIndent indentLog(dw);

        if (statsMap.size() == 0) {

            dw.println("<no server>");

DnsStats.h

+7 −7
Original line number Diff line number Diff line
@@ -33,12 +33,12 @@ namespace android::net { 


// The overall information of a StatsRecords.

struct StatsData {

    StatsData(const netdutils::IPSockAddr& ipSockAddr) : serverSockAddr(ipSockAddr) {

    StatsData(const netdutils::IPSockAddr& ipSockAddr) : sockAddr(ipSockAddr) {

        lastUpdate = std::chrono::steady_clock::now();

    };



    // Server socket address.

    netdutils::IPSockAddr serverSockAddr;

    // Socket address.

    netdutils::IPSockAddr sockAddr;



    // The most recent number of records being accumulated.

    int total = 0;
@@ -110,11 +110,11 @@ class StatsRecords { 
// The class itself is not thread-safe.

class DnsStats {

  public:

    using ServerStatsMap = std::map<netdutils::IPSockAddr, StatsRecords>;

    using StatsMap = std::map<netdutils::IPSockAddr, StatsRecords>;



    // Add |servers| to the map, and remove no-longer-used servers.

    // Add |addrs| to the map, and remove no-longer-used addresses.

    // Return true if they are successfully added; otherwise, return false.

    bool setServers(const std::vector<netdutils::IPSockAddr>& servers, Protocol protocol);

    bool setAddrs(const std::vector<netdutils::IPSockAddr>& addrs, Protocol protocol);



    // Return true if |record| is successfully added into |server|'s stats; otherwise, return false.

    bool addStats(const netdutils::IPSockAddr& server, const DnsQueryEvent& record);
@@ -133,7 +133,7 @@ class DnsStats { 
    static constexpr size_t kLogSize = 128;



  private:

    std::map<Protocol, ServerStatsMap> mStats;

    std::map<Protocol, StatsMap> mStats;

};



}  // namespace android::net

DnsStatsTest.cpp

+28 −28
Original line number Diff line number Diff line
@@ -140,7 +140,7 @@ class DnsStatsTest : public ::testing::Test { 


            for (const auto& stats : statsData) {

                ASSERT_TRUE(std::regex_search(*dumpString, sm, pattern));

                EXPECT_EQ(sm[1], stats.serverSockAddr.ip().toString());

                EXPECT_EQ(sm[1], stats.sockAddr.ip().toString());

                EXPECT_FALSE(sm[2].str().empty());

                EXPECT_FALSE(sm[3].str().empty());

                *dumpString = sm.suffix();
@@ -169,7 +169,7 @@ class DnsStatsTest : public ::testing::Test { 
    DnsStats mDnsStats;

};



TEST_F(DnsStatsTest, SetServers) {

TEST_F(DnsStatsTest, SetAddrs) {

    // Check before any operation to mDnsStats.

    verifyDumpOutput({}, {}, {});
@@ -213,9 +213,9 @@ TEST_F(DnsStatsTest, SetServers) { 
            ipSockAddrs.push_back(IPSockAddr::toIPSockAddr(server, 53));

        }



        EXPECT_TRUE(mDnsStats.setServers(ipSockAddrs, PROTO_TCP) == isSuccess);

        EXPECT_TRUE(mDnsStats.setServers(ipSockAddrs, PROTO_UDP) == isSuccess);

        EXPECT_TRUE(mDnsStats.setServers(ipSockAddrs, PROTO_DOT) == isSuccess);

        EXPECT_TRUE(mDnsStats.setAddrs(ipSockAddrs, PROTO_TCP) == isSuccess);

        EXPECT_TRUE(mDnsStats.setAddrs(ipSockAddrs, PROTO_UDP) == isSuccess);

        EXPECT_TRUE(mDnsStats.setAddrs(ipSockAddrs, PROTO_DOT) == isSuccess);



        std::vector<StatsData> expectedStats;

        expectedStats.reserve(expectation.size());
@@ -240,18 +240,18 @@ TEST_F(DnsStatsTest, SetServersDifferentPorts) { 
    };



    // Servers setup fails due to port unset.

    EXPECT_FALSE(mDnsStats.setServers(servers, PROTO_TCP));

    EXPECT_FALSE(mDnsStats.setServers(servers, PROTO_UDP));

    EXPECT_FALSE(mDnsStats.setServers(servers, PROTO_DOT));

    EXPECT_FALSE(mDnsStats.setAddrs(servers, PROTO_TCP));

    EXPECT_FALSE(mDnsStats.setAddrs(servers, PROTO_UDP));

    EXPECT_FALSE(mDnsStats.setAddrs(servers, PROTO_DOT));



    EXPECT_NO_FAILURE(verifyDnsStatsContent(PROTO_TCP, {}, NO_AVERAGE_LATENCY));

    EXPECT_NO_FAILURE(verifyDnsStatsContent(PROTO_UDP, {}, NO_AVERAGE_LATENCY));

    EXPECT_NO_FAILURE(verifyDnsStatsContent(PROTO_DOT, {}, NO_AVERAGE_LATENCY));

    verifyDumpOutput({}, {}, {});



    EXPECT_TRUE(mDnsStats.setServers(std::vector(servers.begin() + 2, servers.end()), PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setServers(std::vector(servers.begin() + 2, servers.end()), PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setServers(std::vector(servers.begin() + 2, servers.end()), PROTO_DOT));

    EXPECT_TRUE(mDnsStats.setAddrs(std::vector(servers.begin() + 2, servers.end()), PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setAddrs(std::vector(servers.begin() + 2, servers.end()), PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs(std::vector(servers.begin() + 2, servers.end()), PROTO_DOT));



    const std::vector<StatsData> expectedStats = {

            makeStatsData(servers[2], 0, 0ms, {}), makeStatsData(servers[3], 0, 0ms, {}),
@@ -272,8 +272,8 @@ TEST_F(DnsStatsTest, AddStatsAndClear) { 
    };

    const DnsQueryEvent record = makeDnsQueryEvent(PROTO_UDP, NS_R_NO_ERROR, 10ms);



    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_UDP));



    // Fail to add stats because of incorrect arguments.

    EXPECT_FALSE(mDnsStats.addStats(IPSockAddr::toIPSockAddr("127.0.0.4", 53), record));
@@ -298,9 +298,9 @@ TEST_F(DnsStatsTest, AddStatsAndClear) { 
    verifyDumpOutput(expectedStatsForTcp, expectedStatsForUdp, {});



    // Clear stats.

    EXPECT_TRUE(mDnsStats.setServers({}, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setServers({}, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setServers({}, PROTO_DOT));

    EXPECT_TRUE(mDnsStats.setAddrs({}, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setAddrs({}, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs({}, PROTO_DOT));

    EXPECT_NO_FAILURE(verifyDnsStatsContent(PROTO_TCP, {}, NO_AVERAGE_LATENCY));

    EXPECT_NO_FAILURE(verifyDnsStatsContent(PROTO_UDP, {}, NO_AVERAGE_LATENCY));

    EXPECT_NO_FAILURE(verifyDnsStatsContent(PROTO_DOT, {}, NO_AVERAGE_LATENCY));
@@ -315,7 +315,7 @@ TEST_F(DnsStatsTest, StatsRemainsInExistentServer) { 
    const DnsQueryEvent recordNoError = makeDnsQueryEvent(PROTO_UDP, NS_R_NO_ERROR, 10ms);

    const DnsQueryEvent recordTimeout = makeDnsQueryEvent(PROTO_UDP, NS_R_TIMEOUT, 250ms);



    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_UDP));



    // Add a record to 127.0.0.1.

    EXPECT_TRUE(mDnsStats.addStats(servers[0], recordNoError));
@@ -340,7 +340,7 @@ TEST_F(DnsStatsTest, StatsRemainsInExistentServer) { 
            IPSockAddr::toIPSockAddr("127.0.0.3", 53),

            IPSockAddr::toIPSockAddr("127.0.0.4", 53),

    };

    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_UDP));

    expectedStats = {

            makeStatsData(servers[0], 4, 520ms, {{NS_R_NO_ERROR, 2}, {NS_R_TIMEOUT, 2}}),

            makeStatsData(servers[1], 0, 0ms, {}),
@@ -383,9 +383,9 @@ TEST_F(DnsStatsTest, AddStatsRecords_100000) { 
            NS_R_INTERNAL_ERROR,  // INTERNAL_ERROR

    };



    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setServers(servers, PROTO_DOT));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_TCP));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs(servers, PROTO_DOT));



    for (size_t i = 0; i < operations; i++) {

        const NsRcode rcode = static_cast<NsRcode>(rcodes[i % rcodeNum]);
@@ -430,8 +430,8 @@ TEST_F(DnsStatsTest, GetServers_SortingByLatency) { 
    EXPECT_THAT(mDnsStats.getSortedServers(PROTO_UDP), IsEmpty());



    // Before there's any stats, the list of the sorted servers is the same as the setup's one.

    EXPECT_TRUE(mDnsStats.setServers({server1, server2, server3, server4}, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setServers({server1, server2, server3, server4}, PROTO_DOT));

    EXPECT_TRUE(mDnsStats.setAddrs({server1, server2, server3, server4}, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs({server1, server2, server3, server4}, PROTO_DOT));

    EXPECT_THAT(mDnsStats.getSortedServers(PROTO_UDP),

                testing::ElementsAreArray({server1, server2, server3, server4}));
@@ -473,7 +473,7 @@ TEST_F(DnsStatsTest, GetServers_SortingByLatency) { 
                testing::ElementsAreArray({server2, server3, server1, server4}));



    // The list of the DNS servers changed.

    EXPECT_TRUE(mDnsStats.setServers({server2, server4}, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs({server2, server4}, PROTO_UDP));

    EXPECT_THAT(mDnsStats.getSortedServers(PROTO_UDP),

                testing::ElementsAreArray({server2, server4}));
@@ -490,7 +490,7 @@ TEST_F(DnsStatsTest, GetServers_DeprioritizingBadServers) { 
    const IPSockAddr server3 = IPSockAddr::toIPSockAddr("127.0.0.3", 53);

    const IPSockAddr server4 = IPSockAddr::toIPSockAddr("127.0.0.4", 53);



    EXPECT_TRUE(mDnsStats.setServers({server1, server2, server3, server4}, PROTO_UDP));

    EXPECT_TRUE(mDnsStats.setAddrs({server1, server2, server3, server4}, PROTO_UDP));



    int server1Counts = 0;

    int server2Counts = 0;
@@ -521,15 +521,15 @@ TEST_F(DnsStatsTest, GetServers_DeprioritizingBadServers) { 
    const std::vector<StatsData> allStatsData = mDnsStats.getStats(PROTO_UDP);

    for (const auto& data : allStatsData) {

        EXPECT_EQ(data.rcodeCounts.size(), 1U);

        if (data.serverSockAddr == server1 || data.serverSockAddr == server2) {

        if (data.sockAddr == server1 || data.sockAddr == server2) {

            const auto it = data.rcodeCounts.find(NS_R_NO_ERROR);

            ASSERT_NE(it, data.rcodeCounts.end());

            EXPECT_GT(server2Counts, 2 * server1Counts);  // At least twice larger.

        } else if (data.serverSockAddr == server3) {

        } else if (data.sockAddr == server3) {

            const auto it = data.rcodeCounts.find(NS_R_TIMEOUT);

            ASSERT_NE(it, data.rcodeCounts.end());

            EXPECT_LT(it->second, 10);

        } else if (data.serverSockAddr == server4) {

        } else if (data.sockAddr == server4) {

            const auto it = data.rcodeCounts.find(NS_R_INTERNAL_ERROR);

            ASSERT_NE(it, data.rcodeCounts.end());

            EXPECT_LT(it->second, 10);

res_cache.cpp

+3 −3
Original line number Diff line number Diff line
@@ -1649,8 +1649,8 @@ int resolv_set_nameservers(unsigned netid, const std::vector<std::string>& serve 
    netconfig->search_domains = filter_domains(domains);



    // Setup stats for cleartext dns servers.

    if (!netconfig->dnsStats.setServers(netconfig->nameserverSockAddrs, PROTO_TCP) ||

        !netconfig->dnsStats.setServers(netconfig->nameserverSockAddrs, PROTO_UDP)) {

    if (!netconfig->dnsStats.setAddrs(netconfig->nameserverSockAddrs, PROTO_TCP) ||

        !netconfig->dnsStats.setAddrs(netconfig->nameserverSockAddrs, PROTO_UDP)) {

        LOG(WARNING) << __func__ << ": netid = " << netid << ", failed to set dns stats";

        return -EINVAL;

    }
@@ -1910,7 +1910,7 @@ int resolv_stats_set_servers_for_dot(unsigned netid, const std::vector<std::stri 
        serverSockAddrs.push_back(IPSockAddr::toIPSockAddr(server, 853));

    }



    if (!info->dnsStats.setServers(serverSockAddrs, android::net::PROTO_DOT)) {

    if (!info->dnsStats.setAddrs(serverSockAddrs, android::net::PROTO_DOT)) {

        LOG(WARNING) << __func__ << ": netid = " << netid << ", failed to set dns stats";

        return -EINVAL;

    }