commit 50cc17ea85dbb32270e2d82380d92b9b2e2d03f8 Author: stack Date: Tue May 12 11:22:16 2015 -0700 HBASE-3616 Move ServerShutdownHandler to Pv2 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 b127489..adca3d7 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 @@ -846,7 +846,7 @@ public class HRegionInfo implements Comparable { } /** - * Convert a HRegionInfo to a RegionInfo + * Convert a HRegionInfo to the protobuf RegionInfo * * @return the converted RegionInfo */ 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..519680f 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,181 +11354,1787 @@ 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(); + + // optional float progress = 6 [default = 0]; + /** + * optional float progress = 6 [default = 0]; + */ + boolean hasProgress(); + /** + * optional float progress = 6 [default = 0]; + */ + float getProgress(); } - 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); + /** + * 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; + } + case 53: { + bitField0_ |= 0x00000008; + progress_ = input.readFloat(); + 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_; + } + + // optional float progress = 6 [default = 0]; + public static final int PROGRESS_FIELD_NUMBER = 6; + private float progress_; + /** + * optional float progress = 6 [default = 0]; + */ + public boolean hasProgress() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional float progress = 6 [default = 0]; + */ + public float getProgress() { + return progress_; + } + + 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; + progress_ = 0F; + } + 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_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeFloat(6, progress_); + } + 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_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(6, progress_); + } + 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 && (hasProgress() == other.hasProgress()); + if (hasProgress()) { + result = result && (Float.floatToIntBits(getProgress()) == Float.floatToIntBits(other.getProgress())); + } + 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()); + } + if (hasProgress()) { + hash = (37 * hash) + PROGRESS_FIELD_NUMBER; + hash = (53 * hash) + Float.floatToIntBits( + getProgress()); + } + 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); + progress_ = 0F; + bitField0_ = (bitField0_ & ~0x00000020); + 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_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000008; + } + result.progress_ = progress_; + 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()); + } + if (other.hasProgress()) { + setProgress(other.getProgress()); + } + 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; + } + + // optional float progress = 6 [default = 0]; + private float progress_ ; + /** + * optional float progress = 6 [default = 0]; + */ + public boolean hasProgress() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional float progress = 6 [default = 0]; + */ + public float getProgress() { + return progress_; + } + /** + * optional float progress = 6 [default = 0]; + */ + public Builder setProgress(float value) { + bitField0_ |= 0x00000020; + progress_ = value; + onChanged(); + return this; + } + /** + * optional float progress = 6 [default = 0]; + */ + public Builder clearProgress() { + bitField0_ = (bitField0_ & ~0x00000020); + progress_ = 0F; + 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\"\334\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\022\023\n\010prog" + + "ress\030\006 \001(\002:\0010*\330\001\n\020CreateTableState\022\036\n\032CR" + + "EATE_TABLE_PRE_OPERATION\020\001\022 \n\034CREATE_TAB" + + "LE_WRITE_FS_LAYOUT\020\002\022\034\n\030CREATE_TABLE_ADD" + + "_TO_META\020\003\022\037\n\033CREATE_TABLE_ASSIGN_REGION" + + "S\020\004\022\"\n\036CREATE_TABLE_UPDATE_DESC_CACHE\020\005\022" + + "\037\n\033CREATE_TABLE_POST_OPERATION\020\006*\207\002\n\020Mod" + + "ifyTableState\022\030\n\024MODIFY_TABLE_PREPARE\020\001\022", + "\036\n\032MODIFY_TABLE_PRE_OPERATION\020\002\022(\n$MODIF" + + "Y_TABLE_UPDATE_TABLE_DESCRIPTOR\020\003\022&\n\"MOD" + + "IFY_TABLE_REMOVE_REPLICA_COLUMN\020\004\022!\n\035MOD" + + "IFY_TABLE_DELETE_FS_LAYOUT\020\005\022\037\n\033MODIFY_T" + + "ABLE_POST_OPERATION\020\006\022#\n\037MODIFY_TABLE_RE" + + "OPEN_ALL_REGIONS\020\007*\212\002\n\022TruncateTableStat" + + "e\022 \n\034TRUNCATE_TABLE_PRE_OPERATION\020\001\022#\n\037T" + + "RUNCATE_TABLE_REMOVE_FROM_META\020\002\022\"\n\036TRUN" + + "CATE_TABLE_CLEAR_FS_LAYOUT\020\003\022#\n\037TRUNCATE" + + "_TABLE_CREATE_FS_LAYOUT\020\004\022\036\n\032TRUNCATE_TA", + "BLE_ADD_TO_META\020\005\022!\n\035TRUNCATE_TABLE_ASSI" + + "GN_REGIONS\020\006\022!\n\035TRUNCATE_TABLE_POST_OPER" + + "ATION\020\007*\337\001\n\020DeleteTableState\022\036\n\032DELETE_T" + + "ABLE_PRE_OPERATION\020\001\022!\n\035DELETE_TABLE_REM" + + "OVE_FROM_META\020\002\022 \n\034DELETE_TABLE_CLEAR_FS" + + "_LAYOUT\020\003\022\"\n\036DELETE_TABLE_UPDATE_DESC_CA" + + "CHE\020\004\022!\n\035DELETE_TABLE_UNASSIGN_REGIONS\020\005" + + "\022\037\n\033DELETE_TABLE_POST_OPERATION\020\006*\331\001\n\024Ad" + + "dColumnFamilyState\022\035\n\031ADD_COLUMN_FAMILY_" + + "PREPARE\020\001\022#\n\037ADD_COLUMN_FAMILY_PRE_OPERA", + "TION\020\002\022-\n)ADD_COLUMN_FAMILY_UPDATE_TABLE" + + "_DESCRIPTOR\020\003\022$\n ADD_COLUMN_FAMILY_POST_" + + "OPERATION\020\004\022(\n$ADD_COLUMN_FAMILY_REOPEN_" + + "ALL_REGIONS\020\005*\353\001\n\027ModifyColumnFamilyStat" + + "e\022 \n\034MODIFY_COLUMN_FAMILY_PREPARE\020\001\022&\n\"M" + + "ODIFY_COLUMN_FAMILY_PRE_OPERATION\020\002\0220\n,M" + + "ODIFY_COLUMN_FAMILY_UPDATE_TABLE_DESCRIP" + + "TOR\020\003\022\'\n#MODIFY_COLUMN_FAMILY_POST_OPERA" + + "TION\020\004\022+\n\'MODIFY_COLUMN_FAMILY_REOPEN_AL" + + "L_REGIONS\020\005*\226\002\n\027DeleteColumnFamilyState\022", + " \n\034DELETE_COLUMN_FAMILY_PREPARE\020\001\022&\n\"DEL" + + "ETE_COLUMN_FAMILY_PRE_OPERATION\020\002\0220\n,DEL" + + "ETE_COLUMN_FAMILY_UPDATE_TABLE_DESCRIPTO" + + "R\020\003\022)\n%DELETE_COLUMN_FAMILY_DELETE_FS_LA" + + "YOUT\020\004\022\'\n#DELETE_COLUMN_FAMILY_POST_OPER" + + "ATION\020\005\022+\n\'DELETE_COLUMN_FAMILY_REOPEN_A" + + "LL_REGIONS\020\006*\350\001\n\020EnableTableState\022\030\n\024ENA" + + "BLE_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 ENABLE_TABLE_MARK_REGI", + "ONS_ONLINE\020\004\022(\n$ENABLE_TABLE_SET_ENABLED" + + "_TABLE_STATE\020\005\022\037\n\033ENABLE_TABLE_POST_OPER" + + "ATION\020\006*\362\001\n\021DisableTableState\022\031\n\025DISABLE" + + "_TABLE_PREPARE\020\001\022\037\n\033DISABLE_TABLE_PRE_OP" + + "ERATION\020\002\022+\n\'DISABLE_TABLE_SET_DISABLING" + + "_TABLE_STATE\020\003\022&\n\"DISABLE_TABLE_MARK_REG" + + "IONS_OFFLINE\020\004\022*\n&DISABLE_TABLE_SET_DISA" + + "BLED_TABLE_STATE\020\005\022 \n\034DISABLE_TABLE_POST" + + "_OPERATION\020\006*\270\001\n\020ServerCrashState\022\t\n\005STA" + + "RT\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\022PR" + + "EPARE_LOG_REPLAY\020\006\022\n\n\006ASSIGN\020\007\022\022\n\016WAIT_O" + + "N_ASSIGN\020\010\022\017\n\013WAIT_ASSIGN\020\t\022\n\n\006FINISH\020dB" + + "K\n*org.apache.hadoop.hbase.protobuf.gene" + + "ratedB\025MasterProcedureProtosH\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, @@ -11409,6 +13169,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", "Progress", }); return null; } }; diff --git a/hbase-protocol/src/main/protobuf/MasterProcedure.proto b/hbase-protocol/src/main/protobuf/MasterProcedure.proto index e1c6880..b3222e2 100644 --- a/hbase-protocol/src/main/protobuf/MasterProcedure.proto +++ b/hbase-protocol/src/main/protobuf/MasterProcedure.proto @@ -183,3 +183,25 @@ 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; + optional float progress = 6 [default = 0]; +} + +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 0fe59a6..eabb5ec 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 @@ -2058,15 +2058,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. @@ -2084,8 +2084,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/MasterFileSystem.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterFileSystem.java index de28cdc..e2cd2e2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterFileSystem.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterFileSystem.java @@ -46,7 +46,6 @@ import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.HFileArchiver; -import org.apache.hadoop.hbase.client.TableState; import org.apache.hadoop.hbase.exceptions.DeserializationException; import org.apache.hadoop.hbase.fs.HFileSystem; import org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode; 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/TableLockManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/TableLockManager.java index cfaeb98..ef1e84f 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/TableLockManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/TableLockManager.java @@ -25,17 +25,16 @@ import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.InterProcessLock; import org.apache.hadoop.hbase.InterProcessLock.MetadataHandler; import org.apache.hadoop.hbase.InterProcessReadWriteLock; import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.exceptions.LockTimeoutException; import org.apache.hadoop.hbase.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos; -import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.zookeeper.ZKUtil; import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; 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/MasterProcedureQueue.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureQueue.java index 0dd0c3d..35ce50b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureQueue.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureQueue.java @@ -27,6 +27,7 @@ import java.util.concurrent.locks.ReentrantLock; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableExistsException; import org.apache.hadoop.hbase.TableNotFoundException; @@ -43,11 +44,12 @@ import org.apache.hadoop.hbase.master.procedure.TableProcedureInterface.TableOpe * ProcedureRunnableSet for the Master Procedures. * This RunnableSet tries to provide to the ProcedureExecutor procedures * that can be executed without having to wait on a lock. - * Most of the master operations can be executed concurrently, if the they + * Most of the master operations can be executed concurrently, if they * are operating on different tables (e.g. two create table can be performed - * at the same, time assuming table A and table B). + * at the same, time assuming table A and table B) or against two different servers; say + * two servers that crashed at about the same time. * - * Each procedure should implement an interface providing information for this queue. + *

