YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// THIS FILE IS AUTOGENERATED FROM yb/master/master_ddl.proto

#include "yb/master/master_ddl.pb.h"

#include "yb/master/master_ddl.service.h"

#include <glog/logging.h>

#include "yb/rpc/inbound_call.h"

#include "yb/rpc/local_call.h"

#include "yb/rpc/remote_method.h"

#include "yb/rpc/rpc_context.h"

#include "yb/rpc/rpc_service.h"

#include "yb/rpc/service_if.h"

#include "yb/util/metrics.h"

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_CreateTable,

  "Bytes received by yb.master.MasterDdl.CreateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.CreateTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_CreateTable,

  "Bytes sent in response to yb.master.MasterDdl.CreateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.CreateTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_CreateTable,

  "Microseconds spent handling yb.master.MasterDdl.CreateTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.CreateTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_IsCreateTableDone,

  "Bytes received by yb.master.MasterDdl.IsCreateTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.IsCreateTableDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_IsCreateTableDone,

  "Bytes sent in response to yb.master.MasterDdl.IsCreateTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.IsCreateTableDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_IsCreateTableDone,

  "Microseconds spent handling yb.master.MasterDdl.IsCreateTableDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.IsCreateTableDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_ListTables,

  "Bytes received by yb.master.MasterDdl.ListTables() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.ListTables() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_ListTables,

  "Bytes sent in response to yb.master.MasterDdl.ListTables() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.ListTables() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_ListTables,

  "Microseconds spent handling yb.master.MasterDdl.ListTables() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.ListTables() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_GetTableSchema,

  "Bytes received by yb.master.MasterDdl.GetTableSchema() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.GetTableSchema() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_GetTableSchema,

  "Bytes sent in response to yb.master.MasterDdl.GetTableSchema() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.GetTableSchema() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_GetTableSchema,

  "Microseconds spent handling yb.master.MasterDdl.GetTableSchema() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.GetTableSchema() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_GetTablegroupSchema,

  "Bytes received by yb.master.MasterDdl.GetTablegroupSchema() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.GetTablegroupSchema() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_GetTablegroupSchema,

  "Bytes sent in response to yb.master.MasterDdl.GetTablegroupSchema() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.GetTablegroupSchema() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_GetTablegroupSchema,

  "Microseconds spent handling yb.master.MasterDdl.GetTablegroupSchema() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.GetTablegroupSchema() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_GetColocatedTabletSchema,

  "Bytes received by yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_GetColocatedTabletSchema,

  "Bytes sent in response to yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_GetColocatedTabletSchema,

  "Microseconds spent handling yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_TruncateTable,

  "Bytes received by yb.master.MasterDdl.TruncateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.TruncateTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_TruncateTable,

  "Bytes sent in response to yb.master.MasterDdl.TruncateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.TruncateTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_TruncateTable,

  "Microseconds spent handling yb.master.MasterDdl.TruncateTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.TruncateTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_IsTruncateTableDone,

  "Bytes received by yb.master.MasterDdl.IsTruncateTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.IsTruncateTableDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_IsTruncateTableDone,

  "Bytes sent in response to yb.master.MasterDdl.IsTruncateTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.IsTruncateTableDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_IsTruncateTableDone,

  "Microseconds spent handling yb.master.MasterDdl.IsTruncateTableDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.IsTruncateTableDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_BackfillIndex,

  "Bytes received by yb.master.MasterDdl.BackfillIndex() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.BackfillIndex() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_BackfillIndex,

  "Bytes sent in response to yb.master.MasterDdl.BackfillIndex() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.BackfillIndex() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_BackfillIndex,

  "Microseconds spent handling yb.master.MasterDdl.BackfillIndex() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.BackfillIndex() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable,

  "Bytes received by yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable,

  "Bytes sent in response to yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_LaunchBackfillIndexForTable,

  "Microseconds spent handling yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_GetBackfillJobs,

  "Bytes received by yb.master.MasterDdl.GetBackfillJobs() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.GetBackfillJobs() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_GetBackfillJobs,

  "Bytes sent in response to yb.master.MasterDdl.GetBackfillJobs() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.GetBackfillJobs() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_GetBackfillJobs,

  "Microseconds spent handling yb.master.MasterDdl.GetBackfillJobs() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.GetBackfillJobs() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_DeleteTable,

  "Bytes received by yb.master.MasterDdl.DeleteTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.DeleteTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_DeleteTable,

  "Bytes sent in response to yb.master.MasterDdl.DeleteTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.DeleteTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_DeleteTable,

  "Microseconds spent handling yb.master.MasterDdl.DeleteTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.DeleteTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_IsDeleteTableDone,

  "Bytes received by yb.master.MasterDdl.IsDeleteTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.IsDeleteTableDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_IsDeleteTableDone,

  "Bytes sent in response to yb.master.MasterDdl.IsDeleteTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.IsDeleteTableDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_IsDeleteTableDone,

  "Microseconds spent handling yb.master.MasterDdl.IsDeleteTableDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.IsDeleteTableDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_AlterTable,

  "Bytes received by yb.master.MasterDdl.AlterTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.AlterTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_AlterTable,

  "Bytes sent in response to yb.master.MasterDdl.AlterTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.AlterTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_AlterTable,

  "Microseconds spent handling yb.master.MasterDdl.AlterTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.AlterTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_IsAlterTableDone,

  "Bytes received by yb.master.MasterDdl.IsAlterTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.IsAlterTableDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_IsAlterTableDone,

  "Bytes sent in response to yb.master.MasterDdl.IsAlterTableDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.IsAlterTableDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_IsAlterTableDone,

  "Microseconds spent handling yb.master.MasterDdl.IsAlterTableDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.IsAlterTableDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_CreateNamespace,

  "Bytes received by yb.master.MasterDdl.CreateNamespace() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.CreateNamespace() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_CreateNamespace,

  "Bytes sent in response to yb.master.MasterDdl.CreateNamespace() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.CreateNamespace() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_CreateNamespace,

  "Microseconds spent handling yb.master.MasterDdl.CreateNamespace() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.CreateNamespace() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_IsCreateNamespaceDone,

  "Bytes received by yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_IsCreateNamespaceDone,

  "Bytes sent in response to yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_IsCreateNamespaceDone,

  "Microseconds spent handling yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_DeleteNamespace,

  "Bytes received by yb.master.MasterDdl.DeleteNamespace() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.DeleteNamespace() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_DeleteNamespace,

  "Bytes sent in response to yb.master.MasterDdl.DeleteNamespace() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.DeleteNamespace() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_DeleteNamespace,

  "Microseconds spent handling yb.master.MasterDdl.DeleteNamespace() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.DeleteNamespace() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone,

  "Bytes received by yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone,

  "Bytes sent in response to yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_IsDeleteNamespaceDone,

  "Microseconds spent handling yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_AlterNamespace,

  "Bytes received by yb.master.MasterDdl.AlterNamespace() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.AlterNamespace() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_AlterNamespace,

  "Bytes sent in response to yb.master.MasterDdl.AlterNamespace() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.AlterNamespace() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_AlterNamespace,

  "Microseconds spent handling yb.master.MasterDdl.AlterNamespace() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.AlterNamespace() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_ListNamespaces,

  "Bytes received by yb.master.MasterDdl.ListNamespaces() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.ListNamespaces() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_ListNamespaces,

  "Bytes sent in response to yb.master.MasterDdl.ListNamespaces() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.ListNamespaces() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_ListNamespaces,

  "Microseconds spent handling yb.master.MasterDdl.ListNamespaces() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.ListNamespaces() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_GetNamespaceInfo,

  "Bytes received by yb.master.MasterDdl.GetNamespaceInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.GetNamespaceInfo() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_GetNamespaceInfo,

  "Bytes sent in response to yb.master.MasterDdl.GetNamespaceInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.GetNamespaceInfo() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_GetNamespaceInfo,

  "Microseconds spent handling yb.master.MasterDdl.GetNamespaceInfo() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.GetNamespaceInfo() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_CreateTablegroup,

  "Bytes received by yb.master.MasterDdl.CreateTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.CreateTablegroup() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_CreateTablegroup,

  "Bytes sent in response to yb.master.MasterDdl.CreateTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.CreateTablegroup() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_CreateTablegroup,

  "Microseconds spent handling yb.master.MasterDdl.CreateTablegroup() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.CreateTablegroup() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_DeleteTablegroup,

  "Bytes received by yb.master.MasterDdl.DeleteTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.DeleteTablegroup() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_DeleteTablegroup,

  "Bytes sent in response to yb.master.MasterDdl.DeleteTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.DeleteTablegroup() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_DeleteTablegroup,

  "Microseconds spent handling yb.master.MasterDdl.DeleteTablegroup() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.DeleteTablegroup() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_ListTablegroups,

  "Bytes received by yb.master.MasterDdl.ListTablegroups() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.ListTablegroups() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_ListTablegroups,

  "Bytes sent in response to yb.master.MasterDdl.ListTablegroups() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.ListTablegroups() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_ListTablegroups,

  "Microseconds spent handling yb.master.MasterDdl.ListTablegroups() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.ListTablegroups() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_CreateUDType,

  "Bytes received by yb.master.MasterDdl.CreateUDType() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.CreateUDType() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_CreateUDType,

  "Bytes sent in response to yb.master.MasterDdl.CreateUDType() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.CreateUDType() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_CreateUDType,

  "Microseconds spent handling yb.master.MasterDdl.CreateUDType() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.CreateUDType() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_DeleteUDType,

  "Bytes received by yb.master.MasterDdl.DeleteUDType() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.DeleteUDType() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_DeleteUDType,

  "Bytes sent in response to yb.master.MasterDdl.DeleteUDType() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.DeleteUDType() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_DeleteUDType,

  "Microseconds spent handling yb.master.MasterDdl.DeleteUDType() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.DeleteUDType() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_ListUDTypes,

  "Bytes received by yb.master.MasterDdl.ListUDTypes() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.ListUDTypes() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_ListUDTypes,

  "Bytes sent in response to yb.master.MasterDdl.ListUDTypes() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.ListUDTypes() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_ListUDTypes,

  "Microseconds spent handling yb.master.MasterDdl.ListUDTypes() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.ListUDTypes() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterDdl_GetUDTypeInfo,

  "Bytes received by yb.master.MasterDdl.GetUDTypeInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterDdl.GetUDTypeInfo() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterDdl_GetUDTypeInfo,

  "Bytes sent in response to yb.master.MasterDdl.GetUDTypeInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterDdl.GetUDTypeInfo() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterDdl_GetUDTypeInfo,

  "Microseconds spent handling yb.master.MasterDdl.GetUDTypeInfo() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterDdl.GetUDTypeInfo() RPC requests",

  60000000LU, 2);

