ceph/src/rocksdb/utilities/trace/file_trace_reader_writer.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 #include "utilities/trace/file_trace_reader_writer.h"
   7
   8 #include "util/coding.h"
   9 #include "util/file_reader_writer.h"
  10 #include "util/trace_replay.h"
  11
  12 namespace rocksdb {
  13
  14 const unsigned int FileTraceReader::kBufferSize = 1024;  // 1KB
  15
  16 FileTraceReader::FileTraceReader(
  17     std::unique_ptr<RandomAccessFileReader>&& reader)
  18     : file_reader_(std::move(reader)),
  19       offset_(0),
  20       buffer_(new char[kBufferSize]) {}
  21
  22 FileTraceReader::~FileTraceReader() {
  23   Close();
  24   delete[] buffer_;
  25 }
  26
  27 Status FileTraceReader::Close() {
  28   file_reader_.reset();
  29   return Status::OK();
  30 }
  31
  32 Status FileTraceReader::Read(std::string* data) {
  33   assert(file_reader_ != nullptr);
  34   Status s = file_reader_->Read(offset_, kTraceMetadataSize, &result_, buffer_);
  35   if (!s.ok()) {
  36     return s;
  37   }
  38   if (result_.size() == 0) {
  39     // No more data to read
  40     // Todo: Come up with a better way to indicate end of data. May be this
  41     // could be avoided once footer is introduced.
  42     return Status::Incomplete();
  43   }
  44   if (result_.size() < kTraceMetadataSize) {
  45     return Status::Corruption("Corrupted trace file.");
  46   }
  47   *data = result_.ToString();
  48   offset_ += kTraceMetadataSize;
  49
  50   uint32_t payload_len =
  51       DecodeFixed32(&buffer_[kTraceTimestampSize + kTraceTypeSize]);
  52
  53   // Read Payload
  54   unsigned int bytes_to_read = payload_len;
  55   unsigned int to_read =
  56       bytes_to_read > kBufferSize ? kBufferSize : bytes_to_read;
  57   while (to_read > 0) {
  58     s = file_reader_->Read(offset_, to_read, &result_, buffer_);
  59     if (!s.ok()) {
  60       return s;
  61     }
  62     if (result_.size() < to_read) {
  63       return Status::Corruption("Corrupted trace file.");
  64     }
  65     data->append(result_.data(), result_.size());
  66
  67     offset_ += to_read;
  68     bytes_to_read -= to_read;
  69     to_read = bytes_to_read > kBufferSize ? kBufferSize : bytes_to_read;
  70   }
  71
  72   return s;
  73 }
  74
  75 FileTraceWriter::~FileTraceWriter() { Close(); }
  76
  77 Status FileTraceWriter::Close() {
  78   file_writer_.reset();
  79   return Status::OK();
  80 }
  81
  82 Status FileTraceWriter::Write(const Slice& data) {
  83   return file_writer_->Append(data);
  84 }
  85
  86 Status NewFileTraceReader(Env* env, const EnvOptions& env_options,
  87                           const std::string& trace_filename,
  88                           std::unique_ptr<TraceReader>* trace_reader) {
  89   unique_ptr<RandomAccessFile> trace_file;
  90   Status s = env->NewRandomAccessFile(trace_filename, &trace_file, env_options);
  91   if (!s.ok()) {
  92     return s;
  93   }
  94
  95   unique_ptr<RandomAccessFileReader> file_reader;
  96   file_reader.reset(
  97       new RandomAccessFileReader(std::move(trace_file), trace_filename));
  98   trace_reader->reset(new FileTraceReader(std::move(file_reader)));
  99   return s;
 100 }
 101
 102 Status NewFileTraceWriter(Env* env, const EnvOptions& env_options,
 103                           const std::string& trace_filename,
 104                           std::unique_ptr<TraceWriter>* trace_writer) {
 105   unique_ptr<WritableFile> trace_file;
 106   Status s = env->NewWritableFile(trace_filename, &trace_file, env_options);
 107   if (!s.ok()) {
 108     return s;
 109   }
 110
 111   unique_ptr<WritableFileWriter> file_writer;
 112   file_writer.reset(new WritableFileWriter(std::move(trace_file),
 113                                            trace_filename, env_options));
 114   trace_writer->reset(new FileTraceWriter(std::move(file_writer)));
 115   return s;
 116 }
 117
 118 }  // namespace rocksdb