hbase-protocol-shaded/src/main/protobuf/Admin.proto

   1 /**
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 // This file contains protocol buffers that are used for Admin service.
  20 package hbase.pb;
  21
  22 option java_package = "org.apache.hadoop.hbase.shaded.protobuf.generated";
  23 option java_outer_classname = "AdminProtos";
  24 option java_generic_services = true;
  25 option java_generate_equals_and_hash = true;
  26 option optimize_for = SPEED;
  27
  28 import "ClusterStatus.proto";
  29 import "HBase.proto";
  30 import "WAL.proto";
  31
  32 message GetRegionInfoRequest {
  33   required RegionSpecifier region = 1;
  34   optional bool compaction_state = 2;
  35 }
  36
  37 message GetRegionInfoResponse {
  38   required RegionInfo region_info = 1;
  39   optional CompactionState compaction_state = 2;
  40   optional bool isRecovering = 3;
  41
  42   enum CompactionState {
  43     NONE = 0;
  44     MINOR = 1;
  45     MAJOR = 2;
  46     MAJOR_AND_MINOR = 3;
  47   }
  48 }
  49
  50 /**
  51  * Get a list of store files for a set of column families in a particular region.
  52  * If no column family is specified, get the store files for all column families.
  53  */
  54 message GetStoreFileRequest {
  55   required RegionSpecifier region = 1;
  56   repeated bytes family = 2;
  57 }
  58
  59 message GetStoreFileResponse {
  60   repeated string store_file = 1;
  61 }
  62
  63 message GetOnlineRegionRequest {
  64 }
  65
  66 message GetOnlineRegionResponse {
  67   repeated RegionInfo region_info = 1;
  68 }
  69
  70 message OpenRegionRequest {
  71   repeated RegionOpenInfo open_info = 1;
  72   // the intended server for this RPC.
  73   optional uint64 serverStartCode = 2;
  74   // wall clock time from master
  75   optional uint64 master_system_time = 5;
  76
  77   message RegionOpenInfo {
  78     required RegionInfo region = 1;
  79     optional uint32 version_of_offline_node = 2;
  80     repeated ServerName favored_nodes = 3;
  81     // open region for distributedLogReplay
  82     optional bool openForDistributedLogReplay = 4;
  83   }
  84 }
  85
  86 message OpenRegionResponse {
  87   repeated RegionOpeningState opening_state = 1;
  88
  89   enum RegionOpeningState {
  90     OPENED = 0;
  91     ALREADY_OPENED = 1;
  92     FAILED_OPENING = 2;
  93   }
  94 }
  95
  96 message WarmupRegionRequest {
  97
  98     required RegionInfo regionInfo = 1;
  99 }
 100
 101 message WarmupRegionResponse {
 102 }
 103
 104 /**
 105  * Closes the specified region and will use or not use ZK during the close
 106  * according to the specified flag.
 107  */
 108 message CloseRegionRequest {
 109   required RegionSpecifier region = 1;
 110   optional uint32 version_of_closing_node = 2;
 111   optional bool transition_in_ZK = 3 [default = true];
 112   optional ServerName destination_server = 4;
 113   // the intended server for this RPC.
 114   optional uint64 serverStartCode = 5;
 115 }
 116
 117 message CloseRegionResponse {
 118   required bool closed = 1;
 119 }
 120
 121 /**
 122  * Closes the specified region(s) for
 123  * split or merge
 124  */
 125 message CloseRegionForSplitOrMergeRequest {
 126   repeated RegionSpecifier region = 1;
 127 }
 128
 129 message CloseRegionForSplitOrMergeResponse {
 130   required bool closed = 1;
 131 }
 132
 133 /**
 134  * Flushes the MemStore of the specified region.
 135  * <p>
 136  * This method is synchronous.
 137  */
 138 message FlushRegionRequest {
 139   required RegionSpecifier region = 1;
 140   optional uint64 if_older_than_ts = 2;
 141   optional bool write_flush_wal_marker = 3; // whether to write a marker to WAL even if not flushed
 142 }
 143
 144 message FlushRegionResponse {
 145   required uint64 last_flush_time = 1;
 146   optional bool flushed = 2;
 147   optional bool wrote_flush_wal_marker = 3;
 148 }
 149
 150 /**
 151  * Splits the specified region.
 152  * <p>
 153  * This method currently flushes the region and then forces a compaction which
 154  * will then trigger a split.  The flush is done synchronously but the
 155  * compaction is asynchronous.
 156  */
 157 message SplitRegionRequest {
 158   required RegionSpecifier region = 1;
 159   optional bytes split_point = 2;
 160 }
 161
 162 message SplitRegionResponse {
 163 }
 164
 165 /**
 166  * Compacts the specified region.  Performs a major compaction if specified.
 167  * <p>
 168  * This method is asynchronous.
 169  */
 170 message CompactRegionRequest {
 171   required RegionSpecifier region = 1;
 172   optional bool major = 2;
 173   optional bytes family = 3;
 174 }
 175
 176 message CompactRegionResponse {
 177 }
 178
 179 message UpdateFavoredNodesRequest {
 180   repeated RegionUpdateInfo update_info = 1;
 181
 182   message RegionUpdateInfo {
 183     required RegionInfo region = 1;
 184     repeated ServerName favored_nodes = 2;
 185   }
 186 }
 187
 188 message UpdateFavoredNodesResponse {
 189   optional uint32 response = 1;
 190 }
 191
 192 // Protocol buffer version of WAL for replication
 193 message WALEntry {
 194   required WALKey key = 1;
 195   // Following may be null if the KVs/Cells are carried along the side in a cellblock (See
 196   // RPC for more on cellblocks). If Cells/KVs are in a cellblock, this next field is null
 197   // and associated_cell_count has count of Cells associated w/ this WALEntry
 198   repeated bytes key_value_bytes = 2;
 199   // If Cell data is carried alongside in a cellblock, this is count of Cells in the cellblock.
 200   optional int32 associated_cell_count = 3;
 201 }
 202
 203 /**
 204  * Replicates the given entries. The guarantee is that the given entries
 205  * will be durable on the slave cluster if this method returns without
 206  * any exception.
 207  */
 208 message ReplicateWALEntryRequest {
 209   repeated WALEntry entry = 1;
 210   optional string replicationClusterId = 2;
 211   optional string sourceBaseNamespaceDirPath = 3;
 212   optional string sourceHFileArchiveDirPath = 4;
 213 }
 214
 215 message ReplicateWALEntryResponse {
 216 }
 217
 218 message RollWALWriterRequest {
 219 }
 220
 221 /*
 222  * Roll request responses no longer include regions to flush
 223  * this list will always be empty when talking to a 1.0 server
 224  */
 225 message RollWALWriterResponse {
 226   // A list of encoded name of regions to flush
 227   repeated bytes region_to_flush = 1;
 228 }
 229
 230 message StopServerRequest {
 231   required string reason = 1;
 232 }
 233
 234 message StopServerResponse {
 235 }
 236
 237 message GetServerInfoRequest {
 238 }
 239
 240 message ServerInfo {
 241   required ServerName server_name = 1;
 242   optional uint32 webui_port = 2;
 243 }
 244
 245 message GetServerInfoResponse {
 246   required ServerInfo server_info = 1;
 247 }
 248
 249 message UpdateConfigurationRequest {
 250 }
 251
 252 message UpdateConfigurationResponse {
 253 }
 254
 255 message GetRegionLoadRequest {
 256   optional TableName table_name = 1;
 257 }
 258
 259 message GetRegionLoadResponse {
 260   repeated RegionLoad region_loads = 1;
 261 }
 262
 263 service AdminService {
 264   rpc GetRegionInfo(GetRegionInfoRequest)
 265     returns(GetRegionInfoResponse);
 266
 267   rpc GetStoreFile(GetStoreFileRequest)
 268     returns(GetStoreFileResponse);
 269
 270   rpc GetOnlineRegion(GetOnlineRegionRequest)
 271     returns(GetOnlineRegionResponse);
 272
 273   rpc OpenRegion(OpenRegionRequest)
 274     returns(OpenRegionResponse);
 275
 276   rpc WarmupRegion(WarmupRegionRequest)
 277     returns(WarmupRegionResponse);
 278
 279   rpc CloseRegion(CloseRegionRequest)
 280     returns(CloseRegionResponse);
 281
 282   rpc CloseRegionForSplitOrMerge(CloseRegionForSplitOrMergeRequest)
 283     returns(CloseRegionForSplitOrMergeResponse);
 284
 285   rpc FlushRegion(FlushRegionRequest)
 286     returns(FlushRegionResponse);
 287
 288   rpc SplitRegion(SplitRegionRequest)
 289     returns(SplitRegionResponse);
 290
 291   rpc CompactRegion(CompactRegionRequest)
 292     returns(CompactRegionResponse);
 293
 294   rpc ReplicateWALEntry(ReplicateWALEntryRequest)
 295     returns(ReplicateWALEntryResponse);
 296
 297   rpc Replay(ReplicateWALEntryRequest)
 298     returns(ReplicateWALEntryResponse);
 299
 300   rpc RollWALWriter(RollWALWriterRequest)
 301     returns(RollWALWriterResponse);
 302
 303   rpc GetServerInfo(GetServerInfoRequest)
 304     returns(GetServerInfoResponse);
 305
 306   rpc StopServer(StopServerRequest)
 307     returns(StopServerResponse);
 308
 309   rpc UpdateFavoredNodes(UpdateFavoredNodesRequest)
 310     returns(UpdateFavoredNodesResponse);
 311
 312   rpc UpdateConfiguration(UpdateConfigurationRequest)
 313     returns(UpdateConfigurationResponse);
 314
 315   rpc GetRegionLoad(GetRegionLoadRequest)
 316     returns(GetRegionLoadResponse);
 317 }