/Users/deen/code/yugabyte-db/src/yb/tools/yb-admin_client.h

Source (jump to first uncovered line)
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.
//
// 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.
//
#ifndef YB_TOOLS_YB_ADMIN_CLIENT_H
#define YB_TOOLS_YB_ADMIN_CLIENT_H

#include <string>
#include <vector>

#include <boost/optional.hpp>

#include "yb/client/yb_table_name.h"

#include "yb/rpc/rpc_controller.h"

#include "yb/util/status_fwd.h"
#include "yb/util/monotime.h"
#include "yb/util/net/net_util.h"
#include "yb/util/net/sockaddr.h"
#include "yb/util/status.h"
#include "yb/util/type_traits.h"
#include "yb/common/entity_ids.h"
#include "yb/consensus/consensus_types.pb.h"

#include "yb/master/master_client.pb.h"
#include "yb/master/master_cluster.pb.h"
#include "yb/master/master_fwd.h"

#include "yb/tools/yb-admin_cli.h"
#include "yb/rpc/rpc_fwd.h"

namespace yb {

class HybridTime;

namespace consensus {
class ConsensusServiceProxy;
}

namespace client {
class YBClient;
}

namespace tools {

struct TypedNamespaceName {
  YQLDatabase db_type = YQL_DATABASE_UNKNOWN;
  std::string name;
};

class TableNameResolver {
 public:
  TableNameResolver(std::vector<client::YBTableName> tables,
                    std::vector<master::NamespaceIdentifierPB> namespaces);
  TableNameResolver(TableNameResolver&&);
  ~TableNameResolver();

  Result<bool> Feed(const std::string& value);
  std::vector<client::YBTableName>& values();
  master::NamespaceIdentifierPB last_namespace();

 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};

HAS_MEMBER_FUNCTION(error);
HAS_MEMBER_FUNCTION(status);

template<class Response>
CHECKED_STATUS ResponseStatus(
    const Response& response,
    typename std::enable_if<HasMemberFunction_error<Response>::value, void*>::type = nullptr) {
  // Response has has_error method, use status from it.
  if (response.has_error()) {
    return StatusFromPB(response.error().status());
  }
  return Status::OK();
}

template<class Response>
CHECKED_STATUS ResponseStatus(
    const Response& response,
    typename std::enable_if<HasMemberFunction_status<Response>::value, void*>::type = nullptr) {
  if (response.has_status()) {
    return StatusFromPB(response.status());
  }
  return Status::OK();
}

class ClusterAdminClient {
 public:
  enum PeerMode {
    LEADER = 1,
    FOLLOWER
  };

  // Creates an admin client for host/port combination e.g.,
  // "localhost" or "127.0.0.1:7050" with the given timeout.
  // If certs_dir is non-empty, caller will init the yb_client_.
  ClusterAdminClient(std::string addrs, MonoDelta timeout);

  ClusterAdminClient(const HostPort& init_master_addr, MonoDelta timeout);

  virtual ~ClusterAdminClient();

  // Initialized the client and connects to the specified tablet server.
  CHECKED_STATUS Init();

  // Parse the user-specified change type to consensus change type
  CHECKED_STATUS ParseChangeType(
      const std::string& change_type,
      consensus::ChangeConfigType* cc_type);

  // Change the configuration of the specified tablet.
  CHECKED_STATUS ChangeConfig(
      const TabletId& tablet_id,
      const std::string& change_type,
      const PeerId& peer_uuid,
      const boost::optional<std::string>& member_type);

  // Change the configuration of the master tablet.
  CHECKED_STATUS ChangeMasterConfig(
      const std::string& change_type,
      const std::string& peer_host,
      uint16_t peer_port,
      const std::string& peer_uuid = "");

  CHECKED_STATUS DumpMasterState(bool to_console);

  // List all the tables.
  CHECKED_STATUS ListTables(bool include_db_type,
                            bool include_table_id,
                            bool include_table_type);

  // List all tablets of this table
  CHECKED_STATUS ListTablets(const client::YBTableName& table_name,
                             int max_tablets,
                             bool json,
                             bool followers);

  // Per Tablet list of all tablet servers
  CHECKED_STATUS ListPerTabletTabletServers(const PeerId& tablet_id);

  // Delete a single table by name.
  CHECKED_STATUS DeleteTable(const client::YBTableName& table_name);

  // Delete a single table by ID.
  CHECKED_STATUS DeleteTableById(const TableId& table_id);

  // Delete a single index by name.
  CHECKED_STATUS DeleteIndex(const client::YBTableName& table_name);

  // Delete a single index by ID.
  CHECKED_STATUS DeleteIndexById(const TableId& table_id);

  // Delete a single namespace by name.
  CHECKED_STATUS DeleteNamespace(const TypedNamespaceName& name);

  // Delete a single namespace by ID.
  CHECKED_STATUS DeleteNamespaceById(const NamespaceId& namespace_id);

  // Launch backfill for (deferred) indexes on the specified table.
  CHECKED_STATUS LaunchBackfillIndexForTable(const client::YBTableName& table_name);

