YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// 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/tablet/tablet-harness.h"

#include "yb/common/index.h"

#include "yb/common/partition.h"

#include "yb/consensus/log_anchor_registry.h"

#include "yb/server/logical_clock.h"

#include "yb/tablet/tablet.h"

#include "yb/tablet/tablet_metadata.h"

#include "yb/util/result.h"

namespace yb {

namespace tablet {

std::pair<PartitionSchema, Partition> CreateDefaultPartition(const Schema& schema) {

  // Create a default partition schema.

  PartitionSchema partition_schema;

  CHECK_OK(PartitionSchema::FromPB(PartitionSchemaPB(), schema, &partition_schema));

  // Create the tablet partitions.

  vector<Partition> partitions;

  CHECK_OK(partition_schema.CreatePartitions(vector<YBPartialRow>(), schema, &partitions));

  CHECK_EQ(1, partitions.size());

  return std::make_pair(partition_schema, partitions[0]);

}

CHECKED_STATUS TabletHarness::Create(bool first_time) {

  std::pair<PartitionSchema, Partition> partition(CreateDefaultPartition(schema_));

  // Build the Tablet

  fs_manager_.reset(new FsManager(options_.env, options_.root_dir, "tserver_test"));

  if (first_time) {

    RETURN_NOT_OK(fs_manager_->CreateInitialFileSystemLayout());

  }

  RETURN_NOT_OK(fs_manager_->CheckAndOpenFileSystemRoots());

  auto table_info = std::make_shared<TableInfo>(

      "YBTableTest", "test", "YBTableTest", options_.table_type, schema_, IndexMap(), boost::none,

      0 /* schema_version */, partition.first);

  auto metadata = VERIFY_RESULT(RaftGroupMetadata::LoadOrCreate(RaftGroupMetadataData {

    .fs_manager = fs_manager_.get(),

    .table_info = table_info,

    .raft_group_id = options_.tablet_id,

    .partition = partition.second,

    .tablet_data_state = TABLET_DATA_READY,

  }));

  if (options_.enable_metrics) {

    metrics_registry_.reset(new MetricRegistry());

  }

  clock_ = server::LogicalClock::CreateStartingAt(HybridTime::kInitial);

  tablet_ = std::make_shared<Tablet>(MakeTabletInitData(metadata));

  return Status::OK();

}

CHECKED_STATUS TabletHarness::Open() {

  RETURN_NOT_OK(tablet_->Open());

  tablet_->MarkFinishedBootstrapping();

  return tablet_->EnableCompactions(/* non_abortable_ops_pause */ nullptr);

}

Result<TabletPtr> TabletHarness::OpenTablet(const TabletId& tablet_id) {

  auto metadata = VERIFY_RESULT(RaftGroupMetadata::Load(fs_manager_.get(), tablet_id));

  auto tablet = std::make_shared<Tablet>(MakeTabletInitData(metadata));

  RETURN_NOT_OK(tablet->Open());

  tablet->MarkFinishedBootstrapping();

  RETURN_NOT_OK(tablet->EnableCompactions(/* non_abortable_ops_pause */ nullptr));

  return tablet;

}

TabletInitData TabletHarness::MakeTabletInitData(const RaftGroupMetadataPtr& metadata) {

  return TabletInitData {

    .metadata = metadata,

    .client_future = std::shared_future<client::YBClient*>(),

    .clock = clock_,

    .parent_mem_tracker = std::shared_ptr<MemTracker>(),

    .block_based_table_mem_tracker = std::shared_ptr<MemTracker>(),

    .metric_registry = metrics_registry_.get(),

    .log_anchor_registry = new log::LogAnchorRegistry(),

    .tablet_options = TabletOptions(),

    .log_prefix_suffix = std::string(),

    .transaction_participant_context = nullptr,

    .local_tablet_filter = client::LocalTabletFilter(),

    .transaction_coordinator_context = nullptr,

    .txns_enabled = TransactionsEnabled::kFalse,

    .is_sys_catalog = IsSysCatalogTablet::kFalse,

    .snapshot_coordinator = nullptr,

    .tablet_splitter = nullptr

  };

}

} // namespace tablet

} // namespace yb