Each procedure should implement an interface providing information for this queue. * for example table related procedures should implement TableProcedureInterface. * each procedure will be pushed in its own queue, and based on the operation type * we may take smarter decision. e.g. we can abort all the operations preceding @@ -58,7 +60,9 @@ import org.apache.hadoop.hbase.master.procedure.TableProcedureInterface.TableOpe public class MasterProcedureQueue implements ProcedureRunnableSet { private static final Log LOG = LogFactory.getLog(MasterProcedureQueue.class); - private final ProcedureFairRunQueues fairq; + private final ProcedureFairRunQueues tableFairQ; + private final ProcedureFairRunQueues serverFairQ; + private final ReentrantLock lock = new ReentrantLock(); private final Condition waitCond = lock.newCondition(); private final TableLockManager lockManager; @@ -67,16 +71,28 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { private final int userTablePriority; private final int sysTablePriority; + private final int metaServerPriority; + private final int userServerPriority; + private final int sysServerPriority; + + /** + * Keeps count across server and table queues. + */ private int queueSize; public MasterProcedureQueue(final Configuration conf, final TableLockManager lockManager) { - this.fairq = new ProcedureFairRunQueues(1); + this.tableFairQ = new ProcedureFairRunQueues(1); + this.serverFairQ = new ProcedureFairRunQueues(1); this.lockManager = lockManager; // TODO: should this be part of the HTD? metaTablePriority = conf.getInt("hbase.master.procedure.queue.meta.table.priority", 3); sysTablePriority = conf.getInt("hbase.master.procedure.queue.system.table.priority", 2); userTablePriority = conf.getInt("hbase.master.procedure.queue.user.table.priority", 1); + + metaServerPriority = conf.getInt("hbase.master.procedure.queue.meta.server.priority", 3); + sysServerPriority = conf.getInt("hbase.master.procedure.queue.system.server.priority", 2); + userServerPriority = conf.getInt("hbase.master.procedure.queue.user.server.priority", 1); } @Override @@ -111,6 +127,7 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { @Override @edu.umd.cs.findbugs.annotations.SuppressWarnings("WA_AWAIT_NOT_IN_LOOP") public Long poll() { + Long pollResult = null; lock.lock(); try { if (queueSize == 0) { @@ -119,19 +136,25 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { return null; } } - - RunQueue queue = fairq.poll(); - if (queue != null && queue.isAvailable()) { - queueSize--; - return queue.poll(); + // For now, let server handling have precedence over table handling; presumption is that it + // is more important handling crashed servers than it is running the + // enabling/disabling tables, etc. + pollResult = doPoll(serverFairQ.poll()); + if (pollResult == null) { + pollResult = doPoll(tableFairQ.poll()); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); - return null; } finally { lock.unlock(); } - return null; + return pollResult; + } + + private Long doPoll(final RunQueue rq) { + if (rq == null || !rq.isAvailable()) return null; + this.queueSize--; + return rq.poll(); } @Override @@ -148,7 +171,8 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { public void clear() { lock.lock(); try { - fairq.clear(); + serverFairQ.clear(); + tableFairQ.clear(); queueSize = 0; } finally { lock.unlock(); @@ -169,7 +193,8 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { public String toString() { lock.lock(); try { - return "MasterProcedureQueue size=" + queueSize + ": " + fairq; + return "MasterProcedureQueue size=" + queueSize + ": tableFairQ: " + tableFairQ + + ", serverFairQ: " + serverFairQ; } finally { lock.unlock(); } @@ -197,6 +222,7 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { markTableAsDeleted(iProcTable.getTableName()); } } + // No cleanup for ServerProcedureInterface types, yet. } private RunQueue getRunQueueOrCreate(final Procedure proc) { @@ -204,17 +230,26 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { final TableName table = ((TableProcedureInterface)proc).getTableName(); return getRunQueueOrCreate(table); } - // TODO: at the moment we only have Table procedures - // if you are implementing a non-table procedure, you have two option create - // a group for all the non-table procedures or try to find a key for your - // non-table procedure and implement something similar to the TableRunQueue. + if (proc instanceof ServerProcedureInterface) { + return getRunQueueOrCreate((ServerProcedureInterface)proc); + } + // TODO: at the moment we only have Table and Server procedures + // if you are implementing a non-table/non-server procedure, you have two options: create + // a group for all the non-table/non-server procedures or try to find a key for your + // non-table/non-server procedures and implement something similar to the TableRunQueue. throw new UnsupportedOperationException("RQs for non-table procedures are not implemented yet"); } private TableRunQueue getRunQueueOrCreate(final TableName table) { final TableRunQueue queue = getRunQueue(table); if (queue != null) return queue; - return (TableRunQueue)fairq.add(table, createTableRunQueue(table)); + return (TableRunQueue)tableFairQ.add(table, createTableRunQueue(table)); + } + + private ServerRunQueue getRunQueueOrCreate(final ServerProcedureInterface spi) { + final ServerRunQueue queue = getRunQueue(spi.getServerName()); + if (queue != null) return queue; + return (ServerRunQueue)serverFairQ.add(spi.getServerName(), createServerRunQueue(spi)); } private TableRunQueue createTableRunQueue(final TableName table) { @@ -227,8 +262,22 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { return new TableRunQueue(priority); } + private ServerRunQueue createServerRunQueue(final ServerProcedureInterface spi) { + int priority = userServerPriority; + if (spi.hasMetaTableRegion()) { + priority = metaServerPriority; + } else if (spi.hasSystemTableRegion()) { + priority = sysServerPriority; + } + return new ServerRunQueue(priority); + } + private TableRunQueue getRunQueue(final TableName table) { - return (TableRunQueue)fairq.get(table); + return (TableRunQueue)tableFairQ.get(table); + } + + private ServerRunQueue getRunQueue(final ServerName sn) { + return (ServerRunQueue)serverFairQ.get(sn); } /** @@ -252,6 +301,44 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { } /** + * Try to acquire the write lock on the specified server. + * @see #releaseServerWrite(ServerProcedureInterface) + * @param spi Server to lock + * @return true if we were able to acquire the lock on the server, otherwise false. + */ + public boolean tryAcquireServerWrite(final ServerProcedureInterface spi) { + return getRunQueueOrCreate(spi).tryWrite(); + } + + /** + * Release the write lock + * @see #tryAcquireServerWrite(ServerProcedureInterface) + * @param spi the server that has the write lock + */ + public void releaseServerWrite(final ServerProcedureInterface spi) { + getRunQueue(spi.getServerName()).releaseWrite(); + } + + /** + * Try to acquire the read lock on the specified server. + * @see #releaseServerRead(ServerProcedureInterface) + * @param spi Server to lock + * @return true if we were able to acquire the lock on the server, otherwise false. + */ + public boolean tryAcquireServerRead(final ServerProcedureInterface spi) { + return getRunQueueOrCreate(spi).tryRead(); + } + + /** + * Release the read lock taken + * @see #tryAcquireServerRead(ServerProcedureInterface) + * @param spi the server that has the read lock + */ + public void releaseServerRead(final ServerProcedureInterface spi) { + getRunQueue(spi.getServerName()).releaseRead(); + } + + /** * Try to acquire the write lock on the specified table. * other operations in the table-queue will be executed after the lock is released. * @param table Table to lock @@ -284,7 +371,7 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { lock.lock(); try { if (queue.isEmpty() && !queue.isLocked()) { - fairq.remove(table); + tableFairQ.remove(table); // Remove the table lock try { @@ -311,114 +398,163 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { } /** - * Run Queue for a Table. It contains a read-write lock that is used by the - * MasterProcedureQueue to decide if we should fetch an item from this queue - * or skip to another one which will be able to run without waiting for locks. + * Base abstract class for RunQueue implementations. + * Be careful honoring synchronizations in subclasses. + * Implements basic in-memory read/write locking mechanism to prevent procedure steps being run + * in parallel. */ - private static class TableRunQueue implements RunQueue { + private static abstract class AbstractRunQueue implements RunQueue { + // All modification of runnables happens with #lock held. private final Deque runnables = new ArrayDeque(); private final int priority; - - private TableLock tableLock = null; private boolean wlock = false; private int rlock = 0; - public TableRunQueue(int priority) { + public AbstractRunQueue(int priority) { this.priority = priority; } + boolean isEmpty() { + return this.runnables.isEmpty(); + } + @Override - public void addFront(final Procedure proc) { - runnables.addFirst(proc.getProcId()); + public boolean isAvailable() { + synchronized (this) { + return !wlock && !runnables.isEmpty(); + } } - // TODO: Improve run-queue push with TableProcedureInterface.getType() - // we can take smart decisions based on the type of the operation (e.g. create/delete) @Override - public void addBack(final Procedure proc) { - runnables.addLast(proc.getProcId()); + public int getPriority() { + return this.priority; + } + + @Override + public void addFront(Procedure proc) { + this.runnables.addFirst(proc.getProcId()); + } + + @Override + public void addBack(Procedure proc) { + this.runnables.addLast(proc.getProcId()); } @Override public Long poll() { - return runnables.poll(); + return this.runnables.poll(); } @Override - public boolean isAvailable() { - synchronized (this) { - return !wlock && !runnables.isEmpty(); - } + public synchronized boolean isLocked() { + return isWriteLocked() || rlock > 0; } - public boolean isEmpty() { - return runnables.isEmpty(); + synchronized boolean isWriteLocked() { + return this.wlock; } + public synchronized boolean tryRead() { + if (isWriteLocked()) return false; + rlock++; + return true; + } + + public synchronized void releaseRead() { + rlock--; + } + + synchronized boolean isOneReader() { + return rlock == 1; + } + + public synchronized boolean tryWrite() { + if (!isLocked()) return false; + wlock = true; + return true; + } + + public synchronized void releaseWrite() { + wlock = false; + } + @Override - public boolean isLocked() { - synchronized (this) { - return wlock || rlock > 0; - } + public String toString() { + return this.runnables.toString(); } + } - public boolean tryRead(final TableLockManager lockManager, - final TableName tableName, final String purpose) { - synchronized (this) { - if (wlock) { - return false; - } + /** + * Run Queue for Server procedures. + */ + private static class ServerRunQueue extends AbstractRunQueue { + public ServerRunQueue(int priority) { + super(priority); + } + } - // Take zk-read-lock - tableLock = lockManager.readLock(tableName, purpose); - try { - tableLock.acquire(); - } catch (IOException e) { - LOG.error("failed acquire read lock on " + tableName, e); - tableLock = null; - return false; - } + /** + * Run Queue for a Table. It contains a read-write lock that is used by the + * MasterProcedureQueue to decide if we should fetch an item from this queue + * or skip to another one which will be able to run without waiting for locks. + */ + private static class TableRunQueue extends AbstractRunQueue { + private TableLock tableLock = null; + + public TableRunQueue(int priority) { + super(priority); + } + + // TODO: Improve run-queue push with TableProcedureInterface.getType() + // we can take smart decisions based on the type of the operation (e.g. create/delete) + @Override + public void addBack(final Procedure proc) { + super.addBack(proc); + } + + public synchronized boolean tryRead(final TableLockManager lockManager, + final TableName tableName, final String purpose) { + if (isWriteLocked()) return false; - rlock++; + // Take zk-read-lock + tableLock = lockManager.readLock(tableName, purpose); + try { + tableLock.acquire(); + } catch (IOException e) { + LOG.error("failed acquire read lock on " + tableName, e); + tableLock = null; + return false; } + tryRead(); return true; } - public void releaseRead(final TableLockManager lockManager, + public synchronized void releaseRead(final TableLockManager lockManager, final TableName tableName) { - synchronized (this) { - releaseTableLock(lockManager, rlock == 1); - rlock--; - } + releaseTableLock(lockManager, isOneReader()); + releaseRead(); } - public boolean tryWrite(final TableLockManager lockManager, + public synchronized boolean tryWrite(final TableLockManager lockManager, final TableName tableName, final String purpose) { - synchronized (this) { - if (wlock || rlock > 0) { - return false; - } - - // Take zk-write-lock - tableLock = lockManager.writeLock(tableName, purpose); - try { - tableLock.acquire(); - } catch (IOException e) { - LOG.error("failed acquire write lock on " + tableName, e); - tableLock = null; - return false; - } - wlock = true; + if (isLocked()) return false; + // Take zk-write-lock + tableLock = lockManager.writeLock(tableName, purpose); + try { + tableLock.acquire(); + } catch (IOException e) { + LOG.error("failed acquire write lock on " + tableName, e); + tableLock = null; + return false; } + tryWrite(); return true; } - public void releaseWrite(final TableLockManager lockManager, + public synchronized void releaseWrite(final TableLockManager lockManager, final TableName tableName) { - synchronized (this) { - releaseTableLock(lockManager, true); - wlock = false; - } + releaseTableLock(lockManager, true); + releaseWrite(); } private void releaseTableLock(final TableLockManager lockManager, boolean reset) { @@ -434,15 +570,5 @@ public class MasterProcedureQueue implements ProcedureRunnableSet { } } } - - @Override - public int getPriority() { - return priority; - } - - @Override - public String toString() { - return runnables.toString(); - } } -} +} \ No newline at end of file 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..b4941c7 --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java @@ -0,0 +1,550 @@ +/** + * 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.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 (at least) 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: Add test to prove we have this. + * TODO: How to ensure only one SSP per server? Lock... We do not want more than one procedure + * doing meta recovery. TODO: Add test to prove this. + * 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. I was thinking of adding 'progress' to ServerProcedureInterface and have us report + * progress as we moved through the procedure only, it is a little awkward at the moment since + * in this implementation there are a few pathways to completion dependent on if hosting meta and + * if distributed log replay or not. TODO: Add test to prove we have this. + */ +public class ServerCrashProcedure +extends StateMachineProcedure +implements ServerProcedureInterface { + 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 servername 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; + return env.getProcedureQueue().tryAcquireServerWrite(this); + } + + @Override + protected void releaseLock(final MasterProcedureEnv env) { + env.getProcedureQueue().releaseServerWrite(this); + } + + @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(HRegionInfo.convert(hri)); + } + } + if (this.regionsToAssign != null) { + for (HRegionInfo hri: this.regionsOnCrashedServer) { + state.addRegionsToAssign(HRegionInfo.convert(hri)); + } + } + 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++; + } + } + } + + @Override + public ServerName getServerName() { + return this.serverName; + } + + @Override + public boolean hasMetaTableRegion() { + return this.carryingMeta; + } + + @Override + public boolean hasSystemTableRegion() { + // TODO + return false; + } +} \ No newline at end of file diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerProcedureInterface.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerProcedureInterface.java new file mode 100644 index 0000000..dda323a --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerProcedureInterface.java @@ -0,0 +1,45 @@ +/** + * 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.procedure; + +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.classification.InterfaceStability; + +/** + * Procedures that handle servers -- e.g. server crash -- must implement this Interface. + * It is used by the procedure runner to figure locking and what queuing. + */ +@InterfaceAudience.Private +@InterfaceStability.Evolving +public interface ServerProcedureInterface { + /** + * @return Name of this server instance. + */ + ServerName getServerName(); + + /** + * @return True if this server has an hbase:meta table region. + */ + boolean hasMetaTableRegion(); + + /** + * @return True if server has a system table region on it: e.g. namespaces + */ + boolean hasSystemTableRegion(); +} \ 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