public HRegion stepsAfterPONR(
final Server server, final RegionServerServices services, HRegion mergedRegion)
throws IOException {
openMergedRegion(server, services, mergedRegion);
if (useCoordination(server)) {
((BaseCoordinatedStateManager) server.getCoordinatedStateManager())
.getRegionMergeCoordination()
.completeRegionMergeTransaction(
services, mergedRegionInfo, region_a, region_b, rmd, mergedRegion);
}
if (rsCoprocessorHost != null) {
rsCoprocessorHost.postMerge(this.region_a, this.region_b, mergedRegion);
}
return mergedRegion;
}
/**
* Run the transaction.
*
* @param server Hosting server instance. Can be null when testing
* @param services Used to online/offline regions.
* @throws IOException If thrown, transaction failed. Call {@link #rollback(Server,
* RegionServerServices)}
* @return merged region
* @throws IOException
* @see #rollback(Server, RegionServerServices)
*/
public HRegion execute(final Server server, final RegionServerServices services)
throws IOException {
useCoordinationForAssignment =
server == null ? true : ConfigUtil.useZKForAssignment(server.getConfiguration());
if (rmd == null) {
rmd =
server != null && server.getCoordinatedStateManager() != null
? ((BaseCoordinatedStateManager) server.getCoordinatedStateManager())
.getRegionMergeCoordination()
.getDefaultDetails()
: null;
}
if (rsCoprocessorHost == null) {
rsCoprocessorHost =
server != null ? ((HRegionServer) server).getRegionServerCoprocessorHost() : null;
}
HRegion mergedRegion = createMergedRegion(server, services);
if (rsCoprocessorHost != null) {
rsCoprocessorHost.postMergeCommit(this.region_a, this.region_b, mergedRegion);
}
return stepsAfterPONR(server, services, mergedRegion);
}
/**
* @param server Hosting server instance (May be null when testing).
* @param services Services of regionserver, used to online regions.
* @throws IOException If thrown, rollback failed. Take drastic action.
* @return True if we successfully rolled back, false if we got to the point of no return and so
* now need to abort the server to minimize damage.
*/
@SuppressWarnings("deprecation")
public boolean rollback(final Server server, final RegionServerServices services)
throws IOException {
assert this.mergedRegionInfo != null;
// Coprocessor callback
if (rsCoprocessorHost != null) {
rsCoprocessorHost.preRollBackMerge(this.region_a, this.region_b);
}
boolean result = true;
ListIterator<JournalEntry> iterator = this.journal.listIterator(this.journal.size());
// Iterate in reverse.
while (iterator.hasPrevious()) {
JournalEntry je = iterator.previous();
switch (je) {
case SET_MERGING:
if (useCoordination(server)) {
((BaseCoordinatedStateManager) server.getCoordinatedStateManager())
.getRegionMergeCoordination()
.clean(this.mergedRegionInfo);
} else if (services != null
&& !useCoordinationForAssignment
&& !services.reportRegionStateTransition(
TransitionCode.MERGE_REVERTED,
mergedRegionInfo,
region_a.getRegionInfo(),
region_b.getRegionInfo())) {
return false;
}
break;
case CREATED_MERGE_DIR:
this.region_a.writestate.writesEnabled = true;
this.region_b.writestate.writesEnabled = true;
this.region_a.getRegionFileSystem().cleanupMergesDir();
break;
case CLOSED_REGION_A:
try {
// So, this returns a seqid but if we just closed and then reopened,
// we should be ok. On close, we flushed using sequenceid obtained
// from hosting regionserver so no need to propagate the sequenceid
// returned out of initialize below up into regionserver as we
// normally do.
this.region_a.initialize();
} catch (IOException e) {
LOG.error(
"Failed rollbacking CLOSED_REGION_A of region "
+ this.region_a.getRegionNameAsString(),
e);
throw new RuntimeException(e);
}
break;
case OFFLINED_REGION_A:
if (services != null) services.addToOnlineRegions(this.region_a);
break;
case CLOSED_REGION_B:
try {
this.region_b.initialize();
} catch (IOException e) {
LOG.error(
"Failed rollbacking CLOSED_REGION_A of region "
+ this.region_b.getRegionNameAsString(),
e);
throw new RuntimeException(e);
}
break;
case OFFLINED_REGION_B:
if (services != null) services.addToOnlineRegions(this.region_b);
break;
case STARTED_MERGED_REGION_CREATION:
this.region_a.getRegionFileSystem().cleanupMergedRegion(this.mergedRegionInfo);
break;
case PONR:
// We got to the point-of-no-return so we need to just abort. Return
// immediately. Do not clean up created merged regions.
return false;
default:
throw new RuntimeException("Unhandled journal entry: " + je);
}
}
// Coprocessor callback
if (rsCoprocessorHost != null) {
rsCoprocessorHost.postRollBackMerge(this.region_a, this.region_b);
}
return result;
}
/**
* Prepare the merged region and region files.
*
* @param server Hosting server instance. Can be null when testing
* @param services Used to online/offline regions.
* @return merged region
* @throws IOException If thrown, transaction failed. Call {@link #rollback(Server,
* RegionServerServices)}
*/
HRegion createMergedRegion(final Server server, final RegionServerServices services)
throws IOException {
LOG.info(
"Starting merge of "
+ region_a
+ " and "
+ region_b.getRegionNameAsString()
+ ", forcible="
+ forcible);
if ((server != null && server.isStopped()) || (services != null && services.isStopping())) {
throw new IOException("Server is stopped or stopping");
}
if (rsCoprocessorHost != null) {
if (rsCoprocessorHost.preMerge(this.region_a, this.region_b)) {
throw new IOException(
"Coprocessor bypassing regions " + this.region_a + " " + this.region_b + " merge.");
}
}
// If true, no cluster to write meta edits to or to use coordination.
boolean testing =
server == null
? true
: server.getConfiguration().getBoolean("hbase.testing.nocluster", false);
HRegion mergedRegion = stepsBeforePONR(server, services, testing);
@MetaMutationAnnotation List<Mutation> metaEntries = new ArrayList<Mutation>();
if (rsCoprocessorHost != null) {
if (rsCoprocessorHost.preMergeCommit(this.region_a, this.region_b, metaEntries)) {
throw new IOException(
"Coprocessor bypassing regions " + this.region_a + " " + this.region_b + " merge.");
}
try {
for (Mutation p : metaEntries) {
HRegionInfo.parseRegionName(p.getRow());
}
} catch (IOException e) {
LOG.error(
"Row key of mutation from coprocessor is not parsable as region name."
+ "Mutations from coprocessor should only be for hbase:meta table.",
e);
throw e;
}
}
// This is the point of no return. Similar with SplitTransaction.
// IF we reach the PONR then subsequent failures need to crash out this
// regionserver
this.journal.add(JournalEntry.PONR);
// Add merged region and delete region_a and region_b
// as an atomic update. See HBASE-7721. This update to hbase:meta makes the region
// will determine whether the region is merged or not in case of failures.
// If it is successful, master will roll-forward, if not, master will
// rollback
if (!testing && useCoordinationForAssignment) {
if (metaEntries.isEmpty()) {
MetaTableAccessor.mergeRegions(
server.getConnection(),
mergedRegion.getRegionInfo(),
region_a.getRegionInfo(),
region_b.getRegionInfo(),
server.getServerName(),
region_a.getTableDesc().getRegionReplication());
} else {
mergeRegionsAndPutMetaEntries(
server.getConnection(),
mergedRegion.getRegionInfo(),
region_a.getRegionInfo(),
region_b.getRegionInfo(),
server.getServerName(),
metaEntries,
region_a.getTableDesc().getRegionReplication());
}
} else if (services != null && !useCoordinationForAssignment) {
if (!services.reportRegionStateTransition(
TransitionCode.MERGE_PONR,
mergedRegionInfo,
region_a.getRegionInfo(),
region_b.getRegionInfo())) {
// Passed PONR, let SSH clean it up
throw new IOException(
"Failed to notify master that merge passed PONR: "
+ region_a.getRegionInfo().getRegionNameAsString()
+ " and "
+ region_b.getRegionInfo().getRegionNameAsString());
}
}
return mergedRegion;
}
