�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Flogging%2F'>logging</a>/</p><hr><h3>✏️ Editing: auto_roll_logger_test.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
//

#ifndef ROCKSDB_LITE

#include &quot;logging/auto_roll_logger.h&quot;
#include &lt;errno.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;algorithm&gt;
#include &lt;cmath&gt;
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &quot;logging/logging.h&quot;
#include &quot;port/port.h&quot;
#include &quot;rocksdb/db.h&quot;
#include &quot;test_util/sync_point.h&quot;
#include &quot;test_util/testharness.h&quot;
#include &quot;test_util/testutil.h&quot;

namespace ROCKSDB_NAMESPACE {
namespace {
class NoSleepEnv : public EnvWrapper {
 public:
  NoSleepEnv(Env* base) : EnvWrapper(base) {}
  void SleepForMicroseconds(int micros) override {
    fake_time_ += static_cast&lt;uint64_t&gt;(micros);
  }

  uint64_t NowNanos() override { return fake_time_ * 1000; }

  uint64_t NowMicros() override { return fake_time_; }

 private:
  uint64_t fake_time_ = 6666666666;
};
}  // namespace

// In this test we only want to Log some simple log message with
// no format. LogMessage() provides such a simple interface and
// avoids the [format-security] warning which occurs when you
// call ROCKS_LOG_INFO(logger, log_message) directly.
namespace {
void LogMessage(Logger* logger, const char* message) {
  ROCKS_LOG_INFO(logger, &quot;%s&quot;, message);
}

void LogMessage(const InfoLogLevel log_level, Logger* logger,
                const char* message) {
  Log(log_level, logger, &quot;%s&quot;, message);
}
}  // namespace

class AutoRollLoggerTest : public testing::Test {
 public:
  static void InitTestDb() {
#ifdef OS_WIN
    // Replace all slashes in the path so windows CompSpec does not
    // become confused
    std::string testDir(kTestDir);
    std::replace_if(testDir.begin(), testDir.end(),
                    [](char ch) { return ch == &#039;/&#039;; }, &#039;\\&#039;);
    std::string deleteCmd = &quot;if exist &quot; + testDir + &quot; rd /s /q &quot; + testDir;
#else
    std::string deleteCmd = &quot;rm -rf &quot; + kTestDir;
#endif
    ASSERT_TRUE(system(deleteCmd.c_str()) == 0);
    Env::Default()-&gt;CreateDir(kTestDir);
  }

  void RollLogFileBySizeTest(AutoRollLogger* logger, size_t log_max_size,
                             const std::string&amp; log_message);
  void RollLogFileByTimeTest(Env*, AutoRollLogger* logger, size_t time,
                             const std::string&amp; log_message);
  // return list of files under kTestDir that contains &quot;LOG&quot;
  std::vector&lt;std::string&gt; GetLogFiles() {
    std::vector&lt;std::string&gt; ret;
    std::vector&lt;std::string&gt; files;
    Status s = default_env-&gt;GetChildren(kTestDir, &amp;files);
    // Should call ASSERT_OK() here but it doesn&#039;t compile. It&#039;s not
    // worth the time figuring out why.
    EXPECT_TRUE(s.ok());
    for (const auto&amp; f : files) {
      if (f.find(&quot;LOG&quot;) != std::string::npos) {
        ret.push_back(f);
      }
    }
    return ret;
  }

  // Delete all log files under kTestDir
  void CleanupLogFiles() {
    for (const std::string&amp; f : GetLogFiles()) {
      ASSERT_OK(default_env-&gt;DeleteFile(kTestDir + &quot;/&quot; + f));
    }
  }

  void RollNTimesBySize(Logger* auto_roll_logger, size_t file_num,
                        size_t max_log_file_size) {
    // Roll the log 4 times, and it will trim to 3 files.
    std::string dummy_large_string;
    dummy_large_string.assign(max_log_file_size, &#039;=&#039;);
    auto_roll_logger-&gt;SetInfoLogLevel(InfoLogLevel::INFO_LEVEL);
    for (size_t i = 0; i &lt; file_num + 1; i++) {
      // Log enough bytes to trigger at least one roll.
      LogMessage(auto_roll_logger, dummy_large_string.c_str());
      LogMessage(auto_roll_logger, &quot;&quot;);
    }
  }

  static const std::string kSampleMessage;
  static const std::string kTestDir;
  static const std::string kLogFile;
  static Env* default_env;
};

const std::string AutoRollLoggerTest::kSampleMessage(
    &quot;this is the message to be written to the log file!!&quot;);
const std::string AutoRollLoggerTest::kTestDir(
    test::PerThreadDBPath(&quot;db_log_test&quot;));
const std::string AutoRollLoggerTest::kLogFile(
    test::PerThreadDBPath(&quot;db_log_test&quot;) + &quot;/LOG&quot;);
Env* AutoRollLoggerTest::default_env = Env::Default();

void AutoRollLoggerTest::RollLogFileBySizeTest(AutoRollLogger* logger,
                                               size_t log_max_size,
                                               const std::string&amp; log_message) {
  logger-&gt;SetInfoLogLevel(InfoLogLevel::INFO_LEVEL);
  ASSERT_EQ(InfoLogLevel::INFO_LEVEL, logger-&gt;GetInfoLogLevel());
  ASSERT_EQ(InfoLogLevel::INFO_LEVEL,
            logger-&gt;TEST_inner_logger()-&gt;GetInfoLogLevel());
  // measure the size of each message, which is supposed
  // to be equal or greater than log_message.size()
  LogMessage(logger, log_message.c_str());
  size_t message_size = logger-&gt;GetLogFileSize();
  size_t current_log_size = message_size;

  // Test the cases when the log file will not be rolled.
  while (current_log_size + message_size &lt; log_max_size) {
    LogMessage(logger, log_message.c_str());
    current_log_size += message_size;
    ASSERT_EQ(current_log_size, logger-&gt;GetLogFileSize());
  }

  // Now the log file will be rolled
  LogMessage(logger, log_message.c_str());
  // Since rotation is checked before actual logging, we need to
  // trigger the rotation by logging another message.
  LogMessage(logger, log_message.c_str());

  ASSERT_TRUE(message_size == logger-&gt;GetLogFileSize());
}

void AutoRollLoggerTest::RollLogFileByTimeTest(Env* env, AutoRollLogger* logger,
                                               size_t time,
                                               const std::string&amp; log_message) {
  uint64_t expected_ctime;
  uint64_t actual_ctime;

  uint64_t total_log_size;
  EXPECT_OK(env-&gt;GetFileSize(kLogFile, &amp;total_log_size));
  expected_ctime = logger-&gt;TEST_ctime();
  logger-&gt;SetCallNowMicrosEveryNRecords(0);

  // -- Write to the log for several times, which is supposed
  // to be finished before time.
  for (int i = 0; i &lt; 10; ++i) {
    env-&gt;SleepForMicroseconds(50000);
    LogMessage(logger, log_message.c_str());
    EXPECT_OK(logger-&gt;GetStatus());
    // Make sure we always write to the same log file (by
    // checking the create time);

    actual_ctime = logger-&gt;TEST_ctime();

    // Also make sure the log size is increasing.
    EXPECT_EQ(expected_ctime, actual_ctime);
    EXPECT_GT(logger-&gt;GetLogFileSize(), total_log_size);
    total_log_size = logger-&gt;GetLogFileSize();
  }

  // -- Make the log file expire
  env-&gt;SleepForMicroseconds(static_cast&lt;int&gt;(time * 1000000));
  LogMessage(logger, log_message.c_str());

  // At this time, the new log file should be created.
  actual_ctime = logger-&gt;TEST_ctime();
  EXPECT_LT(expected_ctime, actual_ctime);
  EXPECT_LT(logger-&gt;GetLogFileSize(), total_log_size);
}

TEST_F(AutoRollLoggerTest, RollLogFileBySize) {
    InitTestDb();
    size_t log_max_size = 1024 * 5;
    size_t keep_log_file_num = 10;

    AutoRollLogger logger(Env::Default(), kTestDir, &quot;&quot;, log_max_size, 0,
                          keep_log_file_num);

    RollLogFileBySizeTest(&amp;logger, log_max_size,
                          kSampleMessage + &quot;:RollLogFileBySize&quot;);
}

TEST_F(AutoRollLoggerTest, RollLogFileByTime) {
  NoSleepEnv nse(Env::Default());

  size_t time = 2;
  size_t log_size = 1024 * 5;
  size_t keep_log_file_num = 10;

  InitTestDb();
  // -- Test the existence of file during the server restart.
  ASSERT_EQ(Status::NotFound(), default_env-&gt;FileExists(kLogFile));
  AutoRollLogger logger(&amp;nse, kTestDir, &quot;&quot;, log_size, time, keep_log_file_num);
  ASSERT_OK(default_env-&gt;FileExists(kLogFile));

  RollLogFileByTimeTest(&amp;nse, &amp;logger, time,
                        kSampleMessage + &quot;:RollLogFileByTime&quot;);
}

TEST_F(AutoRollLoggerTest, SetInfoLogLevel) {
  InitTestDb();
  Options options;
  options.info_log_level = InfoLogLevel::FATAL_LEVEL;
  options.max_log_file_size = 1024;
  std::shared_ptr&lt;Logger&gt; logger;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
  auto* auto_roll_logger = dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());
  ASSERT_NE(nullptr, auto_roll_logger);
  ASSERT_EQ(InfoLogLevel::FATAL_LEVEL, auto_roll_logger-&gt;GetInfoLogLevel());
  ASSERT_EQ(InfoLogLevel::FATAL_LEVEL,
            auto_roll_logger-&gt;TEST_inner_logger()-&gt;GetInfoLogLevel());
  auto_roll_logger-&gt;SetInfoLogLevel(InfoLogLevel::DEBUG_LEVEL);
  ASSERT_EQ(InfoLogLevel::DEBUG_LEVEL, auto_roll_logger-&gt;GetInfoLogLevel());
  ASSERT_EQ(InfoLogLevel::DEBUG_LEVEL, logger-&gt;GetInfoLogLevel());
  ASSERT_EQ(InfoLogLevel::DEBUG_LEVEL,
            auto_roll_logger-&gt;TEST_inner_logger()-&gt;GetInfoLogLevel());
}

TEST_F(AutoRollLoggerTest, OpenLogFilesMultipleTimesWithOptionLog_max_size) {
  // If only &#039;log_max_size&#039; options is specified, then every time
  // when rocksdb is restarted, a new empty log file will be created.
  InitTestDb();
  // WORKAROUND:
  // avoid complier&#039;s complaint of &quot;comparison between signed
  // and unsigned integer expressions&quot; because literal 0 is
  // treated as &quot;singed&quot;.
  size_t kZero = 0;
  size_t log_size = 1024;
  size_t keep_log_file_num = 10;

  AutoRollLogger* logger = new AutoRollLogger(Env::Default(), kTestDir, &quot;&quot;,
                                              log_size, 0, keep_log_file_num);

  LogMessage(logger, kSampleMessage.c_str());
  ASSERT_GT(logger-&gt;GetLogFileSize(), kZero);
  delete logger;

  // reopens the log file and an empty log file will be created.
  logger = new AutoRollLogger(Env::Default(), kTestDir, &quot;&quot;, log_size, 0, 10);
  ASSERT_EQ(logger-&gt;GetLogFileSize(), kZero);
  delete logger;
}

TEST_F(AutoRollLoggerTest, CompositeRollByTimeAndSizeLogger) {
  size_t time = 2, log_max_size = 1024 * 5;
  size_t keep_log_file_num = 10;

  InitTestDb();

  NoSleepEnv nse(Env::Default());
  AutoRollLogger logger(&amp;nse, kTestDir, &quot;&quot;, log_max_size, time,
                        keep_log_file_num);

  // Test the ability to roll by size
  RollLogFileBySizeTest(&amp;logger, log_max_size,
                        kSampleMessage + &quot;:CompositeRollByTimeAndSizeLogger&quot;);

  // Test the ability to roll by Time
  RollLogFileByTimeTest(&amp;nse, &amp;logger, time,
                        kSampleMessage + &quot;:CompositeRollByTimeAndSizeLogger&quot;);
}

#ifndef OS_WIN
// TODO: does not build for Windows because of PosixLogger use below. Need to
// port
TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) {
  DBOptions options;
  NoSleepEnv nse(Env::Default());
  std::shared_ptr&lt;Logger&gt; logger;

  // Normal logger
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
  ASSERT_TRUE(dynamic_cast&lt;PosixLogger*&gt;(logger.get()));

  // Only roll by size
  InitTestDb();
  options.max_log_file_size = 1024;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
  AutoRollLogger* auto_roll_logger =
    dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());
  ASSERT_TRUE(auto_roll_logger);
  RollLogFileBySizeTest(
      auto_roll_logger, options.max_log_file_size,
      kSampleMessage + &quot;:CreateLoggerFromOptions - size&quot;);