  // List all tablet servers known to master
  CHECKED_STATUS ListAllTabletServers(bool exclude_dead = false);

  // List all masters
  CHECKED_STATUS ListAllMasters();

  // List the log locations of all tablet servers, by uuid
  CHECKED_STATUS ListTabletServersLogLocations();

  // List all the tablets a certain tablet server is serving
  CHECKED_STATUS ListTabletsForTabletServer(const PeerId& ts_uuid);

  CHECKED_STATUS SetLoadBalancerEnabled(bool is_enabled);

  CHECKED_STATUS GetLoadBalancerState();

  CHECKED_STATUS GetLoadMoveCompletion();

  CHECKED_STATUS GetLeaderBlacklistCompletion();

  CHECKED_STATUS GetIsLoadBalancerIdle();

  CHECKED_STATUS ListLeaderCounts(const client::YBTableName& table_name);

  Result<std::unordered_map<std::string, int>> GetLeaderCounts(
      const client::YBTableName& table_name);

  CHECKED_STATUS SetupRedisTable();

  CHECKED_STATUS DropRedisTable();

  CHECKED_STATUS FlushTables(const std::vector<client::YBTableName>& table_names,
                             bool add_indexes,
                             int timeout_secs,
                             bool is_compaction);

  CHECKED_STATUS FlushTablesById(const std::vector<TableId>& table_id,
                                 bool add_indexes,
                                 int timeout_secs,
                                 bool is_compaction);

  CHECKED_STATUS FlushSysCatalog();

  CHECKED_STATUS CompactSysCatalog();

  CHECKED_STATUS ModifyTablePlacementInfo(const client::YBTableName& table_name,
                                          const std::string& placement_info,
                                          int replication_factor,
                                          const std::string& optional_uuid);

  CHECKED_STATUS ModifyPlacementInfo(std::string placement_infos,
                                     int replication_factor,
                                     const std::string& optional_uuid);

  CHECKED_STATUS ClearPlacementInfo();

  CHECKED_STATUS AddReadReplicaPlacementInfo(const std::string& placement_info,
                                             int replication_factor,
                                             const std::string& optional_uuid);

  CHECKED_STATUS ModifyReadReplicaPlacementInfo(const std::string& placement_uuid,
                                                const std::string& placement_info,
                                                int replication_factor);

  CHECKED_STATUS DeleteReadReplicaPlacementInfo();

  CHECKED_STATUS GetUniverseConfig();

  CHECKED_STATUS ChangeBlacklist(const std::vector<HostPort>& servers, bool add,
      bool blacklist_leader);

  Result<const master::NamespaceIdentifierPB&> GetNamespaceInfo(YQLDatabase db_type,
                                                                const std::string& namespace_name);

  CHECKED_STATUS LeaderStepDownWithNewLeader(
      const std::string& tablet_id,
      const std::string& dest_ts_uuid);

  CHECKED_STATUS MasterLeaderStepDown(
      const std::string& leader_uuid,
      const std::string& new_leader_uuid = std::string());

  CHECKED_STATUS SplitTablet(const std::string& tablet_id);

  CHECKED_STATUS DisableTabletSplitting(int64_t disable_duration_ms);

  CHECKED_STATUS IsTabletSplittingComplete();

  CHECKED_STATUS CreateTransactionsStatusTable(const std::string& table_name);

  Result<TableNameResolver> BuildTableNameResolver();

  Result<std::string> GetMasterLeaderUuid();

  CHECKED_STATUS GetYsqlCatalogVersion();

  Result<rapidjson::Document> DdlLog();

  // Upgrade YSQL cluster (all databases) to the latest version, applying necessary migrations.
  // Note: Works with a tserver but is placed here (and not in yb-ts-cli) because it doesn't
  //       look like this workflow is a good fit there.
  CHECKED_STATUS UpgradeYsql();

  // Set WAL retention time in secs for a table name.
  CHECKED_STATUS SetWalRetentionSecs(
    const client::YBTableName& table_name, const uint32_t wal_ret_secs);

  CHECKED_STATUS GetWalRetentionSecs(const client::YBTableName& table_name);

 protected:
  // Fetch the locations of the replicas for a given tablet from the Master.
  CHECKED_STATUS GetTabletLocations(const TabletId& tablet_id,
                                    master::TabletLocationsPB* locations);

  // Fetch information about the location of a tablet peer from the leader master.
  CHECKED_STATUS GetTabletPeer(
      const TabletId& tablet_id,
      PeerMode mode,
      master::TSInfoPB* ts_info);

  // Set the uuid and the socket information for a peer of this tablet.
  CHECKED_STATUS SetTabletPeerInfo(
      const TabletId& tablet_id,
      PeerMode mode,
      PeerId* peer_uuid,
      HostPort* peer_addr);

  // Fetch the latest list of tablet servers from the Master.
  CHECKED_STATUS ListTabletServers(
      google::protobuf::RepeatedPtrField<master::ListTabletServersResponsePB_Entry>* servers);

