YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

// in compliance with the License.  You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software distributed under the License

// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

// or implied.  See the License for the specific language governing permissions and limitations

// under the License.

//

// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#ifndef YB_ROCKSDB_DB_LOG_READER_H

#define YB_ROCKSDB_DB_LOG_READER_H

#include <stdint.h>

#include <memory>

#include "yb/rocksdb/db/log_format.h"

#include "yb/util/slice.h"

#include "yb/rocksdb/status.h"

#include "yb/rocksdb/options.h"

namespace rocksdb {

class SequentialFileReader;

class Logger;

namespace log {

/**

 * Reader is a general purpose log stream reader implementation. The actual job

 * of reading from the device is implemented by the SequentialFile interface.

 *

 * Please see Writer for details on the file and record layout.

 */

class Reader {

 public:

  // Interface for reporting errors.

  class Reporter {

   public:

    virtual ~Reporter();

    // Some corruption was detected.  "size" is the approximate number

    // of bytes dropped due to the corruption.

    virtual void Corruption(size_t bytes, const Status& status) = 0;

  };

  // Create a reader that will return log records from "*file".

  // "*file" must remain live while this Reader is in use.

  //

  // If "reporter" is non-nullptr, it is notified whenever some data is

  // dropped due to a detected corruption.  "*reporter" must remain

  // live while this Reader is in use.

  //

  // If "checksum" is true, verify checksums if available.

  //

  // The Reader will start reading at the first record located at physical

  // position >= initial_offset within the file.

  Reader(

      std::shared_ptr<Logger> info_log,

      std::unique_ptr<SequentialFileReader>&& file,

      Reporter* reporter,

      bool checksum,

      uint64_t initial_offset,

      uint64_t log_num);

  ~Reader();

  // Read the next record into *record.  Returns true if read

  // successfully, false if we hit end of the input.  May use

  // "*scratch" as temporary storage.  The contents filled in *record

  // will only be valid until the next mutating operation on this

  // reader or the next mutation to *scratch.

  bool ReadRecord(Slice* record, std::string* scratch,

                  WALRecoveryMode wal_recovery_mode =

                      WALRecoveryMode::kTolerateCorruptedTailRecords);

  // Returns the physical offset of the last record returned by ReadRecord.

  //

  // Undefined before the first call to ReadRecord.

  uint64_t LastRecordOffset();

  // returns true if the reader has encountered an eof condition.

  bool IsEOF() {

    return eof_;

  }

  // when we know more data has been written to the file. we can use this

  // function to force the reader to look again in the file.

  // Also aligns the file position indicator to the start of the next block

  // by reading the rest of the data from the EOF position to the end of the

  // block that was partially read.

  void UnmarkEOF();

  SequentialFileReader* file() { return file_.get(); }

 private:

  std::shared_ptr<Logger> info_log_;

  const std::unique_ptr<SequentialFileReader> file_;

  Reporter* const reporter_;

  bool const checksum_;

  uint8_t* const backing_store_;

  Slice buffer_;

  bool eof_;   // Last Read() indicated EOF by returning < kBlockSize

  bool read_error_;   // Error occurred while reading from file

  // Offset of the file position indicator within the last block when an

  // EOF was detected.

  size_t eof_offset_;

  // Offset of the last record returned by ReadRecord.

  uint64_t last_record_offset_;

  // Offset of the first location past the end of buffer_.

  uint64_t end_of_buffer_offset_;

  // Offset at which to start looking for the first record to return

  uint64_t const initial_offset_;

  // which log number this is

  uint64_t const log_number_;

  // Extend record types with the following special values

  enum {

    kEof = kMaxRecordType + 1,

    // Returned whenever we find an invalid physical record.

    // Currently there are three situations in which this happens:

    // * The record has an invalid CRC (ReadPhysicalRecord reports a drop)

    // * The record is a 0-length record (No drop is reported)

    // * The record is below constructor's initial_offset (No drop is reported)

    kBadRecord = kMaxRecordType + 2,

    // Returned when we fail to read a valid header.

    kBadHeader = kMaxRecordType + 3,

    // Returned when we read an old record from a previous user of the log.

    kOldRecord = kMaxRecordType + 4,

  };

  // Skips all blocks that are completely before "initial_offset_".

  //

  // Returns true on success. Handles reporting.

  bool SkipToInitialBlock();

  // Return type, or one of the preceding special values

  unsigned int ReadPhysicalRecord(Slice* result, size_t* drop_size);

  // Read some more

  bool ReadMore(size_t* drop_size, int *error);

  // Reports dropped bytes to the reporter.

  // buffer_ must be updated to remove the dropped bytes prior to invocation.

  void ReportCorruption(size_t bytes, const char* reason);

  void ReportDrop(size_t bytes, const Status& reason);

  // No copying allowed

  Reader(const Reader&);

  void operator=(const Reader&);

};

}  // namespace log

}  // namespace rocksdb

#endif  // YB_ROCKSDB_DB_LOG_READER_H