YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// 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/common/wire_protocol.h"

#include "yb/common/wire_protocol-test-util.h"

#include "yb/rpc/messenger.h"

#include "yb/rpc/rpc_controller.h"

#include "yb/tablet/tablet.h"

#include "yb/tablet/tablet_metadata.h"

#include "yb/tablet/tablet_peer.h"

#include "yb/tablet/tablet_snapshots.h"

#include "yb/tserver/backup.proxy.h"

#include "yb/tserver/mini_tablet_server.h"

#include "yb/tserver/tablet_server.h"

#include "yb/tserver/tablet_server-test-base.h"

#include "yb/tserver/ts_tablet_manager.h"

#include "yb/tserver/tserver.pb.h"

#include "yb/tserver/tserver_service.proxy.h"

namespace yb {

namespace tserver {

using std::string;

using yb::rpc::RpcController;

using yb::tablet::TabletPeer;

using yb::tablet::Tablet;

class BackupServiceTest : public TabletServerTestBase {

 public:

  BackupServiceTest() : TabletServerTestBase(TableType::YQL_TABLE_TYPE) {}

 protected:

  void SetUp() override {

    TabletServerTestBase::SetUp();

    StartTabletServer();

    backup_proxy_.reset(

        new TabletServerBackupServiceProxy(

            proxy_cache_.get(), HostPort::FromBoundEndpoint(mini_server_->bound_rpc_addr())));

  }

  std::unique_ptr<TabletServerBackupServiceProxy> backup_proxy_;

};

TEST_F(BackupServiceTest, TestCreateTabletSnapshot) {

  // Verify that the tablet exists.

  std::shared_ptr<TabletPeer> tablet;

  ASSERT_TRUE(mini_server_->server()->tablet_manager()->LookupTablet(kTabletId, &tablet));

  FsManager* const fs = tablet->tablet_metadata()->fs_manager();

  const string snapshot_id = "00000000000000000000000000000000";

  const string rocksdb_dir = tablet->tablet_metadata()->rocksdb_dir();

  const string top_snapshots_dir = tablet->tablet_metadata()->snapshots_dir();

  const string snapshot_dir = JoinPathSegments(top_snapshots_dir, snapshot_id);

  TabletSnapshotOpRequestPB req;

  TabletSnapshotOpResponsePB resp;

  req.set_operation(TabletSnapshotOpRequestPB::CREATE_ON_TABLET);

  req.set_dest_uuid(mini_server_->server()->fs_manager()->uuid());

  req.set_snapshot_id(snapshot_id);

  // Test empty tablet list - expected error.

  // Send the call.

  {

    RpcController rpc;

    SCOPED_TRACE(req.DebugString());

    ASSERT_OK(backup_proxy_->TabletSnapshotOp(req, &resp, &rpc));

    ASSERT_NOK(StatusFromPB(resp.error().status()));

  }

  req.add_tablet_id(kTabletId);

  ASSERT_TRUE(fs->Exists(rocksdb_dir));

  ASSERT_TRUE(fs->Exists(top_snapshots_dir));

  // Send the call.

  {

    RpcController rpc;

    SCOPED_TRACE(req.DebugString());

    ASSERT_OK(backup_proxy_->TabletSnapshotOp(req, &resp, &rpc));

    SCOPED_TRACE(resp.DebugString());

    ASSERT_FALSE(resp.has_error());

  }

  ASSERT_TRUE(fs->Exists(rocksdb_dir));

  ASSERT_TRUE(fs->Exists(top_snapshots_dir));

  ASSERT_TRUE(fs->Exists(snapshot_dir));

  // Check existence of snapshot files:

  ASSERT_TRUE(fs->Exists(JoinPathSegments(snapshot_dir, "CURRENT")));

  ASSERT_TRUE(fs->Exists(JoinPathSegments(snapshot_dir, "MANIFEST-000001")));

}

TEST_F(BackupServiceTest, TestSnapshotData) {

  // Verify that the tablet exists.

  std::shared_ptr<TabletPeer> tablet;

  ASSERT_TRUE(mini_server_->server()->tablet_manager()->LookupTablet(kTabletId, &tablet));

  tablet.reset();

  WriteRequestPB write_req;

  WriteResponsePB write_resp;

  write_req.set_tablet_id(kTabletId);

  // Send an actual row insert.

  {

    AddTestRowInsert(1, 11, "key1", &write_req);

    RpcController rpc;

    SCOPED_TRACE(write_req.DebugString());

    ASSERT_OK(proxy_->Write(write_req, &write_resp, &rpc));

    SCOPED_TRACE(write_resp.DebugString());

    ASSERT_FALSE(write_resp.has_error());

  }

  VerifyRows(schema_, { KeyValue(1, 11) });

  const string snapshot_id = "00000000000000000000000000000000";

  TabletSnapshotOpRequestPB req;

  TabletSnapshotOpResponsePB resp;

  // Send the create snapshot request.

  req.set_operation(TabletSnapshotOpRequestPB::CREATE_ON_TABLET);

  req.set_dest_uuid(mini_server_->server()->fs_manager()->uuid());

  req.set_snapshot_id(snapshot_id);

  req.add_tablet_id(kTabletId);

  {

    RpcController rpc;

    SCOPED_TRACE(req.DebugString());

    ASSERT_OK(backup_proxy_->TabletSnapshotOp(req, &resp, &rpc));

    SCOPED_TRACE(resp.DebugString());

    ASSERT_FALSE(resp.has_error());

  }

  SleepFor(MonoDelta::FromMilliseconds(500));

  LOG(INFO) << "CREATED SNAPSHOT. UPDATING THE TABLET DATA..";

  // Send the second row.

  {

    AddTestRowInsert(2, 22, "key1", &write_req);

    RpcController rpc;

    SCOPED_TRACE(write_req.DebugString());

    ASSERT_OK(proxy_->Write(write_req, &write_resp, &rpc));

    SCOPED_TRACE(write_resp.DebugString());

    ASSERT_FALSE(write_resp.has_error());

  }

  VerifyRows(schema_, { KeyValue(1, 11), KeyValue(2, 22) });

  // Send the restore snapshot request.

  req.set_operation(TabletSnapshotOpRequestPB::RESTORE_ON_TABLET);

  {

    RpcController rpc;

    SCOPED_TRACE(req.DebugString());

    ASSERT_OK(backup_proxy_->TabletSnapshotOp(req, &resp, &rpc));

    SCOPED_TRACE(resp.DebugString());

    ASSERT_FALSE(resp.has_error());

  }

  SleepFor(MonoDelta::FromMilliseconds(500));

  LOG(INFO) << "RESTORED SNAPSHOT. CHECKING THE TABLET DATA..";

  // Expected the first row only from the snapshot.

  // FIXME: Current implementation of VerifyRows() can fail due to RocksDB reset in

  //        RestoreSnapshot(). VerifyRows() must be fixed.

  // VerifyRows(schema_, { KeyValue(1, 11) });

  LOG(INFO) << "THE TABLET DATA IS VALID. Test TestSnapshotData finished.";

}

} // namespace tserver

} // namespace yb