Make FileSystem a Customizable Class (#8649)

Summary: Pull Request resolved: #8649 Reviewed By: zhichao-cao Differential Revision: D32036059 Pulled By: mrambacher fbshipit-source-id: 4f1e7557ecac52eb849b83ae02b8d7d232112295
facebook · Nov 2, 2021 · f72c834 · f72c834
1 parent cfc57f5
commit f72c834
Show file tree

Hide file tree

Showing 24 changed files with 889 additions and 360 deletions.
diff --git a/HISTORY.md b/HISTORY.md
@@ -15,6 +15,9 @@
 ### Public Interface Change
 * When options.ttl is used with leveled compaction with compactinon priority kMinOverlappingRatio, files exceeding half of TTL value will be prioritized more, so that by the time TTL is reached, fewer extra compactions will be scheduled to clear them up. At the same time, when compacting files with data older than half of TTL, output files may be cut off based on those files' boundaries, in order for the early TTL compaction to work properly.
 
+### Public API change
+* Made FileSystem extend the Customizable class and added a CreateFromString method.  Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method.
+
 ## 6.26.0 (2021-10-20)
 ### Bug Fixes
 * Fixes a bug in directed IO mode when calling MultiGet() for blobs in the same blob file. The bug is caused by not sorting the blob read requests by file offsets.

diff --git a/db/db_basic_test.cc b/db/db_basic_test.cc
@@ -3296,6 +3296,9 @@ class DeadlineFS : public FileSystemWrapper {
         ignore_deadline_(false),
         error_on_delay_(error_on_delay) {}
 
+  static const char* kClassName() { return "DeadlineFileSystem"; }
+  const char* Name() const override { return kClassName(); }
+
   IOStatus NewRandomAccessFile(const std::string& fname,
                                const FileOptions& opts,
                                std::unique_ptr<FSRandomAccessFile>* result,

diff --git a/env/env.cc b/env/env.cc
@@ -324,7 +324,8 @@ class LegacyFileSystemWrapper : public FileSystem {
   explicit LegacyFileSystemWrapper(Env* t) : target_(t) {}
   ~LegacyFileSystemWrapper() override {}
 
-  const char* Name() const override { return "Legacy File System"; }
+  static const char* kClassName() { return "LegacyFileSystem"; }
+  const char* Name() const override { return kClassName(); }
 
   // Return the target to which this Env forwards all calls
   Env* target() const { return target_; }

diff --git a/env/env_chroot.cc b/env/env_chroot.cc
@@ -13,20 +13,35 @@
 
 #include "env/composite_env_wrapper.h"
 #include "env/fs_remap.h"
+#include "rocksdb/utilities/options_type.h"
 #include "util/string_util.h"  // errnoStr
 
 namespace ROCKSDB_NAMESPACE {
 namespace {
-class ChrootFileSystem : public RemapFileSystem {
- public:
-  ChrootFileSystem(const std::shared_ptr<FileSystem>& base,
-                   const std::string& chroot_dir)
-      : RemapFileSystem(base) {
+static std::unordered_map<std::string, OptionTypeInfo> chroot_fs_type_info = {
+    {"chroot_dir", {0, OptionType::kString}}};
+}  // namespace
+ChrootFileSystem::ChrootFileSystem(const std::shared_ptr<FileSystem>& base,
+                                   const std::string& chroot_dir)
+    : RemapFileSystem(base), chroot_dir_(chroot_dir) {
+  RegisterOptions("chroot_dir", &chroot_dir_, &chroot_fs_type_info);
+}
+
+Status ChrootFileSystem::PrepareOptions(const ConfigOptions& options) {
+  Status s = FileSystemWrapper::PrepareOptions(options);
+  if (!s.ok()) {
+    return s;
+  } else if (chroot_dir_.empty()) {
+    s = Status::InvalidArgument("ChRootFileSystem requires a chroot dir");
+  } else {
+    s = target_->FileExists(chroot_dir_, IOOptions(), nullptr);
+  }
+  if (s.ok()) {
 #if defined(OS_AIX)
     char resolvedName[PATH_MAX];
-    char* real_chroot_dir = realpath(chroot_dir.c_str(), resolvedName);
+    char* real_chroot_dir = realpath(chroot_dir_.c_str(), resolvedName);
 #else
-    char* real_chroot_dir = realpath(chroot_dir.c_str(), nullptr);
+    char* real_chroot_dir = realpath(chroot_dir_.c_str(), nullptr);
 #endif
     // chroot_dir must exist so realpath() returns non-nullptr.
     assert(real_chroot_dir != nullptr);
@@ -35,32 +50,32 @@ class ChrootFileSystem : public RemapFileSystem {
     free(real_chroot_dir);
 #endif
   }
+  return s;
+}
 
-  const char* Name() const override { return "ChrootFS"; }
-
-  IOStatus GetTestDirectory(const IOOptions& options, std::string* path,
-                            IODebugContext* dbg) override {
-    // Adapted from PosixEnv's implementation since it doesn't provide a way to
-    // create directory in the chroot.
-    char buf[256];
-    snprintf(buf, sizeof(buf), "/rocksdbtest-%d", static_cast<int>(geteuid()));
-    *path = buf;
-
-    // Directory may already exist, so ignore return
-    return CreateDirIfMissing(*path, options, dbg);
-  }
+IOStatus ChrootFileSystem::GetTestDirectory(const IOOptions& options,
+                                            std::string* path,
+                                            IODebugContext* dbg) {
+  // Adapted from PosixEnv's implementation since it doesn't provide a way to
+  // create directory in the chroot.
+  char buf[256];
+  snprintf(buf, sizeof(buf), "/rocksdbtest-%d", static_cast<int>(geteuid()));
+  *path = buf;
+
+  // Directory may already exist, so ignore return
+  return CreateDirIfMissing(*path, options, dbg);
+}
 
- protected:
   // Returns status and expanded absolute path including the chroot directory.
   // Checks whether the provided path breaks out of the chroot. If it returns
   // non-OK status, the returned path should not be used.
-  std::pair<IOStatus, std::string> EncodePath(
-      const std::string& path) override {
-    if (path.empty() || path[0] != '/') {
-      return {IOStatus::InvalidArgument(path, "Not an absolute path"), ""};
-    }
-    std::pair<IOStatus, std::string> res;
-    res.second = chroot_dir_ + path;
+std::pair<IOStatus, std::string> ChrootFileSystem::EncodePath(
+    const std::string& path) {
+  if (path.empty() || path[0] != '/') {
+    return {IOStatus::InvalidArgument(path, "Not an absolute path"), ""};
+  }
+  std::pair<IOStatus, std::string> res;
+  res.second = chroot_dir_ + path;
 #if defined(OS_AIX)
     char resolvedName[PATH_MAX];
     char* normalized_path = realpath(res.second.c_str(), resolvedName);
@@ -81,47 +96,51 @@ class ChrootFileSystem : public RemapFileSystem {
     free(normalized_path);
 #endif
     return res;
-  }
+}
 
   // Similar to EncodePath() except assumes the basename in the path hasn't been
   // created yet.
-  std::pair<IOStatus, std::string> EncodePathWithNewBasename(
-      const std::string& path) override {
-    if (path.empty() || path[0] != '/') {
-      return {IOStatus::InvalidArgument(path, "Not an absolute path"), ""};
-    }
-    // Basename may be followed by trailing slashes
-    size_t final_idx = path.find_last_not_of('/');
-    if (final_idx == std::string::npos) {
-      // It's only slashes so no basename to extract
-      return EncodePath(path);
-    }
-
-    // Pull off the basename temporarily since realname(3) (used by
-    // EncodePath()) requires a path that exists
-    size_t base_sep = path.rfind('/', final_idx);
-    auto status_and_enc_path = EncodePath(path.substr(0, base_sep + 1));
-    status_and_enc_path.second.append(path.substr(base_sep + 1));
-    return status_and_enc_path;
+std::pair<IOStatus, std::string> ChrootFileSystem::EncodePathWithNewBasename(
+    const std::string& path) {
+  if (path.empty() || path[0] != '/') {
+    return {IOStatus::InvalidArgument(path, "Not an absolute path"), ""};
+  }
+  // Basename may be followed by trailing slashes
+  size_t final_idx = path.find_last_not_of('/');
+  if (final_idx == std::string::npos) {
+    // It's only slashes so no basename to extract
+    return EncodePath(path);
   }
 
- private:
-  std::string chroot_dir_;
-};
-}  // namespace
+  // Pull off the basename temporarily since realname(3) (used by
+  // EncodePath()) requires a path that exists
+  size_t base_sep = path.rfind('/', final_idx);
+  auto status_and_enc_path = EncodePath(path.substr(0, base_sep + 1));
+  status_and_enc_path.second.append(path.substr(base_sep + 1));
+  return status_and_enc_path;
+}
 
 std::shared_ptr<FileSystem> NewChrootFileSystem(
     const std::shared_ptr<FileSystem>& base, const std::string& chroot_dir) {
-  return std::make_shared<ChrootFileSystem>(base, chroot_dir);
+  auto chroot_fs = std::make_shared<ChrootFileSystem>(base, chroot_dir);
+  Status s = chroot_fs->PrepareOptions(ConfigOptions());
+  if (s.ok()) {
+    return chroot_fs;
+  } else {
+    return nullptr;
+  }
 }
 
 Env* NewChrootEnv(Env* base_env, const std::string& chroot_dir) {
   if (!base_env->FileExists(chroot_dir).ok()) {
     return nullptr;
   }
-  std::shared_ptr<FileSystem> chroot_fs =
-      NewChrootFileSystem(base_env->GetFileSystem(), chroot_dir);
-  return new CompositeEnvWrapper(base_env, chroot_fs);
+  auto chroot_fs = NewChrootFileSystem(base_env->GetFileSystem(), chroot_dir);
+  if (chroot_fs != nullptr) {
+    return new CompositeEnvWrapper(base_env, chroot_fs);
+  } else {
+    return nullptr;
+  }
 }
 
 }  // namespace ROCKSDB_NAMESPACE

diff --git a/env/env_chroot.h b/env/env_chroot.h
@@ -9,16 +9,46 @@
 
 #include <string>
 
-#include "rocksdb/env.h"
+#include "env/fs_remap.h"
+#include "rocksdb/file_system.h"
 
 namespace ROCKSDB_NAMESPACE {
+class ChrootFileSystem : public RemapFileSystem {
+ public:
+  ChrootFileSystem(const std::shared_ptr<FileSystem>& base,
+                   const std::string& chroot_dir);
+
+  static const char* kClassName() { return "ChrootFS"; }
+  const char* Name() const override { return kClassName(); }
+
+  IOStatus GetTestDirectory(const IOOptions& options, std::string* path,
+                            IODebugContext* dbg) override;
+
+  Status PrepareOptions(const ConfigOptions& options) override;
+
+ protected:
+  // Returns status and expanded absolute path including the chroot directory.
+  // Checks whether the provided path breaks out of the chroot. If it returns
+  // non-OK status, the returned path should not be used.
+  std::pair<IOStatus, std::string> EncodePath(const std::string& path) override;
+
+  // Similar to EncodePath() except assumes the basename in the path hasn't been
+  // created yet.
+  std::pair<IOStatus, std::string> EncodePathWithNewBasename(
+      const std::string& path) override;
+
+ private:
+  std::string chroot_dir_;
+};
 
 // Returns an Env that translates paths such that the root directory appears to
 // be chroot_dir. chroot_dir should refer to an existing directory.
 //
 // This class has not been fully analyzed for providing strong security
 // guarantees.
 Env* NewChrootEnv(Env* base_env, const std::string& chroot_dir);
+std::shared_ptr<FileSystem> NewChrootFileSystem(
+    const std::shared_ptr<FileSystem>& base, const std::string& chroot_dir);
 
 }  // namespace ROCKSDB_NAMESPACE
 

diff --git a/env/env_encryption.cc b/env/env_encryption.cc
@@ -438,11 +438,20 @@ IOStatus EncryptedRandomRWFile::Close(const IOOptions& options,
 }
 
 namespace {
+static std::unordered_map<std::string, OptionTypeInfo> encrypted_fs_type_info =
+    {
+        {"provider",
+         OptionTypeInfo::AsCustomSharedPtr<EncryptionProvider>(
+             0 /* No offset, whole struct*/, OptionVerificationType::kByName,
+             OptionTypeFlags::kNone)},
+};
 // EncryptedFileSystemImpl implements an FileSystemWrapper that adds encryption
 // to files stored on disk.
 class EncryptedFileSystemImpl : public EncryptedFileSystem {
  public:
-  const char* Name() const override { return "EncryptedFS"; }
+  const char* Name() const override {
+    return EncryptedFileSystem::kClassName();
+  }
   // Returns the raw encryption provider that should be used to write the input
   // encrypted file.  If there is no such provider, NotFound is returned.
   IOStatus GetWritableProvider(const std::string& /*fname*/,
@@ -664,6 +673,7 @@ class EncryptedFileSystemImpl : public EncryptedFileSystem {
                           const std::shared_ptr<EncryptionProvider>& provider)
       : EncryptedFileSystem(base) {
     provider_ = provider;
+    RegisterOptions("EncryptionProvider", &provider_, &encrypted_fs_type_info);
   }
 
   Status AddCipher(const std::string& descriptor, const char* cipher,
@@ -910,10 +920,28 @@ class EncryptedFileSystemImpl : public EncryptedFileSystem {
 };
 }  // namespace
 
+Status NewEncryptedFileSystemImpl(
+    const std::shared_ptr<FileSystem>& base,
+    const std::shared_ptr<EncryptionProvider>& provider,
+    std::unique_ptr<FileSystem>* result) {
+  result->reset(new EncryptedFileSystemImpl(base, provider));
+  return Status::OK();
+}
+
 std::shared_ptr<FileSystem> NewEncryptedFS(
     const std::shared_ptr<FileSystem>& base,
     const std::shared_ptr<EncryptionProvider>& provider) {
-  return std::make_shared<EncryptedFileSystemImpl>(base, provider);
+  std::unique_ptr<FileSystem> efs;
+  Status s = NewEncryptedFileSystemImpl(base, provider, &efs);
+  if (s.ok()) {
+    s = efs->PrepareOptions(ConfigOptions());
+  }
+  if (s.ok()) {
+    std::shared_ptr<FileSystem> result(efs.release());
+    return result;
+  } else {
+    return nullptr;
+  }
 }
 // Returns an Env that encrypts data when stored on disk and decrypts data when
 // read from disk.

diff --git a/env/env_encryption_ctr.h b/env/env_encryption_ctr.h
@@ -105,6 +105,12 @@ class CTREncryptionProvider : public EncryptionProvider {
       uint64_t initialCounter, const Slice& iv, const Slice& prefix,
       std::unique_ptr<BlockAccessCipherStream>* result);
 };
+
+Status NewEncryptedFileSystemImpl(
+    const std::shared_ptr<FileSystem>& base_fs,
+    const std::shared_ptr<EncryptionProvider>& provider,
+    std::unique_ptr<FileSystem>* fs);
+
 }  // namespace ROCKSDB_NAMESPACE
 
 #endif  // !defined(ROCKSDB_LITE)