  // Only roll by Time
  options.env = &amp;nse;
  InitTestDb();
  options.max_log_file_size = 0;
  options.log_file_time_to_roll = 2;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
  auto_roll_logger =
    dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());
  RollLogFileByTimeTest(&amp;nse, auto_roll_logger, options.log_file_time_to_roll,
                        kSampleMessage + &quot;:CreateLoggerFromOptions - time&quot;);

  // roll by both Time and size
  InitTestDb();
  options.max_log_file_size = 1024 * 5;
  options.log_file_time_to_roll = 2;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
  auto_roll_logger =
    dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());
  RollLogFileBySizeTest(auto_roll_logger, options.max_log_file_size,
                        kSampleMessage + &quot;:CreateLoggerFromOptions - both&quot;);
  RollLogFileByTimeTest(&amp;nse, auto_roll_logger, options.log_file_time_to_roll,
                        kSampleMessage + &quot;:CreateLoggerFromOptions - both&quot;);

  // Set keep_log_file_num
  {
    const size_t kFileNum = 3;
    InitTestDb();
    options.max_log_file_size = 512;
    options.log_file_time_to_roll = 2;
    options.keep_log_file_num = kFileNum;
    ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
    auto_roll_logger = dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());

    // Roll the log 4 times, and it will trim to 3 files.
    std::string dummy_large_string;
    dummy_large_string.assign(options.max_log_file_size, &#039;=&#039;);
    auto_roll_logger-&gt;SetInfoLogLevel(InfoLogLevel::INFO_LEVEL);
    for (size_t i = 0; i &lt; kFileNum + 1; i++) {
      // Log enough bytes to trigger at least one roll.
      LogMessage(auto_roll_logger, dummy_large_string.c_str());
      LogMessage(auto_roll_logger, &quot;&quot;);
    }

    std::vector&lt;std::string&gt; files = GetLogFiles();
    ASSERT_EQ(kFileNum, files.size());

    CleanupLogFiles();
  }

  // Set keep_log_file_num and dbname is different from
  // db_log_dir.
  {
    const size_t kFileNum = 3;
    InitTestDb();
    options.max_log_file_size = 512;
    options.log_file_time_to_roll = 2;
    options.keep_log_file_num = kFileNum;
    options.db_log_dir = kTestDir;
    ASSERT_OK(CreateLoggerFromOptions(&quot;/dummy/db/name&quot;, options, &amp;logger));
    auto_roll_logger = dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());

    // Roll the log 4 times, and it will trim to 3 files.
    std::string dummy_large_string;
    dummy_large_string.assign(options.max_log_file_size, &#039;=&#039;);
    auto_roll_logger-&gt;SetInfoLogLevel(InfoLogLevel::INFO_LEVEL);
    for (size_t i = 0; i &lt; kFileNum + 1; i++) {
      // Log enough bytes to trigger at least one roll.
      LogMessage(auto_roll_logger, dummy_large_string.c_str());
      LogMessage(auto_roll_logger, &quot;&quot;);
    }

    std::vector&lt;std::string&gt; files = GetLogFiles();
    ASSERT_EQ(kFileNum, files.size());
    for (const auto&amp; f : files) {
      ASSERT_TRUE(f.find(&quot;dummy&quot;) != std::string::npos);
    }

    // Cleaning up those files.
    CleanupLogFiles();
  }
}