namespace yb {

namespace master {

MasterDdlIf::MasterDdlIf(const scoped_refptr<MetricEntity>& entity) {

  InitMethods(entity);

}

MasterDdlIf::~MasterDdlIf() {

}

void MasterDdlIf::FillEndpoints(const ::yb::rpc::RpcServicePtr& service, ::yb::rpc::RpcEndpointMap* map) {

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTable)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateTableDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateTableDone)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTables)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTables)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTableSchema)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTableSchema)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kTruncateTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kTruncateTable)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kBackfillIndex)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kBackfillIndex)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetBackfillJobs)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetBackfillJobs)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTable)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterTable)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsAlterTableDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsAlterTableDone)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateNamespace)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateNamespace)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteNamespace)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteNamespace)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterNamespace)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterNamespace)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListNamespaces)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kListNamespaces)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTablegroup)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTablegroup)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTablegroup)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTablegroup)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTablegroups)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTablegroups)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateUDType)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateUDType)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteUDType)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteUDType)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListUDTypes)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kListUDTypes)));

  map->emplace(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)));

}

void MasterDdlIf::Handle(::yb::rpc::InboundCallPtr call) {

  auto index = call->method_index();

  methods_[index].handler(std::move(call));

}

std::string MasterDdlIf::service_name() const {

  return "yb.master.MasterService";

}

