ceph/src/rocksdb/env/file_system.cc

   1 // Copyright (c) 2019-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 #include "env/composite_env_wrapper.h"
   7 #include "rocksdb/file_system.h"
   8 #include "options/db_options.h"
   9 #include "rocksdb/utilities/object_registry.h"
  10
  11 namespace ROCKSDB_NAMESPACE {
  12
  13 FileSystem::FileSystem() {}
  14
  15 FileSystem::~FileSystem() {}
  16
  17 Status FileSystem::Load(const std::string& value,
  18                         std::shared_ptr<FileSystem>* result) {
  19   Status s;
  20 #ifndef ROCKSDB_LITE
  21   s = ObjectRegistry::NewInstance()->NewSharedObject<FileSystem>(value, result);
  22 #else
  23   (void)result;
  24   s = Status::NotSupported("Cannot load FileSystem in LITE mode: ", value);
  25 #endif
  26   return s;
  27 }
  28
  29 FileOptions FileSystem::OptimizeForLogRead(
  30               const FileOptions& file_options) const {
  31   FileOptions optimized_file_options(file_options);
  32   optimized_file_options.use_direct_reads = false;
  33   return optimized_file_options;
  34 }
  35
  36 FileOptions FileSystem::OptimizeForManifestRead(
  37     const FileOptions& file_options) const {
  38   FileOptions optimized_file_options(file_options);
  39   optimized_file_options.use_direct_reads = false;
  40   return optimized_file_options;
  41 }
  42
  43 FileOptions FileSystem::OptimizeForLogWrite(const FileOptions& file_options,
  44                                            const DBOptions& db_options) const {
  45   FileOptions optimized_file_options(file_options);
  46   optimized_file_options.bytes_per_sync = db_options.wal_bytes_per_sync;
  47   optimized_file_options.writable_file_max_buffer_size =
  48       db_options.writable_file_max_buffer_size;
  49   return optimized_file_options;
  50 }
  51
  52 FileOptions FileSystem::OptimizeForManifestWrite(
  53     const FileOptions& file_options) const {
  54   return file_options;
  55 }
  56
  57 FileOptions FileSystem::OptimizeForCompactionTableWrite(
  58     const FileOptions& file_options,
  59     const ImmutableDBOptions& db_options) const {
  60   FileOptions optimized_file_options(file_options);
  61   optimized_file_options.use_direct_writes =
  62       db_options.use_direct_io_for_flush_and_compaction;
  63   return optimized_file_options;
  64 }
  65
  66 FileOptions FileSystem::OptimizeForCompactionTableRead(
  67     const FileOptions& file_options,
  68     const ImmutableDBOptions& db_options) const {
  69   FileOptions optimized_file_options(file_options);
  70   optimized_file_options.use_direct_reads = db_options.use_direct_reads;
  71   return optimized_file_options;
  72 }
  73
  74 Status ReadFileToString(FileSystem* fs, const std::string& fname,
  75                         std::string* data) {
  76   FileOptions soptions;
  77   data->clear();
  78   std::unique_ptr<FSSequentialFile> file;
  79   Status s = fs->NewSequentialFile(fname, soptions, &file, nullptr);
  80   if (!s.ok()) {
  81     return s;
  82   }
  83   static const int kBufferSize = 8192;
  84   char* space = new char[kBufferSize];
  85   while (true) {
  86     Slice fragment;
  87     s = file->Read(kBufferSize, IOOptions(), &fragment, space,
  88                    nullptr);
  89     if (!s.ok()) {
  90       break;
  91     }
  92     data->append(fragment.data(), fragment.size());
  93     if (fragment.empty()) {
  94       break;
  95     }
  96   }
  97   delete[] space;
  98   return s;
  99 }
 100
 101 #ifdef OS_WIN
 102 std::shared_ptr<FileSystem> FileSystem::Default() {
 103   static LegacyFileSystemWrapper default_fs(Env::Default());
 104   static std::shared_ptr<LegacyFileSystemWrapper> default_fs_ptr(
 105       &default_fs, [](LegacyFileSystemWrapper*) {});
 106   return default_fs_ptr;
 107 }
 108 #endif
 109
 110 }  // namespace ROCKSDB_NAMESPACE