YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// 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.

//  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.

//

#include "yb/rocksdb/table/mock_table.h"

#include <gtest/gtest.h>

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

#include "yb/rocksdb/port/port.h"

#include "yb/rocksdb/table_properties.h"

#include "yb/rocksdb/table/get_context.h"

#include "yb/rocksdb/util/coding.h"

#include "yb/rocksdb/util/file_reader_writer.h"

#include "yb/util/status_log.h"

namespace rocksdb {

namespace mock {

namespace {

const InternalKeyComparator icmp_(BytewiseComparator());

}  // namespace

stl_wrappers::KVMap MakeMockFile(

    std::initializer_list<std::pair<const std::string, std::string>> l) {

  return stl_wrappers::KVMap(l, stl_wrappers::LessOfComparator(&icmp_));

}

InternalIterator* MockTableReader::NewIterator(const ReadOptions&, Arena* arena,

                                               bool skip_filters) {

  return new MockTableIterator(table_);

}

Status MockTableReader::Get(const ReadOptions&, const Slice& key,

                            GetContext* get_context, bool skip_filters) {

  std::unique_ptr<MockTableIterator> iter(new MockTableIterator(table_));

  for (iter->Seek(key); iter->Valid(); iter->Next()) {

    ParsedInternalKey parsed_key;

    if (!ParseInternalKey(iter->key(), &parsed_key)) {

      return STATUS(Corruption, Slice());

    }

    if (!get_context->SaveValue(parsed_key, iter->value())) {

      break;

    }

  }

  return Status::OK();

}

std::shared_ptr<const TableProperties> MockTableReader::GetTableProperties()

    const {

  return std::shared_ptr<const TableProperties>(new TableProperties());

}

MockTableFactory::MockTableFactory() : next_id_(1) {}

Status MockTableFactory::NewTableReader(

    const TableReaderOptions& table_reader_options,

    unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,

    unique_ptr<TableReader>* table_reader) const {

  uint32_t id = GetIDFromFile(file.get());

  MutexLock lock_guard(&file_system_.mutex);

  auto it = file_system_.files.find(id);

  if (it == file_system_.files.end()) {

    return STATUS(IOError, "Mock file not found");

  }

  table_reader->reset(new MockTableReader(it->second));

  return Status::OK();

}

TableBuilder* MockTableFactory::NewTableBuilder(

    const TableBuilderOptions& table_builder_options, uint32_t column_family_id,

    WritableFileWriter* base_file, WritableFileWriter* data_file) const {

  // This table factory doesn't support separate files for metadata and data, because tests using

  // mock tables don't assume separate data file since they are intended for unit testing features

  // which are independent of SST storage format.

  assert(data_file == nullptr);

  uint32_t id = GetAndWriteNextID(base_file);

  return new MockTableBuilder(id, &file_system_);

}

Status MockTableFactory::CreateMockTable(Env* env, const std::string& fname,

                                         stl_wrappers::KVMap file_contents) {

  std::unique_ptr<WritableFile> file;

  auto s = env->NewWritableFile(fname, &file, EnvOptions());

  if (!s.ok()) {

    return s;

  }

  WritableFileWriter file_writer(std::move(file), EnvOptions());

  uint32_t id = GetAndWriteNextID(&file_writer);

  file_system_.files.insert({id, std::move(file_contents)});

  return Status::OK();

}

uint32_t MockTableFactory::GetAndWriteNextID(WritableFileWriter* file) const {

  uint32_t next_id = next_id_.fetch_add(1);

  char buf[4];

  EncodeFixed32(buf, next_id);

  CHECK_OK(file->Append(Slice(buf, 4)));

  return next_id;

}

uint32_t MockTableFactory::GetIDFromFile(RandomAccessFileReader* file) const {

  char buf[4];

  Slice result;

  CHECK_OK(file->Read(0, 4, &result, buf));

  assert(result.size() == 4);

  return DecodeFixed32(buf);

}

void MockTableFactory::AssertSingleFile(

    const stl_wrappers::KVMap& file_contents) {

  ASSERT_EQ(file_system_.files.size(), 1U);

  ASSERT_TRUE(file_contents == file_system_.files.begin()->second);

}

void MockTableFactory::AssertLatestFile(

    const stl_wrappers::KVMap& file_contents) {

  ASSERT_GE(file_system_.files.size(), 1U);

  auto latest = file_system_.files.end();

  --latest;

  if (file_contents != latest->second) {

    std::cout << "Wrong content! Content of latest file:" << std::endl;

    for (const auto& kv : latest->second) {

      ParsedInternalKey ikey;

      std::string key, value;

      std::tie(key, value) = kv;

      ParseInternalKey(Slice(key), &ikey);

      std::cout << ikey.DebugString(false) << " -> " << value << std::endl;

    }

    ASSERT_TRUE(false);

  }

}

}  // namespace mock

}  // namespace rocksdb