ceph/src/rocksdb/db/filename_test.cc

   1 //  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5 //
   6 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   7 // Use of this source code is governed by a BSD-style license that can be
   8 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   9
  10 #include "file/filename.h"
  11
  12 #include "db/dbformat.h"
  13 #include "port/port.h"
  14 #include "test_util/testharness.h"
  15
  16 namespace ROCKSDB_NAMESPACE {
  17
  18 class FileNameTest : public testing::Test {};
  19
  20 TEST_F(FileNameTest, Parse) {
  21   Slice db;
  22   FileType type;
  23   uint64_t number;
  24
  25   char kDefautInfoLogDir = 1;
  26   char kDifferentInfoLogDir = 2;
  27   char kNoCheckLogDir = 4;
  28   char kAllMode = kDefautInfoLogDir | kDifferentInfoLogDir | kNoCheckLogDir;
  29
  30   // Successful parses
  31   static struct {
  32     const char* fname;
  33     uint64_t number;
  34     FileType type;
  35     char mode;
  36   } cases[] = {
  37       {"100.log", 100, kWalFile, kAllMode},
  38       {"0.log", 0, kWalFile, kAllMode},
  39       {"0.sst", 0, kTableFile, kAllMode},
  40       {"CURRENT", 0, kCurrentFile, kAllMode},
  41       {"LOCK", 0, kDBLockFile, kAllMode},
  42       {"MANIFEST-2", 2, kDescriptorFile, kAllMode},
  43       {"MANIFEST-7", 7, kDescriptorFile, kAllMode},
  44       {"METADB-2", 2, kMetaDatabase, kAllMode},
  45       {"METADB-7", 7, kMetaDatabase, kAllMode},
  46       {"LOG", 0, kInfoLogFile, kDefautInfoLogDir},
  47       {"LOG.old", 0, kInfoLogFile, kDefautInfoLogDir},
  48       {"LOG.old.6688", 6688, kInfoLogFile, kDefautInfoLogDir},
  49       {"rocksdb_dir_LOG", 0, kInfoLogFile, kDifferentInfoLogDir},
  50       {"rocksdb_dir_LOG.old", 0, kInfoLogFile, kDifferentInfoLogDir},
  51       {"rocksdb_dir_LOG.old.6688", 6688, kInfoLogFile, kDifferentInfoLogDir},
  52       {"18446744073709551615.log", 18446744073709551615ull, kWalFile, kAllMode},
  53   };
  54   for (char mode : {kDifferentInfoLogDir, kDefautInfoLogDir, kNoCheckLogDir}) {
  55     for (unsigned int i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
  56       InfoLogPrefix info_log_prefix(mode != kDefautInfoLogDir, "/rocksdb/dir");
  57       if (cases[i].mode & mode) {
  58         std::string f = cases[i].fname;
  59         if (mode == kNoCheckLogDir) {
  60           ASSERT_TRUE(ParseFileName(f, &number, &type)) << f;
  61         } else {
  62           ASSERT_TRUE(ParseFileName(f, &number, info_log_prefix.prefix, &type))
  63               << f;
  64         }
  65         ASSERT_EQ(cases[i].type, type) << f;
  66         ASSERT_EQ(cases[i].number, number) << f;
  67       }
  68     }
  69   }
  70
  71   // Errors
  72   static const char* errors[] = {
  73     "",
  74     "foo",
  75     "foo-dx-100.log",
  76     ".log",
  77     "",
  78     "manifest",
  79     "CURREN",
  80     "CURRENTX",
  81     "MANIFES",
  82     "MANIFEST",
  83     "MANIFEST-",
  84     "XMANIFEST-3",
  85     "MANIFEST-3x",
  86     "META",
  87     "METADB",
  88     "METADB-",
  89     "XMETADB-3",
  90     "METADB-3x",
  91     "LOC",
  92     "LOCKx",
  93     "LO",
  94     "LOGx",
  95     "18446744073709551616.log",
  96     "184467440737095516150.log",
  97     "100",
  98     "100.",
  99     "100.lop"
 100   };
 101   for (unsigned int i = 0; i < sizeof(errors) / sizeof(errors[0]); i++) {
 102     std::string f = errors[i];
 103     ASSERT_TRUE(!ParseFileName(f, &number, &type)) << f;
 104   };
 105 }
 106
 107 TEST_F(FileNameTest, InfoLogFileName) {
 108   std::string dbname = ("/data/rocksdb");
 109   std::string db_absolute_path;
 110   ASSERT_OK(Env::Default()->GetAbsolutePath(dbname, &db_absolute_path));
 111
 112   ASSERT_EQ("/data/rocksdb/LOG", InfoLogFileName(dbname, db_absolute_path, ""));
 113   ASSERT_EQ("/data/rocksdb/LOG.old.666",
 114             OldInfoLogFileName(dbname, 666u, db_absolute_path, ""));
 115
 116   ASSERT_EQ("/data/rocksdb_log/data_rocksdb_LOG",
 117             InfoLogFileName(dbname, db_absolute_path, "/data/rocksdb_log"));
 118   ASSERT_EQ(
 119       "/data/rocksdb_log/data_rocksdb_LOG.old.666",
 120       OldInfoLogFileName(dbname, 666u, db_absolute_path, "/data/rocksdb_log"));
 121 }
 122
 123 TEST_F(FileNameTest, Construction) {
 124   uint64_t number;
 125   FileType type;
 126   std::string fname;
 127
 128   fname = CurrentFileName("foo");
 129   ASSERT_EQ("foo/", std::string(fname.data(), 4));
 130   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 131   ASSERT_EQ(0U, number);
 132   ASSERT_EQ(kCurrentFile, type);
 133
 134   fname = LockFileName("foo");
 135   ASSERT_EQ("foo/", std::string(fname.data(), 4));
 136   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 137   ASSERT_EQ(0U, number);
 138   ASSERT_EQ(kDBLockFile, type);
 139
 140   fname = LogFileName("foo", 192);
 141   ASSERT_EQ("foo/", std::string(fname.data(), 4));
 142   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 143   ASSERT_EQ(192U, number);
 144   ASSERT_EQ(kWalFile, type);
 145
 146   fname = TableFileName({DbPath("bar", 0)}, 200, 0);
 147   std::string fname1 =
 148       TableFileName({DbPath("foo", 0), DbPath("bar", 0)}, 200, 1);
 149   ASSERT_EQ(fname, fname1);
 150   ASSERT_EQ("bar/", std::string(fname.data(), 4));
 151   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 152   ASSERT_EQ(200U, number);
 153   ASSERT_EQ(kTableFile, type);
 154
 155   fname = DescriptorFileName("bar", 100);
 156   ASSERT_EQ("bar/", std::string(fname.data(), 4));
 157   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 158   ASSERT_EQ(100U, number);
 159   ASSERT_EQ(kDescriptorFile, type);
 160
 161   fname = TempFileName("tmp", 999);
 162   ASSERT_EQ("tmp/", std::string(fname.data(), 4));
 163   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 164   ASSERT_EQ(999U, number);
 165   ASSERT_EQ(kTempFile, type);
 166
 167   fname = MetaDatabaseName("met", 100);
 168   ASSERT_EQ("met/", std::string(fname.data(), 4));
 169   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 170   ASSERT_EQ(100U, number);
 171   ASSERT_EQ(kMetaDatabase, type);
 172 }
 173
 174 }  // namespace ROCKSDB_NAMESPACE
 175
 176 int main(int argc, char** argv) {
 177   ::testing::InitGoogleTest(&argc, argv);
 178   return RUN_ALL_TESTS();
 179 }