std::string MasterDdlIf::static_service_name() {

  return "yb.master.MasterService";

}

void MasterDdlIf::InitMethods(const scoped_refptr<MetricEntity>& entity) {

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "CreateTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::CreateTableRequestPB, ::yb::master::CreateTableResponsePB>>(

          std::move(call), [this](const ::yb::master::CreateTableRequestPB* req, ::yb::master::CreateTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_CreateTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_CreateTable.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_CreateTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateTableDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsCreateTableDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateTableDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsCreateTableDoneRequestPB, ::yb::master::IsCreateTableDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsCreateTableDoneRequestPB* req, ::yb::master::IsCreateTableDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsCreateTableDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_IsCreateTableDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_IsCreateTableDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_IsCreateTableDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTables)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "ListTables"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTables)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListTablesRequestPB, ::yb::master::ListTablesResponsePB>>(

          std::move(call), [this](const ::yb::master::ListTablesRequestPB* req, ::yb::master::ListTablesResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ListTables(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_ListTables.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_ListTables.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_ListTables.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTableSchema)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetTableSchema"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTableSchema)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetTableSchemaRequestPB, ::yb::master::GetTableSchemaResponsePB>>(

          std::move(call), [this](const ::yb::master::GetTableSchemaRequestPB* req, ::yb::master::GetTableSchemaResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetTableSchema(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_GetTableSchema.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_GetTableSchema.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_GetTableSchema.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetTablegroupSchema"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetTablegroupSchemaRequestPB, ::yb::master::GetTablegroupSchemaResponsePB>>(

          std::move(call), [this](const ::yb::master::GetTablegroupSchemaRequestPB* req, ::yb::master::GetTablegroupSchemaResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetTablegroupSchema(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_GetTablegroupSchema.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_GetTablegroupSchema.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_GetTablegroupSchema.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetColocatedTabletSchema"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetColocatedTabletSchemaRequestPB, ::yb::master::GetColocatedTabletSchemaResponsePB>>(

          std::move(call), [this](const ::yb::master::GetColocatedTabletSchemaRequestPB* req, ::yb::master::GetColocatedTabletSchemaResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetColocatedTabletSchema(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_GetColocatedTabletSchema.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_GetColocatedTabletSchema.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_GetColocatedTabletSchema.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kTruncateTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "TruncateTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kTruncateTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::TruncateTableRequestPB, ::yb::master::TruncateTableResponsePB>>(

          std::move(call), [this](const ::yb::master::TruncateTableRequestPB* req, ::yb::master::TruncateTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        TruncateTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_TruncateTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_TruncateTable.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_TruncateTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsTruncateTableDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsTruncateTableDoneRequestPB, ::yb::master::IsTruncateTableDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsTruncateTableDoneRequestPB* req, ::yb::master::IsTruncateTableDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsTruncateTableDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_IsTruncateTableDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_IsTruncateTableDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_IsTruncateTableDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kBackfillIndex)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "BackfillIndex"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kBackfillIndex)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::BackfillIndexRequestPB, ::yb::master::BackfillIndexResponsePB>>(

          std::move(call), [this](const ::yb::master::BackfillIndexRequestPB* req, ::yb::master::BackfillIndexResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        BackfillIndex(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_BackfillIndex.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_BackfillIndex.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_BackfillIndex.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "LaunchBackfillIndexForTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::LaunchBackfillIndexForTableRequestPB, ::yb::master::LaunchBackfillIndexForTableResponsePB>>(

          std::move(call), [this](const ::yb::master::LaunchBackfillIndexForTableRequestPB* req, ::yb::master::LaunchBackfillIndexForTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        LaunchBackfillIndexForTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_LaunchBackfillIndexForTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetBackfillJobs)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetBackfillJobs"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetBackfillJobs)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetBackfillJobsRequestPB, ::yb::master::GetBackfillJobsResponsePB>>(

          std::move(call), [this](const ::yb::master::GetBackfillJobsRequestPB* req, ::yb::master::GetBackfillJobsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetBackfillJobs(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_GetBackfillJobs.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_GetBackfillJobs.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_GetBackfillJobs.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "DeleteTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::DeleteTableRequestPB, ::yb::master::DeleteTableResponsePB>>(

          std::move(call), [this](const ::yb::master::DeleteTableRequestPB* req, ::yb::master::DeleteTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DeleteTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_DeleteTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_DeleteTable.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_DeleteTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsDeleteTableDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsDeleteTableDoneRequestPB, ::yb::master::IsDeleteTableDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsDeleteTableDoneRequestPB* req, ::yb::master::IsDeleteTableDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsDeleteTableDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_IsDeleteTableDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_IsDeleteTableDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_IsDeleteTableDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "AlterTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::AlterTableRequestPB, ::yb::master::AlterTableResponsePB>>(

          std::move(call), [this](const ::yb::master::AlterTableRequestPB* req, ::yb::master::AlterTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        AlterTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_AlterTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_AlterTable.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_AlterTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsAlterTableDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsAlterTableDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsAlterTableDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsAlterTableDoneRequestPB, ::yb::master::IsAlterTableDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsAlterTableDoneRequestPB* req, ::yb::master::IsAlterTableDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsAlterTableDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_IsAlterTableDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_IsAlterTableDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_IsAlterTableDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateNamespace)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "CreateNamespace"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateNamespace)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::CreateNamespaceRequestPB, ::yb::master::CreateNamespaceResponsePB>>(

          std::move(call), [this](const ::yb::master::CreateNamespaceRequestPB* req, ::yb::master::CreateNamespaceResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateNamespace(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_CreateNamespace.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_CreateNamespace.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_CreateNamespace.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsCreateNamespaceDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsCreateNamespaceDoneRequestPB, ::yb::master::IsCreateNamespaceDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsCreateNamespaceDoneRequestPB* req, ::yb::master::IsCreateNamespaceDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsCreateNamespaceDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_IsCreateNamespaceDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_IsCreateNamespaceDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_IsCreateNamespaceDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteNamespace)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "DeleteNamespace"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteNamespace)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::DeleteNamespaceRequestPB, ::yb::master::DeleteNamespaceResponsePB>>(

          std::move(call), [this](const ::yb::master::DeleteNamespaceRequestPB* req, ::yb::master::DeleteNamespaceResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DeleteNamespace(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_DeleteNamespace.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_DeleteNamespace.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_DeleteNamespace.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsDeleteNamespaceDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsDeleteNamespaceDoneRequestPB, ::yb::master::IsDeleteNamespaceDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsDeleteNamespaceDoneRequestPB* req, ::yb::master::IsDeleteNamespaceDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsDeleteNamespaceDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_IsDeleteNamespaceDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterNamespace)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "AlterNamespace"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterNamespace)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::AlterNamespaceRequestPB, ::yb::master::AlterNamespaceResponsePB>>(

          std::move(call), [this](const ::yb::master::AlterNamespaceRequestPB* req, ::yb::master::AlterNamespaceResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        AlterNamespace(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_AlterNamespace.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_AlterNamespace.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_AlterNamespace.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListNamespaces)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "ListNamespaces"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListNamespaces)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListNamespacesRequestPB, ::yb::master::ListNamespacesResponsePB>>(

          std::move(call), [this](const ::yb::master::ListNamespacesRequestPB* req, ::yb::master::ListNamespacesResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ListNamespaces(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_ListNamespaces.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_ListNamespaces.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_ListNamespaces.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetNamespaceInfo"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetNamespaceInfoRequestPB, ::yb::master::GetNamespaceInfoResponsePB>>(

          std::move(call), [this](const ::yb::master::GetNamespaceInfoRequestPB* req, ::yb::master::GetNamespaceInfoResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetNamespaceInfo(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_GetNamespaceInfo.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_GetNamespaceInfo.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_GetNamespaceInfo.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTablegroup)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "CreateTablegroup"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTablegroup)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::CreateTablegroupRequestPB, ::yb::master::CreateTablegroupResponsePB>>(

          std::move(call), [this](const ::yb::master::CreateTablegroupRequestPB* req, ::yb::master::CreateTablegroupResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateTablegroup(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_CreateTablegroup.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_CreateTablegroup.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_CreateTablegroup.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTablegroup)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "DeleteTablegroup"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTablegroup)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::DeleteTablegroupRequestPB, ::yb::master::DeleteTablegroupResponsePB>>(

          std::move(call), [this](const ::yb::master::DeleteTablegroupRequestPB* req, ::yb::master::DeleteTablegroupResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DeleteTablegroup(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_DeleteTablegroup.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_DeleteTablegroup.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_DeleteTablegroup.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTablegroups)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "ListTablegroups"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTablegroups)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListTablegroupsRequestPB, ::yb::master::ListTablegroupsResponsePB>>(

          std::move(call), [this](const ::yb::master::ListTablegroupsRequestPB* req, ::yb::master::ListTablegroupsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ListTablegroups(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_ListTablegroups.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_ListTablegroups.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_ListTablegroups.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateUDType)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "CreateUDType"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateUDType)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::CreateUDTypeRequestPB, ::yb::master::CreateUDTypeResponsePB>>(

          std::move(call), [this](const ::yb::master::CreateUDTypeRequestPB* req, ::yb::master::CreateUDTypeResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateUDType(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_CreateUDType.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_CreateUDType.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_CreateUDType.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteUDType)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "DeleteUDType"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteUDType)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::DeleteUDTypeRequestPB, ::yb::master::DeleteUDTypeResponsePB>>(

          std::move(call), [this](const ::yb::master::DeleteUDTypeRequestPB* req, ::yb::master::DeleteUDTypeResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DeleteUDType(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_DeleteUDType.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_DeleteUDType.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_DeleteUDType.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListUDTypes)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "ListUDTypes"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kListUDTypes)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListUDTypesRequestPB, ::yb::master::ListUDTypesResponsePB>>(

          std::move(call), [this](const ::yb::master::ListUDTypesRequestPB* req, ::yb::master::ListUDTypesResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ListUDTypes(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_ListUDTypes.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_ListUDTypes.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_ListUDTypes.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetUDTypeInfo"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetUDTypeInfoRequestPB, ::yb::master::GetUDTypeInfoResponsePB>>(

          std::move(call), [this](const ::yb::master::GetUDTypeInfoRequestPB* req, ::yb::master::GetUDTypeInfoResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetUDTypeInfo(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_master_MasterDdl_GetUDTypeInfo.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterDdl_GetUDTypeInfo.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterDdl_GetUDTypeInfo.Instantiate(entity))

  };

}

} // namespace master

} // namespace yb