| /** |
| * 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. |
| */ |
| |
| // This file contains protocol buffers that are used for ClustStatus |
| package hbase.pb; |
| |
| option java_package = "org.apache.hadoop.hbase.protobuf.generated"; |
| option java_outer_classname = "ClusterStatusProtos"; |
| option java_generate_equals_and_hash = true; |
| option optimize_for = SPEED; |
| |
| import "HBase.proto"; |
| import "ClusterId.proto"; |
| import "FS.proto"; |
| |
| message RegionState { |
| required RegionInfo region_info = 1; |
| required State state = 2; |
| optional uint64 stamp = 3; |
| enum State { |
| OFFLINE = 0; // region is in an offline state |
| PENDING_OPEN = 1; // sent rpc to server to open but has not begun |
| OPENING = 2; // server has begun to open but not yet done |
| OPEN = 3; // server opened region and updated meta |
| PENDING_CLOSE = 4; // sent rpc to server to close but has not begun |
| CLOSING = 5; // server has begun to close but not yet done |
| CLOSED = 6; // server closed region and updated meta |
| SPLITTING = 7; // server started split of a region |
| SPLIT = 8; // server completed split of a region |
| FAILED_OPEN = 9; // failed to open, and won't retry any more |
| FAILED_CLOSE = 10; // failed to close, and won't retry any more |
| MERGING = 11; // server started merge a region |
| MERGED = 12; // server completed merge of a region |
| SPLITTING_NEW = 13; // new region to be created when RS splits a parent |
| // region but hasn't be created yet, or master doesn't |
| // know it's already created |
| MERGING_NEW = 14; // new region to be created when RS merges two |
| // daughter regions but hasn't be created yet, or |
| // master doesn't know it's already created |
| } |
| } |
| |
| message RegionInTransition { |
| required RegionSpecifier spec = 1; |
| required RegionState region_state = 2; |
| } |
| |
| /** |
| * sequence Id of a store |
| */ |
| message StoreSequenceId { |
| required bytes family_name = 1; |
| required uint64 sequence_id = 2; |
| } |
| |
| /** |
| * contains a sequence id of a region which should be the minimum of its store sequence ids and |
| * list of sequence ids of the region's stores |
| */ |
| message RegionStoreSequenceIds { |
| required uint64 last_flushed_sequence_id = 1; |
| repeated StoreSequenceId store_sequence_id = 2; |
| } |
| |
| message RegionLoad { |
| /** the region specifier */ |
| required RegionSpecifier region_specifier = 1; |
| |
| /** the number of stores for the region */ |
| optional uint32 stores = 2; |
| |
| /** the number of storefiles for the region */ |
| optional uint32 storefiles = 3; |
| |
| /** the total size of the store files for the region, uncompressed, in MB */ |
| optional uint32 store_uncompressed_size_MB = 4; |
| |
| /** the current total size of the store files for the region, in MB */ |
| optional uint32 storefile_size_MB = 5; |
| |
| /** the current size of the memstore for the region, in MB */ |
| optional uint32 memstore_size_MB = 6; |
| |
| /** |
| * The current total size of root-level store file indexes for the region, |
| * in MB. The same as {@link #rootIndexSizeKB} but in MB. |
| */ |
| optional uint32 storefile_index_size_MB = 7; |
| |
| /** the current total read requests made to region */ |
| optional uint64 read_requests_count = 8; |
| |
| /** the current total write requests made to region */ |
| optional uint64 write_requests_count = 9; |
| |
| /** the total compacting key values in currently running compaction */ |
| optional uint64 total_compacting_KVs = 10; |
| |
| /** the completed count of key values in currently running compaction */ |
| optional uint64 current_compacted_KVs = 11; |
| |
| /** The current total size of root-level indexes for the region, in KB. */ |
| optional uint32 root_index_size_KB = 12; |
| |
| /** The total size of all index blocks, not just the root level, in KB. */ |
| optional uint32 total_static_index_size_KB = 13; |
| |
| /** |
| * The total size of all Bloom filter blocks, not just loaded into the |
| * block cache, in KB. |
| */ |
| optional uint32 total_static_bloom_size_KB = 14; |
| |
| /** the most recent sequence Id from cache flush */ |
| optional uint64 complete_sequence_id = 15; |
| |
| /** The current data locality for region in the regionserver */ |
| optional float data_locality = 16; |
| |
| optional uint64 last_major_compaction_ts = 17 [default = 0]; |
| |
| /** the most recent sequence Id of store from cache flush */ |
| repeated StoreSequenceId store_complete_sequence_id = 18; |
| |
| /** the current total filtered read requests made to region */ |
| optional uint64 filtered_read_requests_count = 19; |
| } |
| |
| /* Server-level protobufs */ |
| |
| message ReplicationLoadSink { |
| required uint64 ageOfLastAppliedOp = 1; |
| required uint64 timeStampsOfLastAppliedOp = 2; |
| } |
| |
| message ReplicationLoadSource { |
| required string peerID = 1; |
| required uint64 ageOfLastShippedOp = 2; |
| required uint32 sizeOfLogQueue = 3; |
| required uint64 timeStampOfLastShippedOp = 4; |
| required uint64 replicationLag = 5; |
| } |
| |
| message ServerLoad { |
| /** Number of requests since last report. */ |
| optional uint64 number_of_requests = 1; |
| |
| /** Total Number of requests from the start of the region server. */ |
| optional uint64 total_number_of_requests = 2; |
| |
| /** the amount of used heap, in MB. */ |
| optional uint32 used_heap_MB = 3; |
| |
| /** the maximum allowable size of the heap, in MB. */ |
| optional uint32 max_heap_MB = 4; |
| |
| /** Information on the load of individual regions. */ |
| repeated RegionLoad region_loads = 5; |
| |
| /** |
| * Regionserver-level coprocessors, e.g., WALObserver implementations. |
| * Region-level coprocessors, on the other hand, are stored inside RegionLoad |
| * objects. |
| */ |
| repeated Coprocessor coprocessors = 6; |
| |
| /** |
| * Time when incremental (non-total) counts began being calculated (e.g. number_of_requests) |
| * time is measured as the difference, measured in milliseconds, between the current time |
| * and midnight, January 1, 1970 UTC. |
| */ |
| optional uint64 report_start_time = 7; |
| |
| /** |
| * Time when report was generated. |
| * time is measured as the difference, measured in milliseconds, between the current time |
| * and midnight, January 1, 1970 UTC. |
| */ |
| optional uint64 report_end_time = 8; |
| |
| /** |
| * The port number that this region server is hosing an info server on. |
| */ |
| optional uint32 info_server_port = 9; |
| |
| /** |
| * The replicationLoadSource for the replication Source status of this region server. |
| */ |
| repeated ReplicationLoadSource replLoadSource = 10; |
| |
| /** |
| * The replicationLoadSink for the replication Sink status of this region server. |
| */ |
| optional ReplicationLoadSink replLoadSink = 11; |
| } |
| |
| message LiveServerInfo { |
| required ServerName server = 1; |
| required ServerLoad server_load = 2; |
| } |
| |
| message ClusterStatus { |
| optional HBaseVersionFileContent hbase_version = 1; |
| repeated LiveServerInfo live_servers = 2; |
| repeated ServerName dead_servers = 3; |
| repeated RegionInTransition regions_in_transition = 4; |
| optional ClusterId cluster_id = 5; |
| repeated Coprocessor master_coprocessors = 6; |
| optional ServerName master = 7; |
| repeated ServerName backup_masters = 8; |
| optional bool balancer_on = 9; |
| } |