TEST_F(AutoRollLoggerTest, AutoDeleting) {
  for (int attempt = 0; attempt &lt; 2; attempt++) {
    // In the first attemp, db_log_dir is not set, while in the
    // second it is set.
    std::string dbname = (attempt == 0) ? kTestDir : &quot;/test/dummy/dir&quot;;
    std::string db_log_dir = (attempt == 0) ? &quot;&quot; : kTestDir;

    InitTestDb();
    const size_t kMaxFileSize = 512;
    {
      size_t log_num = 8;
      AutoRollLogger logger(Env::Default(), dbname, db_log_dir, kMaxFileSize, 0,
                            log_num);
      RollNTimesBySize(&amp;logger, log_num, kMaxFileSize);

      ASSERT_EQ(log_num, GetLogFiles().size());
    }
    // Shrink number of files
    {
      size_t log_num = 5;
      AutoRollLogger logger(Env::Default(), dbname, db_log_dir, kMaxFileSize, 0,
                            log_num);
      ASSERT_EQ(log_num, GetLogFiles().size());

      RollNTimesBySize(&amp;logger, 3, kMaxFileSize);
      ASSERT_EQ(log_num, GetLogFiles().size());
    }

    // Increase number of files again.
    {
      size_t log_num = 7;
      AutoRollLogger logger(Env::Default(), dbname, db_log_dir, kMaxFileSize, 0,
                            log_num);
      ASSERT_EQ(6, GetLogFiles().size());

      RollNTimesBySize(&amp;logger, 3, kMaxFileSize);
      ASSERT_EQ(log_num, GetLogFiles().size());
    }

    CleanupLogFiles();
  }
}