  // Look up the RPC address of the server with the specified UUID from the Master.
  Result<HostPort> GetFirstRpcAddressForTS(const std::string& uuid);

  // Step down the leader of this tablet.
  // If leader_uuid is empty, look it up with the master.
  // If leader_uuid is not empty, must provide a leader_proxy.
  // If new_leader_uuid is not empty, it is used as a suggestion for the StepDown operation.
  CHECKED_STATUS LeaderStepDown(
      const PeerId& leader_uuid,
      const TabletId& tablet_id,
      const PeerId& new_leader_uuid,
      std::unique_ptr<consensus::ConsensusServiceProxy>* leader_proxy);

  CHECKED_STATUS StartElection(const std::string& tablet_id);

  CHECKED_STATUS WaitUntilMasterLeaderReady();

  template <class Resp, class F>
  CHECKED_STATUS RequestMasterLeader(Resp* resp, const F& f) {
    auto deadline = CoarseMonoClock::now() + timeout_;
    rpc::RpcController rpc;
    rpc.set_timeout(timeout_);
    for (;;) {
      resp->Clear();
      RETURN_NOT_OK(f(&rpc));

      auto status = ResponseStatus(*resp);
      if (status.ok()) {
        return Status::OK();
      }

      if (!status.IsLeaderHasNoLease() && !status.IsLeaderNotReadyToServe() &&
          !status.IsServiceUnavailable()) {
        return status;
      }

      auto timeout = deadline - CoarseMonoClock::now();
      if (timeout <= MonoDelta::kZero) {
        return status;
      }

      rpc.Reset();
      rpc.set_timeout(timeout);
      ResetMasterProxy();
    }
  }

  void ResetMasterProxy(const HostPort& leader_addr = HostPort());

  std::string master_addr_list_;
  HostPort init_master_addr_;
  const MonoDelta timeout_;
  HostPort leader_addr_;
  std::unique_ptr<rpc::SecureContext> secure_context_;
  std::unique_ptr<rpc::Messenger> messenger_;
  std::unique_ptr<rpc::ProxyCache> proxy_cache_;
  std::unique_ptr<master::MasterAdminProxy> master_admin_proxy_;
  std::unique_ptr<master::MasterBackupProxy> master_backup_proxy_;
  std::unique_ptr<master::MasterClientProxy> master_client_proxy_;
  std::unique_ptr<master::MasterClusterProxy> master_cluster_proxy_;
  std::unique_ptr<master::MasterDdlProxy> master_ddl_proxy_;
  std::unique_ptr<master::MasterEncryptionProxy> master_encryption_proxy_;
  std::unique_ptr<master::MasterReplicationProxy> master_replication_proxy_;

  // Skip yb_client_ and related fields' initialization.
  std::unique_ptr<client::YBClient> yb_client_;
  bool initted_ = false;

 private:

  CHECKED_STATUS DiscoverAllMasters(
    const HostPort& init_master_addr, std::string* all_master_addrs);

  CHECKED_STATUS FillPlacementInfo(
      master::PlacementInfoPB* placement_info_pb, const std::string& placement_str);

  Result<int> GetReadReplicaConfigFromPlacementUuid(
      master::ReplicationInfoPB* replication_info, const std::string& placement_uuid);


  Result<master::GetMasterClusterConfigResponsePB> GetMasterClusterConfig();

  // Perform RPC call without checking Response structure for error
  template<class Response, class Request, class Object>
  Result<Response> InvokeRpcNoResponseCheck(
      Status (Object::*func)(const Request&, Response*, rpc::RpcController*) const,
      const Object& obj, const Request& req, const char* error_message = nullptr);

  // Perform RPC call by calling InvokeRpcNoResponseCheck
  // and check Response structure for error by using its has_error method (if any)
  template<class Response, class Request, class Object>
  Result<Response> InvokeRpc(
      Status (Object::*func)(const Request&, Response*, rpc::RpcController*) const,
      const Object& obj, const Request& req, const char* error_message = nullptr);

 private:
  using NamespaceMap = std::unordered_map<NamespaceId, master::NamespaceIdentifierPB>;
  Result<const NamespaceMap&> GetNamespaceMap();

  NamespaceMap namespace_map_;

  DISALLOW_COPY_AND_ASSIGN(ClusterAdminClient);
};

static constexpr const char* kColumnSep = " \t";

std::string RightPadToUuidWidth(const std::string &s);

Result<TypedNamespaceName> ParseNamespaceName(
    const std::string& full_namespace_name,
    const YQLDatabase default_if_no_prefix = YQL_DATABASE_CQL);

void AddStringField(
    const char* name, const std::string& value, rapidjson::Value* out,
    rapidjson::Value::AllocatorType* allocator);

// Renders hybrid time to string for user, time is rendered in local TZ.
std::string HybridTimeToString(HybridTime ht);

}  // namespace tools
}  // namespace yb

#endif // YB_TOOLS_YB_ADMIN_CLIENT_H

YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

Coverage Report

Created: 2022-03-22 16:43