ceph/src/rocksdb/db/blob/blob_file_reader.h

   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 #pragma once
   7
   8 #include <cinttypes>
   9 #include <memory>
  10
  11 #include "db/blob/blob_read_request.h"
  12 #include "file/random_access_file_reader.h"
  13 #include "rocksdb/compression_type.h"
  14 #include "rocksdb/rocksdb_namespace.h"
  15 #include "util/autovector.h"
  16
  17 namespace ROCKSDB_NAMESPACE {
  18
  19 class Status;
  20 struct ImmutableOptions;
  21 struct FileOptions;
  22 class HistogramImpl;
  23 struct ReadOptions;
  24 class Slice;
  25 class FilePrefetchBuffer;
  26 class BlobContents;
  27 class Statistics;
  28
  29 class BlobFileReader {
  30  public:
  31   static Status Create(const ImmutableOptions& immutable_options,
  32                        const FileOptions& file_options,
  33                        uint32_t column_family_id,
  34                        HistogramImpl* blob_file_read_hist,
  35                        uint64_t blob_file_number,
  36                        const std::shared_ptr<IOTracer>& io_tracer,
  37                        std::unique_ptr<BlobFileReader>* reader);
  38
  39   BlobFileReader(const BlobFileReader&) = delete;
  40   BlobFileReader& operator=(const BlobFileReader&) = delete;
  41
  42   ~BlobFileReader();
  43
  44   Status GetBlob(const ReadOptions& read_options, const Slice& user_key,
  45                  uint64_t offset, uint64_t value_size,
  46                  CompressionType compression_type,
  47                  FilePrefetchBuffer* prefetch_buffer,
  48                  MemoryAllocator* allocator,
  49                  std::unique_ptr<BlobContents>* result,
  50                  uint64_t* bytes_read) const;
  51
  52   // offsets must be sorted in ascending order by caller.
  53   void MultiGetBlob(
  54       const ReadOptions& read_options, MemoryAllocator* allocator,
  55       autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>&
  56           blob_reqs,
  57       uint64_t* bytes_read) const;
  58
  59   CompressionType GetCompressionType() const { return compression_type_; }
  60
  61   uint64_t GetFileSize() const { return file_size_; }
  62
  63  private:
  64   BlobFileReader(std::unique_ptr<RandomAccessFileReader>&& file_reader,
  65                  uint64_t file_size, CompressionType compression_type,
  66                  SystemClock* clock, Statistics* statistics);
  67
  68   static Status OpenFile(const ImmutableOptions& immutable_options,
  69                          const FileOptions& file_opts,
  70                          HistogramImpl* blob_file_read_hist,
  71                          uint64_t blob_file_number,
  72                          const std::shared_ptr<IOTracer>& io_tracer,
  73                          uint64_t* file_size,
  74                          std::unique_ptr<RandomAccessFileReader>* file_reader);
  75
  76   static Status ReadHeader(const RandomAccessFileReader* file_reader,
  77                            uint32_t column_family_id, Statistics* statistics,
  78                            CompressionType* compression_type);
  79
  80   static Status ReadFooter(const RandomAccessFileReader* file_reader,
  81                            uint64_t file_size, Statistics* statistics);
  82
  83   using Buffer = std::unique_ptr<char[]>;
  84
  85   static Status ReadFromFile(const RandomAccessFileReader* file_reader,
  86                              uint64_t read_offset, size_t read_size,
  87                              Statistics* statistics, Slice* slice, Buffer* buf,
  88                              AlignedBuf* aligned_buf,
  89                              Env::IOPriority rate_limiter_priority);
  90
  91   static Status VerifyBlob(const Slice& record_slice, const Slice& user_key,
  92                            uint64_t value_size);
  93
  94   static Status UncompressBlobIfNeeded(const Slice& value_slice,
  95                                        CompressionType compression_type,
  96                                        MemoryAllocator* allocator,
  97                                        SystemClock* clock,
  98                                        Statistics* statistics,
  99                                        std::unique_ptr<BlobContents>* result);
 100
 101   std::unique_ptr<RandomAccessFileReader> file_reader_;
 102   uint64_t file_size_;
 103   CompressionType compression_type_;
 104   SystemClock* clock_;
 105   Statistics* statistics_;
 106 };
 107
 108 }  // namespace ROCKSDB_NAMESPACE