ceph/src/rocksdb/db/filename_test.cc

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