You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by sy...@apache.org on 2016/10/28 04:46:04 UTC
[3/7] hbase git commit: HBASE-14551 Procedure v2 - Reimplement split
(Stephen Yuan Jiang)
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-protocol-shaded/src/main/protobuf/RegionServerStatus.proto
----------------------------------------------------------------------
diff --git a/hbase-protocol-shaded/src/main/protobuf/RegionServerStatus.proto b/hbase-protocol-shaded/src/main/protobuf/RegionServerStatus.proto
index 60cf77a..1c373ee 100644
--- a/hbase-protocol-shaded/src/main/protobuf/RegionServerStatus.proto
+++ b/hbase-protocol-shaded/src/main/protobuf/RegionServerStatus.proto
@@ -26,6 +26,7 @@ option java_generate_equals_and_hash = true;
option optimize_for = SPEED;
import "HBase.proto";
+import "Master.proto";
import "ClusterStatus.proto";
message RegionServerStartupRequest {
@@ -126,6 +127,20 @@ message ReportRegionStateTransitionResponse {
optional string error_message = 1;
}
+/**
+ * Splits the specified region.
+ */
+message SplitTableRegionRequest {
+ required RegionInfo region_info = 1;
+ required bytes split_row = 2;
+ optional uint64 nonce_group = 3 [default = 0];
+ optional uint64 nonce = 4 [default = 0];
+}
+
+message SplitTableRegionResponse {
+ optional uint64 proc_id = 1;
+}
+
service RegionServerStatusService {
/** Called when a region server first starts. */
rpc RegionServerStartup(RegionServerStartupRequest)
@@ -155,4 +170,16 @@ service RegionServerStatusService {
*/
rpc ReportRegionStateTransition(ReportRegionStateTransitionRequest)
returns(ReportRegionStateTransitionResponse);
+
+ /**
+ * Split region
+ */
+ rpc SplitRegion(SplitTableRegionRequest)
+ returns(SplitTableRegionResponse);
+
+ /**
+ * Get procedure result
+ */
+ rpc getProcedureResult(GetProcedureResultRequest)
+ returns(GetProcedureResultResponse);
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupAdminEndpoint.java
----------------------------------------------------------------------
diff --git a/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupAdminEndpoint.java b/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupAdminEndpoint.java
index ed07c5c..70167bb 100644
--- a/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupAdminEndpoint.java
+++ b/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupAdminEndpoint.java
@@ -45,6 +45,7 @@ import org.apache.hadoop.hbase.ServerName;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.client.MasterSwitchType;
+import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.constraint.ConstraintException;
import org.apache.hadoop.hbase.coprocessor.CoprocessorService;
import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
@@ -80,7 +81,6 @@ import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RSGroupAdmi
import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveRSGroupRequest;
import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveRSGroupResponse;
-
@InterfaceAudience.Private
public class RSGroupAdminEndpoint extends RSGroupAdminService
implements CoprocessorService, Coprocessor, MasterObserver {
@@ -1098,4 +1098,42 @@ public class RSGroupAdminEndpoint extends RSGroupAdminService
public void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList) throws IOException {
}
+
+ @Override
+ public void preSplitRegion(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ }
+
+ @Override
+ public void postCompletedSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final HRegionInfo regionInfoA,
+ final HRegionInfo regionInfoB) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionBeforePONRAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx,
+ final byte[] splitKey,
+ final List<Mutation> metaEntries) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionAfterPONRAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
+ }
+
+ @Override
+ public void preRollBackSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
+ }
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterAndRegionObserver.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterAndRegionObserver.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterAndRegionObserver.java
index 15c8299..21381e8 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterAndRegionObserver.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterAndRegionObserver.java
@@ -37,11 +37,13 @@ import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.classification.InterfaceStability;
import org.apache.hadoop.hbase.client.MasterSwitchType;
+import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.master.RegionPlan;
import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.SnapshotDescription;
import org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas;
+import org.apache.hadoop.hbase.regionserver.Region;
@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.COPROC)
@InterfaceStability.Evolving
@@ -794,4 +796,42 @@ public class BaseMasterAndRegionObserver extends BaseRegionObserver
public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
throws IOException {
}
+
+ @Override
+ public void preSplitRegion(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ }
+
+ @Override
+ public void postCompletedSplitRegionAction(
+ ObserverContext<MasterCoprocessorEnvironment> c,
+ final HRegionInfo regionInfoA,
+ final HRegionInfo regionInfoB) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionBeforePONRAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx,
+ final byte[] splitKey,
+ final List<Mutation> metaEntries) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionAfterPONRAction(final ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ }
+
+ @Override
+ public void preRollBackSplitRegionAction(final ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ }
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterObserver.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterObserver.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterObserver.java
index 3a07315..4d24a84 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterObserver.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/BaseMasterObserver.java
@@ -37,11 +37,13 @@ import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.classification.InterfaceStability;
import org.apache.hadoop.hbase.client.MasterSwitchType;
+import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.master.RegionPlan;
import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.SnapshotDescription;
import org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas;
+import org.apache.hadoop.hbase.regionserver.Region;
@InterfaceAudience.LimitedPrivate({HBaseInterfaceAudience.COPROC, HBaseInterfaceAudience.CONFIG})
@InterfaceStability.Evolving
@@ -817,6 +819,44 @@ public class BaseMasterObserver implements MasterObserver {
}
@Override
+ public void preSplitRegion(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ }
+
+ @Override
+ public void postCompletedSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final HRegionInfo regionInfoA,
+ final HRegionInfo regionInfoB) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionBeforePONRAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx,
+ final byte[] splitKey,
+ final List<Mutation> metaEntries) throws IOException {
+ }
+
+ @Override
+ public void preSplitRegionAfterPONRAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
+ }
+
+ @Override
+ public void preRollBackSplitRegionAction(final ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ }
+
+ @Override
public void preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
throws IOException {
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/MasterObserver.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/MasterObserver.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/MasterObserver.java
index fd795d6..e347adf 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/MasterObserver.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/MasterObserver.java
@@ -37,6 +37,7 @@ import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.classification.InterfaceStability;
import org.apache.hadoop.hbase.client.MasterSwitchType;
+import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.master.RegionPlan;
import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
@@ -1133,6 +1134,76 @@ public interface MasterObserver extends Coprocessor {
final boolean newValue, final MasterSwitchType switchType) throws IOException;
/**
+ * Called before the split region procedure is called.
+ * @param c the environment to interact with the framework and master
+ * @param tableName the table where the region belongs to
+ * @param splitRow split point
+ * @throws IOException if an error occurred on the coprocessor
+ */
+ void preSplitRegion(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow)
+ throws IOException;
+
+ /**
+ * Called before the region is split.
+ * @param c the environment to interact with the framework and master
+ * @param tableName the table where the region belongs to
+ * @param splitRow split point
+ * @throws IOException if an error occurred on the coprocessor
+ */
+ void preSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final TableName tableName,
+ final byte[] splitRow)
+ throws IOException;
+
+ /**
+ * Called after the region is split.
+ * @param c the environment to interact with the framework and master
+ * @param regionInfoA the left daughter region
+ * @param regionInfoB the right daughter region
+ * @throws IOException if an error occurred on the coprocessor
+ */
+ void postCompletedSplitRegionAction(
+ final ObserverContext<MasterCoprocessorEnvironment> c,
+ final HRegionInfo regionInfoA,
+ final HRegionInfo regionInfoB) throws IOException;
+
+ /**
+ * This will be called before PONR step as part of split transaction. Calling
+ * {@link org.apache.hadoop.hbase.coprocessor.ObserverContext#bypass()} rollback the split
+ * @param ctx the environment to interact with the framework and master
+ * @param splitKey
+ * @param metaEntries
+ * @throws IOException
+ */
+ void preSplitRegionBeforePONRAction(
+ final ObserverContext<MasterCoprocessorEnvironment> ctx,
+ final byte[] splitKey,
+ final List<Mutation> metaEntries) throws IOException;
+
+
+ /**
+ * This will be called after PONR step as part of split transaction
+ * Calling {@link org.apache.hadoop.hbase.coprocessor.ObserverContext#bypass()} has no
+ * effect in this hook.
+ * @param ctx the environment to interact with the framework and master
+ * @throws IOException
+ */
+ void preSplitRegionAfterPONRAction(final ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException;
+
+ /**
+ * This will be called before the roll back of the split region is completed
+ * @param ctx the environment to interact with the framework and master
+ * @throws IOException
+ */
+ void preRollBackSplitRegionAction(final ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException;
+
+ /**
* Called prior to modifying the flag used to enable/disable region balancing.
* @param ctx the coprocessor instance's environment
* @param newValue the new flag value submitted in the call
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/RegionObserver.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/RegionObserver.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/RegionObserver.java
index 4c94644..aaa3b6a 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/RegionObserver.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/coprocessor/RegionObserver.java
@@ -359,7 +359,10 @@ public interface RegionObserver extends Coprocessor {
* @param c the environment provided by the region server
* (e.getRegion() returns the parent region)
* @throws IOException if an error occurred on the coprocessor
+ *
+ * Note: the logic moves to Master; it is unused in RS
*/
+ @Deprecated
void preSplit(final ObserverContext<RegionCoprocessorEnvironment> c, byte[] splitRow)
throws IOException;
@@ -383,32 +386,43 @@ public interface RegionObserver extends Coprocessor {
* @param splitKey
* @param metaEntries
* @throws IOException
- */
+ *
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
void preSplitBeforePONR(final ObserverContext<RegionCoprocessorEnvironment> ctx,
byte[] splitKey, List<Mutation> metaEntries) throws IOException;
-
/**
* This will be called after PONR step as part of split transaction
* Calling {@link org.apache.hadoop.hbase.coprocessor.ObserverContext#bypass()} has no
* effect in this hook.
* @param ctx
* @throws IOException
- */
+ *
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
void preSplitAfterPONR(final ObserverContext<RegionCoprocessorEnvironment> ctx) throws IOException;
/**
* This will be called before the roll back of the split region is completed
* @param ctx
* @throws IOException
- */
+ *
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
void preRollBackSplit(final ObserverContext<RegionCoprocessorEnvironment> ctx) throws IOException;
/**
* This will be called after the roll back of the split region is completed
* @param ctx
* @throws IOException
- */
+ *
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
void postRollBackSplit(final ObserverContext<RegionCoprocessorEnvironment> ctx)
throws IOException;
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java
----------------------------------------------------------------------
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 82ae03f..c8c25f1 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
@@ -61,7 +61,6 @@ import org.apache.hadoop.hbase.RegionLocations;
import org.apache.hadoop.hbase.RegionStateListener;
import org.apache.hadoop.hbase.ServerName;
import org.apache.hadoop.hbase.TableName;
-import org.apache.hadoop.hbase.TableNotFoundException;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.client.MasterSwitchType;
import org.apache.hadoop.hbase.client.RegionReplicaUtil;
@@ -2432,6 +2431,39 @@ public class AssignmentManager {
return null;
}
+ public void assignDaughterRegions(
+ final HRegionInfo parentHRI,
+ final HRegionInfo daughterAHRI,
+ final HRegionInfo daughterBHRI) throws InterruptedException, IOException {
+ //Offline the parent region
+ regionOffline(parentHRI, State.SPLIT);
+
+ //Set daughter regions to offline
+ regionStates.prepareAssignDaughters(daughterAHRI, daughterBHRI);
+
+ // Assign daughter regions
+ invokeAssign(daughterAHRI);
+ invokeAssign(daughterBHRI);
+
+ Callable<Object> splitReplicasCallable = new Callable<Object>() {
+ @Override
+ public Object call() {
+ doSplittingOfReplicas(parentHRI, daughterAHRI, daughterBHRI);
+ return null;
+ }
+ };
+ threadPoolExecutorService.submit(splitReplicasCallable);
+
+ // wait for assignment completion
+ ArrayList<HRegionInfo> regionAssignSet = new ArrayList<HRegionInfo>(2);
+ regionAssignSet.add(daughterAHRI);
+ regionAssignSet.add(daughterBHRI);
+ while (!waitForAssignment(regionAssignSet, true, regionAssignSet.size(),
+ Long.MAX_VALUE)) {
+ LOG.debug("some user regions are still in transition: " + regionAssignSet);
+ }
+ }
+
private String onRegionSplit(final RegionState current, final HRegionInfo hri,
final ServerName serverName, final RegionStateTransition transition) {
// The region must be splitting on this server, and the daughters must be in
@@ -2866,7 +2898,7 @@ public class AssignmentManager {
* (d) Other scenarios should be handled similarly as for
* region open/close
*/
- protected String onRegionTransition(final ServerName serverName,
+ public String onRegionTransition(final ServerName serverName,
final RegionStateTransition transition) {
TransitionCode code = transition.getTransitionCode();
HRegionInfo hri = HRegionInfo.convert(transition.getRegionInfo(0));
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
index eac2fa2..beec198 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
@@ -111,6 +111,7 @@ import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
import org.apache.hadoop.hbase.master.procedure.ModifyColumnFamilyProcedure;
import org.apache.hadoop.hbase.master.procedure.ModifyTableProcedure;
import org.apache.hadoop.hbase.master.procedure.ProcedurePrepareLatch;
+import org.apache.hadoop.hbase.master.procedure.SplitTableRegionProcedure;
import org.apache.hadoop.hbase.master.procedure.TruncateTableProcedure;
import org.apache.hadoop.hbase.master.snapshot.SnapshotManager;
import org.apache.hadoop.hbase.mob.MobConstants;
@@ -1352,6 +1353,30 @@ public class HMaster extends HRegionServer implements MasterServices {
return procId;
}
+ @Override
+ public long splitRegion(
+ final HRegionInfo regionInfo,
+ final byte[] splitRow,
+ final long nonceGroup,
+ final long nonce) throws IOException {
+ checkInitialized();
+
+ if (cpHost != null) {
+ cpHost.preSplitRegion(regionInfo.getTable(), splitRow);
+ }
+
+ LOG.info(getClientIdAuditPrefix() + " Split region " + regionInfo);
+
+ // Execute the operation asynchronously
+ long procId = this.procedureExecutor.submitProcedure(
+ new SplitTableRegionProcedure(
+ procedureExecutor.getEnvironment(), regionInfo.getTable(), regionInfo, splitRow),
+ nonceGroup,
+ nonce);
+
+ return procId;
+ }
+
void move(final byte[] encodedRegionName,
final byte[] destServerName) throws HBaseIOException {
RegionState regionState = assignmentManager.getRegionStates().
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterCoprocessorHost.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterCoprocessorHost.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterCoprocessorHost.java
index 9eec0dd..d0ac765 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterCoprocessorHost.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterCoprocessorHost.java
@@ -39,6 +39,7 @@ import org.apache.hadoop.hbase.ServerName;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.client.MasterSwitchType;
+import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.coprocessor.CoprocessorHost;
import org.apache.hadoop.hbase.coprocessor.CoprocessorService;
import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
@@ -833,6 +834,114 @@ public class MasterCoprocessorHost
});
}
+ /**
+ * Invoked just before calling the split region procedure
+ * @param tableName the table where the region belongs to
+ * @param splitRow the split point
+ * @throws IOException
+ */
+ public void preSplitRegion(
+ final TableName tableName,
+ final byte[] splitRow) throws IOException {
+ execOperation(coprocessors.isEmpty() ? null : new CoprocessorOperation() {
+ @Override
+ public void call(MasterObserver oserver, ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ oserver.preSplitRegion(ctx, tableName, splitRow);
+ }
+ });
+ }
+
+ /**
+ * Invoked just before a split
+ * @param tableName the table where the region belongs to
+ * @param splitRow the split point
+ * @param user the user
+ * @throws IOException
+ */
+ public void preSplitRegionAction(
+ final TableName tableName,
+ final byte[] splitRow,
+ final User user) throws IOException {
+ execOperation(coprocessors.isEmpty() ? null : new CoprocessorOperation(user) {
+ @Override
+ public void call(MasterObserver oserver, ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ oserver.preSplitRegionAction(ctx, tableName, splitRow);
+ }
+ });
+ }
+
+ /**
+ * Invoked just after a split
+ * @param regionInfoA the new left-hand daughter region
+ * @param regionInfoB the new right-hand daughter region
+ * @param user the user
+ * @throws IOException
+ */
+ public void postCompletedSplitRegionAction(
+ final HRegionInfo regionInfoA,
+ final HRegionInfo regionInfoB,
+ final User user) throws IOException {
+ execOperation(coprocessors.isEmpty() ? null : new CoprocessorOperation(user) {
+ @Override
+ public void call(MasterObserver oserver, ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ oserver.postCompletedSplitRegionAction(ctx, regionInfoA, regionInfoB);
+ }
+ });
+ }
+
+ /**
+ * This will be called before PONR step as part of split table region procedure.
+ * @param splitKey
+ * @param metaEntries
+ * @param user the user
+ * @throws IOException
+ */
+ public boolean preSplitBeforePONRAction(
+ final byte[] splitKey,
+ final List<Mutation> metaEntries,
+ final User user) throws IOException {
+ return execOperation(coprocessors.isEmpty() ? null : new CoprocessorOperation(user) {
+ @Override
+ public void call(MasterObserver oserver, ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ oserver.preSplitRegionBeforePONRAction(ctx, splitKey, metaEntries);
+ }
+ });
+ }
+
+ /**
+ * This will be called after PONR step as part of split table region procedure.
+ * @param user the user
+ * @throws IOException
+ */
+ public void preSplitAfterPONRAction(final User user) throws IOException {
+ execOperation(coprocessors.isEmpty() ? null : new CoprocessorOperation(user) {
+ @Override
+ public void call(MasterObserver oserver, ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ oserver.preSplitRegionAfterPONRAction(ctx);
+ }
+ });
+ }
+
+ /**
+ * Invoked just before the rollback of a failed split is started
+ * @param user the user
+ * @throws IOException
+ */
+ public void preRollBackSplitAction(final User user) throws IOException {
+ execOperation(coprocessors.isEmpty() ? null : new CoprocessorOperation(user) {
+ @Override
+ public void call(MasterObserver oserver, ObserverContext<MasterCoprocessorEnvironment> ctx)
+ throws IOException {
+ oserver.preRollBackSplitRegionAction(ctx);
+ }
+ });
+ }
+
public boolean preBalanceSwitch(final boolean b) throws IOException {
return execOperationWithResult(b, coprocessors.isEmpty() ? null :
new CoprocessorOperationWithResult<Boolean>() {
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterRpcServices.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterRpcServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterRpcServices.java
index 7cc58aa..94b5f56 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterRpcServices.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterRpcServices.java
@@ -83,6 +83,8 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProto
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRSFatalErrorResponse;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.SplitTableRegionRequest;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.SplitTableRegionResponse;
import org.apache.hadoop.hbase.regionserver.RSRpcServices;
import org.apache.hadoop.hbase.security.User;
import org.apache.hadoop.hbase.security.access.AccessController;
@@ -550,6 +552,22 @@ public class MasterRpcServices extends RSRpcServices
}
@Override
+ public SplitTableRegionResponse splitRegion(
+ final RpcController controller,
+ final SplitTableRegionRequest request) throws ServiceException {
+ try {
+ long procId = master.splitRegion(
+ HRegionInfo.convert(request.getRegionInfo()),
+ request.getSplitRow().toByteArray(),
+ request.getNonceGroup(),
+ request.getNonce());
+ return SplitTableRegionResponse.newBuilder().setProcId(procId).build();
+ } catch (IOException ie) {
+ throw new ServiceException(ie);
+ }
+ }
+
+ @Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
try {
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterServices.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterServices.java
index 9bdcf76..fa1c33d 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterServices.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/MasterServices.java
@@ -265,6 +265,21 @@ public interface MasterServices extends Server {
throws IOException;
/**
+ * Split a region.
+ * @param regionInfo region to split
+ * @param splitRow split point
+ * @param nonceGroup used to detect duplicate
+ * @param nonce used to detect duplicate
+ * @return procedure Id
+ * @throws IOException
+ */
+ public long splitRegion(
+ final HRegionInfo regionInfo,
+ final byte [] splitRow,
+ final long nonceGroup,
+ final long nonce) throws IOException;
+
+ /**
* @return Return table descriptors implementation.
*/
TableDescriptors getTableDescriptors();
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionStates.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionStates.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionStates.java
index ba08a05..f69925a 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionStates.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionStates.java
@@ -51,6 +51,7 @@ import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.RegionReplicaUtil;
import org.apache.hadoop.hbase.master.RegionState.State;
import org.apache.hadoop.hbase.client.TableState;
+import org.apache.hadoop.hbase.constraint.ConstraintException;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.util.FSUtils;
import org.apache.hadoop.hbase.util.Pair;
@@ -873,6 +874,17 @@ public class RegionStates {
return regions == null ? false : regions.contains(hri);
}
+ public void prepareAssignDaughters(HRegionInfo a, HRegionInfo b) {
+ synchronized (this) {
+ if (isRegionInState(a, State.SPLITTING_NEW)) {
+ updateRegionState(a, State.OFFLINE, null);
+ }
+ if (isRegionInState(b, State.SPLITTING_NEW)) {
+ updateRegionState(b, State.OFFLINE, null);
+ }
+ }
+ }
+
void splitRegion(HRegionInfo p,
HRegionInfo a, HRegionInfo b, ServerName sn) throws IOException {
@@ -1032,7 +1044,7 @@ public class RegionStates {
return result;
}
- protected RegionState getRegionState(final HRegionInfo hri) {
+ public RegionState getRegionState(final HRegionInfo hri) {
return getRegionState(hri.getEncodedName());
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java
----------------------------------------------------------------------
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 437c787..278030f 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
@@ -80,7 +80,6 @@ import org.apache.zookeeper.KeeperException;
import com.google.common.annotations.VisibleForTesting;
-import org.apache.hadoop.hbase.shaded.com.google.protobuf.ByteString;
import org.apache.hadoop.hbase.shaded.com.google.protobuf.ServiceException;
import org.apache.hadoop.hbase.shaded.com.google.protobuf.UnsafeByteOperations;
@@ -829,6 +828,31 @@ public class ServerManager {
}
/**
+ * Sends an CLOSE RPC to the specified server to close the specified region for SPLIT.
+ * <p>
+ * A region server could reject the close request because it either does not
+ * have the specified region or the region is being split.
+ * @param server server to close a region
+ * @param regionToClose the info of the region to close
+ * @throws IOException
+ */
+ public boolean sendRegionCloseForSplit(
+ final ServerName server,
+ final HRegionInfo regionToClose) throws IOException {
+ if (server == null) {
+ throw new NullPointerException("Passed server is null");
+ }
+ AdminService.BlockingInterface admin = getRsAdmin(server);
+ if (admin == null) {
+ throw new IOException("Attempting to send CLOSE For Split RPC to server " +
+ server.toString() + " for region " + regionToClose.getRegionNameAsString() +
+ " failed because no RPC connection found to this server");
+ }
+ HBaseRpcController controller = newRpcController();
+ return ProtobufUtil.closeRegionForSplit(controller, admin, server, regionToClose);
+ }
+
+ /**
* Sends a WARMUP RPC to the specified server to warmup the specified region.
* <p>
* A region server could reject the close request because it either does not
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/SplitTableRegionProcedure.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/SplitTableRegionProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/SplitTableRegionProcedure.java
new file mode 100644
index 0000000..61f7601
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/SplitTableRegionProcedure.java
@@ -0,0 +1,821 @@
+/**
+ * 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.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hbase.HColumnDescriptor;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HRegionInfo;
+import org.apache.hadoop.hbase.ServerName;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.classification.InterfaceAudience;
+import org.apache.hadoop.hbase.client.Mutation;
+import org.apache.hadoop.hbase.io.hfile.CacheConfig;
+import org.apache.hadoop.hbase.master.MasterCoprocessorHost;
+import org.apache.hadoop.hbase.master.MasterFileSystem;
+import org.apache.hadoop.hbase.master.RegionState;
+import org.apache.hadoop.hbase.master.RegionStates;
+import org.apache.hadoop.hbase.shaded.com.google.protobuf.UnsafeByteOperations;
+import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SplitTableRegionState;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode;
+import org.apache.hadoop.hbase.regionserver.HRegionFileSystem;
+import org.apache.hadoop.hbase.regionserver.HStore;
+import org.apache.hadoop.hbase.regionserver.StoreFile;
+import org.apache.hadoop.hbase.regionserver.StoreFileInfo;
+import org.apache.hadoop.hbase.security.User;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
+import org.apache.hadoop.hbase.util.FSUtils;
+import org.apache.hadoop.hbase.util.Pair;
+import org.apache.hadoop.hbase.util.Threads;
+
+import com.google.common.annotations.VisibleForTesting;
+
+/**
+ * The procedure to split a region in a table.
+ */
+@InterfaceAudience.Private
+public class SplitTableRegionProcedure
+extends AbstractStateMachineTableProcedure<SplitTableRegionState> {
+ private static final Log LOG = LogFactory.getLog(SplitTableRegionProcedure.class);
+
+ private Boolean traceEnabled;
+ private User user;
+ private TableName tableName;
+
+ /*
+ * Region to split
+ */
+ private HRegionInfo parentHRI;
+ private HRegionInfo daughter_1_HRI;
+ private HRegionInfo daughter_2_HRI;
+
+ /*
+ * Row to split around
+ */
+ private byte [] splitRow;
+
+ public SplitTableRegionProcedure() {
+ this.traceEnabled = null;
+ }
+
+ public SplitTableRegionProcedure(
+ final MasterProcedureEnv env,
+ final TableName tableName,
+ final HRegionInfo parentHRI,
+ final byte [] splitRow) throws IOException {
+ this.traceEnabled = null;
+ this.tableName = tableName;
+ this.parentHRI = parentHRI;
+ this.splitRow = splitRow;
+
+ this.user = env.getRequestUser();
+ this.setOwner(this.user.getShortName());
+ }
+
+ @Override
+ protected Flow executeFromState(
+ final MasterProcedureEnv env,
+ final SplitTableRegionState state) throws InterruptedException {
+ if (isTraceEnabled()) {
+ LOG.trace(this + " execute state=" + state);
+ }
+
+ try {
+ switch (state) {
+ case SPLIT_TABLE_REGION_PREPARE:
+ if (prepareSplitRegion(env)) {
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_PRE_OPERATION);
+ break;
+ } else {
+ assert isFailed() : "split region should have an exception here";
+ return Flow.NO_MORE_STATE;
+ }
+ case SPLIT_TABLE_REGION_PRE_OPERATION:
+ preSplitRegion(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_SET_SPLITTING_TABLE_STATE);
+ break;
+ case SPLIT_TABLE_REGION_SET_SPLITTING_TABLE_STATE:
+ setRegionStateToSplitting(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_CLOSED_PARENT_REGION);
+ break;
+ case SPLIT_TABLE_REGION_CLOSED_PARENT_REGION:
+ closeParentRegionForSplit(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_CREATE_DAUGHTER_REGIONS);
+ break;
+ case SPLIT_TABLE_REGION_CREATE_DAUGHTER_REGIONS:
+ createDaughterRegions(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_PRE_OPERATION_BEFORE_PONR);
+ break;
+ case SPLIT_TABLE_REGION_PRE_OPERATION_BEFORE_PONR:
+ preSplitRegionBeforePONR(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_UPDATE_META);
+ break;
+ case SPLIT_TABLE_REGION_UPDATE_META:
+ // This is the point of no return. Adding subsequent edits to .META. as we
+ // do below when we do the daughter opens adding each to .META. can fail in
+ // various interesting ways the most interesting of which is a timeout
+ // BUT the edits all go through (See HBASE-3872). IF we reach the PONR
+ // then subsequent failures need to crash out this region server; the
+ // server shutdown processing should be able to fix-up the incomplete split.
+ // The offlined parent will have the daughters as extra columns. If
+ // we leave the daughter regions in place and do not remove them when we
+ // crash out, then they will have their references to the parent in place
+ // still and the server shutdown fixup of .META. will point to these
+ // regions.
+ // We should add PONR JournalEntry before offlineParentInMeta,so even if
+ // OfflineParentInMeta timeout,this will cause regionserver exit,and then
+ // master ServerShutdownHandler will fix daughter & avoid data loss. (See
+ // HBase-4562).
+ updateMetaForDaughterRegions(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_PRE_OPERATION_AFTER_PONR);
+ break;
+ case SPLIT_TABLE_REGION_PRE_OPERATION_AFTER_PONR:
+ preSplitRegionAfterPONR(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_OPEN_CHILD_REGIONS);
+ break;
+ case SPLIT_TABLE_REGION_OPEN_CHILD_REGIONS:
+ openDaughterRegions(env);
+ setNextState(SplitTableRegionState.SPLIT_TABLE_REGION_POST_OPERATION);
+ break;
+ case SPLIT_TABLE_REGION_POST_OPERATION:
+ postSplitRegion(env);
+ return Flow.NO_MORE_STATE;
+ default:
+ throw new UnsupportedOperationException(this + " unhandled state=" + state);
+ }
+ } catch (IOException e) {
+ String msg = "Error trying to split region " + parentHRI.getEncodedName() + " in the table "
+ + tableName + " (in state=" + state + ")";
+ if (!isRollbackSupported(state)) {
+ // We reach a state that cannot be rolled back. We just need to keep retry.
+ LOG.warn(msg, e);
+ } else {
+ LOG.error(msg, e);
+ setFailure("master-split-region", e);
+ }
+ }
+ return Flow.HAS_MORE_STATE;
+ }
+
+ @Override
+ protected void rollbackState(final MasterProcedureEnv env, final SplitTableRegionState state)
+ throws IOException, InterruptedException {
+ if (isTraceEnabled()) {
+ LOG.trace(this + " rollback state=" + state);
+ }
+
+ try {
+ switch (state) {
+ case SPLIT_TABLE_REGION_POST_OPERATION:
+ case SPLIT_TABLE_REGION_OPEN_CHILD_REGIONS:
+ case SPLIT_TABLE_REGION_PRE_OPERATION_AFTER_PONR:
+ case SPLIT_TABLE_REGION_UPDATE_META:
+ // PONR
+ throw new UnsupportedOperationException(this + " unhandled state=" + state);
+ case SPLIT_TABLE_REGION_PRE_OPERATION_BEFORE_PONR:
+ break;
+ case SPLIT_TABLE_REGION_CREATE_DAUGHTER_REGIONS:
+ // Doing nothing, as re-open parent region would clean up daughter region directories.
+ break;
+ case SPLIT_TABLE_REGION_CLOSED_PARENT_REGION:
+ openParentRegion(env);
+ break;
+ case SPLIT_TABLE_REGION_SET_SPLITTING_TABLE_STATE:
+ setRegionStateToRevertSplitting(env);
+ break;
+ case SPLIT_TABLE_REGION_PRE_OPERATION:
+ preSplitRegionRollback(env);
+ break;
+ case SPLIT_TABLE_REGION_PREPARE:
+ break; // nothing to do
+ default:
+ throw new UnsupportedOperationException(this + " unhandled state=" + state);
+ }
+ } catch (IOException e) {
+ // This will be retried. Unless there is a bug in the code,
+ // this should be just a "temporary error" (e.g. network down)
+ LOG.warn("Failed rollback attempt step " + state + " for splitting the region "
+ + parentHRI.getEncodedName() + " in table " + tableName, e);
+ throw e;
+ }
+ }
+
+ /*
+ * Check whether we are in the state that can be rollback
+ */
+ @Override
+ protected boolean isRollbackSupported(final SplitTableRegionState state) {
+ switch (state) {
+ case SPLIT_TABLE_REGION_POST_OPERATION:
+ case SPLIT_TABLE_REGION_OPEN_CHILD_REGIONS:
+ case SPLIT_TABLE_REGION_PRE_OPERATION_AFTER_PONR:
+ case SPLIT_TABLE_REGION_UPDATE_META:
+ // It is not safe to rollback if we reach to these states.
+ return false;
+ default:
+ break;
+ }
+ return true;
+ }
+
+ @Override
+ protected SplitTableRegionState getState(final int stateId) {
+ return SplitTableRegionState.valueOf(stateId);
+ }
+
+ @Override
+ protected int getStateId(final SplitTableRegionState state) {
+ return state.getNumber();
+ }
+
+ @Override
+ protected SplitTableRegionState getInitialState() {
+ return SplitTableRegionState.SPLIT_TABLE_REGION_PREPARE;
+ }
+
+ @Override
+ public void serializeStateData(final OutputStream stream) throws IOException {
+ super.serializeStateData(stream);
+
+ MasterProcedureProtos.SplitTableRegionStateData.Builder splitTableRegionMsg =
+ MasterProcedureProtos.SplitTableRegionStateData.newBuilder()
+ .setUserInfo(MasterProcedureUtil.toProtoUserInfo(user))
+ .setTableName(ProtobufUtil.toProtoTableName(tableName))
+ .setParentRegionInfo(HRegionInfo.convert(parentHRI));
+ if (splitRow != null) {
+ splitTableRegionMsg.setSplitRow(UnsafeByteOperations.unsafeWrap(splitRow));
+ }
+ if (daughter_1_HRI != null) {
+ splitTableRegionMsg.addChildRegionInfo(HRegionInfo.convert(daughter_1_HRI));
+ }
+ if (daughter_2_HRI != null) {
+ splitTableRegionMsg.addChildRegionInfo(HRegionInfo.convert(daughter_2_HRI));
+ }
+ splitTableRegionMsg.build().writeDelimitedTo(stream);
+ }
+
+ @Override
+ public void deserializeStateData(final InputStream stream) throws IOException {
+ super.deserializeStateData(stream);
+
+ MasterProcedureProtos.SplitTableRegionStateData splitTableRegionsMsg =
+ MasterProcedureProtos.SplitTableRegionStateData.parseDelimitedFrom(stream);
+ user = MasterProcedureUtil.toUserInfo(splitTableRegionsMsg.getUserInfo());
+ tableName = ProtobufUtil.toTableName(splitTableRegionsMsg.getTableName());
+ parentHRI = HRegionInfo.convert(splitTableRegionsMsg.getParentRegionInfo());
+ if (splitTableRegionsMsg.hasSplitRow()) {
+ splitRow = splitTableRegionsMsg.getSplitRow().toByteArray();
+ } else {
+ splitRow = null;
+ }
+ if (splitTableRegionsMsg.getChildRegionInfoCount() == 0) {
+ daughter_1_HRI = daughter_2_HRI = null;
+ } else {
+ assert(splitTableRegionsMsg.getChildRegionInfoCount() == 2);
+ daughter_1_HRI = HRegionInfo.convert(splitTableRegionsMsg.getChildRegionInfoList().get(0));
+ daughter_2_HRI = HRegionInfo.convert(splitTableRegionsMsg.getChildRegionInfoList().get(1));
+ }
+ }
+
+ @Override
+ public void toStringClassDetails(StringBuilder sb) {
+ sb.append(getClass().getSimpleName());
+ sb.append(" (table=");
+ sb.append(tableName);
+ sb.append(" parent region=");
+ sb.append(parentHRI);
+ if (daughter_1_HRI != null) {
+ sb.append(" first daughter region=");
+ sb.append(daughter_1_HRI);
+ }
+ if (daughter_2_HRI != null) {
+ sb.append(" and second daughter region=");
+ sb.append(daughter_2_HRI);
+ }
+ sb.append(")");
+ }
+
+ @Override
+ protected boolean acquireLock(final MasterProcedureEnv env) {
+ if (env.waitInitialized(this)) {
+ return false;
+ }
+ return !env.getProcedureQueue().waitRegions(this, getTableName(), parentHRI);
+ }
+
+ @Override
+ protected void releaseLock(final MasterProcedureEnv env) {
+ env.getProcedureQueue().wakeRegions(this, getTableName(), parentHRI);
+ }
+
+ @Override
+ public TableName getTableName() {
+ return tableName;
+ }
+
+ @Override
+ public TableOperationType getTableOperationType() {
+ return TableOperationType.SPLIT;
+ }
+
+ /**
+ * Prepare to Split region.
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ @VisibleForTesting
+ public Boolean prepareSplitRegion(final MasterProcedureEnv env) throws IOException {
+ // Check whether the region is splittable
+ RegionState state = getParentRegionState(env);
+ if (state.isClosing() ||
+ state.isClosed() ||
+ state.isSplittingOrSplitOnServer(state.getServerName())) {
+ setFailure(
+ "master-split-region",
+ new IOException("Split region " + parentHRI + " failed due to region is not splittable"));
+ return false;
+ }
+ // Split key can be null if this region is unsplittable; i.e. has refs.
+ if (this.splitRow == null || this.splitRow.length == 0) {
+ setFailure(
+ "master-split-region",
+ new IOException("Split region " + parentHRI + " failed due to invalid split point"));
+ return false;
+ }
+
+ // Check splitRow.
+ byte [] startKey = parentHRI.getStartKey();
+ byte [] endKey = parentHRI.getEndKey();
+ if (Bytes.equals(startKey, splitRow) ||
+ !this.parentHRI.containsRow(splitRow)) {
+ String msg = "Split row is not inside region key range or is equal to " +
+ "startkey: " + Bytes.toStringBinary(this.splitRow);
+ LOG.warn(msg);
+ setFailure("master-split-region", new IOException(msg));
+ return false;
+ }
+
+ long rid = getDaughterRegionIdTimestamp(parentHRI);
+ this.daughter_1_HRI = new HRegionInfo(tableName, startKey, this.splitRow, false, rid);
+ this.daughter_2_HRI = new HRegionInfo(tableName, this.splitRow, endKey, false, rid);
+
+ return true;
+ }
+
+ /**
+ * Action before splitting region in a table.
+ * @param env MasterProcedureEnv
+ * @param state the procedure state
+ * @throws IOException
+ * @throws InterruptedException
+ */
+ private void preSplitRegion(final MasterProcedureEnv env)
+ throws IOException, InterruptedException {
+ final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
+ if (cpHost != null) {
+ cpHost.preSplitRegionAction(getTableName(), splitRow, user);
+ }
+ }
+
+ /**
+ * Action during rollback a pre split table region.
+ * @param env MasterProcedureEnv
+ * @param state the procedure state
+ * @throws IOException
+ */
+ private void preSplitRegionRollback(final MasterProcedureEnv env) throws IOException {
+ final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
+ if (cpHost != null) {
+ cpHost.preRollBackSplitAction(user);
+ }
+ }
+
+ /**
+ * Set the parent region state to SPLITTING state
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ @VisibleForTesting
+ public void setRegionStateToSplitting(final MasterProcedureEnv env) throws IOException {
+ RegionStateTransition.Builder transition = RegionStateTransition.newBuilder();
+ transition.setTransitionCode(TransitionCode.READY_TO_SPLIT);
+ transition.addRegionInfo(HRegionInfo.convert(parentHRI));
+ transition.addRegionInfo(HRegionInfo.convert(daughter_1_HRI));
+ transition.addRegionInfo(HRegionInfo.convert(daughter_2_HRI));
+ if (env.getMasterServices().getAssignmentManager().onRegionTransition(
+ getParentRegionState(env).getServerName(), transition.build()) != null) {
+ throw new IOException("Failed to update region state to SPLITTING for "
+ + parentHRI.getRegionNameAsString());
+ }
+ }
+
+ /**
+ * Rollback the region state change
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ private void setRegionStateToRevertSplitting(final MasterProcedureEnv env) throws IOException {
+ RegionStateTransition.Builder transition = RegionStateTransition.newBuilder();
+ transition.setTransitionCode(TransitionCode.SPLIT_REVERTED);
+ transition.addRegionInfo(HRegionInfo.convert(parentHRI));
+ transition.addRegionInfo(HRegionInfo.convert(daughter_1_HRI));
+ transition.addRegionInfo(HRegionInfo.convert(daughter_2_HRI));
+ if (env.getMasterServices().getAssignmentManager().onRegionTransition(
+ getParentRegionState(env).getServerName(), transition.build()) != null) {
+ throw new IOException("Failed to update region state for "
+ + parentHRI.getRegionNameAsString() + " as part of operation for reverting split");
+ }
+ }
+
+ /**
+ * RPC to region server that host the parent region, ask for close the parent regions and
+ * creating daughter regions
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ @VisibleForTesting
+ public void closeParentRegionForSplit(final MasterProcedureEnv env) throws IOException {
+ Boolean success = env.getMasterServices().getServerManager().sendRegionCloseForSplit(
+ getParentRegionState(env).getServerName(), parentHRI);
+ if (!success) {
+ throw new IOException("Close parent region " + parentHRI + " for splitting failed."
+ + " Check region server log for more details");
+ }
+ }
+
+ /**
+ * Rollback close parent region
+ * @param env MasterProcedureEnv
+ **/
+ private void openParentRegion(final MasterProcedureEnv env) throws IOException {
+ // Check whether the region is closed; if so, open it in the same server
+ RegionState state = getParentRegionState(env);
+ if (state.isClosing() || state.isClosed()) {
+ env.getMasterServices().getServerManager().sendRegionOpen(
+ getParentRegionState(env).getServerName(),
+ parentHRI,
+ ServerName.EMPTY_SERVER_LIST);
+ }
+ }
+
+ /**
+ * Create daughter regions
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ @VisibleForTesting
+ public void createDaughterRegions(final MasterProcedureEnv env) throws IOException {
+ final MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem();
+ final Path tabledir = FSUtils.getTableDir(mfs.getRootDir(), parentHRI.getTable());
+ final FileSystem fs = mfs.getFileSystem();
+ HRegionFileSystem regionFs = HRegionFileSystem.openRegionFromFileSystem(
+ env.getMasterConfiguration(), fs, tabledir, parentHRI, false);
+ regionFs.createSplitsDir();
+
+ Pair<Integer, Integer> expectedReferences = splitStoreFiles(env, regionFs);
+
+ assertReferenceFileCount(
+ fs, expectedReferences.getFirst(), regionFs.getSplitsDir(daughter_1_HRI));
+ //Move the files from the temporary .splits to the final /table/region directory
+ regionFs.commitDaughterRegion(daughter_1_HRI);
+ assertReferenceFileCount(
+ fs,
+ expectedReferences.getFirst(),
+ new Path(tabledir, daughter_1_HRI.getEncodedName()));
+
+ assertReferenceFileCount(
+ fs, expectedReferences.getSecond(), regionFs.getSplitsDir(daughter_2_HRI));
+ regionFs.commitDaughterRegion(daughter_2_HRI);
+ assertReferenceFileCount(
+ fs,
+ expectedReferences.getSecond(),
+ new Path(tabledir, daughter_2_HRI.getEncodedName()));
+ }
+
+ /**
+ * Create Split directory
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ private Pair<Integer, Integer> splitStoreFiles(
+ final MasterProcedureEnv env,
+ final HRegionFileSystem regionFs) throws IOException {
+ final MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem();
+ final Configuration conf = env.getMasterConfiguration();
+
+ // The following code sets up a thread pool executor with as many slots as
+ // there's files to split. It then fires up everything, waits for
+ // completion and finally checks for any exception
+ //
+ // Note: splitStoreFiles creates daughter region dirs under the parent splits dir
+ // Nothing to unroll here if failure -- re-run createSplitsDir will
+ // clean this up.
+ int nbFiles = 0;
+ Collection<StoreFileInfo> storeFiles;
+ for (String family: regionFs.getFamilies()) {
+ storeFiles = regionFs.getStoreFiles(family);
+ if (storeFiles != null) {
+ nbFiles += storeFiles.size();
+ }
+ }
+ if (nbFiles == 0) {
+ // no file needs to be splitted.
+ return new Pair<Integer, Integer>(0,0);
+ }
+ // Default max #threads to use is the smaller of table's configured number of blocking store
+ // files or the available number of logical cores.
+ int defMaxThreads = Math.min(
+ conf.getInt(HStore.BLOCKING_STOREFILES_KEY, HStore.DEFAULT_BLOCKING_STOREFILE_COUNT),
+ Runtime.getRuntime().availableProcessors());
+ // Max #threads is the smaller of the number of storefiles or the default max determined above.
+ int maxThreads = Math.min(
+ conf.getInt(HConstants.REGION_SPLIT_THREADS_MAX, defMaxThreads), nbFiles);
+ LOG.info("Preparing to split " + nbFiles + " storefiles for region " + parentHRI +
+ " using " + maxThreads + " threads");
+ ThreadPoolExecutor threadPool = (ThreadPoolExecutor) Executors.newFixedThreadPool(
+ maxThreads, Threads.getNamedThreadFactory("StoreFileSplitter-%1$d"));
+ List<Future<Pair<Path,Path>>> futures = new ArrayList<Future<Pair<Path,Path>>> (nbFiles);
+
+ // Split each store file.
+ for (String family: regionFs.getFamilies()) {
+ HColumnDescriptor hcd =
+ env.getMasterServices().getTableDescriptors().get(tableName).getFamily(family.getBytes());
+ CacheConfig cacheConf = new CacheConfig(conf, hcd);
+ storeFiles = regionFs.getStoreFiles(family);
+ if (storeFiles != null) {
+ for (StoreFileInfo storeFileInfo: storeFiles) {
+ StoreFileSplitter sfs = new StoreFileSplitter(
+ regionFs,
+ family.getBytes(),
+ new StoreFile(
+ mfs.getFileSystem(), storeFileInfo, conf, cacheConf, hcd.getBloomFilterType()));
+ futures.add(threadPool.submit(sfs));
+ }
+ }
+ }
+ // Shutdown the pool
+ threadPool.shutdown();
+
+ // Wait for all the tasks to finish
+ long fileSplitTimeout = conf.getLong("hbase.master.fileSplitTimeout", 30000);
+ try {
+ boolean stillRunning = !threadPool.awaitTermination(fileSplitTimeout, TimeUnit.MILLISECONDS);
+ if (stillRunning) {
+ threadPool.shutdownNow();
+ // wait for the thread to shutdown completely.
+ while (!threadPool.isTerminated()) {
+ Thread.sleep(50);
+ }
+ throw new IOException("Took too long to split the" +
+ " files and create the references, aborting split");
+ }
+ } catch (InterruptedException e) {
+ throw (InterruptedIOException)new InterruptedIOException().initCause(e);
+ }
+
+ int daughterA = 0;
+ int daughterB = 0;
+ // Look for any exception
+ for (Future<Pair<Path, Path>> future : futures) {
+ try {
+ Pair<Path, Path> p = future.get();
+ daughterA += p.getFirst() != null ? 1 : 0;
+ daughterB += p.getSecond() != null ? 1 : 0;
+ } catch (InterruptedException e) {
+ throw (InterruptedIOException) new InterruptedIOException().initCause(e);
+ } catch (ExecutionException e) {
+ throw new IOException(e);
+ }
+ }
+
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Split storefiles for region " + parentHRI + " Daughter A: " + daughterA
+ + " storefiles, Daughter B: " + daughterB + " storefiles.");
+ }
+ return new Pair<Integer, Integer>(daughterA, daughterB);
+ }
+
+ private void assertReferenceFileCount(
+ final FileSystem fs,
+ final int expectedReferenceFileCount,
+ final Path dir)
+ throws IOException {
+ if (expectedReferenceFileCount != 0 &&
+ expectedReferenceFileCount != FSUtils.getRegionReferenceFileCount(fs, dir)) {
+ throw new IOException("Failing split. Expected reference file count isn't equal.");
+ }
+ }
+
+ private Pair<Path, Path> splitStoreFile(
+ final HRegionFileSystem regionFs,
+ final byte[] family,
+ final StoreFile sf)
+ throws IOException {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Splitting started for store file: " + sf.getPath() + " for region: " + parentHRI);
+ }
+
+ String familyName = Bytes.toString(family);
+ Path path_first =
+ regionFs.splitStoreFile(this.daughter_1_HRI, familyName, sf, this.splitRow, false, null);
+ Path path_second =
+ regionFs.splitStoreFile(this.daughter_2_HRI, familyName, sf, this.splitRow, true, null);
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Splitting complete for store file: " + sf.getPath() + " for region: " + parentHRI);
+ }
+ return new Pair<Path,Path>(path_first, path_second);
+ }
+
+ /**
+ * Utility class used to do the file splitting / reference writing
+ * in parallel instead of sequentially.
+ */
+ private class StoreFileSplitter implements Callable<Pair<Path,Path>> {
+ private final HRegionFileSystem regionFs;
+ private final byte[] family;
+ private final StoreFile sf;
+
+ /**
+ * Constructor that takes what it needs to split
+ * @param regionFs the file system
+ * @param family Family that contains the store file
+ * @param sf which file
+ */
+ public StoreFileSplitter(
+ final HRegionFileSystem regionFs,
+ final byte[] family,
+ final StoreFile sf) {
+ this.regionFs = regionFs;
+ this.sf = sf;
+ this.family = family;
+ }
+
+ public Pair<Path,Path> call() throws IOException {
+ return splitStoreFile(regionFs, family, sf);
+ }
+ }
+
+ /**
+ * Post split region actions before the Point-of-No-Return step
+ * @param env MasterProcedureEnv
+ **/
+ private void preSplitRegionBeforePONR(final MasterProcedureEnv env)
+ throws IOException, InterruptedException {
+ final List<Mutation> metaEntries = new ArrayList<Mutation>();
+ boolean ret = false;
+ final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
+ if (cpHost != null) {
+ ret = cpHost.preSplitBeforePONRAction(splitRow, metaEntries, user);
+
+ if (ret) {
+ throw new IOException("Coprocessor bypassing region "
+ + parentHRI.getRegionNameAsString() + " split.");
+ }
+ try {
+ for (Mutation p : metaEntries) {
+ HRegionInfo.parseRegionName(p.getRow());
+ }
+ } catch (IOException e) {
+ LOG.error("Row key of mutation from coprossor is not parsable as region name."
+ + "Mutations from coprocessor should only for hbase:meta table.");
+ throw e;
+ }
+ }
+ }
+
+ /**
+ * Add daughter regions to META
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ */
+ private void updateMetaForDaughterRegions(final MasterProcedureEnv env) throws IOException {
+ RegionStateTransition.Builder transition = RegionStateTransition.newBuilder();
+ transition.setTransitionCode(TransitionCode.SPLIT_PONR);
+ transition.addRegionInfo(HRegionInfo.convert(parentHRI));
+ transition.addRegionInfo(HRegionInfo.convert(daughter_1_HRI));
+ transition.addRegionInfo(HRegionInfo.convert(daughter_2_HRI));
+ if (env.getMasterServices().getAssignmentManager().onRegionTransition(
+ getParentRegionState(env).getServerName(), transition.build()) != null) {
+ throw new IOException("Failed to update meta to add daughter regions in split region "
+ + parentHRI.getRegionNameAsString());
+ }
+ }
+
+ /**
+ * Pre split region actions after the Point-of-No-Return step
+ * @param env MasterProcedureEnv
+ **/
+ private void preSplitRegionAfterPONR(final MasterProcedureEnv env)
+ throws IOException, InterruptedException {
+ final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
+ if (cpHost != null) {
+ cpHost.preSplitAfterPONRAction(user);
+ }
+ }
+
+ /**
+ * Assign daughter regions
+ * @param env MasterProcedureEnv
+ * @throws IOException
+ * @throws InterruptedException
+ **/
+ private void openDaughterRegions(
+ final MasterProcedureEnv env) throws IOException, InterruptedException {
+ env.getMasterServices().getAssignmentManager().assignDaughterRegions(
+ parentHRI, daughter_1_HRI, daughter_2_HRI);
+ }
+
+ /**
+ * Post split region actions
+ * @param env MasterProcedureEnv
+ **/
+ private void postSplitRegion(final MasterProcedureEnv env)
+ throws IOException {
+ final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
+ if (cpHost != null) {
+ cpHost.postCompletedSplitRegionAction(daughter_1_HRI, daughter_2_HRI, user);
+ }
+ }
+
+ /**
+ * Calculate daughter regionid to use.
+ * @param hri Parent {@link HRegionInfo}
+ * @return Daughter region id (timestamp) to use.
+ */
+ private long getDaughterRegionIdTimestamp(final HRegionInfo hri) {
+ long rid = EnvironmentEdgeManager.currentTime();
+ // Regionid is timestamp. Can't be less than that of parent else will insert
+ // at wrong location in hbase:meta (See HBASE-710).
+ if (rid < hri.getRegionId()) {
+ LOG.warn("Clock skew: parent regions id is " + hri.getRegionId() +
+ " but current time here is " + rid);
+ rid = hri.getRegionId() + 1;
+ }
+ return rid;
+ }
+
+ /**
+ * Get parent region state
+ * @param env MasterProcedureEnv
+ * @return parent region state
+ */
+ private RegionState getParentRegionState(final MasterProcedureEnv env) {
+ RegionStates regionStates = env.getMasterServices().getAssignmentManager().getRegionStates();
+ RegionState state = regionStates.getRegionState(parentHRI);
+ if (state == null) {
+ LOG.warn("Split but not in region states: " + parentHRI);
+ state = regionStates.createRegionState(parentHRI);
+ }
+ return state;
+ }
+
+ /**
+ * The procedure could be restarted from a different machine. If the variable is null, we need to
+ * retrieve it.
+ * @return traceEnabled
+ */
+ private Boolean isTraceEnabled() {
+ if (traceEnabled == null) {
+ traceEnabled = LOG.isTraceEnabled();
+ }
+ return traceEnabled;
+ }
+}
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
index 2c25efd..99c389d 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
@@ -6649,7 +6649,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi
* @param hri Spec. for daughter region to open.
* @throws IOException
*/
- HRegion createDaughterRegionFromSplits(final HRegionInfo hri) throws IOException {
+ public HRegion createDaughterRegionFromSplits(final HRegionInfo hri) throws IOException {
// Move the files from the temporary .splits to the final /table/region directory
fs.commitDaughterRegion(hri);
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionFileSystem.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionFileSystem.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionFileSystem.java
index 12e93c2..50382a4 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionFileSystem.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionFileSystem.java
@@ -480,7 +480,7 @@ public class HRegionFileSystem {
return new Path(getRegionDir(), REGION_SPLITS_DIR);
}
- Path getSplitsDir(final HRegionInfo hri) {
+ public Path getSplitsDir(final HRegionInfo hri) {
return new Path(getSplitsDir(), hri.getEncodedName());
}
@@ -539,7 +539,7 @@ public class HRegionFileSystem {
* @param regionInfo daughter {@link org.apache.hadoop.hbase.HRegionInfo}
* @throws IOException
*/
- Path commitDaughterRegion(final HRegionInfo regionInfo)
+ public Path commitDaughterRegion(final HRegionInfo regionInfo)
throws IOException {
Path regionDir = new Path(this.tableDir, regionInfo.getEncodedName());
Path daughterTmpDir = this.getSplitsDir(regionInfo);
@@ -563,7 +563,7 @@ public class HRegionFileSystem {
/**
* Create the region splits directory.
*/
- void createSplitsDir() throws IOException {
+ public void createSplitsDir() throws IOException {
Path splitdir = getSplitsDir();
if (fs.exists(splitdir)) {
LOG.info("The " + splitdir + " directory exists. Hence deleting it to recreate it");
@@ -590,12 +590,15 @@ public class HRegionFileSystem {
* @return Path to created reference.
* @throws IOException
*/
- Path splitStoreFile(final HRegionInfo hri, final String familyName, final StoreFile f,
+ public Path splitStoreFile(final HRegionInfo hri, final String familyName, final StoreFile f,
final byte[] splitRow, final boolean top, RegionSplitPolicy splitPolicy)
throws IOException {
if (splitPolicy == null || !splitPolicy.skipStoreFileRangeCheck(familyName)) {
// Check whether the split row lies in the range of the store file
// If it is outside the range, return directly.
+ if (f.getReader() == null) {
+ f.createReader();
+ }
try {
if (top) {
//check if larger than last key.
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java
index 8bea130..495aace 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java
@@ -83,6 +83,7 @@ import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.client.ClusterConnection;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionUtils;
+import org.apache.hadoop.hbase.client.NonceGenerator;
import org.apache.hadoop.hbase.client.RpcRetryingCallerFactory;
import org.apache.hadoop.hbase.conf.ConfigurationManager;
import org.apache.hadoop.hbase.conf.ConfigurationObserver;
@@ -142,6 +143,8 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.NameStringP
import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionServerInfo;
import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionSpecifier;
import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionSpecifier.RegionSpecifierType;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetProcedureResultRequest;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetProcedureResultResponse;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.GetLastFlushedSequenceIdRequest;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.GetLastFlushedSequenceIdResponse;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerReportRequest;
@@ -153,6 +156,8 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProto
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRSFatalErrorRequest;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest;
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.SplitTableRegionRequest;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.SplitTableRegionResponse;
import org.apache.hadoop.hbase.trace.SpanReceiverHost;
import org.apache.hadoop.hbase.util.Addressing;
import org.apache.hadoop.hbase.util.Bytes;
@@ -160,6 +165,7 @@ import org.apache.hadoop.hbase.util.CompressionTest;
import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
import org.apache.hadoop.hbase.util.FSTableDescriptors;
import org.apache.hadoop.hbase.util.FSUtils;
+import org.apache.hadoop.hbase.util.ForeignExceptionUtil;
import org.apache.hadoop.hbase.util.HasThread;
import org.apache.hadoop.hbase.util.JSONBean;
import org.apache.hadoop.hbase.util.JvmPauseMonitor;
@@ -2099,6 +2105,81 @@ public class HRegionServer extends HasThread implements
return false;
}
+ @Override
+ public long requestRegionSplit(final HRegionInfo regionInfo, final byte[] splitRow) {
+ NonceGenerator ng = clusterConnection.getNonceGenerator();
+ final long nonceGroup = ng.getNonceGroup();
+ final long nonce = ng.newNonce();
+ long procId = -1;
+ SplitTableRegionRequest request =
+ RequestConverter.buildSplitTableRegionRequest(regionInfo, splitRow, nonceGroup, nonce);
+
+ while (keepLooping()) {
+ RegionServerStatusService.BlockingInterface rss = rssStub;
+ try {
+ if (rss == null) {
+ createRegionServerStatusStub();
+ continue;
+ }
+ SplitTableRegionResponse response = rss.splitRegion(null, request);
+
+ //TODO: should we limit the retry number before quitting?
+ if (response == null || (procId = response.getProcId()) == -1) {
+ LOG.warn("Failed to split " + regionInfo + " retrying...");
+ continue;
+ }
+
+ break;
+ } catch (ServiceException se) {
+ // TODO: retry or just fail
+ IOException ioe = ProtobufUtil.getRemoteException(se);
+ LOG.info("Failed to split region, will retry", ioe);
+ if (rssStub == rss) {
+ rssStub = null;
+ }
+ }
+ }
+ return procId;
+ }
+
+ @Override
+ public boolean isProcedureFinished(final long procId) throws IOException {
+ GetProcedureResultRequest request =
+ GetProcedureResultRequest.newBuilder().setProcId(procId).build();
+
+ while (keepLooping()) {
+ RegionServerStatusService.BlockingInterface rss = rssStub;
+ try {
+ if (rss == null) {
+ createRegionServerStatusStub();
+ continue;
+ }
+ // TODO: find a way to get proc result
+ GetProcedureResultResponse response = rss.getProcedureResult(null, request);
+
+ if (response == null) {
+ LOG.warn("Failed to get procedure (id=" + procId + ") status.");
+ return false;
+ } else if (response.getState() == GetProcedureResultResponse.State.RUNNING) {
+ return false;
+ } else if (response.hasException()) {
+ // Procedure failed.
+ throw ForeignExceptionUtil.toIOException(response.getException());
+ }
+ // Procedure completes successfully
+ break;
+ } catch (ServiceException se) {
+ // TODO: retry or just fail
+ IOException ioe = ProtobufUtil.getRemoteException(se);
+ LOG.warn("Failed to get split region procedure result. Retrying", ioe);
+ if (rssStub == rss) {
+ rssStub = null;
+ }
+ }
+ }
+ return true;
+ }
+
/**
* Trigger a flush in the primary region replica if this region is a secondary replica. Does not
* block this thread. See RegionReplicaFlushHandler for details.
@@ -2946,6 +3027,41 @@ public class HRegionServer extends HasThread implements
return true;
}
+ /**
+ * Close and offline the region for split
+ *
+ * @param parentRegionEncodedName the name of the region to close
+ * @return True if closed the region successfully.
+ * @throws IOException
+ */
+ protected boolean closeAndOfflineRegionForSplit(
+ final String parentRegionEncodedName) throws IOException {
+ Region parentRegion = this.getFromOnlineRegions(parentRegionEncodedName);
+ if (parentRegion != null) {
+ Map<byte[], List<StoreFile>> hstoreFilesToSplit = null;
+ Exception exceptionToThrow = null;
+ try{
+ hstoreFilesToSplit = ((HRegion)parentRegion).close(false);
+ } catch (Exception e) {
+ exceptionToThrow = e;
+ }
+ if (exceptionToThrow == null && hstoreFilesToSplit == null) {
+ // The region was closed by someone else
+ exceptionToThrow =
+ new IOException("Failed to close region: already closed by another thread");
+ }
+
+ if (exceptionToThrow != null) {
+ if (exceptionToThrow instanceof IOException) throw (IOException)exceptionToThrow;
+ throw new IOException(exceptionToThrow);
+ }
+
+ // Offline the region
+ this.removeFromOnlineRegions(parentRegion, null);
+ }
+ return true;
+ }
+
/**
* @param regionName
* @return HRegion for the passed binary <code>regionName</code> or null if
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
index 09c7fb9..35b2ab0 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
@@ -93,6 +93,8 @@ import org.apache.hadoop.hbase.ipc.ServerNotRunningYetException;
import org.apache.hadoop.hbase.ipc.ServerRpcController;
import org.apache.hadoop.hbase.master.MasterRpcServices;
import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionForSplitRequest;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionForSplitResponse;
import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionRequest;
import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionResponse;
import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CompactRegionRequest;
@@ -1361,6 +1363,33 @@ public class RSRpcServices implements HBaseRPCErrorHandler,
}
}
+ @Override
+ @QosPriority(priority=HConstants.ADMIN_QOS)
+ public CloseRegionForSplitResponse closeRegionForSplit(
+ final RpcController controller,
+ final CloseRegionForSplitRequest request) throws ServiceException {
+ try {
+ checkOpen();
+
+ final String encodedRegionName = ProtobufUtil.getRegionEncodedName(request.getRegion());
+
+ // Can be null if we're calling close on a region that's not online
+ final Region parentRegion = regionServer.getFromOnlineRegions(encodedRegionName);
+ if ((parentRegion != null) && (parentRegion.getCoprocessorHost() != null)) {
+ parentRegion.getCoprocessorHost().preClose(false);
+ }
+
+ requestCount.increment();
+ LOG.info("Close and offline " + encodedRegionName + " and prepare for split.");
+ boolean closed = regionServer.closeAndOfflineRegionForSplit(encodedRegionName);
+ CloseRegionForSplitResponse.Builder builder =
+ CloseRegionForSplitResponse.newBuilder().setClosed(closed);
+ return builder.build();
+ } catch (IOException ie) {
+ throw new ServiceException(ie);
+ }
+ }
+
/**
* Compact a region on the region server.
*
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java
index 567664e..0e4d0fc 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java
@@ -707,7 +707,7 @@ public class RegionCoprocessorHost
* Invoked just before a split
* @throws IOException
*/
- // TODO: Deprecate this
+ @Deprecated
public void preSplit(final User user) throws IOException {
execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@Override
@@ -721,7 +721,10 @@ public class RegionCoprocessorHost
/**
* Invoked just before a split
* @throws IOException
+ *
+ * Note: the logic moves to Master; it is unused in RS
*/
+ @Deprecated
public void preSplit(final byte[] splitRow, final User user) throws IOException {
execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@Override
@@ -737,7 +740,10 @@ public class RegionCoprocessorHost
* @param l the new left-hand daughter region
* @param r the new right-hand daughter region
* @throws IOException
+ *
+ * Note: the logic moves to Master; it is unused in RS
*/
+ @Deprecated
public void postSplit(final Region l, final Region r, final User user) throws IOException {
execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@Override
@@ -748,6 +754,10 @@ public class RegionCoprocessorHost
});
}
+ /**
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
public boolean preSplitBeforePONR(final byte[] splitKey,
final List<Mutation> metaEntries, final User user) throws IOException {
return execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@@ -759,6 +769,10 @@ public class RegionCoprocessorHost
});
}
+ /**
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
public void preSplitAfterPONR(final User user) throws IOException {
execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@Override
@@ -772,7 +786,10 @@ public class RegionCoprocessorHost
/**
* Invoked just before the rollback of a failed split is started
* @throws IOException
- */
+ *
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
public void preRollBackSplit(final User user) throws IOException {
execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@Override
@@ -786,7 +803,10 @@ public class RegionCoprocessorHost
/**
* Invoked just after the rollback of a failed split is done
* @throws IOException
- */
+ *
+ * Note: the logic moves to Master; it is unused in RS
+ */
+ @Deprecated
public void postRollBackSplit(final User user) throws IOException {
execOperation(coprocessors.isEmpty() ? null : new RegionOperation(user) {
@Override
http://git-wip-us.apache.org/repos/asf/hbase/blob/e108a4f8/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerServices.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerServices.java
index 36c8a32..2fbd340 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerServices.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerServices.java
@@ -181,6 +181,16 @@ public interface RegionServerServices extends OnlineRegions, FavoredNodesForRegi
boolean reportRegionStateTransition(TransitionCode code, HRegionInfo... hris);
/**
+ * Notify master that a region wants to be splitted.
+ */
+ long requestRegionSplit(final HRegionInfo regionInfo, final byte[] splitRow);
+
+ /**
+ * Check with master whether a procedure is completed (either succeed or fail)
+ */
+ boolean isProcedureFinished(final long procId) throws IOException;
+
+ /**
* Returns a reference to the region server's RPC server
*/
RpcServerInterface getRpcServer();