Coverage Report

Created: 2026-03-16 11:17

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
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
7
DNSCache::DNSCache() {
26
7
    refresh_thread = std::thread(&DNSCache::_refresh_cache, this);
27
7
}
28
29
3
DNSCache::~DNSCache() {
30
3
    stop_refresh = true;
31
3
    if (refresh_thread.joinable()) {
32
3
        refresh_thread.join();
33
3
    }
34
3
}
35
36
104k
Status DNSCache::get(const std::string& hostname, std::string* ip) {
37
104k
    {
38
104k
        std::shared_lock<std::shared_mutex> lock(mutex);
39
104k
        auto it = cache.find(hostname);
40
104k
        if (it != cache.end()) {
41
104k
            *ip = it->second;
42
104k
            return Status::OK();
43
104k
        }
44
104k
    }
45
    // Update if not found
46
187
    RETURN_IF_ERROR(_update(hostname));
47
187
    {
48
187
        std::shared_lock<std::shared_mutex> lock(mutex);
49
187
        *ip = cache[hostname];
50
187
        return Status::OK();
51
187
    }
52
187
}
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
110
std::string DNSCache::_resolve_hostname(const std::string& hostname) {
58
    // Get cached IP first (if any)
59
110
    std::string cached_ip;
60
110
    {
61
110
        std::shared_lock<std::shared_mutex> lock(mutex);
62
110
        auto it = cache.find(hostname);
63
110
        if (it != cache.end()) {
64
103
            cached_ip = it->second;
65
103
        }
66
110
    }
67
68
    // Try to resolve hostname
69
110
    std::string resolved_ip;
70
110
    Status status = hostname_to_ip(hostname, resolved_ip, BackendOptions::is_bind_ipv6());
71
72
110
    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
110
    return resolved_ip;
85
110
}
86
87
110
Status DNSCache::_update(const std::string& hostname) {
88
110
    std::string real_ip = _resolve_hostname(hostname);
89
110
    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
110
    std::unique_lock<std::shared_mutex> lock(mutex);
95
110
    auto it = cache.find(hostname);
96
110
    if (it == cache.end() || it->second != real_ip) {
97
7
        cache[hostname] = real_ip;
98
7
        LOG(INFO) << "update hostname " << hostname << "'s ip to " << real_ip;
99
7
    }
100
110
    return Status::OK();
101
110
}
102
103
7
void DNSCache::_refresh_cache() {
104
116
    while (!stop_refresh) {
105
        // refresh every 1 min
106
109
        std::this_thread::sleep_for(std::chrono::minutes(1));
107
109
        std::unordered_set<std::string> keys;
108
109
        {
109
109
            std::shared_lock<std::shared_mutex> lock(mutex);
110
109
            std::transform(cache.begin(), cache.end(), std::inserter(keys, keys.end()),
111
109
                           [](const auto& pair) { return pair.first; });
112
109
        }
113
109
        for (auto& key : keys) {
114
103
            Status st = _update(key);
115
103
            if (!st.ok()) {
116
                LOG(WARNING) << "Failed to update DNS cache for hostname " << key << ": "
117
0
                             << st.to_string();
118
0
            }
119
103
        }
120
109
    }
121
7
}
122
123
} // end of namespace doris