TEST_F(AutoRollLoggerTest, LogFlushWhileRolling) {
  DBOptions options;
  std::shared_ptr&lt;Logger&gt; logger;

  InitTestDb();
  options.max_log_file_size = 1024 * 5;
  ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &amp;logger));
  AutoRollLogger* auto_roll_logger =
      dynamic_cast&lt;AutoRollLogger*&gt;(logger.get());
  ASSERT_TRUE(auto_roll_logger);
  ROCKSDB_NAMESPACE::port::Thread flush_thread;

  // Notes:
  // (1) Need to pin the old logger before beginning the roll, as rolling grabs
  //     the mutex, which would prevent us from accessing the old logger. This
  //     also marks flush_thread with AutoRollLogger::Flush:PinnedLogger.
  // (2) Need to reset logger during PosixLogger::Flush() to exercise a race
  //     condition case, which is executing the flush with the pinned (old)
  //     logger after auto-roll logger has cut over to a new logger.
  // (3) PosixLogger::Flush() happens in both threads but its SyncPoints only
  //     are enabled in flush_thread (the one pinning the old logger).
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()-&gt;LoadDependencyAndMarkers(
      {{&quot;AutoRollLogger::Flush:PinnedLogger&quot;,
        &quot;AutoRollLoggerTest::LogFlushWhileRolling:PreRollAndPostThreadInit&quot;},
       {&quot;PosixLogger::Flush:Begin1&quot;,
        &quot;AutoRollLogger::ResetLogger:BeforeNewLogger&quot;},
       {&quot;AutoRollLogger::ResetLogger:AfterNewLogger&quot;,
        &quot;PosixLogger::Flush:Begin2&quot;}},
      {{&quot;AutoRollLogger::Flush:PinnedLogger&quot;, &quot;PosixLogger::Flush:Begin1&quot;},
       {&quot;AutoRollLogger::Flush:PinnedLogger&quot;, &quot;PosixLogger::Flush:Begin2&quot;}});
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()-&gt;EnableProcessing();

  flush_thread = port::Thread([&amp;]() { auto_roll_logger-&gt;Flush(); });
  TEST_SYNC_POINT(
      &quot;AutoRollLoggerTest::LogFlushWhileRolling:PreRollAndPostThreadInit&quot;);
  RollLogFileBySizeTest(auto_roll_logger, options.max_log_file_size,
                        kSampleMessage + &quot;:LogFlushWhileRolling&quot;);
  flush_thread.join();
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()-&gt;DisableProcessing();
}

