commit 0abf0810de0d6fefb9de235e1a991bf737cae4e3 Author: stack Date: Wed May 6 16:21:12 2015 -0700 First cut diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/HRegionInfo.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/HRegionInfo.java index 7b754f4..34296db 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/HRegionInfo.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/HRegionInfo.java @@ -886,11 +886,11 @@ public class HRegionInfo implements Comparable { } /** - * Convert a HRegionInfo to a RegionInfo + * Convert a HRegionInfo to the protobuf RegionInfo * * @return the converted RegionInfo */ - RegionInfo convert() { + public RegionInfo convert() { return convert(this); } diff --git a/hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/MasterProcedureProtos.java b/hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/MasterProcedureProtos.java index e0a4775..3ea6ec4 100644 --- a/hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/MasterProcedureProtos.java +++ b/hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/MasterProcedureProtos.java @@ -1070,6 +1070,160 @@ public final class MasterProcedureProtos { // @@protoc_insertion_point(enum_scope:DisableTableState) } + /** + * Protobuf enum {@code ServerCrashState} + */ + public enum ServerCrashState + implements com.google.protobuf.ProtocolMessageEnum { + /** + * START = 1; + */ + START(0, 1), + /** + * PROCESS_META = 2; + */ + PROCESS_META(1, 2), + /** + * GET_REGIONS = 3; + */ + GET_REGIONS(2, 3), + /** + * NO_SPLIT_LOGS = 4; + */ + NO_SPLIT_LOGS(3, 4), + /** + * SPLIT_LOGS = 5; + */ + SPLIT_LOGS(4, 5), + /** + * PREPARE_LOG_REPLAY = 6; + */ + PREPARE_LOG_REPLAY(5, 6), + /** + * ASSIGN = 7; + */ + ASSIGN(6, 7), + /** + * WAIT_ON_ASSIGN = 8; + */ + WAIT_ON_ASSIGN(7, 8), + /** + * WAIT_ASSIGN = 9; + */ + WAIT_ASSIGN(8, 9), + /** + * FINISH = 100; + */ + FINISH(9, 100), + ; + + /** + * START = 1; + */ + public static final int START_VALUE = 1; + /** + * PROCESS_META = 2; + */ + public static final int PROCESS_META_VALUE = 2; + /** + * GET_REGIONS = 3; + */ + public static final int GET_REGIONS_VALUE = 3; + /** + * NO_SPLIT_LOGS = 4; + */ + public static final int NO_SPLIT_LOGS_VALUE = 4; + /** + * SPLIT_LOGS = 5; + */ + public static final int SPLIT_LOGS_VALUE = 5; + /** + * PREPARE_LOG_REPLAY = 6; + */ + public static final int PREPARE_LOG_REPLAY_VALUE = 6; + /** + * ASSIGN = 7; + */ + public static final int ASSIGN_VALUE = 7; + /** + * WAIT_ON_ASSIGN = 8; + */ + public static final int WAIT_ON_ASSIGN_VALUE = 8; + /** + * WAIT_ASSIGN = 9; + */ + public static final int WAIT_ASSIGN_VALUE = 9; + /** + * FINISH = 100; + */ + public static final int FINISH_VALUE = 100; + + + public final int getNumber() { return value; } + + public static ServerCrashState valueOf(int value) { + switch (value) { + case 1: return START; + case 2: return PROCESS_META; + case 3: return GET_REGIONS; + case 4: return NO_SPLIT_LOGS; + case 5: return SPLIT_LOGS; + case 6: return PREPARE_LOG_REPLAY; + case 7: return ASSIGN; + case 8: return WAIT_ON_ASSIGN; + case 9: return WAIT_ASSIGN; + case 100: return FINISH; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ServerCrashState findValueByNumber(int number) { + return ServerCrashState.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.getDescriptor().getEnumTypes().get(9); + } + + private static final ServerCrashState[] VALUES = values(); + + public static ServerCrashState valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private ServerCrashState(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:ServerCrashState) + } + public interface CreateTableStateDataOrBuilder extends com.google.protobuf.MessageOrBuilder { @@ -11200,186 +11354,1702 @@ public final class MasterProcedureProtos { // @@protoc_insertion_point(class_scope:DisableTableStateData) } - private static com.google.protobuf.Descriptors.Descriptor - internal_static_CreateTableStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_CreateTableStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_ModifyTableStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_ModifyTableStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_TruncateTableStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_TruncateTableStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_DeleteTableStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_DeleteTableStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_AddColumnFamilyStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_AddColumnFamilyStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_ModifyColumnFamilyStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_ModifyColumnFamilyStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_DeleteColumnFamilyStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_DeleteColumnFamilyStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_EnableTableStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_EnableTableStateData_fieldAccessorTable; - private static com.google.protobuf.Descriptors.Descriptor - internal_static_DisableTableStateData_descriptor; - private static - com.google.protobuf.GeneratedMessage.FieldAccessorTable - internal_static_DisableTableStateData_fieldAccessorTable; + public interface ServerCrashStateDataOrBuilder + extends com.google.protobuf.MessageOrBuilder { - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; + // required .ServerName server_name = 1; + /** + * required .ServerName server_name = 1; + */ + boolean hasServerName(); + /** + * required .ServerName server_name = 1; + */ + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName getServerName(); + /** + * required .ServerName server_name = 1; + */ + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerNameOrBuilder getServerNameOrBuilder(); + + // optional bool distributed_log_replay = 2; + /** + * optional bool distributed_log_replay = 2; + */ + boolean hasDistributedLogReplay(); + /** + * optional bool distributed_log_replay = 2; + */ + boolean getDistributedLogReplay(); + + // repeated .RegionInfo regions_on_crashed_server = 3; + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + java.util.List + getRegionsOnCrashedServerList(); + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo getRegionsOnCrashedServer(int index); + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + int getRegionsOnCrashedServerCount(); + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + java.util.List + getRegionsOnCrashedServerOrBuilderList(); + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder getRegionsOnCrashedServerOrBuilder( + int index); + + // repeated .RegionInfo regions_to_assign = 4; + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + java.util.List + getRegionsToAssignList(); + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo getRegionsToAssign(int index); + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + int getRegionsToAssignCount(); + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + java.util.List + getRegionsToAssignOrBuilderList(); + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder getRegionsToAssignOrBuilder( + int index); + + // optional bool carrying_meta = 5; + /** + * optional bool carrying_meta = 5; + */ + boolean hasCarryingMeta(); + /** + * optional bool carrying_meta = 5; + */ + boolean getCarryingMeta(); } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\025MasterProcedure.proto\032\013HBase.proto\032\tRP" + - "C.proto\"\201\001\n\024CreateTableStateData\022#\n\tuser" + - "_info\030\001 \002(\0132\020.UserInformation\022\"\n\014table_s" + - "chema\030\002 \002(\0132\014.TableSchema\022 \n\013region_info" + - "\030\003 \003(\0132\013.RegionInfo\"\277\001\n\024ModifyTableState" + - "Data\022#\n\tuser_info\030\001 \002(\0132\020.UserInformatio" + - "n\022-\n\027unmodified_table_schema\030\002 \001(\0132\014.Tab" + - "leSchema\022+\n\025modified_table_schema\030\003 \002(\0132" + - "\014.TableSchema\022&\n\036delete_column_family_in" + - "_modify\030\004 \002(\010\"\274\001\n\026TruncateTableStateData", - "\022#\n\tuser_info\030\001 \002(\0132\020.UserInformation\022\027\n" + - "\017preserve_splits\030\002 \002(\010\022\036\n\ntable_name\030\003 \001" + - "(\0132\n.TableName\022\"\n\014table_schema\030\004 \001(\0132\014.T" + - "ableSchema\022 \n\013region_info\030\005 \003(\0132\013.Region" + - "Info\"}\n\024DeleteTableStateData\022#\n\tuser_inf" + - "o\030\001 \002(\0132\020.UserInformation\022\036\n\ntable_name\030" + - "\002 \002(\0132\n.TableName\022 \n\013region_info\030\003 \003(\0132\013" + - ".RegionInfo\"\300\001\n\030AddColumnFamilyStateData" + - "\022#\n\tuser_info\030\001 \002(\0132\020.UserInformation\022\036\n" + - "\ntable_name\030\002 \002(\0132\n.TableName\0220\n\023columnf", - "amily_schema\030\003 \002(\0132\023.ColumnFamilySchema\022" + - "-\n\027unmodified_table_schema\030\004 \001(\0132\014.Table" + - "Schema\"\303\001\n\033ModifyColumnFamilyStateData\022#" + - "\n\tuser_info\030\001 \002(\0132\020.UserInformation\022\036\n\nt" + - "able_name\030\002 \002(\0132\n.TableName\0220\n\023columnfam" + - "ily_schema\030\003 \002(\0132\023.ColumnFamilySchema\022-\n" + - "\027unmodified_table_schema\030\004 \001(\0132\014.TableSc" + - "hema\"\254\001\n\033DeleteColumnFamilyStateData\022#\n\t" + - "user_info\030\001 \002(\0132\020.UserInformation\022\036\n\ntab" + - "le_name\030\002 \002(\0132\n.TableName\022\031\n\021columnfamil", - "y_name\030\003 \002(\014\022-\n\027unmodified_table_schema\030" + - "\004 \001(\0132\014.TableSchema\"{\n\024EnableTableStateD" + - "ata\022#\n\tuser_info\030\001 \002(\0132\020.UserInformation" + - "\022\036\n\ntable_name\030\002 \002(\0132\n.TableName\022\036\n\026skip" + - "_table_state_check\030\003 \002(\010\"|\n\025DisableTable" + - "StateData\022#\n\tuser_info\030\001 \002(\0132\020.UserInfor" + - "mation\022\036\n\ntable_name\030\002 \002(\0132\n.TableName\022\036" + - "\n\026skip_table_state_check\030\003 \002(\010*\330\001\n\020Creat" + - "eTableState\022\036\n\032CREATE_TABLE_PRE_OPERATIO" + - "N\020\001\022 \n\034CREATE_TABLE_WRITE_FS_LAYOUT\020\002\022\034\n", - "\030CREATE_TABLE_ADD_TO_META\020\003\022\037\n\033CREATE_TA" + - "BLE_ASSIGN_REGIONS\020\004\022\"\n\036CREATE_TABLE_UPD" + - "ATE_DESC_CACHE\020\005\022\037\n\033CREATE_TABLE_POST_OP" + - "ERATION\020\006*\207\002\n\020ModifyTableState\022\030\n\024MODIFY" + - "_TABLE_PREPARE\020\001\022\036\n\032MODIFY_TABLE_PRE_OPE" + - "RATION\020\002\022(\n$MODIFY_TABLE_UPDATE_TABLE_DE" + - "SCRIPTOR\020\003\022&\n\"MODIFY_TABLE_REMOVE_REPLIC" + - "A_COLUMN\020\004\022!\n\035MODIFY_TABLE_DELETE_FS_LAY" + - "OUT\020\005\022\037\n\033MODIFY_TABLE_POST_OPERATION\020\006\022#" + - "\n\037MODIFY_TABLE_REOPEN_ALL_REGIONS\020\007*\212\002\n\022", - "TruncateTableState\022 \n\034TRUNCATE_TABLE_PRE" + - "_OPERATION\020\001\022#\n\037TRUNCATE_TABLE_REMOVE_FR" + - "OM_META\020\002\022\"\n\036TRUNCATE_TABLE_CLEAR_FS_LAY" + - "OUT\020\003\022#\n\037TRUNCATE_TABLE_CREATE_FS_LAYOUT" + - "\020\004\022\036\n\032TRUNCATE_TABLE_ADD_TO_META\020\005\022!\n\035TR" + - "UNCATE_TABLE_ASSIGN_REGIONS\020\006\022!\n\035TRUNCAT" + - "E_TABLE_POST_OPERATION\020\007*\337\001\n\020DeleteTable" + - "State\022\036\n\032DELETE_TABLE_PRE_OPERATION\020\001\022!\n" + - "\035DELETE_TABLE_REMOVE_FROM_META\020\002\022 \n\034DELE" + - "TE_TABLE_CLEAR_FS_LAYOUT\020\003\022\"\n\036DELETE_TAB", - "LE_UPDATE_DESC_CACHE\020\004\022!\n\035DELETE_TABLE_U" + - "NASSIGN_REGIONS\020\005\022\037\n\033DELETE_TABLE_POST_O" + - "PERATION\020\006*\331\001\n\024AddColumnFamilyState\022\035\n\031A" + - "DD_COLUMN_FAMILY_PREPARE\020\001\022#\n\037ADD_COLUMN" + - "_FAMILY_PRE_OPERATION\020\002\022-\n)ADD_COLUMN_FA" + - "MILY_UPDATE_TABLE_DESCRIPTOR\020\003\022$\n ADD_CO" + - "LUMN_FAMILY_POST_OPERATION\020\004\022(\n$ADD_COLU" + - "MN_FAMILY_REOPEN_ALL_REGIONS\020\005*\353\001\n\027Modif" + - "yColumnFamilyState\022 \n\034MODIFY_COLUMN_FAMI" + - "LY_PREPARE\020\001\022&\n\"MODIFY_COLUMN_FAMILY_PRE", - "_OPERATION\020\002\0220\n,MODIFY_COLUMN_FAMILY_UPD" + - "ATE_TABLE_DESCRIPTOR\020\003\022\'\n#MODIFY_COLUMN_" + - "FAMILY_POST_OPERATION\020\004\022+\n\'MODIFY_COLUMN" + - "_FAMILY_REOPEN_ALL_REGIONS\020\005*\226\002\n\027DeleteC" + - "olumnFamilyState\022 \n\034DELETE_COLUMN_FAMILY" + - "_PREPARE\020\001\022&\n\"DELETE_COLUMN_FAMILY_PRE_O" + - "PERATION\020\002\0220\n,DELETE_COLUMN_FAMILY_UPDAT" + - "E_TABLE_DESCRIPTOR\020\003\022)\n%DELETE_COLUMN_FA" + - "MILY_DELETE_FS_LAYOUT\020\004\022\'\n#DELETE_COLUMN" + - "_FAMILY_POST_OPERATION\020\005\022+\n\'DELETE_COLUM", - "N_FAMILY_REOPEN_ALL_REGIONS\020\006*\350\001\n\020Enable" + - "TableState\022\030\n\024ENABLE_TABLE_PREPARE\020\001\022\036\n\032" + - "ENABLE_TABLE_PRE_OPERATION\020\002\022)\n%ENABLE_T" + - "ABLE_SET_ENABLING_TABLE_STATE\020\003\022$\n ENABL" + - "E_TABLE_MARK_REGIONS_ONLINE\020\004\022(\n$ENABLE_" + - "TABLE_SET_ENABLED_TABLE_STATE\020\005\022\037\n\033ENABL" + - "E_TABLE_POST_OPERATION\020\006*\362\001\n\021DisableTabl" + - "eState\022\031\n\025DISABLE_TABLE_PREPARE\020\001\022\037\n\033DIS" + - "ABLE_TABLE_PRE_OPERATION\020\002\022+\n\'DISABLE_TA" + - "BLE_SET_DISABLING_TABLE_STATE\020\003\022&\n\"DISAB", - "LE_TABLE_MARK_REGIONS_OFFLINE\020\004\022*\n&DISAB" + - "LE_TABLE_SET_DISABLED_TABLE_STATE\020\005\022 \n\034D" + - "ISABLE_TABLE_POST_OPERATION\020\006BK\n*org.apa" + - "che.hadoop.hbase.protobuf.generatedB\025Mas" + - "terProcedureProtosH\001\210\001\001\240\001\001" - }; - com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = - new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { - public com.google.protobuf.ExtensionRegistry assignDescriptors( - com.google.protobuf.Descriptors.FileDescriptor root) { - descriptor = root; - internal_static_CreateTableStateData_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_CreateTableStateData_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_CreateTableStateData_descriptor, - new java.lang.String[] { "UserInfo", "TableSchema", "RegionInfo", }); - internal_static_ModifyTableStateData_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_ModifyTableStateData_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_ModifyTableStateData_descriptor, - new java.lang.String[] { "UserInfo", "UnmodifiedTableSchema", "ModifiedTableSchema", "DeleteColumnFamilyInModify", }); - internal_static_TruncateTableStateData_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_TruncateTableStateData_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_TruncateTableStateData_descriptor, - new java.lang.String[] { "UserInfo", "PreserveSplits", "TableName", "TableSchema", "RegionInfo", }); - internal_static_DeleteTableStateData_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_DeleteTableStateData_fieldAccessorTable = new - com.google.protobuf.GeneratedMessage.FieldAccessorTable( - internal_static_DeleteTableStateData_descriptor, - new java.lang.String[] { "UserInfo", "TableName", "RegionInfo", }); - internal_static_AddColumnFamilyStateData_descriptor = + /** + * Protobuf type {@code ServerCrashStateData} + */ + public static final class ServerCrashStateData extends + com.google.protobuf.GeneratedMessage + implements ServerCrashStateDataOrBuilder { + // Use ServerCrashStateData.newBuilder() to construct. + private ServerCrashStateData(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private ServerCrashStateData(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final ServerCrashStateData defaultInstance; + public static ServerCrashStateData getDefaultInstance() { + return defaultInstance; + } + + public ServerCrashStateData getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ServerCrashStateData( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = serverName_.toBuilder(); + } + serverName_ = input.readMessage(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(serverName_); + serverName_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + bitField0_ |= 0x00000002; + distributedLogReplay_ = input.readBool(); + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + regionsOnCrashedServer_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + regionsOnCrashedServer_.add(input.readMessage(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.PARSER, extensionRegistry)); + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + regionsToAssign_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + regionsToAssign_.add(input.readMessage(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.PARSER, extensionRegistry)); + break; + } + case 40: { + bitField0_ |= 0x00000004; + carryingMeta_ = input.readBool(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + regionsOnCrashedServer_ = java.util.Collections.unmodifiableList(regionsOnCrashedServer_); + } + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + regionsToAssign_ = java.util.Collections.unmodifiableList(regionsToAssign_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.internal_static_ServerCrashStateData_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.internal_static_ServerCrashStateData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.class, org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public ServerCrashStateData parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ServerCrashStateData(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required .ServerName server_name = 1; + public static final int SERVER_NAME_FIELD_NUMBER = 1; + private org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName serverName_; + /** + * required .ServerName server_name = 1; + */ + public boolean hasServerName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ServerName server_name = 1; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName getServerName() { + return serverName_; + } + /** + * required .ServerName server_name = 1; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerNameOrBuilder getServerNameOrBuilder() { + return serverName_; + } + + // optional bool distributed_log_replay = 2; + public static final int DISTRIBUTED_LOG_REPLAY_FIELD_NUMBER = 2; + private boolean distributedLogReplay_; + /** + * optional bool distributed_log_replay = 2; + */ + public boolean hasDistributedLogReplay() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bool distributed_log_replay = 2; + */ + public boolean getDistributedLogReplay() { + return distributedLogReplay_; + } + + // repeated .RegionInfo regions_on_crashed_server = 3; + public static final int REGIONS_ON_CRASHED_SERVER_FIELD_NUMBER = 3; + private java.util.List regionsOnCrashedServer_; + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public java.util.List getRegionsOnCrashedServerList() { + return regionsOnCrashedServer_; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public java.util.List + getRegionsOnCrashedServerOrBuilderList() { + return regionsOnCrashedServer_; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public int getRegionsOnCrashedServerCount() { + return regionsOnCrashedServer_.size(); + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo getRegionsOnCrashedServer(int index) { + return regionsOnCrashedServer_.get(index); + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder getRegionsOnCrashedServerOrBuilder( + int index) { + return regionsOnCrashedServer_.get(index); + } + + // repeated .RegionInfo regions_to_assign = 4; + public static final int REGIONS_TO_ASSIGN_FIELD_NUMBER = 4; + private java.util.List regionsToAssign_; + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public java.util.List getRegionsToAssignList() { + return regionsToAssign_; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public java.util.List + getRegionsToAssignOrBuilderList() { + return regionsToAssign_; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public int getRegionsToAssignCount() { + return regionsToAssign_.size(); + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo getRegionsToAssign(int index) { + return regionsToAssign_.get(index); + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder getRegionsToAssignOrBuilder( + int index) { + return regionsToAssign_.get(index); + } + + // optional bool carrying_meta = 5; + public static final int CARRYING_META_FIELD_NUMBER = 5; + private boolean carryingMeta_; + /** + * optional bool carrying_meta = 5; + */ + public boolean hasCarryingMeta() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional bool carrying_meta = 5; + */ + public boolean getCarryingMeta() { + return carryingMeta_; + } + + private void initFields() { + serverName_ = org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.getDefaultInstance(); + distributedLogReplay_ = false; + regionsOnCrashedServer_ = java.util.Collections.emptyList(); + regionsToAssign_ = java.util.Collections.emptyList(); + carryingMeta_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasServerName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getServerName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getRegionsOnCrashedServerCount(); i++) { + if (!getRegionsOnCrashedServer(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getRegionsToAssignCount(); i++) { + if (!getRegionsToAssign(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, serverName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBool(2, distributedLogReplay_); + } + for (int i = 0; i < regionsOnCrashedServer_.size(); i++) { + output.writeMessage(3, regionsOnCrashedServer_.get(i)); + } + for (int i = 0; i < regionsToAssign_.size(); i++) { + output.writeMessage(4, regionsToAssign_.get(i)); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(5, carryingMeta_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, serverName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(2, distributedLogReplay_); + } + for (int i = 0; i < regionsOnCrashedServer_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, regionsOnCrashedServer_.get(i)); + } + for (int i = 0; i < regionsToAssign_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, regionsToAssign_.get(i)); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(5, carryingMeta_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData)) { + return super.equals(obj); + } + org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData other = (org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData) obj; + + boolean result = true; + result = result && (hasServerName() == other.hasServerName()); + if (hasServerName()) { + result = result && getServerName() + .equals(other.getServerName()); + } + result = result && (hasDistributedLogReplay() == other.hasDistributedLogReplay()); + if (hasDistributedLogReplay()) { + result = result && (getDistributedLogReplay() + == other.getDistributedLogReplay()); + } + result = result && getRegionsOnCrashedServerList() + .equals(other.getRegionsOnCrashedServerList()); + result = result && getRegionsToAssignList() + .equals(other.getRegionsToAssignList()); + result = result && (hasCarryingMeta() == other.hasCarryingMeta()); + if (hasCarryingMeta()) { + result = result && (getCarryingMeta() + == other.getCarryingMeta()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + private int memoizedHashCode = 0; + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasServerName()) { + hash = (37 * hash) + SERVER_NAME_FIELD_NUMBER; + hash = (53 * hash) + getServerName().hashCode(); + } + if (hasDistributedLogReplay()) { + hash = (37 * hash) + DISTRIBUTED_LOG_REPLAY_FIELD_NUMBER; + hash = (53 * hash) + hashBoolean(getDistributedLogReplay()); + } + if (getRegionsOnCrashedServerCount() > 0) { + hash = (37 * hash) + REGIONS_ON_CRASHED_SERVER_FIELD_NUMBER; + hash = (53 * hash) + getRegionsOnCrashedServerList().hashCode(); + } + if (getRegionsToAssignCount() > 0) { + hash = (37 * hash) + REGIONS_TO_ASSIGN_FIELD_NUMBER; + hash = (53 * hash) + getRegionsToAssignList().hashCode(); + } + if (hasCarryingMeta()) { + hash = (37 * hash) + CARRYING_META_FIELD_NUMBER; + hash = (53 * hash) + hashBoolean(getCarryingMeta()); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ServerCrashStateData} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateDataOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.internal_static_ServerCrashStateData_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.internal_static_ServerCrashStateData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.class, org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.Builder.class); + } + + // Construct using org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getServerNameFieldBuilder(); + getRegionsOnCrashedServerFieldBuilder(); + getRegionsToAssignFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (serverNameBuilder_ == null) { + serverName_ = org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.getDefaultInstance(); + } else { + serverNameBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + distributedLogReplay_ = false; + bitField0_ = (bitField0_ & ~0x00000002); + if (regionsOnCrashedServerBuilder_ == null) { + regionsOnCrashedServer_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + } else { + regionsOnCrashedServerBuilder_.clear(); + } + if (regionsToAssignBuilder_ == null) { + regionsToAssign_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + regionsToAssignBuilder_.clear(); + } + carryingMeta_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.internal_static_ServerCrashStateData_descriptor; + } + + public org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData getDefaultInstanceForType() { + return org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.getDefaultInstance(); + } + + public org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData build() { + org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData buildPartial() { + org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData result = new org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (serverNameBuilder_ == null) { + result.serverName_ = serverName_; + } else { + result.serverName_ = serverNameBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.distributedLogReplay_ = distributedLogReplay_; + if (regionsOnCrashedServerBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004)) { + regionsOnCrashedServer_ = java.util.Collections.unmodifiableList(regionsOnCrashedServer_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.regionsOnCrashedServer_ = regionsOnCrashedServer_; + } else { + result.regionsOnCrashedServer_ = regionsOnCrashedServerBuilder_.build(); + } + if (regionsToAssignBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008)) { + regionsToAssign_ = java.util.Collections.unmodifiableList(regionsToAssign_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.regionsToAssign_ = regionsToAssign_; + } else { + result.regionsToAssign_ = regionsToAssignBuilder_.build(); + } + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000004; + } + result.carryingMeta_ = carryingMeta_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData) { + return mergeFrom((org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData other) { + if (other == org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData.getDefaultInstance()) return this; + if (other.hasServerName()) { + mergeServerName(other.getServerName()); + } + if (other.hasDistributedLogReplay()) { + setDistributedLogReplay(other.getDistributedLogReplay()); + } + if (regionsOnCrashedServerBuilder_ == null) { + if (!other.regionsOnCrashedServer_.isEmpty()) { + if (regionsOnCrashedServer_.isEmpty()) { + regionsOnCrashedServer_ = other.regionsOnCrashedServer_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.addAll(other.regionsOnCrashedServer_); + } + onChanged(); + } + } else { + if (!other.regionsOnCrashedServer_.isEmpty()) { + if (regionsOnCrashedServerBuilder_.isEmpty()) { + regionsOnCrashedServerBuilder_.dispose(); + regionsOnCrashedServerBuilder_ = null; + regionsOnCrashedServer_ = other.regionsOnCrashedServer_; + bitField0_ = (bitField0_ & ~0x00000004); + regionsOnCrashedServerBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getRegionsOnCrashedServerFieldBuilder() : null; + } else { + regionsOnCrashedServerBuilder_.addAllMessages(other.regionsOnCrashedServer_); + } + } + } + if (regionsToAssignBuilder_ == null) { + if (!other.regionsToAssign_.isEmpty()) { + if (regionsToAssign_.isEmpty()) { + regionsToAssign_ = other.regionsToAssign_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureRegionsToAssignIsMutable(); + regionsToAssign_.addAll(other.regionsToAssign_); + } + onChanged(); + } + } else { + if (!other.regionsToAssign_.isEmpty()) { + if (regionsToAssignBuilder_.isEmpty()) { + regionsToAssignBuilder_.dispose(); + regionsToAssignBuilder_ = null; + regionsToAssign_ = other.regionsToAssign_; + bitField0_ = (bitField0_ & ~0x00000008); + regionsToAssignBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getRegionsToAssignFieldBuilder() : null; + } else { + regionsToAssignBuilder_.addAllMessages(other.regionsToAssign_); + } + } + } + if (other.hasCarryingMeta()) { + setCarryingMeta(other.getCarryingMeta()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasServerName()) { + + return false; + } + if (!getServerName().isInitialized()) { + + return false; + } + for (int i = 0; i < getRegionsOnCrashedServerCount(); i++) { + if (!getRegionsOnCrashedServer(i).isInitialized()) { + + return false; + } + } + for (int i = 0; i < getRegionsToAssignCount(); i++) { + if (!getRegionsToAssign(i).isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashStateData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .ServerName server_name = 1; + private org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName serverName_ = org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerNameOrBuilder> serverNameBuilder_; + /** + * required .ServerName server_name = 1; + */ + public boolean hasServerName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ServerName server_name = 1; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName getServerName() { + if (serverNameBuilder_ == null) { + return serverName_; + } else { + return serverNameBuilder_.getMessage(); + } + } + /** + * required .ServerName server_name = 1; + */ + public Builder setServerName(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName value) { + if (serverNameBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + serverName_ = value; + onChanged(); + } else { + serverNameBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ServerName server_name = 1; + */ + public Builder setServerName( + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.Builder builderForValue) { + if (serverNameBuilder_ == null) { + serverName_ = builderForValue.build(); + onChanged(); + } else { + serverNameBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ServerName server_name = 1; + */ + public Builder mergeServerName(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName value) { + if (serverNameBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + serverName_ != org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.getDefaultInstance()) { + serverName_ = + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.newBuilder(serverName_).mergeFrom(value).buildPartial(); + } else { + serverName_ = value; + } + onChanged(); + } else { + serverNameBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ServerName server_name = 1; + */ + public Builder clearServerName() { + if (serverNameBuilder_ == null) { + serverName_ = org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.getDefaultInstance(); + onChanged(); + } else { + serverNameBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .ServerName server_name = 1; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.Builder getServerNameBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getServerNameFieldBuilder().getBuilder(); + } + /** + * required .ServerName server_name = 1; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerNameOrBuilder getServerNameOrBuilder() { + if (serverNameBuilder_ != null) { + return serverNameBuilder_.getMessageOrBuilder(); + } else { + return serverName_; + } + } + /** + * required .ServerName server_name = 1; + */ + private com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerNameOrBuilder> + getServerNameFieldBuilder() { + if (serverNameBuilder_ == null) { + serverNameBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerNameOrBuilder>( + serverName_, + getParentForChildren(), + isClean()); + serverName_ = null; + } + return serverNameBuilder_; + } + + // optional bool distributed_log_replay = 2; + private boolean distributedLogReplay_ ; + /** + * optional bool distributed_log_replay = 2; + */ + public boolean hasDistributedLogReplay() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bool distributed_log_replay = 2; + */ + public boolean getDistributedLogReplay() { + return distributedLogReplay_; + } + /** + * optional bool distributed_log_replay = 2; + */ + public Builder setDistributedLogReplay(boolean value) { + bitField0_ |= 0x00000002; + distributedLogReplay_ = value; + onChanged(); + return this; + } + /** + * optional bool distributed_log_replay = 2; + */ + public Builder clearDistributedLogReplay() { + bitField0_ = (bitField0_ & ~0x00000002); + distributedLogReplay_ = false; + onChanged(); + return this; + } + + // repeated .RegionInfo regions_on_crashed_server = 3; + private java.util.List regionsOnCrashedServer_ = + java.util.Collections.emptyList(); + private void ensureRegionsOnCrashedServerIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + regionsOnCrashedServer_ = new java.util.ArrayList(regionsOnCrashedServer_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder> regionsOnCrashedServerBuilder_; + + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public java.util.List getRegionsOnCrashedServerList() { + if (regionsOnCrashedServerBuilder_ == null) { + return java.util.Collections.unmodifiableList(regionsOnCrashedServer_); + } else { + return regionsOnCrashedServerBuilder_.getMessageList(); + } + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public int getRegionsOnCrashedServerCount() { + if (regionsOnCrashedServerBuilder_ == null) { + return regionsOnCrashedServer_.size(); + } else { + return regionsOnCrashedServerBuilder_.getCount(); + } + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo getRegionsOnCrashedServer(int index) { + if (regionsOnCrashedServerBuilder_ == null) { + return regionsOnCrashedServer_.get(index); + } else { + return regionsOnCrashedServerBuilder_.getMessage(index); + } + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder setRegionsOnCrashedServer( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo value) { + if (regionsOnCrashedServerBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.set(index, value); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder setRegionsOnCrashedServer( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder builderForValue) { + if (regionsOnCrashedServerBuilder_ == null) { + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.set(index, builderForValue.build()); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder addRegionsOnCrashedServer(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo value) { + if (regionsOnCrashedServerBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.add(value); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder addRegionsOnCrashedServer( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo value) { + if (regionsOnCrashedServerBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.add(index, value); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder addRegionsOnCrashedServer( + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder builderForValue) { + if (regionsOnCrashedServerBuilder_ == null) { + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.add(builderForValue.build()); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder addRegionsOnCrashedServer( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder builderForValue) { + if (regionsOnCrashedServerBuilder_ == null) { + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.add(index, builderForValue.build()); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder addAllRegionsOnCrashedServer( + java.lang.Iterable values) { + if (regionsOnCrashedServerBuilder_ == null) { + ensureRegionsOnCrashedServerIsMutable(); + super.addAll(values, regionsOnCrashedServer_); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder clearRegionsOnCrashedServer() { + if (regionsOnCrashedServerBuilder_ == null) { + regionsOnCrashedServer_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.clear(); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public Builder removeRegionsOnCrashedServer(int index) { + if (regionsOnCrashedServerBuilder_ == null) { + ensureRegionsOnCrashedServerIsMutable(); + regionsOnCrashedServer_.remove(index); + onChanged(); + } else { + regionsOnCrashedServerBuilder_.remove(index); + } + return this; + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder getRegionsOnCrashedServerBuilder( + int index) { + return getRegionsOnCrashedServerFieldBuilder().getBuilder(index); + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder getRegionsOnCrashedServerOrBuilder( + int index) { + if (regionsOnCrashedServerBuilder_ == null) { + return regionsOnCrashedServer_.get(index); } else { + return regionsOnCrashedServerBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public java.util.List + getRegionsOnCrashedServerOrBuilderList() { + if (regionsOnCrashedServerBuilder_ != null) { + return regionsOnCrashedServerBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(regionsOnCrashedServer_); + } + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder addRegionsOnCrashedServerBuilder() { + return getRegionsOnCrashedServerFieldBuilder().addBuilder( + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.getDefaultInstance()); + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder addRegionsOnCrashedServerBuilder( + int index) { + return getRegionsOnCrashedServerFieldBuilder().addBuilder( + index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.getDefaultInstance()); + } + /** + * repeated .RegionInfo regions_on_crashed_server = 3; + */ + public java.util.List + getRegionsOnCrashedServerBuilderList() { + return getRegionsOnCrashedServerFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder> + getRegionsOnCrashedServerFieldBuilder() { + if (regionsOnCrashedServerBuilder_ == null) { + regionsOnCrashedServerBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder>( + regionsOnCrashedServer_, + ((bitField0_ & 0x00000004) == 0x00000004), + getParentForChildren(), + isClean()); + regionsOnCrashedServer_ = null; + } + return regionsOnCrashedServerBuilder_; + } + + // repeated .RegionInfo regions_to_assign = 4; + private java.util.List regionsToAssign_ = + java.util.Collections.emptyList(); + private void ensureRegionsToAssignIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + regionsToAssign_ = new java.util.ArrayList(regionsToAssign_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder> regionsToAssignBuilder_; + + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public java.util.List getRegionsToAssignList() { + if (regionsToAssignBuilder_ == null) { + return java.util.Collections.unmodifiableList(regionsToAssign_); + } else { + return regionsToAssignBuilder_.getMessageList(); + } + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public int getRegionsToAssignCount() { + if (regionsToAssignBuilder_ == null) { + return regionsToAssign_.size(); + } else { + return regionsToAssignBuilder_.getCount(); + } + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo getRegionsToAssign(int index) { + if (regionsToAssignBuilder_ == null) { + return regionsToAssign_.get(index); + } else { + return regionsToAssignBuilder_.getMessage(index); + } + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder setRegionsToAssign( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo value) { + if (regionsToAssignBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRegionsToAssignIsMutable(); + regionsToAssign_.set(index, value); + onChanged(); + } else { + regionsToAssignBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder setRegionsToAssign( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder builderForValue) { + if (regionsToAssignBuilder_ == null) { + ensureRegionsToAssignIsMutable(); + regionsToAssign_.set(index, builderForValue.build()); + onChanged(); + } else { + regionsToAssignBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder addRegionsToAssign(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo value) { + if (regionsToAssignBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRegionsToAssignIsMutable(); + regionsToAssign_.add(value); + onChanged(); + } else { + regionsToAssignBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder addRegionsToAssign( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo value) { + if (regionsToAssignBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRegionsToAssignIsMutable(); + regionsToAssign_.add(index, value); + onChanged(); + } else { + regionsToAssignBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder addRegionsToAssign( + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder builderForValue) { + if (regionsToAssignBuilder_ == null) { + ensureRegionsToAssignIsMutable(); + regionsToAssign_.add(builderForValue.build()); + onChanged(); + } else { + regionsToAssignBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder addRegionsToAssign( + int index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder builderForValue) { + if (regionsToAssignBuilder_ == null) { + ensureRegionsToAssignIsMutable(); + regionsToAssign_.add(index, builderForValue.build()); + onChanged(); + } else { + regionsToAssignBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder addAllRegionsToAssign( + java.lang.Iterable values) { + if (regionsToAssignBuilder_ == null) { + ensureRegionsToAssignIsMutable(); + super.addAll(values, regionsToAssign_); + onChanged(); + } else { + regionsToAssignBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder clearRegionsToAssign() { + if (regionsToAssignBuilder_ == null) { + regionsToAssign_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + regionsToAssignBuilder_.clear(); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public Builder removeRegionsToAssign(int index) { + if (regionsToAssignBuilder_ == null) { + ensureRegionsToAssignIsMutable(); + regionsToAssign_.remove(index); + onChanged(); + } else { + regionsToAssignBuilder_.remove(index); + } + return this; + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder getRegionsToAssignBuilder( + int index) { + return getRegionsToAssignFieldBuilder().getBuilder(index); + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder getRegionsToAssignOrBuilder( + int index) { + if (regionsToAssignBuilder_ == null) { + return regionsToAssign_.get(index); } else { + return regionsToAssignBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public java.util.List + getRegionsToAssignOrBuilderList() { + if (regionsToAssignBuilder_ != null) { + return regionsToAssignBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(regionsToAssign_); + } + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder addRegionsToAssignBuilder() { + return getRegionsToAssignFieldBuilder().addBuilder( + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.getDefaultInstance()); + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder addRegionsToAssignBuilder( + int index) { + return getRegionsToAssignFieldBuilder().addBuilder( + index, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.getDefaultInstance()); + } + /** + * repeated .RegionInfo regions_to_assign = 4; + */ + public java.util.List + getRegionsToAssignBuilderList() { + return getRegionsToAssignFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder> + getRegionsToAssignFieldBuilder() { + if (regionsToAssignBuilder_ == null) { + regionsToAssignBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo.Builder, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfoOrBuilder>( + regionsToAssign_, + ((bitField0_ & 0x00000008) == 0x00000008), + getParentForChildren(), + isClean()); + regionsToAssign_ = null; + } + return regionsToAssignBuilder_; + } + + // optional bool carrying_meta = 5; + private boolean carryingMeta_ ; + /** + * optional bool carrying_meta = 5; + */ + public boolean hasCarryingMeta() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bool carrying_meta = 5; + */ + public boolean getCarryingMeta() { + return carryingMeta_; + } + /** + * optional bool carrying_meta = 5; + */ + public Builder setCarryingMeta(boolean value) { + bitField0_ |= 0x00000010; + carryingMeta_ = value; + onChanged(); + return this; + } + /** + * optional bool carrying_meta = 5; + */ + public Builder clearCarryingMeta() { + bitField0_ = (bitField0_ & ~0x00000010); + carryingMeta_ = false; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ServerCrashStateData) + } + + static { + defaultInstance = new ServerCrashStateData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ServerCrashStateData) + } + + private static com.google.protobuf.Descriptors.Descriptor + internal_static_CreateTableStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_CreateTableStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ModifyTableStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ModifyTableStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_TruncateTableStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_TruncateTableStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_DeleteTableStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_DeleteTableStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_AddColumnFamilyStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_AddColumnFamilyStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ModifyColumnFamilyStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ModifyColumnFamilyStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_DeleteColumnFamilyStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_DeleteColumnFamilyStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_EnableTableStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_EnableTableStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_DisableTableStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_DisableTableStateData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ServerCrashStateData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ServerCrashStateData_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\025MasterProcedure.proto\032\013HBase.proto\032\tRP" + + "C.proto\"\201\001\n\024CreateTableStateData\022#\n\tuser" + + "_info\030\001 \002(\0132\020.UserInformation\022\"\n\014table_s" + + "chema\030\002 \002(\0132\014.TableSchema\022 \n\013region_info" + + "\030\003 \003(\0132\013.RegionInfo\"\277\001\n\024ModifyTableState" + + "Data\022#\n\tuser_info\030\001 \002(\0132\020.UserInformatio" + + "n\022-\n\027unmodified_table_schema\030\002 \001(\0132\014.Tab" + + "leSchema\022+\n\025modified_table_schema\030\003 \002(\0132" + + "\014.TableSchema\022&\n\036delete_column_family_in" + + "_modify\030\004 \002(\010\"\274\001\n\026TruncateTableStateData", + "\022#\n\tuser_info\030\001 \002(\0132\020.UserInformation\022\027\n" + + "\017preserve_splits\030\002 \002(\010\022\036\n\ntable_name\030\003 \001" + + "(\0132\n.TableName\022\"\n\014table_schema\030\004 \001(\0132\014.T" + + "ableSchema\022 \n\013region_info\030\005 \003(\0132\013.Region" + + "Info\"}\n\024DeleteTableStateData\022#\n\tuser_inf" + + "o\030\001 \002(\0132\020.UserInformation\022\036\n\ntable_name\030" + + "\002 \002(\0132\n.TableName\022 \n\013region_info\030\003 \003(\0132\013" + + ".RegionInfo\"\300\001\n\030AddColumnFamilyStateData" + + "\022#\n\tuser_info\030\001 \002(\0132\020.UserInformation\022\036\n" + + "\ntable_name\030\002 \002(\0132\n.TableName\0220\n\023columnf", + "amily_schema\030\003 \002(\0132\023.ColumnFamilySchema\022" + + "-\n\027unmodified_table_schema\030\004 \001(\0132\014.Table" + + "Schema\"\303\001\n\033ModifyColumnFamilyStateData\022#" + + "\n\tuser_info\030\001 \002(\0132\020.UserInformation\022\036\n\nt" + + "able_name\030\002 \002(\0132\n.TableName\0220\n\023columnfam" + + "ily_schema\030\003 \002(\0132\023.ColumnFamilySchema\022-\n" + + "\027unmodified_table_schema\030\004 \001(\0132\014.TableSc" + + "hema\"\254\001\n\033DeleteColumnFamilyStateData\022#\n\t" + + "user_info\030\001 \002(\0132\020.UserInformation\022\036\n\ntab" + + "le_name\030\002 \002(\0132\n.TableName\022\031\n\021columnfamil", + "y_name\030\003 \002(\014\022-\n\027unmodified_table_schema\030" + + "\004 \001(\0132\014.TableSchema\"{\n\024EnableTableStateD" + + "ata\022#\n\tuser_info\030\001 \002(\0132\020.UserInformation" + + "\022\036\n\ntable_name\030\002 \002(\0132\n.TableName\022\036\n\026skip" + + "_table_state_check\030\003 \002(\010\"|\n\025DisableTable" + + "StateData\022#\n\tuser_info\030\001 \002(\0132\020.UserInfor" + + "mation\022\036\n\ntable_name\030\002 \002(\0132\n.TableName\022\036" + + "\n\026skip_table_state_check\030\003 \002(\010\"\307\001\n\024Serve" + + "rCrashStateData\022 \n\013server_name\030\001 \002(\0132\013.S" + + "erverName\022\036\n\026distributed_log_replay\030\002 \001(", + "\010\022.\n\031regions_on_crashed_server\030\003 \003(\0132\013.R" + + "egionInfo\022&\n\021regions_to_assign\030\004 \003(\0132\013.R" + + "egionInfo\022\025\n\rcarrying_meta\030\005 \001(\010*\330\001\n\020Cre" + + "ateTableState\022\036\n\032CREATE_TABLE_PRE_OPERAT" + + "ION\020\001\022 \n\034CREATE_TABLE_WRITE_FS_LAYOUT\020\002\022" + + "\034\n\030CREATE_TABLE_ADD_TO_META\020\003\022\037\n\033CREATE_" + + "TABLE_ASSIGN_REGIONS\020\004\022\"\n\036CREATE_TABLE_U" + + "PDATE_DESC_CACHE\020\005\022\037\n\033CREATE_TABLE_POST_" + + "OPERATION\020\006*\207\002\n\020ModifyTableState\022\030\n\024MODI" + + "FY_TABLE_PREPARE\020\001\022\036\n\032MODIFY_TABLE_PRE_O", + "PERATION\020\002\022(\n$MODIFY_TABLE_UPDATE_TABLE_" + + "DESCRIPTOR\020\003\022&\n\"MODIFY_TABLE_REMOVE_REPL" + + "ICA_COLUMN\020\004\022!\n\035MODIFY_TABLE_DELETE_FS_L" + + "AYOUT\020\005\022\037\n\033MODIFY_TABLE_POST_OPERATION\020\006" + + "\022#\n\037MODIFY_TABLE_REOPEN_ALL_REGIONS\020\007*\212\002" + + "\n\022TruncateTableState\022 \n\034TRUNCATE_TABLE_P" + + "RE_OPERATION\020\001\022#\n\037TRUNCATE_TABLE_REMOVE_" + + "FROM_META\020\002\022\"\n\036TRUNCATE_TABLE_CLEAR_FS_L" + + "AYOUT\020\003\022#\n\037TRUNCATE_TABLE_CREATE_FS_LAYO" + + "UT\020\004\022\036\n\032TRUNCATE_TABLE_ADD_TO_META\020\005\022!\n\035", + "TRUNCATE_TABLE_ASSIGN_REGIONS\020\006\022!\n\035TRUNC" + + "ATE_TABLE_POST_OPERATION\020\007*\337\001\n\020DeleteTab" + + "leState\022\036\n\032DELETE_TABLE_PRE_OPERATION\020\001\022" + + "!\n\035DELETE_TABLE_REMOVE_FROM_META\020\002\022 \n\034DE" + + "LETE_TABLE_CLEAR_FS_LAYOUT\020\003\022\"\n\036DELETE_T" + + "ABLE_UPDATE_DESC_CACHE\020\004\022!\n\035DELETE_TABLE" + + "_UNASSIGN_REGIONS\020\005\022\037\n\033DELETE_TABLE_POST" + + "_OPERATION\020\006*\331\001\n\024AddColumnFamilyState\022\035\n" + + "\031ADD_COLUMN_FAMILY_PREPARE\020\001\022#\n\037ADD_COLU" + + "MN_FAMILY_PRE_OPERATION\020\002\022-\n)ADD_COLUMN_", + "FAMILY_UPDATE_TABLE_DESCRIPTOR\020\003\022$\n ADD_" + + "COLUMN_FAMILY_POST_OPERATION\020\004\022(\n$ADD_CO" + + "LUMN_FAMILY_REOPEN_ALL_REGIONS\020\005*\353\001\n\027Mod" + + "ifyColumnFamilyState\022 \n\034MODIFY_COLUMN_FA" + + "MILY_PREPARE\020\001\022&\n\"MODIFY_COLUMN_FAMILY_P" + + "RE_OPERATION\020\002\0220\n,MODIFY_COLUMN_FAMILY_U" + + "PDATE_TABLE_DESCRIPTOR\020\003\022\'\n#MODIFY_COLUM" + + "N_FAMILY_POST_OPERATION\020\004\022+\n\'MODIFY_COLU" + + "MN_FAMILY_REOPEN_ALL_REGIONS\020\005*\226\002\n\027Delet" + + "eColumnFamilyState\022 \n\034DELETE_COLUMN_FAMI", + "LY_PREPARE\020\001\022&\n\"DELETE_COLUMN_FAMILY_PRE" + + "_OPERATION\020\002\0220\n,DELETE_COLUMN_FAMILY_UPD" + + "ATE_TABLE_DESCRIPTOR\020\003\022)\n%DELETE_COLUMN_" + + "FAMILY_DELETE_FS_LAYOUT\020\004\022\'\n#DELETE_COLU" + + "MN_FAMILY_POST_OPERATION\020\005\022+\n\'DELETE_COL" + + "UMN_FAMILY_REOPEN_ALL_REGIONS\020\006*\350\001\n\020Enab" + + "leTableState\022\030\n\024ENABLE_TABLE_PREPARE\020\001\022\036" + + "\n\032ENABLE_TABLE_PRE_OPERATION\020\002\022)\n%ENABLE" + + "_TABLE_SET_ENABLING_TABLE_STATE\020\003\022$\n ENA" + + "BLE_TABLE_MARK_REGIONS_ONLINE\020\004\022(\n$ENABL", + "E_TABLE_SET_ENABLED_TABLE_STATE\020\005\022\037\n\033ENA" + + "BLE_TABLE_POST_OPERATION\020\006*\362\001\n\021DisableTa" + + "bleState\022\031\n\025DISABLE_TABLE_PREPARE\020\001\022\037\n\033D" + + "ISABLE_TABLE_PRE_OPERATION\020\002\022+\n\'DISABLE_" + + "TABLE_SET_DISABLING_TABLE_STATE\020\003\022&\n\"DIS" + + "ABLE_TABLE_MARK_REGIONS_OFFLINE\020\004\022*\n&DIS" + + "ABLE_TABLE_SET_DISABLED_TABLE_STATE\020\005\022 \n" + + "\034DISABLE_TABLE_POST_OPERATION\020\006*\270\001\n\020Serv" + + "erCrashState\022\t\n\005START\020\001\022\020\n\014PROCESS_META\020" + + "\002\022\017\n\013GET_REGIONS\020\003\022\021\n\rNO_SPLIT_LOGS\020\004\022\016\n", + "\nSPLIT_LOGS\020\005\022\026\n\022PREPARE_LOG_REPLAY\020\006\022\n\n" + + "\006ASSIGN\020\007\022\022\n\016WAIT_ON_ASSIGN\020\010\022\017\n\013WAIT_AS" + + "SIGN\020\t\022\n\n\006FINISH\020dBK\n*org.apache.hadoop." + + "hbase.protobuf.generatedB\025MasterProcedur" + + "eProtosH\001\210\001\001\240\001\001" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + internal_static_CreateTableStateData_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_CreateTableStateData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_CreateTableStateData_descriptor, + new java.lang.String[] { "UserInfo", "TableSchema", "RegionInfo", }); + internal_static_ModifyTableStateData_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_ModifyTableStateData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ModifyTableStateData_descriptor, + new java.lang.String[] { "UserInfo", "UnmodifiedTableSchema", "ModifiedTableSchema", "DeleteColumnFamilyInModify", }); + internal_static_TruncateTableStateData_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_TruncateTableStateData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_TruncateTableStateData_descriptor, + new java.lang.String[] { "UserInfo", "PreserveSplits", "TableName", "TableSchema", "RegionInfo", }); + internal_static_DeleteTableStateData_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_DeleteTableStateData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_DeleteTableStateData_descriptor, + new java.lang.String[] { "UserInfo", "TableName", "RegionInfo", }); + internal_static_AddColumnFamilyStateData_descriptor = getDescriptor().getMessageTypes().get(4); internal_static_AddColumnFamilyStateData_fieldAccessorTable = new com.google.protobuf.GeneratedMessage.FieldAccessorTable( @@ -11409,6 +13079,12 @@ public final class MasterProcedureProtos { com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_DisableTableStateData_descriptor, new java.lang.String[] { "UserInfo", "TableName", "SkipTableStateCheck", }); + internal_static_ServerCrashStateData_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_ServerCrashStateData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ServerCrashStateData_descriptor, + new java.lang.String[] { "ServerName", "DistributedLogReplay", "RegionsOnCrashedServer", "RegionsToAssign", "CarryingMeta", }); return null; } }; diff --git a/hbase-protocol/src/main/protobuf/MasterProcedure.proto b/hbase-protocol/src/main/protobuf/MasterProcedure.proto index e1c6880..c532053 100644 --- a/hbase-protocol/src/main/protobuf/MasterProcedure.proto +++ b/hbase-protocol/src/main/protobuf/MasterProcedure.proto @@ -183,3 +183,24 @@ message DisableTableStateData { required TableName table_name = 2; required bool skip_table_state_check = 3; } + +message ServerCrashStateData { + required ServerName server_name = 1; + optional bool distributed_log_replay = 2; + repeated RegionInfo regions_on_crashed_server = 3; + repeated RegionInfo regions_to_assign = 4; + optional bool carrying_meta = 5; +} + +enum ServerCrashState { + START = 1; + PROCESS_META = 2; + GET_REGIONS = 3; + NO_SPLIT_LOGS = 4; + SPLIT_LOGS = 5; + PREPARE_LOG_REPLAY = 6; + ASSIGN = 7; + WAIT_ON_ASSIGN = 8; + WAIT_ASSIGN = 9; + FINISH = 100; +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java index 4a1e71f..2d2ea7d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java @@ -1990,15 +1990,15 @@ public class AssignmentManager { } /** - * Process shutdown server removing any assignments. + * Clean out crashed server removing any assignments. * @param sn Server that went down. * @return list of regions in transition on this server */ - public List processServerShutdown(final ServerName sn) { + public List cleanOutCrashedServerReferences(final ServerName sn) { // Clean out any existing assignment plans for this server synchronized (this.regionPlans) { - for (Iterator > i = - this.regionPlans.entrySet().iterator(); i.hasNext();) { + for (Iterator > i = this.regionPlans.entrySet().iterator(); + i.hasNext();) { Map.Entry e = i.next(); ServerName otherSn = e.getValue().getDestination(); // The name will be null if the region is planned for a random assign. @@ -2016,8 +2016,7 @@ public class AssignmentManager { // We need a lock on the region as we could update it Lock lock = locker.acquireLock(encodedName); try { - RegionState regionState = - regionStates.getRegionTransitionState(encodedName); + RegionState regionState = regionStates.getRegionTransitionState(encodedName); if (regionState == null || (regionState.getServerName() != null && !regionState.isOnServer(sn)) || !RegionStates.isOneOfStates(regionState, State.PENDING_OPEN, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java index 83b12dd..adcfae9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java @@ -114,8 +114,9 @@ public class DeadServer { } } - public synchronized void finish(ServerName sn) { - LOG.debug("Finished processing " + sn); + public synchronized void finish(ServerName sn, final String contextStr) { + LOG.debug("Processed " + sn + "; " + contextStr + + ", processing=" + this.numProcessing); this.numProcessing--; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java index 1ed2514..74692c8 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java @@ -52,8 +52,7 @@ import org.apache.hadoop.hbase.client.ClusterConnection; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.RetriesExhaustedException; import org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer; -import org.apache.hadoop.hbase.master.handler.MetaServerShutdownHandler; -import org.apache.hadoop.hbase.master.handler.ServerShutdownHandler; +import org.apache.hadoop.hbase.master.procedure.ServerCrashProcedure; import org.apache.hadoop.hbase.monitoring.MonitoredTask; import org.apache.hadoop.hbase.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.protobuf.RequestConverter; @@ -615,13 +614,10 @@ public class ServerManager { } boolean carryingMeta = services.getAssignmentManager().isCarryingMeta(serverName); - if (carryingMeta) { - this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master, - this.services, this.deadservers, serverName)); - } else { - this.services.getExecutorService().submit(new ServerShutdownHandler(this.master, - this.services, this.deadservers, serverName, true)); - } + this.services.getMasterProcedureExecutor(). + submitProcedure(new ServerCrashProcedure( + this.services.getMasterProcedureExecutor().getEnvironment(), this.deadservers, serverName, + true, carryingMeta)); LOG.debug("Added=" + serverName + " to dead servers, submitted shutdown handler to be executed meta=" + carryingMeta); @@ -633,10 +629,6 @@ public class ServerManager { } } - public synchronized void processDeadServer(final ServerName serverName) { - this.processDeadServer(serverName, false); - } - public synchronized void processDeadServer(final ServerName serverName, boolean shouldSplitWal) { // When assignment manager is cleaning up the zookeeper nodes and rebuilding the // in-memory region states, region servers could be down. Meta table can and @@ -652,9 +644,10 @@ public class ServerManager { } this.deadservers.add(serverName); - this.services.getExecutorService().submit( - new ServerShutdownHandler(this.master, this.services, this.deadservers, serverName, - shouldSplitWal)); + this.services.getMasterProcedureExecutor(). + submitProcedure(new ServerCrashProcedure( + this.services.getMasterProcedureExecutor().getEnvironment(), this.deadservers, serverName, + shouldSplitWal, false)); } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/LogReplayHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/LogReplayHandler.java deleted file mode 100644 index 008a04e..0000000 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/LogReplayHandler.java +++ /dev/null @@ -1,88 +0,0 @@ -/** - * Copyright The Apache Software Foundation - * - * 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. - */ -package org.apache.hadoop.hbase.master.handler; - -import java.io.IOException; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.hbase.classification.InterfaceAudience; -import org.apache.hadoop.hbase.Server; -import org.apache.hadoop.hbase.ServerName; -import org.apache.hadoop.hbase.executor.EventHandler; -import org.apache.hadoop.hbase.executor.EventType; -import org.apache.hadoop.hbase.master.DeadServer; -import org.apache.hadoop.hbase.master.MasterServices; - -/** - * Handle logReplay work from SSH. Having a separate handler is not to block SSH in re-assigning - * regions from dead servers. Otherwise, available SSH handlers could be blocked by logReplay work - * (from {@link org.apache.hadoop.hbase.master.MasterFileSystem#splitLog(ServerName)}). - * During logReplay, if a receiving RS(say A) fails again, regions on A won't be able - * to be assigned to another live RS which causes the log replay unable to complete - * because WAL edits replay depends on receiving RS to be live - */ -@InterfaceAudience.Private -public class LogReplayHandler extends EventHandler { - private static final Log LOG = LogFactory.getLog(LogReplayHandler.class); - private final ServerName serverName; - protected final Server master; - protected final MasterServices services; - protected final DeadServer deadServers; - - public LogReplayHandler(final Server server, final MasterServices services, - final DeadServer deadServers, final ServerName serverName) { - super(server, EventType.M_LOG_REPLAY); - this.master = server; - this.services = services; - this.deadServers = deadServers; - this.serverName = serverName; - this.deadServers.add(serverName); - } - - @Override - public String toString() { - String name = serverName.toString(); - return getClass().getSimpleName() + "-" + name + "-" + getSeqid(); - } - - @Override - public void process() throws IOException { - try { - if (this.master != null && this.master.isStopped()) { - // we're exiting ... - return; - } - this.services.getMasterFileSystem().splitLog(serverName); - } catch (Exception ex) { - if (ex instanceof IOException) { - // resubmit log replay work when failed - this.services.getExecutorService().submit((LogReplayHandler) this); - this.deadServers.add(serverName); - throw new IOException("failed log replay for " + serverName + ", will retry", ex); - } else { - throw new IOException(ex); - } - } finally { - this.deadServers.finish(serverName); - } - // logReplay is the last step of SSH so log a line to indicate that - LOG.info("Finished processing shutdown of " + serverName); - } -} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/MetaServerShutdownHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/MetaServerShutdownHandler.java deleted file mode 100644 index 629f941..0000000 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/MetaServerShutdownHandler.java +++ /dev/null @@ -1,216 +0,0 @@ -/** - * - * 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. - */ -package org.apache.hadoop.hbase.master.handler; - -import java.io.IOException; -import java.io.InterruptedIOException; -import java.util.HashSet; -import java.util.Set; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.hbase.classification.InterfaceAudience; -import org.apache.hadoop.hbase.HRegionInfo; -import org.apache.hadoop.hbase.Server; -import org.apache.hadoop.hbase.ServerName; -import org.apache.hadoop.hbase.executor.EventType; -import org.apache.hadoop.hbase.master.AssignmentManager; -import org.apache.hadoop.hbase.master.DeadServer; -import org.apache.hadoop.hbase.master.MasterServices; -import org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode; -import org.apache.hadoop.hbase.util.Threads; -import org.apache.zookeeper.KeeperException; - -import com.google.common.annotations.VisibleForTesting; - -import java.util.concurrent.atomic.AtomicInteger; - -/** - * Shutdown handler for the server hosting hbase:meta - */ -@InterfaceAudience.Private -public class MetaServerShutdownHandler extends ServerShutdownHandler { - private static final Log LOG = LogFactory.getLog(MetaServerShutdownHandler.class); - private AtomicInteger eventExceptionCount = new AtomicInteger(0); - @VisibleForTesting - static final int SHOW_STRACKTRACE_FREQUENCY = 100; - - public MetaServerShutdownHandler(final Server server, - final MasterServices services, - final DeadServer deadServers, final ServerName serverName) { - super(server, services, deadServers, serverName, - EventType.M_META_SERVER_SHUTDOWN, true); - } - - @Override - public void process() throws IOException { - boolean gotException = true; - try { - AssignmentManager am = this.services.getAssignmentManager(); - this.services.getMasterFileSystem().setLogRecoveryMode(); - boolean distributedLogReplay = - (this.services.getMasterFileSystem().getLogRecoveryMode() == RecoveryMode.LOG_REPLAY); - try { - if (this.shouldSplitWal) { - LOG.info("Splitting hbase:meta logs for " + serverName); - if (distributedLogReplay) { - Set regions = new HashSet(); - regions.add(HRegionInfo.FIRST_META_REGIONINFO); - this.services.getMasterFileSystem().prepareLogReplay(serverName, regions); - } else { - this.services.getMasterFileSystem().splitMetaLog(serverName); - } - am.getRegionStates().logSplit(HRegionInfo.FIRST_META_REGIONINFO); - } - } catch (IOException ioe) { - this.services.getExecutorService().submit(this); - this.deadServers.add(serverName); - throw new IOException("failed log splitting for " + serverName + ", will retry", ioe); - } - - // Assign meta if we were carrying it. - // Check again: region may be assigned to other where because of RIT - // timeout - if (am.isCarryingMeta(serverName)) { - LOG.info("Server " + serverName + " was carrying META. Trying to assign."); - verifyAndAssignMetaWithRetries(); - } else { - LOG.info("META has been assigned to otherwhere, skip assigning."); - } - - try { - if (this.shouldSplitWal && distributedLogReplay) { - if (!am.waitOnRegionToClearRegionsInTransition(HRegionInfo.FIRST_META_REGIONINFO, - regionAssignmentWaitTimeout)) { - // Wait here is to avoid log replay hits current dead server and incur a RPC timeout - // when replay happens before region assignment completes. - LOG.warn("Region " + HRegionInfo.FIRST_META_REGIONINFO.getEncodedName() - + " didn't complete assignment in time"); - } - this.services.getMasterFileSystem().splitMetaLog(serverName); - } - } catch (Exception ex) { - if (ex instanceof IOException) { - this.services.getExecutorService().submit(this); - this.deadServers.add(serverName); - throw new IOException("failed log splitting for " + serverName + ", will retry", ex); - } else { - throw new IOException(ex); - } - } - - gotException = false; - } finally { - if (gotException){ - // If we had an exception, this.deadServers.finish will be skipped in super.process() - this.deadServers.finish(serverName); - } - } - - super.process(); - // Clear this counter on successful handling. - this.eventExceptionCount.set(0); - } - - @Override - boolean isCarryingMeta() { - return true; - } - - /** - * Before assign the hbase:meta region, ensure it haven't - * been assigned by other place - *

- * Under some scenarios, the hbase:meta region can be opened twice, so it seemed online - * in two regionserver at the same time. - * If the hbase:meta region has been assigned, so the operation can be canceled. - * @throws InterruptedException - * @throws IOException - * @throws KeeperException - */ - private void verifyAndAssignMeta() - throws InterruptedException, IOException, KeeperException { - long timeout = this.server.getConfiguration(). - getLong("hbase.catalog.verification.timeout", 1000); - if (!server.getMetaTableLocator().verifyMetaRegionLocation(server.getConnection(), - this.server.getZooKeeper(), timeout)) { - this.services.getAssignmentManager().assignMeta(HRegionInfo.FIRST_META_REGIONINFO); - } else if (serverName.equals(server.getMetaTableLocator().getMetaRegionLocation( - this.server.getZooKeeper()))) { - throw new IOException("hbase:meta is onlined on the dead server " - + serverName); - } else { - LOG.info("Skip assigning hbase:meta, because it is online on the " - + server.getMetaTableLocator().getMetaRegionLocation(this.server.getZooKeeper())); - } - } - - /** - * Failed many times, shutdown processing - * @throws IOException - */ - private void verifyAndAssignMetaWithRetries() throws IOException { - int iTimes = this.server.getConfiguration().getInt( - "hbase.catalog.verification.retries", 10); - - long waitTime = this.server.getConfiguration().getLong( - "hbase.catalog.verification.timeout", 1000); - - int iFlag = 0; - while (true) { - try { - verifyAndAssignMeta(); - break; - } catch (KeeperException e) { - this.server.abort("In server shutdown processing, assigning meta", e); - throw new IOException("Aborting", e); - } catch (Exception e) { - if (iFlag >= iTimes) { - this.server.abort("verifyAndAssignMeta failed after" + iTimes - + " times retries, aborting", e); - throw new IOException("Aborting", e); - } - try { - Thread.sleep(waitTime); - } catch (InterruptedException e1) { - LOG.warn("Interrupted when is the thread sleep", e1); - Thread.currentThread().interrupt(); - throw (InterruptedIOException)new InterruptedIOException().initCause(e1); - } - iFlag++; - } - } - } - - @Override - protected void handleException(Throwable t) { - int count = eventExceptionCount.getAndIncrement(); - if (count < 0) count = eventExceptionCount.getAndSet(0); - if (count > SHOW_STRACKTRACE_FREQUENCY) { // Too frequent, let's slow reporting - Threads.sleep(1000); - } - if (count % SHOW_STRACKTRACE_FREQUENCY == 0) { - LOG.error("Caught " + eventType + ", count=" + this.eventExceptionCount, t); - } else { - LOG.error("Caught " + eventType + ", count=" + this.eventExceptionCount + - "; " + t.getMessage() + "; stack trace shows every " + SHOW_STRACKTRACE_FREQUENCY + - "th time."); - } - } -} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/ServerShutdownHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/ServerShutdownHandler.java deleted file mode 100644 index 26594f7..0000000 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/handler/ServerShutdownHandler.java +++ /dev/null @@ -1,371 +0,0 @@ -/** - * - * 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. - */ -package org.apache.hadoop.hbase.master.handler; - -import java.io.IOException; -import java.io.InterruptedIOException; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import java.util.concurrent.locks.Lock; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.hbase.classification.InterfaceAudience; -import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HRegionInfo; -import org.apache.hadoop.hbase.Server; -import org.apache.hadoop.hbase.ServerName; -import org.apache.hadoop.hbase.client.RegionReplicaUtil; -import org.apache.hadoop.hbase.client.TableState; -import org.apache.hadoop.hbase.executor.EventHandler; -import org.apache.hadoop.hbase.executor.EventType; -import org.apache.hadoop.hbase.master.AssignmentManager; -import org.apache.hadoop.hbase.master.DeadServer; -import org.apache.hadoop.hbase.master.MasterFileSystem; -import org.apache.hadoop.hbase.master.MasterServices; -import org.apache.hadoop.hbase.master.RegionState; -import org.apache.hadoop.hbase.master.RegionStates; -import org.apache.hadoop.hbase.master.ServerManager; -import org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer; -import org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode; - -/** - * Process server shutdown. - * Server-to-handle must be already in the deadservers lists. See - * {@link ServerManager#expireServer(ServerName)} - */ -@InterfaceAudience.Private -public class ServerShutdownHandler extends EventHandler { - private static final Log LOG = LogFactory.getLog(ServerShutdownHandler.class); - protected final ServerName serverName; - protected final MasterServices services; - protected final DeadServer deadServers; - protected final boolean shouldSplitWal; // whether to split WAL or not - protected final int regionAssignmentWaitTimeout; - - public ServerShutdownHandler(final Server server, final MasterServices services, - final DeadServer deadServers, final ServerName serverName, - final boolean shouldSplitWal) { - this(server, services, deadServers, serverName, EventType.M_SERVER_SHUTDOWN, - shouldSplitWal); - } - - ServerShutdownHandler(final Server server, final MasterServices services, - final DeadServer deadServers, final ServerName serverName, EventType type, - final boolean shouldSplitWal) { - super(server, type); - this.serverName = serverName; - this.server = server; - this.services = services; - this.deadServers = deadServers; - if (!this.deadServers.isDeadServer(this.serverName)) { - LOG.warn(this.serverName + " is NOT in deadservers; it should be!"); - } - this.shouldSplitWal = shouldSplitWal; - this.regionAssignmentWaitTimeout = server.getConfiguration().getInt( - HConstants.LOG_REPLAY_WAIT_REGION_TIMEOUT, 15000); - } - - @Override - public String getInformativeName() { - if (serverName != null) { - return this.getClass().getSimpleName() + " for " + serverName; - } else { - return super.getInformativeName(); - } - } - - /** - * @return True if the server we are processing was carrying hbase:meta - */ - boolean isCarryingMeta() { - return false; - } - - @Override - public String toString() { - return getClass().getSimpleName() + "-" + serverName + "-" + getSeqid(); - } - - @Override - public void process() throws IOException { - boolean hasLogReplayWork = false; - final ServerName serverName = this.serverName; - try { - - // We don't want worker thread in the MetaServerShutdownHandler - // executor pool to block by waiting availability of hbase:meta - // Otherwise, it could run into the following issue: - // 1. The current MetaServerShutdownHandler instance For RS1 waits for the hbase:meta - // to come online. - // 2. The newly assigned hbase:meta region server RS2 was shutdown right after - // it opens the hbase:meta region. So the MetaServerShutdownHandler - // instance For RS1 will still be blocked. - // 3. The new instance of MetaServerShutdownHandler for RS2 is queued. - // 4. The newly assigned hbase:meta region server RS3 was shutdown right after - // it opens the hbase:meta region. So the MetaServerShutdownHandler - // instance For RS1 and RS2 will still be blocked. - // 5. The new instance of MetaServerShutdownHandler for RS3 is queued. - // 6. Repeat until we run out of MetaServerShutdownHandler worker threads - // The solution here is to resubmit a ServerShutdownHandler request to process - // user regions on that server so that MetaServerShutdownHandler - // executor pool is always available. - // - // If AssignmentManager hasn't finished rebuilding user regions, - // we are not ready to assign dead regions either. So we re-queue up - // the dead server for further processing too. - AssignmentManager am = services.getAssignmentManager(); - ServerManager serverManager = services.getServerManager(); - if (isCarryingMeta() /* hbase:meta */ || !am.isFailoverCleanupDone()) { - serverManager.processDeadServer(serverName, this.shouldSplitWal); - return; - } - - // Wait on meta to come online; we need it to progress. - // TODO: Best way to hold strictly here? We should build this retry logic - // into the MetaTableAccessor operations themselves. - // TODO: Is the reading of hbase:meta necessary when the Master has state of - // cluster in its head? It should be possible to do without reading hbase:meta - // in all but one case. On split, the RS updates the hbase:meta - // table and THEN informs the master of the split via zk nodes in - // 'unassigned' dir. Currently the RS puts ephemeral nodes into zk so if - // the regionserver dies, these nodes do not stick around and this server - // shutdown processing does fixup (see the fixupDaughters method below). - // If we wanted to skip the hbase:meta scan, we'd have to change at least the - // final SPLIT message to be permanent in zk so in here we'd know a SPLIT - // completed (zk is updated after edits to hbase:meta have gone in). See - // {@link SplitTransaction}. We'd also have to be figure another way for - // doing the below hbase:meta daughters fixup. - Set hris = null; - try { - server.getMetaTableLocator().waitMetaRegionLocation(server.getZooKeeper()); - if (BaseLoadBalancer.tablesOnMaster(server.getConfiguration())) { - while (!this.server.isStopped() && serverManager.countOfRegionServers() < 2) { - // Wait till at least another regionserver is up besides the active master - // so that we don't assign all regions to the active master. - // This is best of efforts, because newly joined regionserver - // could crash right after that. - Thread.sleep(100); - } - } - hris = am.getRegionStates().getServerRegions(serverName); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw (InterruptedIOException)new InterruptedIOException().initCause(e); - } - if (this.server.isStopped()) { - throw new IOException("Server is stopped"); - } - - // delayed to set recovery mode based on configuration only after all outstanding splitlogtask - // drained - this.services.getMasterFileSystem().setLogRecoveryMode(); - boolean distributedLogReplay = - (this.services.getMasterFileSystem().getLogRecoveryMode() == RecoveryMode.LOG_REPLAY); - - try { - if (this.shouldSplitWal) { - if (distributedLogReplay) { - LOG.info("Mark regions in recovery for crashed server " + serverName + - " before assignment; regions=" + hris); - MasterFileSystem mfs = this.services.getMasterFileSystem(); - mfs.prepareLogReplay(serverName, hris); - } else { - LOG.info("Splitting logs for " + serverName + - " before assignment; region count=" + (hris == null ? 0 : hris.size())); - this.services.getMasterFileSystem().splitLog(serverName); - } - am.getRegionStates().logSplit(serverName); - } else { - LOG.info("Skipping log splitting for " + serverName); - } - } catch (IOException ioe) { - resubmit(serverName, ioe); - } - List toAssignRegions = new ArrayList(); - int replicaCount = services.getConfiguration().getInt(HConstants.META_REPLICAS_NUM, - HConstants.DEFAULT_META_REPLICA_NUM); - for (int i = 1; i < replicaCount; i++) { - HRegionInfo metaHri = - RegionReplicaUtil.getRegionInfoForReplica(HRegionInfo.FIRST_META_REGIONINFO, i); - if (am.isCarryingMetaReplica(serverName, metaHri)) { - LOG.info("Reassigning meta replica" + metaHri + " that was on " + serverName); - toAssignRegions.add(metaHri); - } - } - // Clean out anything in regions in transition. Being conservative and - // doing after log splitting. Could do some states before -- OPENING? - // OFFLINE? -- and then others after like CLOSING that depend on log - // splitting. - List regionsInTransition = am.processServerShutdown(serverName); - LOG.info("Reassigning " + ((hris == null)? 0: hris.size()) + - " region(s) that " + (serverName == null? "null": serverName) + - " was carrying (and " + regionsInTransition.size() + - " regions(s) that were opening on this server)"); - - toAssignRegions.addAll(regionsInTransition); - - // Iterate regions that were on this server and assign them - if (hris != null && !hris.isEmpty()) { - RegionStates regionStates = am.getRegionStates(); - for (HRegionInfo hri: hris) { - if (regionsInTransition.contains(hri)) { - continue; - } - String encodedName = hri.getEncodedName(); - Lock lock = am.acquireRegionLock(encodedName); - try { - RegionState rit = regionStates.getRegionTransitionState(hri); - if (processDeadRegion(hri, am)) { - ServerName addressFromAM = regionStates.getRegionServerOfRegion(hri); - if (addressFromAM != null && !addressFromAM.equals(this.serverName)) { - // If this region is in transition on the dead server, it must be - // opening or pending_open, which should have been covered by AM#processServerShutdown - LOG.info("Skip assigning region " + hri.getRegionNameAsString() - + " because it has been opened in " + addressFromAM.getServerName()); - continue; - } - if (rit != null) { - if (rit.getServerName() != null && !rit.isOnServer(serverName)) { - // Skip regions that are in transition on other server - LOG.info("Skip assigning region in transition on other server" + rit); - continue; - } - LOG.info("Reassigning region with rs = " + rit); - regionStates.updateRegionState(hri, RegionState.State.OFFLINE); - } else if (regionStates.isRegionInState( - hri, RegionState.State.SPLITTING_NEW, RegionState.State.MERGING_NEW)) { - regionStates.updateRegionState(hri, RegionState.State.OFFLINE); - } - toAssignRegions.add(hri); - } else if (rit != null) { - if ((rit.isClosing() || rit.isFailedClose() || rit.isOffline()) - && am.getTableStateManager().isTableState(hri.getTable(), - TableState.State.DISABLED, TableState.State.DISABLING) || - am.getReplicasToClose().contains(hri)) { - // If the table was partially disabled and the RS went down, we should clear the RIT - // and remove the node for the region. - // The rit that we use may be stale in case the table was in DISABLING state - // but though we did assign we will not be clearing the znode in CLOSING state. - // Doing this will have no harm. See HBASE-5927 - regionStates.updateRegionState(hri, RegionState.State.OFFLINE); - am.offlineDisabledRegion(hri); - } else { - LOG.warn("THIS SHOULD NOT HAPPEN: unexpected region in transition " - + rit + " not to be assigned by SSH of server " + serverName); - } - } - } finally { - lock.unlock(); - } - } - } - - try { - am.assign(toAssignRegions); - } catch (InterruptedException ie) { - LOG.error("Caught " + ie + " during round-robin assignment"); - throw (InterruptedIOException)new InterruptedIOException().initCause(ie); - } catch (IOException ioe) { - LOG.info("Caught " + ioe + " during region assignment, will retry"); - // Only do wal splitting if shouldSplitWal and in DLR mode - serverManager.processDeadServer(serverName, - this.shouldSplitWal && distributedLogReplay); - return; - } - - if (this.shouldSplitWal && distributedLogReplay) { - // wait for region assignment completes - for (HRegionInfo hri : toAssignRegions) { - try { - if (!am.waitOnRegionToClearRegionsInTransition(hri, regionAssignmentWaitTimeout)) { - // Wait here is to avoid log replay hits current dead server and incur a RPC timeout - // when replay happens before region assignment completes. - LOG.warn("Region " + hri.getEncodedName() - + " didn't complete assignment in time"); - } - } catch (InterruptedException ie) { - throw new InterruptedIOException("Caught " + ie - + " during waitOnRegionToClearRegionsInTransition"); - } - } - // submit logReplay work - this.services.getExecutorService().submit( - new LogReplayHandler(this.server, this.services, this.deadServers, this.serverName)); - hasLogReplayWork = true; - } - } finally { - this.deadServers.finish(serverName); - } - - if (!hasLogReplayWork) { - LOG.info("Finished processing of shutdown of " + serverName); - } - } - - private void resubmit(final ServerName serverName, IOException ex) throws IOException { - // typecast to SSH so that we make sure that it is the SSH instance that - // gets submitted as opposed to MSSH or some other derived instance of SSH - this.services.getExecutorService().submit((ServerShutdownHandler) this); - this.deadServers.add(serverName); - throw new IOException("failed log splitting for " + serverName + ", will retry", ex); - } - - /** - * Process a dead region from a dead RS. Checks if the region is disabled or - * disabling or if the region has a partially completed split. - * @param hri - * @param assignmentManager - * @return Returns true if specified region should be assigned, false if not. - * @throws IOException - */ - public static boolean processDeadRegion(HRegionInfo hri, - AssignmentManager assignmentManager) - throws IOException { - boolean tablePresent = assignmentManager.getTableStateManager().isTablePresent(hri.getTable()); - if (!tablePresent) { - LOG.info("The table " + hri.getTable() - + " was deleted. Hence not proceeding."); - return false; - } - // If table is not disabled but the region is offlined, - boolean disabled = assignmentManager.getTableStateManager().isTableState(hri.getTable(), - TableState.State.DISABLED); - if (disabled){ - LOG.info("The table " + hri.getTable() - + " was disabled. Hence not proceeding."); - return false; - } - if (hri.isOffline() && hri.isSplit()) { - //HBASE-7721: Split parent and daughters are inserted into hbase:meta as an atomic operation. - //If the meta scanner saw the parent split, then it should see the daughters as assigned - //to the dead server. We don't have to do anything. - return false; - } - boolean disabling = assignmentManager.getTableStateManager().isTableState(hri.getTable(), - TableState.State.DISABLING); - if (disabling) { - LOG.info("The table " + hri.getTable() - + " is disabled. Hence not assigning region" + hri.getEncodedName()); - return false; - } - return true; - } -} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java new file mode 100644 index 0000000..a3e1d0c --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java @@ -0,0 +1,513 @@ +package org.apache.hadoop.hbase.master.procedure; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InterruptedIOException; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.concurrent.locks.Lock; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.HRegionInfo; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.client.ClusterConnection; +import org.apache.hadoop.hbase.client.RegionReplicaUtil; +import org.apache.hadoop.hbase.client.TableState; +import org.apache.hadoop.hbase.master.AssignmentManager; +import org.apache.hadoop.hbase.master.DeadServer; +import org.apache.hadoop.hbase.master.MasterFileSystem; +import org.apache.hadoop.hbase.master.MasterServices; +import org.apache.hadoop.hbase.master.RegionState; +import org.apache.hadoop.hbase.master.RegionStates; +import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; +import org.apache.hadoop.hbase.procedure2.StateMachineProcedure; +import org.apache.hadoop.hbase.protobuf.ProtobufUtil; +import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionInfo; +import org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos; +import org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.ServerCrashState; +import org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode; +import org.apache.hadoop.hbase.zookeeper.MetaTableLocator; +import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; +import org.apache.zookeeper.KeeperException; + +/** + * Handle crashed server. This is a port to ProcedureV2 of what used to be euphemistically called + * ServerShutdownHandler. + * + *

The steps to achieve this procedure vary dependent on whether meta is assigned, if we are + * doing distributed log replay versus distributed log splitting, and if we are to split logs at + * all. + * + * TODO: ASSIGN and WAIT_ON_ASSIGN are not idempotent. Revisit when assign moves to pv2. + * TODO: How to ensure that meta processing always has a slot and will always run, that it won't + * be blocked by user-space region processing or some other procedure? If meta processing, it + * should be priority. Yeah, I need meta processing to run before any other procedure. It should + * be highest priority. So, round-robin on server processing unless meta processing; it takes + * precedence. + * TODO: How to ensure only one SSP per server? Lock... We do not want more than one procedure + * doing meta recovery. + * TODO: I want the processing of this procedure to run so if more than one dead server, i want + * them all to step through the procedure in lockstep. If a new dead server comes in, I want to + * have it catch up to the others. What we dont want is all slots occupied by procedures that are + * at the log replay state but the regions they want to play into have no slots in which they can + * be assigned. + */ +public class ServerCrashProcedure +extends StateMachineProcedure { + private static final Log LOG = LogFactory.getLog(ServerCrashProcedure.class); + private final MasterProcedureEnv env; + private final DeadServer deadServers; + private final boolean shouldSplitWal; + private final int regionAssignmentWaitTimeout; + // What follows gets serialized out as state 'data' since we discover it as this procedure runs + // except servername. Lets serialize this as user-readable 'key' for this procedure; only + // one procedure per server crash. + private ServerName serverName; + private Set regionsOnCrashedServer; + private boolean distributedLogReplay = false; + private List regionsToAssign; + private boolean carryingMeta = false; + + public ServerCrashProcedure(final MasterProcedureEnv env, final DeadServer deadServers, + final ServerName serverName, final boolean shouldSplitWal, final boolean carryingMeta) { + this.env = env; + this.serverName = serverName; + this.deadServers = deadServers; + if (!this.deadServers.isDeadServer(this.serverName)) { + LOG.warn(this.serverName + " is NOT in deadservers; it should be!"); + } + this.shouldSplitWal = shouldSplitWal; + this.regionAssignmentWaitTimeout = + env.getMasterConfiguration().getInt(HConstants.LOG_REPLAY_WAIT_REGION_TIMEOUT, 1000); + this.carryingMeta = carryingMeta; + } + + @Override + protected Flow executeFromState(MasterProcedureEnv env, ServerCrashState state) + throws ProcedureYieldException { + if (LOG.isTraceEnabled()) { + LOG.trace(state); + } + MasterFileSystem mfs = this.env.getMasterServices().getMasterFileSystem(); + AssignmentManager am = this.env.getMasterServices().getAssignmentManager(); + try { + switch (state) { + case START: + // Is master fully online? + if (!am.isFailoverCleanupDone()) break; + // Set recovery mode late. This is what the old ServerShutdownHandler used do. + mfs.setLogRecoveryMode(); + this.distributedLogReplay = mfs.getLogRecoveryMode() == RecoveryMode.LOG_REPLAY; + // Were we carrying meta? If so, process it before proceeding. + if (this.carryingMeta) setNextState(ServerCrashState.PROCESS_META); + else setNextState(ServerCrashState.GET_REGIONS); + break; + + case GET_REGIONS: + // Is meta assigned? + ZooKeeperWatcher zkw = this.env.getMasterServices().getZooKeeper(); + MetaTableLocator mtl = this.env.getMasterServices().getMetaTableLocator(); + if (!mtl.isLocationAvailable(zkw)) break; + ClusterConnection connection = this.env.getMasterServices().getConnection(); + if (!mtl.verifyMetaRegionLocation(connection, zkw, this.regionAssignmentWaitTimeout)) break; + // What regions were on the dead server? + this.regionsOnCrashedServer = am.getRegionStates().getServerRegions(this.serverName); + + // OK. We've finished this step. Figure where to go next. Depends on whether we should + // split logs at all or if we should do distributed log splitting (DLS) or distributed log + // replay (DLR). + + if (!this.shouldSplitWal) { + LOG.info("Skipping log splitting for crashed " + serverName); + setNextState(ServerCrashState.ASSIGN); + } else { + if (this.distributedLogReplay) setNextState(ServerCrashState.PREPARE_LOG_REPLAY); + else setNextState(ServerCrashState.SPLIT_LOGS); + } + break; + + case PROCESS_META: + if (!this.shouldSplitWal) { + LOG.info("Skipping log splitting for crashed " + serverName + " meta processing"); + setNextState(ServerCrashState.ASSIGN); + } else { + if (this.distributedLogReplay) { + Set metaOnly = new HashSet(); + metaOnly.add(HRegionInfo.FIRST_META_REGIONINFO); + prepareLogReplay(mfs, am, metaOnly); + setNextState(ServerCrashState.PREPARE_LOG_REPLAY); + } else { + mfs.splitMetaLog(serverName); + } + am.getRegionStates().logSplit(HRegionInfo.FIRST_META_REGIONINFO); + } + + // Assign meta if we were carrying it. + // Check again: region may be assigned to other where because of RIT timeout + if (am.isCarryingMeta(serverName)) { + LOG.info("Server " + this.serverName + " was carrying META. Trying to assign."); + verifyAndAssignMetaWithRetries(); + } else { + LOG.info("META has been assigned to otherwhere, skip assigning."); + } + + if (this.shouldSplitWal && distributedLogReplay) { + if (!am.waitOnRegionToClearRegionsInTransition(HRegionInfo.FIRST_META_REGIONINFO, + regionAssignmentWaitTimeout)) { + // Wait here is to avoid log replay hits current dead server and incur a RPC timeout + // when replay happens before region assignment completes. + LOG.warn("Region " + HRegionInfo.FIRST_META_REGIONINFO.getEncodedName() + + " didn't complete assignment in time"); + } + mfs.splitMetaLog(serverName); + } + setNextState(ServerCrashState.GET_REGIONS); + break; + + case PREPARE_LOG_REPLAY: + prepareLogReplay(mfs, am, this.regionsOnCrashedServer); + setNextState(ServerCrashState.ASSIGN); + break; + + case SPLIT_LOGS: + LOG.info("Splitting logs from crashed " + serverName + "; region count=" + + (regionsOnCrashedServer == null ? 0 : regionsOnCrashedServer.size())); + mfs.splitLog(this.serverName); + am.getRegionStates().logSplit(this.serverName); + // If DLR, then we go to FINISH after we've split logs. Otherwise, if DLS, we go to ASSIGN + if (this.distributedLogReplay) setNextState(ServerCrashState.FINISH); + else setNextState(ServerCrashState.ASSIGN); + break; + + case ASSIGN: + // TODO: This step is NOT idempotent. Review as part of refactor of assignment. + List regionsToAssignAggregator = new ArrayList(); + int replicaCount = this.env.getMasterConfiguration().getInt(HConstants.META_REPLICAS_NUM, + HConstants.DEFAULT_META_REPLICA_NUM); + for (int i = 1; i < replicaCount; i++) { + HRegionInfo metaHri = + RegionReplicaUtil.getRegionInfoForReplica(HRegionInfo.FIRST_META_REGIONINFO, i); + if (am.isCarryingMetaReplica(this.serverName, metaHri)) { + LOG.info("Reassigning meta replica" + metaHri + " that was on " + this.serverName); + regionsToAssignAggregator.add(metaHri); + } + } + // Clean out anything in regions in transition. + List regionsInTransition = am.cleanOutCrashedServerReferences(serverName); + LOG.info("Reassigning " + ((regionsOnCrashedServer == null)? 0: + regionsOnCrashedServer.size()) + + " region(s) that " + (serverName == null? "null": serverName) + + " was carrying (and " + regionsInTransition.size() + + " regions(s) that were opening on this server)"); + regionsToAssignAggregator.addAll(regionsInTransition); + + // Iterate regions that were on this server and assign them + if (this.regionsOnCrashedServer != null && !this.regionsOnCrashedServer.isEmpty()) { + RegionStates regionStates = am.getRegionStates(); + for (HRegionInfo hri: this.regionsOnCrashedServer) { + if (regionsInTransition.contains(hri)) continue; + String encodedName = hri.getEncodedName(); + Lock lock = am.acquireRegionLock(encodedName); + try { + RegionState rit = regionStates.getRegionTransitionState(hri); + if (processDeadRegion(hri, am)) { + ServerName addressFromAM = regionStates.getRegionServerOfRegion(hri); + if (addressFromAM != null && !addressFromAM.equals(this.serverName)) { + // If this region is in transition on the dead server, it must be + // opening or pending_open, which should have been covered by + // AM#cleanOutCrashedServerReferences + LOG.info("Skip assigning region " + hri.getRegionNameAsString() + + " because it has been opened in " + addressFromAM.getServerName()); + continue; + } + if (rit != null) { + if (rit.getServerName() != null && !rit.isOnServer(this.serverName)) { + // Skip regions that are in transition on other server + LOG.info("Skip assigning region in transition on other server" + rit); + continue; + } + LOG.info("Reassigning region with rs = " + rit); + regionStates.updateRegionState(hri, RegionState.State.OFFLINE); + } else if (regionStates.isRegionInState( + hri, RegionState.State.SPLITTING_NEW, RegionState.State.MERGING_NEW)) { + regionStates.updateRegionState(hri, RegionState.State.OFFLINE); + } + regionsToAssignAggregator.add(hri); + } else if (rit != null) { + if ((rit.isClosing() || rit.isFailedClose() || rit.isOffline()) + && am.getTableStateManager().isTableState(hri.getTable(), + TableState.State.DISABLED, TableState.State.DISABLING) || + am.getReplicasToClose().contains(hri)) { + // If the table was partially disabled and the RS went down, we should clear the + // RIT and remove the node for the region. + // The rit that we use may be stale in case the table was in DISABLING state + // but though we did assign we will not be clearing the znode in CLOSING state. + // Doing this will have no harm. See HBASE-5927 + regionStates.updateRegionState(hri, RegionState.State.OFFLINE); + am.offlineDisabledRegion(hri); + } else { + LOG.warn("THIS SHOULD NOT HAPPEN: unexpected region in transition " + + rit + " not to be assigned by SSH of server " + serverName); + } + } + } finally { + lock.unlock(); + } + } + } + this.regionsToAssign = regionsToAssignAggregator; + try { + am.assign(this.regionsToAssign); + } catch (InterruptedException ie) { + LOG.error("Caught " + ie + " during round-robin assignment"); + throw (InterruptedIOException)new InterruptedIOException().initCause(ie); + } catch (IOException ioe) { + LOG.info("Caught " + ioe + " during region assignment, will retry"); + break; + } + if (this.shouldSplitWal && distributedLogReplay) { + setNextState(ServerCrashState.WAIT_ON_ASSIGN); + } else { + setNextState(ServerCrashState.FINISH); + } + break; + + case WAIT_ON_ASSIGN: + // TODO: Not idempotent. + // TODO: Do not block in here. If regions not assigned, relinquish our slot so another + // procedure has chance to run (and it can finish the assign we are waiting on). + // Wait for region assignment completes + for (HRegionInfo hri: this.regionsToAssign) { + try { + if (!am.waitOnRegionToClearRegionsInTransition(hri, this.regionAssignmentWaitTimeout)) { + // Wait here is to avoid log replay hits current dead server and incur a RPC timeout + // when replay happens before region assignment completes. + LOG.warn("Region " + hri.getEncodedName() + " didn't complete assignment in time"); + } + } catch (InterruptedException ie) { + throw new InterruptedIOException("Caught " + ie + + " during waitOnRegionToClearRegionsInTransition"); + } + } + // TODO: We sure all have been assigned when we get to here? + setNextState(ServerCrashState.SPLIT_LOGS); + break; + + case FINISH: + this.deadServers.finish(serverName, "user-space"); + LOG.info("Finished processing of shutdown of " + serverName); + return Flow.NO_MORE_STATE; + + default: + throw new UnsupportedOperationException("unhandled state=" + state); + } + } catch (IOException e) { + LOG.warn("Failed serverName=" + this.serverName + ", state=" + state + "; retry", e); + } catch (InterruptedException e) { + LOG.warn("Interrupted serverName=" + this.serverName + ", state=" + state + "; retry", e); + } + return Flow.HAS_MORE_STATE; + } + + private void prepareLogReplay(final MasterFileSystem mfs, final AssignmentManager am, + final Set regions) + throws IOException { + LOG.info("Mark regions-in-recovery from crashed " + this.serverName + + "; regions=" + regionsOnCrashedServer); + mfs.prepareLogReplay(this.serverName, this.regionsOnCrashedServer); + am.getRegionStates().logSplit(this.serverName); + } + + @Override + protected void rollbackState(MasterProcedureEnv env, ServerCrashState state) + throws IOException { + // Can't rollback. + throw new UnsupportedOperationException("unhandled state=" + state); + } + + @Override + protected ServerCrashState getState(int stateId) { + return ServerCrashState.valueOf(stateId); + } + + @Override + protected int getStateId(ServerCrashState state) { + return state.getNumber(); + } + + @Override + protected ServerCrashState getInitialState() { + return ServerCrashState.START; + } + + @Override + protected boolean abort(MasterProcedureEnv env) { + // TODO + return false; + } + + @Override + protected boolean acquireLock(final MasterProcedureEnv env) { + if (!env.isInitialized()) return false; + // TODO + return true; + } + + @Override + protected void releaseLock(final MasterProcedureEnv env) { + // TODO + } + + @Override + public void toStringClassDetails(StringBuilder sb) { + sb.append(getClass().getSimpleName()); + sb.append(" serverName="); + sb.append(this.serverName); + } + + @Override + public void serializeStateData(final OutputStream stream) throws IOException { + super.serializeStateData(stream); + + MasterProcedureProtos.ServerCrashStateData.Builder state = + MasterProcedureProtos.ServerCrashStateData.newBuilder(). + setServerName(ProtobufUtil.toServerName(this.serverName)). + setDistributedLogReplay(this.distributedLogReplay). + setCarryingMeta(this.carryingMeta); + if (this.regionsOnCrashedServer != null) { + for (HRegionInfo hri: this.regionsOnCrashedServer) { + state.addRegionsOnCrashedServer(hri.convert()); + } + } + if (this.regionsToAssign != null) { + for (HRegionInfo hri: this.regionsOnCrashedServer) { + state.addRegionsToAssign(hri.convert()); + } + } + state.build().writeDelimitedTo(stream); + } + + @Override + public void deserializeStateData(final InputStream stream) throws IOException { + super.deserializeStateData(stream); + + MasterProcedureProtos.ServerCrashStateData state = + MasterProcedureProtos.ServerCrashStateData.parseDelimitedFrom(stream); + this.serverName = ProtobufUtil.toServerName(state.getServerName()); + this.distributedLogReplay = state.hasDistributedLogReplay()? + state.getDistributedLogReplay(): false; + this.carryingMeta = state.hasCarryingMeta()? state.getCarryingMeta(): false; + int size = state.getRegionsOnCrashedServerCount(); + if (size > 0) { + this.regionsOnCrashedServer = new HashSet(size); + for (RegionInfo ri: state.getRegionsOnCrashedServerList()) { + this.regionsOnCrashedServer.add(HRegionInfo.convert(ri)); + } + } + size = state.getRegionsToAssignCount(); + if (size > 0) { + this.regionsToAssign = new ArrayList(size); + for (RegionInfo ri: state.getRegionsOnCrashedServerList()) { + this.regionsToAssign.add(HRegionInfo.convert(ri)); + } + } + } + + /** + * Process a dead region from a dead RS. Checks if the region is disabled or + * disabling or if the region has a partially completed split. + * @param hri + * @param assignmentManager + * @return Returns true if specified region should be assigned, false if not. + * @throws IOException + */ + static boolean processDeadRegion(HRegionInfo hri, AssignmentManager assignmentManager) + throws IOException { + boolean tablePresent = assignmentManager.getTableStateManager().isTablePresent(hri.getTable()); + if (!tablePresent) { + LOG.info("The table " + hri.getTable() + " was deleted. Hence not proceeding."); + return false; + } + // If table is not disabled but the region is offlined, + boolean disabled = assignmentManager.getTableStateManager().isTableState(hri.getTable(), + TableState.State.DISABLED); + if (disabled){ + LOG.info("The table " + hri.getTable() + " was disabled. Hence not proceeding."); + return false; + } + if (hri.isOffline() && hri.isSplit()) { + // HBASE-7721: Split parent and daughters are inserted into hbase:meta as an atomic operation. + // If the meta scanner saw the parent split, then it should see the daughters as assigned + // to the dead server. We don't have to do anything. + return false; + } + boolean disabling = assignmentManager.getTableStateManager().isTableState(hri.getTable(), + TableState.State.DISABLING); + if (disabling) { + LOG.info("The table " + hri.getTable() + " is disabled. Hence not assigning region" + + hri.getEncodedName()); + return false; + } + return true; + } + + /** + * Before we assign the hbase:meta region, ensure it hasn't been assigned elsewhere + * @throws InterruptedException + * @throws IOException + * @throws KeeperException + */ + private void verifyAndAssignMeta() + throws InterruptedException, IOException, KeeperException { + MasterServices services = this.env.getMasterServices(); + long timeout = services.getConfiguration().getLong("hbase.catalog.verification.timeout", 1000); + if (!services.getMetaTableLocator().verifyMetaRegionLocation(services.getConnection(), + services.getZooKeeper(), timeout)) { + services.getAssignmentManager().assignMeta(HRegionInfo.FIRST_META_REGIONINFO); + } else if (serverName.equals(services.getMetaTableLocator().getMetaRegionLocation( + services.getZooKeeper()))) { + throw new IOException("hbase:meta is onlined on the dead server " + this.serverName); + } else { + LOG.info("Skip assigning hbase:meta, because it is online on the " + + services.getMetaTableLocator().getMetaRegionLocation(services.getZooKeeper())); + } + } + + /** + * Failed many times, shutdown processing + * @throws IOException + */ + private void verifyAndAssignMetaWithRetries() throws IOException { + MasterServices services = this.env.getMasterServices(); + int iTimes = services.getConfiguration().getInt("hbase.catalog.verification.retries", 10); + long waitTime = services.getConfiguration().getLong("hbase.catalog.verification.timeout", 1000); + int iFlag = 0; + while (true) { + try { + verifyAndAssignMeta(); + break; + } catch (KeeperException e) { + services.abort("In server shutdown processing, assigning meta", e); + throw new IOException("Aborting", e); + } catch (Exception e) { + if (iFlag >= iTimes) { + services.abort("verifyAndAssignMeta failed after" + iTimes + " retries, aborting", e); + throw new IOException("Aborting", e); + } + try { + Thread.sleep(waitTime); + } catch (InterruptedException e1) { + LOG.warn("Interrupted when is the thread sleep", e1); + Thread.currentThread().interrupt(); + throw (InterruptedIOException)new InterruptedIOException().initCause(e1); + } + iFlag++; + } + } + } +} \ No newline at end of file diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerOnCluster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerOnCluster.java index eb72220..cbb20914 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerOnCluster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerOnCluster.java @@ -635,7 +635,7 @@ public class TestAssignmentManagerOnCluster { am.getRegionStates().updateRegionState(hri, RegionState.State.PENDING_OPEN, destServerName); am.getTableStateManager().setTableState(table, TableState.State.DISABLING); - List toAssignRegions = am.processServerShutdown(destServerName); + List toAssignRegions = am.cleanOutCrashedServerReferences(destServerName); assertTrue("Regions to be assigned should be empty.", toAssignRegions.isEmpty()); assertTrue("Regions to be assigned should be empty.", am.getRegionStates() .getRegionState(hri).isOffline()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestDeadServer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestDeadServer.java index 40d26f4..bdefc34 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestDeadServer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestDeadServer.java @@ -44,17 +44,17 @@ public class TestDeadServer { DeadServer ds = new DeadServer(); ds.add(hostname123); assertTrue(ds.areDeadServersInProgress()); - ds.finish(hostname123); + ds.finish(hostname123, "test 1"); assertFalse(ds.areDeadServersInProgress()); ds.add(hostname1234); assertTrue(ds.areDeadServersInProgress()); - ds.finish(hostname1234); + ds.finish(hostname1234, "test 2"); assertFalse(ds.areDeadServersInProgress()); ds.add(hostname12345); assertTrue(ds.areDeadServersInProgress()); - ds.finish(hostname12345); + ds.finish(hostname12345, "test 3"); assertFalse(ds.areDeadServersInProgress()); // Already dead = 127.0.0.1,9090,112321