Coverage Report

Created: 2026-01-27 18:45

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/root/doris/be/src/util/dns_cache.cpp
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#include "util/dns_cache.h"
19
20
#include "service/backend_options.h"
21
#include "util/network_util.h"
22
23
namespace doris {
24
25
0
DNSCache::DNSCache() {
26
0
    refresh_thread = std::thread(&DNSCache::_refresh_cache, this);
27
0
}
28
29
0
DNSCache::~DNSCache() {
30
0
    stop_refresh = true;
31
0
    if (refresh_thread.joinable()) {
32
0
        refresh_thread.join();
33
0
    }
34
0
}
35
36
0
Status DNSCache::get(const std::string& hostname, std::string* ip) {
37
0
    {
38
0
        std::shared_lock<std::shared_mutex> lock(mutex);
39
0
        auto it = cache.find(hostname);
40
0
        if (it != cache.end()) {
41
0
            *ip = it->second;
42
0
            return Status::OK();
43
0
        }
44
0
    }
45
    // Update if not found
46
0
    RETURN_IF_ERROR(_update(hostname));
47
0
    {
48
0
        std::shared_lock<std::shared_mutex> lock(mutex);
49
0
        *ip = cache[hostname];
50
0
        return Status::OK();
51
0
    }
52
0
}
53
54
// Resolve hostname to IP address, similar to Java's DNSCache.resolveHostname.
55
// If resolution fails, falls back to cached IP if available.
56
// Returns the resolved IP, or cached IP on failure, or empty string if no cache available.
57
0
std::string DNSCache::_resolve_hostname(const std::string& hostname) {
58
    // Get cached IP first (if any)
59
0
    std::string cached_ip;
60
0
    {
61
0
        std::shared_lock<std::shared_mutex> lock(mutex);
62
0
        auto it = cache.find(hostname);
63
0
        if (it != cache.end()) {
64
0
            cached_ip = it->second;
65
0
        }
66
0
    }
67
68
    // Try to resolve hostname
69
0
    std::string resolved_ip;
70
0
    Status status = hostname_to_ip(hostname, resolved_ip, BackendOptions::is_bind_ipv6());
71
72
0
    if (!status.ok() || resolved_ip.empty()) {
73
        // Resolution failed
74
0
        if (!cached_ip.empty()) {
75
0
            LOG(WARNING) << "Failed to resolve hostname " << hostname
76
0
                         << ", use cached ip: " << cached_ip;
77
0
            return cached_ip;
78
0
        } else {
79
0
            LOG(WARNING) << "Failed to resolve hostname " << hostname << ", no cached ip available";
80
0
            return "";
81
0
        }
82
0
    }
83
84
0
    return resolved_ip;
85
0
}
86
87
0
Status DNSCache::_update(const std::string& hostname) {
88
0
    std::string real_ip = _resolve_hostname(hostname);
89
0
    if (real_ip.empty()) {
90
0
        return Status::InternalError("Failed to resolve hostname {} and no cached ip available",
91
0
                                     hostname);
92
0
    }
93
94
0
    std::unique_lock<std::shared_mutex> lock(mutex);
95
0
    auto it = cache.find(hostname);
96
0
    if (it == cache.end() || it->second != real_ip) {
97
0
        cache[hostname] = real_ip;
98
0
        LOG(INFO) << "update hostname " << hostname << "'s ip to " << real_ip;
99
0
    }
100
0
    return Status::OK();
101
0
}
102
103
0
void DNSCache::_refresh_cache() {
104
0
    while (!stop_refresh) {
105
        // refresh every 1 min
106
0
        std::this_thread::sleep_for(std::chrono::minutes(1));
107
0
        std::unordered_set<std::string> keys;
108
0
        {
109
0
            std::shared_lock<std::shared_mutex> lock(mutex);
110
0
            std::transform(cache.begin(), cache.end(), std::inserter(keys, keys.end()),
111
0
                           [](const auto& pair) { return pair.first; });
112
0
        }
113
0
        for (auto& key : keys) {
114
0
            Status st = _update(key);
115
0
            if (!st.ok()) {
116
                LOG(WARNING) << "Failed to update DNS cache for hostname " << key << ": "
117
0
                             << st.to_string();
118
0
            }
119
0
        }
120
0
    }
121
0
}
122
123
} // end of namespace doris