#endif  // OS_WIN

TEST_F(AutoRollLoggerTest, InfoLogLevel) {
  InitTestDb();

  size_t log_size = 8192;
  size_t log_lines = 0;
  // an extra-scope to force the AutoRollLogger to flush the log file when it
  // becomes out of scope.
  {
    AutoRollLogger logger(Env::Default(), kTestDir, &quot;&quot;, log_size, 0, 10);
    for (int log_level = InfoLogLevel::HEADER_LEVEL;
         log_level &gt;= InfoLogLevel::DEBUG_LEVEL; log_level--) {
      logger.SetInfoLogLevel((InfoLogLevel)log_level);
      for (int log_type = InfoLogLevel::DEBUG_LEVEL;
           log_type &lt;= InfoLogLevel::HEADER_LEVEL; log_type++) {
        // log messages with log level smaller than log_level will not be
        // logged.
        LogMessage((InfoLogLevel)log_type, &amp;logger, kSampleMessage.c_str());
      }
      log_lines += InfoLogLevel::HEADER_LEVEL - log_level + 1;
    }
    for (int log_level = InfoLogLevel::HEADER_LEVEL;
         log_level &gt;= InfoLogLevel::DEBUG_LEVEL; log_level--) {
      logger.SetInfoLogLevel((InfoLogLevel)log_level);

      // again, messages with level smaller than log_level will not be logged.
      ROCKS_LOG_HEADER(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
      ROCKS_LOG_DEBUG(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
      ROCKS_LOG_INFO(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
      ROCKS_LOG_WARN(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
      ROCKS_LOG_ERROR(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
      ROCKS_LOG_FATAL(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
      log_lines += InfoLogLevel::HEADER_LEVEL - log_level + 1;
    }
  }
  std::ifstream inFile(AutoRollLoggerTest::kLogFile.c_str());
  size_t lines = std::count(std::istreambuf_iterator&lt;char&gt;(inFile),
                         std::istreambuf_iterator&lt;char&gt;(), &#039;\n&#039;);
  ASSERT_EQ(log_lines, lines);
  inFile.close();
}

TEST_F(AutoRollLoggerTest, Close) {
  InitTestDb();

  size_t log_size = 8192;
  size_t log_lines = 0;
  AutoRollLogger logger(Env::Default(), kTestDir, &quot;&quot;, log_size, 0, 10);
  for (int log_level = InfoLogLevel::HEADER_LEVEL;
       log_level &gt;= InfoLogLevel::DEBUG_LEVEL; log_level--) {
    logger.SetInfoLogLevel((InfoLogLevel)log_level);
    for (int log_type = InfoLogLevel::DEBUG_LEVEL;
         log_type &lt;= InfoLogLevel::HEADER_LEVEL; log_type++) {
      // log messages with log level smaller than log_level will not be
      // logged.
      LogMessage((InfoLogLevel)log_type, &amp;logger, kSampleMessage.c_str());
    }
    log_lines += InfoLogLevel::HEADER_LEVEL - log_level + 1;
  }
  for (int log_level = InfoLogLevel::HEADER_LEVEL;
       log_level &gt;= InfoLogLevel::DEBUG_LEVEL; log_level--) {
    logger.SetInfoLogLevel((InfoLogLevel)log_level);

    // again, messages with level smaller than log_level will not be logged.
    ROCKS_LOG_HEADER(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
    ROCKS_LOG_DEBUG(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
    ROCKS_LOG_INFO(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
    ROCKS_LOG_WARN(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
    ROCKS_LOG_ERROR(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
    ROCKS_LOG_FATAL(&amp;logger, &quot;%s&quot;, kSampleMessage.c_str());
    log_lines += InfoLogLevel::HEADER_LEVEL - log_level + 1;
  }
  ASSERT_EQ(logger.Close(), Status::OK());

  std::ifstream inFile(AutoRollLoggerTest::kLogFile.c_str());
  size_t lines = std::count(std::istreambuf_iterator&lt;char&gt;(inFile),
                         std::istreambuf_iterator&lt;char&gt;(), &#039;\n&#039;);
  ASSERT_EQ(log_lines, lines);
  inFile.close();
}

// Test the logger Header function for roll over logs
// We expect the new logs creates as roll over to carry the headers specified
static std::vector&lt;std::string&gt; GetOldFileNames(const std::string&amp; path) {
  std::vector&lt;std::string&gt; ret;

  const std::string dirname = path.substr(/*start=*/0, path.find_last_of(&quot;/&quot;));
  const std::string fname = path.substr(path.find_last_of(&quot;/&quot;) + 1);

  std::vector&lt;std::string&gt; children;
  Env::Default()-&gt;GetChildren(dirname, &amp;children);

  // We know that the old log files are named [path]&lt;something&gt;
  // Return all entities that match the pattern
  for (auto&amp; child : children) {
    if (fname != child &amp;&amp; child.find(fname) == 0) {
      ret.push_back(dirname + &quot;/&quot; + child);
    }
  }

  return ret;
}

TEST_F(AutoRollLoggerTest, LogHeaderTest) {
  static const size_t MAX_HEADERS = 10;
  static const size_t LOG_MAX_SIZE = 1024 * 5;
  static const std::string HEADER_STR = &quot;Log header line&quot;;

  // test_num == 0 -&gt; standard call to Header()
  // test_num == 1 -&gt; call to Log() with InfoLogLevel::HEADER_LEVEL
  for (int test_num = 0; test_num &lt; 2; test_num++) {

    InitTestDb();

    AutoRollLogger logger(Env::Default(), kTestDir, /*db_log_dir=*/&quot;&quot;,
                          LOG_MAX_SIZE, /*log_file_time_to_roll=*/0,
                          /*keep_log_file_num=*/10);

    if (test_num == 0) {
      // Log some headers explicitly using Header()
      for (size_t i = 0; i &lt; MAX_HEADERS; i++) {
        Header(&amp;logger, &quot;%s %&quot; ROCKSDB_PRIszt, HEADER_STR.c_str(), i);
      }
    } else if (test_num == 1) {
      // HEADER_LEVEL should make this behave like calling Header()
      for (size_t i = 0; i &lt; MAX_HEADERS; i++) {
        ROCKS_LOG_HEADER(&amp;logger, &quot;%s %&quot; ROCKSDB_PRIszt, HEADER_STR.c_str(), i);
      }
    }

    const std::string newfname = logger.TEST_log_fname();

    // Log enough data to cause a roll over
    int i = 0;
    for (size_t iter = 0; iter &lt; 2; iter++) {
      while (logger.GetLogFileSize() &lt; LOG_MAX_SIZE) {
        Info(&amp;logger, (kSampleMessage + &quot;:LogHeaderTest line %d&quot;).c_str(), i);
        ++i;
      }

      Info(&amp;logger, &quot;Rollover&quot;);
    }

    // Flush the log for the latest file
    LogFlush(&amp;logger);

    const auto oldfiles = GetOldFileNames(newfname);

    ASSERT_EQ(oldfiles.size(), (size_t) 2);

    for (auto&amp; oldfname : oldfiles) {
      // verify that the files rolled over
      ASSERT_NE(oldfname, newfname);
      // verify that the old log contains all the header logs
      ASSERT_EQ(test::GetLinesCount(oldfname, HEADER_STR), MAX_HEADERS);
    }
  }
}

TEST_F(AutoRollLoggerTest, LogFileExistence) {
  ROCKSDB_NAMESPACE::DB* db;
  ROCKSDB_NAMESPACE::Options options;
#ifdef OS_WIN
  // Replace all slashes in the path so windows CompSpec does not
  // become confused
  std::string testDir(kTestDir);
  std::replace_if(testDir.begin(), testDir.end(),
    [](char ch) { return ch == &#039;/&#039;; }, &#039;\\&#039;);
  std::string deleteCmd = &quot;if exist &quot; + testDir + &quot; rd /s /q &quot; + testDir;
#else
  std::string deleteCmd = &quot;rm -rf &quot; + kTestDir;
#endif
  ASSERT_EQ(system(deleteCmd.c_str()), 0);
  options.max_log_file_size = 100 * 1024 * 1024;
  options.create_if_missing = true;
  ASSERT_OK(ROCKSDB_NAMESPACE::DB::Open(options, kTestDir, &amp;db));
  ASSERT_OK(default_env-&gt;FileExists(kLogFile));
  delete db;
}

TEST_F(AutoRollLoggerTest, FileCreateFailure) {
  Options options;
  options.max_log_file_size = 100 * 1024 * 1024;
  options.db_log_dir = &quot;/a/dir/does/not/exist/at/all&quot;;

  std::shared_ptr&lt;Logger&gt; logger;
  ASSERT_NOK(CreateLoggerFromOptions(&quot;&quot;, options, &amp;logger));
  ASSERT_TRUE(!logger);
}
}  // namespace ROCKSDB_NAMESPACE

int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&amp;argc, argv);
  return RUN_ALL_TESTS();
}

#else
#include &lt;stdio.h&gt;

int main(int /*argc*/, char** /*argv*/) {
  fprintf(stderr,
          &quot;SKIPPED as AutoRollLogger is not supported in ROCKSDB_LITE\n&quot;);
  return 0;
}

#endif  // !ROCKSDB_LITE
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Flogging'>🔙 Back</a></p>