Coverage Report

Created: 2025-03-13 18:54

/root/doris/be/src/util/timezone_utils.cpp
Line
Count
Source (jump to first uncovered line)
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/timezone_utils.h"
19
20
#include <cctz/civil_time.h>
21
#include <cctz/time_zone.h>
22
#include <fcntl.h>
23
#include <glog/logging.h>
24
#include <re2/re2.h>
25
#include <re2/stringpiece.h>
26
#include <sys/mman.h>
27
#include <sys/stat.h>
28
#include <sys/types.h>
29
#include <unistd.h>
30
31
#include <boost/algorithm/string.hpp>
32
#include <boost/algorithm/string/case_conv.hpp>
33
#include <cstdlib>
34
#include <filesystem>
35
#include <memory>
36
#include <string>
37
38
#include "common/exception.h"
39
#include "common/logging.h"
40
#include "common/status.h"
41
42
using boost::algorithm::to_lower_copy;
43
44
namespace fs = std::filesystem;
45
#include "common/compile_check_begin.h"
46
47
namespace doris {
48
49
namespace vectorized {
50
using ZoneList = std::unordered_map<std::string, cctz::time_zone>;
51
}
52
53
RE2 time_zone_offset_format_reg(R"(^[+-]{1}\d{2}\:\d{2}$)"); // visiting is thread-safe
54
55
// for ut, make it never nullptr.
56
std::unique_ptr<vectorized::ZoneList> lower_zone_cache_ = std::make_unique<vectorized::ZoneList>();
57
58
const std::string TimezoneUtils::default_time_zone = "+08:00";
59
static const char* tzdir = "/usr/share/zoneinfo"; // default value, may change by TZDIR env var
60
61
2
void TimezoneUtils::clear_timezone_caches() {
62
2
    lower_zone_cache_->clear();
63
2
}
64
2
size_t TimezoneUtils::cache_size() {
65
2
    return lower_zone_cache_->size();
66
2
}
67
68
38.3k
static bool parse_save_name_tz(const std::string& tz_name) {
69
38.3k
    cctz::time_zone tz;
70
38.3k
    PROPAGATE_FALSE(cctz::load_time_zone(tz_name, &tz));
71
38.0k
    lower_zone_cache_->emplace(to_lower_copy(tz_name), tz);
72
38.0k
    return true;
73
38.3k
}
74
75
64
void TimezoneUtils::load_timezones_to_cache() {
76
64
    std::string base_str;
77
    // try get from system
78
64
    char* tzdir_env = std::getenv("TZDIR");
79
64
    if (tzdir_env && *tzdir_env) {
80
0
        tzdir = tzdir_env;
81
0
    }
82
83
64
    base_str = tzdir;
84
64
    base_str += '/';
85
86
64
    const auto root_path = fs::path {base_str};
87
64
    if (!exists(root_path)) {
88
0
        throw Exception(Status::FatalError("Cannot find system tzfile. Doris exiting!"));
89
0
    }
90
91
64
    std::set<std::string> ignore_paths = {"posix", "right"}; // duplications. ignore them.
92
93
39.8k
    for (fs::recursive_directory_iterator it {base_str}; it != end(it); it++) {
94
39.7k
        const auto& dir_entry = *it;
95
39.7k
        if (dir_entry.is_regular_file() ||
96
39.7k
            (dir_entry.is_symlink() && is_regular_file(read_symlink(dir_entry)))) {
97
38.3k
            auto tz_name = dir_entry.path().string().substr(base_str.length());
98
38.3k
            if (!parse_save_name_tz(tz_name)) {
99
320
                LOG(WARNING) << "Meet illegal tzdata file: " << tz_name << ". skipped";
100
320
            }
101
38.3k
        } else if (dir_entry.is_directory() && ignore_paths.contains(dir_entry.path().filename())) {
102
128
            it.disable_recursion_pending();
103
128
        }
104
39.7k
    }
105
    // some special cases. Z = Zulu. CST = Asia/Shanghai
106
64
    if (auto it = lower_zone_cache_->find("zulu"); it != lower_zone_cache_->end()) {
107
64
        lower_zone_cache_->emplace("z", it->second);
108
64
    }
109
64
    if (auto it = lower_zone_cache_->find("asia/shanghai"); it != lower_zone_cache_->end()) {
110
64
        lower_zone_cache_->emplace("cst", it->second);
111
64
    }
112
113
64
    lower_zone_cache_->erase("lmt"); // local mean time for every timezone
114
115
64
    load_offsets_to_cache();
116
64
    LOG(INFO) << "Preloaded" << lower_zone_cache_->size() << " timezones.";
117
64
}
118
119
3.51k
static std::string to_hour_string(int arg) {
120
3.51k
    if (arg < 0 && arg > -10) { // -9 to -1
121
1.17k
        return std::string {"-0"} + std::to_string(std::abs(arg));
122
2.34k
    } else if (arg >= 0 && arg < 10) { //0 to 9
123
1.30k
        return std::string {"0"} + std::to_string(arg);
124
1.30k
    }
125
1.04k
    return std::to_string(arg);
126
3.51k
}
127
128
65
void TimezoneUtils::load_offsets_to_cache() {
129
1.82k
    for (int hour = -12; hour <= +14; hour++) {
130
5.26k
        for (int minute = 0; minute <= 30; minute += 30) {
131
3.51k
            std::string offset_str = (hour >= 0 ? "+" : "") + to_hour_string(hour) + ':' +
132
3.51k
                                     (minute == 0 ? "00" : "30");
133
3.51k
            cctz::time_zone result;
134
3.51k
            parse_tz_offset_string(offset_str, result);
135
3.51k
            lower_zone_cache_->emplace(offset_str, result);
136
3.51k
        }
137
1.75k
    }
138
    // -00 for hour is also valid
139
65
    std::string offset_str = "-00:00";
140
65
    cctz::time_zone result;
141
65
    parse_tz_offset_string(offset_str, result);
142
65
    lower_zone_cache_->emplace(offset_str, result);
143
65
    offset_str = "-00:30";
144
65
    parse_tz_offset_string(offset_str, result);
145
65
    lower_zone_cache_->emplace(offset_str, result);
146
65
}
147
148
12.1k
bool TimezoneUtils::find_cctz_time_zone(const std::string& timezone, cctz::time_zone& ctz) {
149
12.1k
    if (auto it = lower_zone_cache_->find(to_lower_copy(timezone)); it != lower_zone_cache_->end())
150
11.9k
            [[likely]] {
151
11.9k
        ctz = it->second;
152
11.9k
        return true;
153
11.9k
    }
154
169
    return false;
155
12.1k
}
156
157
3.65k
bool TimezoneUtils::parse_tz_offset_string(const std::string& timezone, cctz::time_zone& ctz) {
158
    // like +08:00, which not in timezone_names_map_
159
3.65k
    re2::StringPiece value;
160
3.65k
    if (time_zone_offset_format_reg.Match(timezone, 0, timezone.size(), RE2::UNANCHORED, &value, 1))
161
3.65k
            [[likely]] {
162
3.65k
        bool positive = value[0] != '-';
163
164
        //Regular expression guarantees hour and minute must be int
165
3.65k
        int hour = std::stoi(value.substr(1, 2).as_string());
166
3.65k
        int minute = std::stoi(value.substr(4, 2).as_string());
167
168
        // timezone offsets around the world extended from -12:00 to +14:00
169
3.65k
        if (!positive && hour > 12) {
170
1
            return false;
171
3.65k
        } else if (positive && hour > 14) {
172
1
            return false;
173
1
        }
174
3.65k
        int offset = hour * 60 * 60 + minute * 60;
175
3.65k
        offset *= positive ? 1 : -1;
176
3.65k
        ctz = cctz::fixed_time_zone(cctz::seconds(offset));
177
3.65k
        return true;
178
3.65k
    }
179
1
    return false;
180
3.65k
}
181
182
#include "common/compile_check_end.h"
183
} // namespace doris