1  // Copyright (c) 2009-2010 Satoshi Nakamoto
  2  // Copyright (c) 2009-present The Bitcoin Core developers
  3  // Distributed under the MIT software license, see the accompanying
  4  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  5  
  6  #include <util/time.h>
  7  
  8  #include <compat/compat.h>
  9  #include <tinyformat.h>
 10  #include <util/check.h>
 11  #include <util/strencodings.h>
 12  
 13  #include <atomic>
 14  #include <chrono>
 15  #include <optional>
 16  #include <string>
 17  #include <string_view>
 18  #include <thread>
 19  
 20  void UninterruptibleSleep(const std::chrono::microseconds& n) { std::this_thread::sleep_for(n); }
 21  
 22  static std::atomic<std::chrono::seconds> g_mock_time{}; //!< For testing
 23  std::atomic<bool> g_used_system_time{false};
 24  static std::atomic<MockableSteadyClock::mock_time_point::duration> g_mock_steady_time{}; //!< For testing
 25  
 26  NodeClock::time_point NodeClock::now() noexcept
 27  {
 28      const auto mocktime{g_mock_time.load(std::memory_order_relaxed)};
 29      if (!mocktime.count()) {
 30          g_used_system_time = true;
 31      }
 32      const auto ret{
 33          mocktime.count() ?
 34              mocktime :
 35              std::chrono::system_clock::now().time_since_epoch()};
 36      assert(ret > 0s);
 37      return time_point{ret};
 38  };
 39  
 40  void SetMockTime(int64_t nMockTimeIn) { SetMockTime(std::chrono::seconds{nMockTimeIn}); }
 41  void SetMockTime(std::chrono::time_point<NodeClock, std::chrono::seconds> mock) { SetMockTime(mock.time_since_epoch()); }
 42  void SetMockTime(std::chrono::seconds mock_time_in)
 43  {
 44      Assert(mock_time_in >= 0s);
 45      g_mock_time.store(mock_time_in, std::memory_order_relaxed);
 46  }
 47  
 48  std::chrono::seconds GetMockTime()
 49  {
 50      return g_mock_time.load(std::memory_order_relaxed);
 51  }
 52  
 53  MockableSteadyClock::time_point MockableSteadyClock::now() noexcept
 54  {
 55      const auto mocktime{g_mock_steady_time.load(std::memory_order_relaxed)};
 56      if (!mocktime.count()) {
 57          g_used_system_time = true;
 58      }
 59      const auto ret{
 60          mocktime.count() ?
 61              mocktime :
 62              std::chrono::steady_clock::now().time_since_epoch()};
 63      return time_point{ret};
 64  };
 65  
 66  void MockableSteadyClock::SetMockTime(mock_time_point::duration mock_time_in)
 67  {
 68      Assert(mock_time_in >= 0s);
 69      g_mock_steady_time.store(mock_time_in, std::memory_order_relaxed);
 70  }
 71  
 72  void MockableSteadyClock::ClearMockTime()
 73  {
 74      g_mock_steady_time.store(0ms, std::memory_order_relaxed);
 75  }
 76  
 77  int64_t GetTime() { return GetTime<std::chrono::seconds>().count(); }
 78  
 79  std::string FormatISO8601DateTime(int64_t nTime)
 80  {
 81      const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}};
 82      const auto days{std::chrono::floor<std::chrono::days>(secs)};
 83      const std::chrono::year_month_day ymd{days};
 84      const std::chrono::hh_mm_ss hms{secs - days};
 85      return strprintf("%04i-%02u-%02uT%02i:%02i:%02iZ", signed{ymd.year()}, unsigned{ymd.month()}, unsigned{ymd.day()}, hms.hours().count(), hms.minutes().count(), hms.seconds().count());
 86  }
 87  
 88  std::string FormatISO8601Date(int64_t nTime)
 89  {
 90      const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}};
 91      const auto days{std::chrono::floor<std::chrono::days>(secs)};
 92      const std::chrono::year_month_day ymd{days};
 93      return strprintf("%04i-%02u-%02u", signed{ymd.year()}, unsigned{ymd.month()}, unsigned{ymd.day()});
 94  }
 95  
 96  std::optional<int64_t> ParseISO8601DateTime(std::string_view str)
 97  {
 98      constexpr auto FMT_SIZE{std::string_view{"2000-01-01T01:01:01Z"}.size()};
 99      if (str.size() != FMT_SIZE || str[4] != '-' || str[7] != '-' || str[10] != 'T' || str[13] != ':' || str[16] != ':' || str[19] != 'Z') {
100          return {};
101      }
102      const auto year{ToIntegral<uint16_t>(str.substr(0, 4))};
103      const auto month{ToIntegral<uint8_t>(str.substr(5, 2))};
104      const auto day{ToIntegral<uint8_t>(str.substr(8, 2))};
105      const auto hour{ToIntegral<uint8_t>(str.substr(11, 2))};
106      const auto min{ToIntegral<uint8_t>(str.substr(14, 2))};
107      const auto sec{ToIntegral<uint8_t>(str.substr(17, 2))};
108      if (!year || !month || !day || !hour || !min || !sec) {
109          return {};
110      }
111      const std::chrono::year_month_day ymd{std::chrono::year{*year}, std::chrono::month{*month}, std::chrono::day{*day}};
112      if (!ymd.ok()) {
113          return {};
114      }
115      const auto time{std::chrono::hours{*hour} + std::chrono::minutes{*min} + std::chrono::seconds{*sec}};
116      const auto tp{std::chrono::sys_days{ymd} + time};
117      return int64_t{TicksSinceEpoch<std::chrono::seconds>(tp)};
118  }
119  
120  struct timeval MillisToTimeval(int64_t nTimeout)
121  {
122      struct timeval timeout;
123      timeout.tv_sec  = nTimeout / 1000;
124      timeout.tv_usec = (nTimeout % 1000) * 1000;
125      return timeout;
126  }
127  
128  struct timeval MillisToTimeval(std::chrono::milliseconds ms)
129  {
130      return MillisToTimeval(count_milliseconds(ms));
131  }